Java 맵의 각 항목을 효율적으로 반복하려면 어떻게 해야 합니까?
https://stackoverflow.com/questions/46898
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
구현하는 객체가 있는 경우 Map Java 인터페이스를 사용하고 그 안에 포함된 모든 쌍을 반복하고 싶은 경우 맵을 통과하는 가장 효율적인 방법은 무엇입니까?
요소의 순서는 인터페이스에 대해 가지고 있는 특정 맵 구현에 따라 달라지나요?
해결책
Map<String, String> map = ...
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println(entry.getKey() + "/" + entry.getValue());
}
다른 팁
다른 답변을 요약하고 내가 아는 것과 결합하기 위해 이를 수행하는 10가지 주요 방법을 찾았습니다(아래 참조).또한 몇 가지 성능 테스트를 작성했습니다(아래 결과 참조).예를 들어, 맵의 모든 키와 값의 합을 찾으려면 다음과 같이 작성할 수 있습니다.
사용 반복자 그리고 지도.입장
long i = 0; Iterator<Map.Entry<Integer, Integer>> it = map.entrySet().iterator(); while (it.hasNext()) { Map.Entry<Integer, Integer> pair = it.next(); i += pair.getKey() + pair.getValue(); }사용 각각 그리고 지도.입장
long i = 0; for (Map.Entry<Integer, Integer> pair : map.entrySet()) { i += pair.getKey() + pair.getValue(); }사용 각각 자바 8부터
final long[] i = {0}; map.forEach((k, v) -> i[0] += k + v);사용 키세트 그리고 각각
long i = 0; for (Integer key : map.keySet()) { i += key + map.get(key); }사용 키세트 그리고 반복자
long i = 0; Iterator<Integer> itr2 = map.keySet().iterator(); while (itr2.hasNext()) { Integer key = itr2.next(); i += key + map.get(key); }사용 ~을 위한 그리고 지도.입장
long i = 0; for (Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator(); entries.hasNext(); ) { Map.Entry<Integer, Integer> entry = entries.next(); i += entry.getKey() + entry.getValue(); }자바 8 사용 스트림 API
final long[] i = {0}; map.entrySet().stream().forEach(e -> i[0] += e.getKey() + e.getValue());자바 8 사용 스트림 API 병렬
final long[] i = {0}; map.entrySet().stream().parallel().forEach(e -> i[0] += e.getKey() + e.getValue());사용 IterableMap ~의
Apache Collectionslong i = 0; MapIterator<Integer, Integer> it = iterableMap.mapIterator(); while (it.hasNext()) { i += it.next() + it.getValue(); }사용 가변 맵 Eclipse(CS) 컬렉션
final long[] i = {0}; mutableMap.forEachKeyValue((key, value) -> { i[0] += key + value; });
성능 테스트 (모드 = AverageTime, 시스템 = Windows 8.1 64비트, Intel i7-4790 3.60GHz, 16GB)
작은 맵(요소 100개)의 경우 점수 0.308이 가장 좋습니다.
Benchmark Mode Cnt Score Error Units test3_UsingForEachAndJava8 avgt 10 0.308 ± 0.021 µs/op test10_UsingEclipseMap avgt 10 0.309 ± 0.009 µs/op test1_UsingWhileAndMapEntry avgt 10 0.380 ± 0.014 µs/op test6_UsingForAndIterator avgt 10 0.387 ± 0.016 µs/op test2_UsingForEachAndMapEntry avgt 10 0.391 ± 0.023 µs/op test7_UsingJava8StreamApi avgt 10 0.510 ± 0.014 µs/op test9_UsingApacheIterableMap avgt 10 0.524 ± 0.008 µs/op test4_UsingKeySetAndForEach avgt 10 0.816 ± 0.026 µs/op test5_UsingKeySetAndIterator avgt 10 0.863 ± 0.025 µs/op test8_UsingJava8StreamApiParallel avgt 10 5.552 ± 0.185 µs/op10000개의 요소가 포함된 지도의 경우 점수 37.606이 가장 좋습니다.
Benchmark Mode Cnt Score Error Units test10_UsingEclipseMap avgt 10 37.606 ± 0.790 µs/op test3_UsingForEachAndJava8 avgt 10 50.368 ± 0.887 µs/op test6_UsingForAndIterator avgt 10 50.332 ± 0.507 µs/op test2_UsingForEachAndMapEntry avgt 10 51.406 ± 1.032 µs/op test1_UsingWhileAndMapEntry avgt 10 52.538 ± 2.431 µs/op test7_UsingJava8StreamApi avgt 10 54.464 ± 0.712 µs/op test4_UsingKeySetAndForEach avgt 10 79.016 ± 25.345 µs/op test5_UsingKeySetAndIterator avgt 10 91.105 ± 10.220 µs/op test8_UsingJava8StreamApiParallel avgt 10 112.511 ± 0.365 µs/op test9_UsingApacheIterableMap avgt 10 125.714 ± 1.935 µs/op100,000개의 요소가 포함된 지도의 경우 점수 1184.767이 가장 좋습니다.
Benchmark Mode Cnt Score Error Units test1_UsingWhileAndMapEntry avgt 10 1184.767 ± 332.968 µs/op test10_UsingEclipseMap avgt 10 1191.735 ± 304.273 µs/op test2_UsingForEachAndMapEntry avgt 10 1205.815 ± 366.043 µs/op test6_UsingForAndIterator avgt 10 1206.873 ± 367.272 µs/op test8_UsingJava8StreamApiParallel avgt 10 1485.895 ± 233.143 µs/op test5_UsingKeySetAndIterator avgt 10 1540.281 ± 357.497 µs/op test4_UsingKeySetAndForEach avgt 10 1593.342 ± 294.417 µs/op test3_UsingForEachAndJava8 avgt 10 1666.296 ± 126.443 µs/op test7_UsingJava8StreamApi avgt 10 1706.676 ± 436.867 µs/op test9_UsingApacheIterableMap avgt 10 3289.866 ± 1445.564 µs/op
그래프(지도 크기에 따른 성능 테스트)
테이블(맵 크기에 따른 성능 테스트)
100 600 1100 1600 2100
test10 0.333 1.631 2.752 5.937 8.024
test3 0.309 1.971 4.147 8.147 10.473
test6 0.372 2.190 4.470 8.322 10.531
test1 0.405 2.237 4.616 8.645 10.707
test2 0.376 2.267 4.809 8.403 10.910
test7 0.473 2.448 5.668 9.790 12.125
test9 0.565 2.830 5.952 13.220 16.965
test4 0.808 5.012 8.813 13.939 17.407
test5 0.810 5.104 8.533 14.064 17.422
test8 5.173 12.499 17.351 24.671 30.403
모든 테스트가 켜져 있습니다. GitHub.
Java 8에서는 새로운 람다 기능을 사용하여 깔끔하고 빠르게 작업을 수행할 수 있습니다.
Map<String,String> map = new HashMap<>();
map.put("SomeKey", "SomeValue");
map.forEach( (k,v) -> [do something with key and value] );
// such as
map.forEach( (k,v) -> System.out.println("Key: " + k + ": Value: " + v));
유형 k 그리고 v 컴파일러에 의해 추론되므로 사용할 필요가 없습니다. Map.Entry 더 이상.
쉬워요!
예, 순서는 특정 Map 구현에 따라 다릅니다.
@ScArcher2에는 더 우아한 Java 1.5 구문이 있습니다..1.4에서는 다음과 같이 할 것입니다:
Iterator entries = myMap.entrySet().iterator();
while (entries.hasNext()) {
Entry thisEntry = (Entry) entries.next();
Object key = thisEntry.getKey();
Object value = thisEntry.getValue();
// ...
}
지도를 반복하는 일반적인 코드는 다음과 같습니다.
Map<String,Thing> map = ...;
for (Map.Entry<String,Thing> entry : map.entrySet()) {
String key = entry.getKey();
Thing thing = entry.getValue();
...
}
HashMap 표준 맵 구현이며 보장하지 않습니다(또는 변경 작업이 수행되지 않는 경우 순서를 변경해서는 안 됨). SortedMap 키의 자연스러운 순서에 따라 항목을 반환합니다. Comparator, 제공된 경우. LinkedHashMap 구성 방법에 따라 삽입 순서 또는 액세스 순서로 항목을 반환합니다. EnumMap 키의 자연 순서로 항목을 반환합니다.
(업데이트:나는 이것이 더 이상 사실이 아니라고 생각합니다.) 메모, IdentityHashMap entrySet 반복자는 현재 동일한 것을 반환하는 독특한 구현을 가지고 있습니다. Map.Entry 인스턴스의 모든 항목에 대해 entrySet!그러나 새로운 반복자가 나올 때마다 Map.Entry 업데이트됩니다.
반복자와 제네릭 사용의 예:
Iterator<Map.Entry<String, String>> entries = myMap.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<String, String> entry = entries.next();
String key = entry.getKey();
String value = entry.getValue();
// ...
}
이것은 두 부분으로 구성된 질문입니다.
지도 항목을 반복하는 방법 - @ScArcher2가 대답했다 그거 완벽해.
반복 순서는 무엇입니까 - 그냥 사용하는 경우 Map, 엄밀히 말하면 다음과 같습니다. 주문 보장 없음.따라서 구현에서 제공하는 순서에 실제로 의존해서는 안 됩니다.그러나, 그 SortedMap 인터페이스 확장 Map 그리고 당신이 찾고 있는 것을 정확히 제공합니다 - 구현은 일관된 정렬 순서를 제공할 것입니다.
NavigableMap 또 다른 유용한 확장 프로그램입니다 - 이것은 SortedMap 키 세트에서 순서가 지정된 위치로 항목을 찾는 추가 방법이 있습니다.따라서 잠재적으로 이는 처음부터 반복의 필요성을 제거할 수 있습니다. 특정 항목을 찾을 수 있을 수도 있습니다. entry 당신은 higherEntry, lowerEntry, ceilingEntry, 또는 floorEntry 행동 양식.그만큼 descendingMap 메소드는 명시적인 메소드도 제공합니다. 순회 순서 반전.
지도를 반복하는 방법에는 여러 가지가 있습니다.
다음은 백만 개의 키 값 쌍을 맵에 저장하고 맵을 반복하여 맵에 저장된 공통 데이터 세트에 대한 성능을 비교한 것입니다.
1) 사용 entrySet() 각 루프마다
for (Map.Entry<String,Integer> entry : testMap.entrySet()) {
entry.getKey();
entry.getValue();
}
50밀리초
2) 사용 keySet() 각 루프마다
for (String key : testMap.keySet()) {
testMap.get(key);
}
76밀리초
3) 사용 entrySet() 그리고 반복자
Iterator<Map.Entry<String,Integer>> itr1 = testMap.entrySet().iterator();
while(itr1.hasNext()) {
Map.Entry<String,Integer> entry = itr1.next();
entry.getKey();
entry.getValue();
}
50밀리초
4) 사용 keySet() 그리고 반복자
Iterator itr2 = testMap.keySet().iterator();
while(itr2.hasNext()) {
String key = itr2.next();
testMap.get(key);
}
75밀리초
나는 언급했다 this link.
이를 수행하는 올바른 방법은 가장 효율적이므로 허용되는 답변을 사용하는 것입니다.다음 코드가 좀 더 깔끔해 보입니다.
for (String key: map.keySet()) {
System.out.println(key + "/" + map.get(key));
}
참고로 다음을 사용할 수도 있습니다. map.keySet() 그리고 map.values() 맵의 키/값에만 관심이 있고 다른 맵에는 관심이 없는 경우.
와 함께 이클립스 컬렉션 (전에 GS 컬렉션), forEachKeyValue 메소드를 사용합니다. MapIterable 인터페이스는 MutableMap 및 ImmutableMap 인터페이스와 해당 구현에 의해 상속됩니다.
final MutableBag<String> result = Bags.mutable.empty();
MutableMap<Integer, String> map = Maps.mutable.of(1, "One", 2, "Two", 3, "Three");
map.forEachKeyValue(new Procedure2<Integer, String>()
{
public void value(Integer key, String value)
{
result.add(key + value);
}
});
Assert.assertEquals(Bags.mutable.of("1One", "2Two", "3Three"), result);
Java 8 람다 구문을 사용하면 다음과 같이 코드를 작성할 수 있습니다.
MutableBag<String> result = Bags.mutable.empty();
MutableMap<Integer, String> map = Maps.mutable.of(1, "One", 2, "Two", 3, "Three");
map.forEachKeyValue((key, value) -> result.add(key + value));
Assert.assertEquals(Bags.mutable.of("1One", "2Two", "3Three"), result);
메모: 저는 Eclipse 컬렉션의 커미터입니다.
이론적으로 가장 효율적인 방법은 Map의 구현에 따라 달라집니다.이를 수행하는 공식적인 방법은 전화하는 것입니다. map.entrySet(), 이는 다음 세트를 반환합니다. Map.Entry, 각각 키와 값(entry.getKey() 그리고 entry.getValue()).
특이한 구현에서는 사용 여부에 따라 약간의 차이가 있을 수 있습니다. map.keySet(), map.entrySet() 또는 다른 것.그러나 나는 누군가가 그런 글을 쓸 이유를 생각할 수 없습니다.아마도 당신이 하는 일이 성능에 아무런 영향을 미치지 않을 것입니다.
그렇습니다. 순서는 구현에 따라 달라집니다. (아마도) 삽입 순서와 기타 제어하기 어려운 요소도 마찬가지입니다.
[편집] 나는 썼다 valueSet() 원래는 당연하지만 entrySet() 실제로 대답입니다.
자바 8:
람다 표현식을 사용할 수 있습니다.
myMap.entrySet().stream().forEach((entry) -> {
Object currentKey = entry.getKey();
Object currentValue = entry.getValue();
});
자세한 내용은 다음을 참조하세요. 이것.
Java 1.4에서 이것을 시도해 보십시오:
for( Iterator entries = myMap.entrySet().iterator(); entries.hasNext();){
Entry entry = (Entry) entries.next();
System.out.println(entry.getKey() + "/" + entry.getValue());
//...
}
와 함께 자바 8
map.forEach((k, v) -> System.out.println((k + ":" + v)));
자바 8
우리는 가지고있다 forEach 을 받아들이는 메소드 람다 식.우리는 또한 가지고 있습니다 개울 아피스.지도를 고려해보세요:
Map<String,String> sample = new HashMap<>();
sample.put("A","Apple");
sample.put("B", "Ball");
키를 반복합니다.
sample.keySet().forEach((k) -> System.out.println(k));
값을 반복합니다.
sample.values().forEach((v) -> System.out.println(v));
항목 반복(forEach 및 Streams 사용):
sample.forEach((k,v) -> System.out.println(k + ":" + v));
sample.entrySet().stream().forEach((entry) -> {
Object currentKey = entry.getKey();
Object currentValue = entry.getValue();
System.out.println(currentKey + ":" + currentValue);
});
스트림의 장점은 원할 경우 쉽게 병렬화할 수 있다는 것입니다.우리는 단순히 parallelStream() 대신에 stream() 위에.
forEachOrdered 대 forEach 스트림으로?그만큼 forEach (정의된 경우) 만남 순서를 따르지 않으며 본질적으로 비결정적입니다. forEachOrdered 하다.그래서 forEach 주문이 유지된다는 것을 보장하지 않습니다.또한 확인 이것 이상.
람다 표현식 자바 8
Java 1.8(Java 8)에서는 다음을 사용하여 훨씬 쉬워졌습니다. 각각 집계 작업의 메서드(스트림 작업) 이는 다음의 반복자와 유사해 보입니다. 반복 가능 상호 작용.
아래 명령문을 코드에 복사하고 이름을 바꾸십시오. 해시맵 변수의 흠 키-값 쌍을 인쇄하려면 HashMap 변수에 추가하세요.
HashMap<Integer,Integer> hm = new HashMap<Integer, Integer>();
/*
* Logic to put the Key,Value pair in your HashMap hm
*/
// Print the key value pair in one line.
hm.forEach((k, v) -> System.out.println("key: " + k + " value:" + v));
// Just copy and paste above line to your code.
다음은 내가 사용해 본 샘플 코드입니다. 람다식.이 물건은 정말 멋지다.꼭 해봐.
HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
Random rand = new Random(47);
int i = 0;
while(i < 5) {
i++;
int key = rand.nextInt(20);
int value = rand.nextInt(50);
System.out.println("Inserting key: " + key + " Value: " + value);
Integer imap = hm.put(key, value);
if( imap == null) {
System.out.println("Inserted");
} else {
System.out.println("Replaced with " + imap);
}
}
hm.forEach((k, v) -> System.out.println("key: " + k + " value:" + v));
Output:
Inserting key: 18 Value: 5
Inserted
Inserting key: 13 Value: 11
Inserted
Inserting key: 1 Value: 29
Inserted
Inserting key: 8 Value: 0
Inserted
Inserting key: 2 Value: 7
Inserted
key: 1 value:29
key: 18 value:5
key: 2 value:7
key: 8 value:0
key: 13 value:11
또한 사용할 수 있습니다 분할기 같은 것.
Spliterator sit = hm.entrySet().spliterator();
업데이트
Oracle Docs에 대한 문서 링크를 포함합니다.자세한 내용은 람다 이것으로 가세요 링크 그리고 꼭 읽어야 할 집계 작업 Spliterator의 경우 여기로 이동하세요. 링크.
Map에서는 반복이 가능합니다. keys 및/또는 values 및/또는 both (e.g., entrySet) 관심이 있는 사람에 따라 다릅니다.
1.) 다음을 반복합니다. keys -> keySet() 지도의:
Map<String, Object> map = ...;
for (String key : map.keySet()) {
//your Business logic...
}
2.) 다음을 반복합니다. values -> values() 지도의:
for (Object value : map.values()) {
//your Business logic...
}
3.) 다음을 반복합니다. both -> entrySet() 지도의:
for (Map.Entry<String, Object> entry : map.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
//your Business logic...
}
게다가 HashMap을 통해 반복하는 방법에는 3가지가 있습니다.그들은 아래와 같습니다_
//1.
for (Map.Entry entry : hm.entrySet()) {
System.out.print("key,val: ");
System.out.println(entry.getKey() + "," + entry.getValue());
}
//2.
Iterator iter = hm.keySet().iterator();
while(iter.hasNext()) {
Integer key = (Integer)iter.next();
String val = (String)hm.get(key);
System.out.println("key,val: " + key + "," + val);
}
//3.
Iterator it = hm.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
Integer key = (Integer)entry.getKey();
String val = (String)entry.getValue();
System.out.println("key,val: " + key + "," + val);
}
Java 8에서 가장 컴팩트함:
map.entrySet().forEach(System.out::println);
public class abcd{
public static void main(String[] args)
{
Map<Integer, String> testMap = new HashMap<Integer, String>();
testMap.put(10, "a");
testMap.put(20, "b");
testMap.put(30, "c");
testMap.put(40, "d");
for (Integer key:testMap.keySet()) {
String value=testMap.get(key);
System.out.println(value);
}
}
}
또는
public class abcd {
public static void main(String[] args)
{
Map<Integer, String> testMap = new HashMap<Integer, String>();
testMap.put(10, "a");
testMap.put(20, "b");
testMap.put(30, "c");
testMap.put(40, "d");
for (Entry<Integer, String> entry : testMap.entrySet()) {
Integer key=entry.getKey();
String value=entry.getValue();
}
}
}
유형이 지정되지 않은 일반 맵이 있는 경우 다음을 사용할 수 있습니다.
Map map = new HashMap();
for (Map.Entry entry : ((Set<Map.Entry>) map.entrySet())) {
System.out.println(entry.getKey() + "/" + entry.getValue());
}
Iterator iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry element = (Map.Entry)it.next();
LOGGER.debug("Key: " + element.getKey());
LOGGER.debug("value: " + element.getValue());
}
제네릭을 사용하여 이를 수행할 수 있습니다.
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<Integer, Integer> entry = entries.next();
System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}
자바 8을 사용하세요:
map.entrySet().forEach(entry -> System.out.println(entry.getValue()));
//Functional Oprations
Map<String, String> mapString = new HashMap<>();
mapString.entrySet().stream().map((entry) -> {
String mapKey = entry.getKey();
return entry;
}).forEach((entry) -> {
String mapValue = entry.getValue();
});
//Intrator
Map<String, String> mapString = new HashMap<>();
for (Iterator<Map.Entry<String, String>> it = mapString.entrySet().iterator(); it.hasNext();) {
Map.Entry<String, String> entry = it.next();
String mapKey = entry.getKey();
String mapValue = entry.getValue();
}
//Simple for loop
Map<String, String> mapString = new HashMap<>();
for (Map.Entry<String, String> entry : mapString.entrySet()) {
String mapKey = entry.getKey();
String mapValue = entry.getValue();
}
순서는 항상 특정 지도 구현에 따라 달라집니다.Java 8을 사용하면 다음 중 하나를 사용할 수 있습니다.
map.forEach((k,v) -> { System.out.println(k + ":" + v); });
또는:
map.entrySet().forEach((e) -> {
System.out.println(e.getKey() + " : " + e.getValue());
});
결과는 동일합니다(동일한 순서).지도가 지원하는 EntrySet이므로 동일한 주문을 받습니다.두 번째는 람다를 사용할 수 있으므로 편리합니다.5보다 큰 Integer 객체만 인쇄하려는 경우:
map.entrySet()
.stream()
.filter(e-> e.getValue() > 5)
.forEach(System.out::println);
아래 코드는 LinkedHashMap과 일반 HashMap(예)을 통한 반복을 보여줍니다.순서에 차이가 있습니다.
public class HMIteration {
public static void main(String[] args) {
Map<Object, Object> linkedHashMap = new LinkedHashMap<>();
Map<Object, Object> hashMap = new HashMap<>();
for (int i=10; i>=0; i--) {
linkedHashMap.put(i, i);
hashMap.put(i, i);
}
System.out.println("LinkedHashMap (1): ");
linkedHashMap.forEach((k,v) -> { System.out.print(k + " (#="+k.hashCode() + "):" + v + ", "); });
System.out.println("\nLinkedHashMap (2): ");
linkedHashMap.entrySet().forEach((e) -> {
System.out.print(e.getKey() + " : " + e.getValue() + ", ");
});
System.out.println("\n\nHashMap (1): ");
hashMap.forEach((k,v) -> { System.out.print(k + " (#:"+k.hashCode() + "):" + v + ", "); });
System.out.println("\nHashMap (2): ");
hashMap.entrySet().forEach((e) -> {
System.out.print(e.getKey() + " : " + e.getValue() + ", ");
});
}
}
LinkedHashMap (1):
10 (#=10):10, 9 (#=9):9, 8 (#=8):8, 7 (#=7):7, 6 (#=6):6, 5 (#=5):5, 4 (#=4):4, 3 (#=3):3, 2 (#=2):2, 1 (#=1):1, 0 (#=0):0,
LinkedHashMap (2):
10 : 10, 9 : 9, 8 : 8, 7 : 7, 6 : 6, 5 : 5, 4 : 4, 3 : 3, 2 : 2, 1 : 1, 0 : 0,
해시맵(1):
0 (#:0):0, 1 (#:1):1, 2 (#:2):2, 3 (#:3):3, 4 (#:4):4, 5 (#:5):5, 6 (#:6):6, 7 (#:7):7, 8 (#:8):8, 9 (#:9):9, 10 (#:10):10,
해시맵(2):
0 : 0, 1 : 1, 2 : 2, 3 : 3, 4 : 4, 5 : 5, 6 : 6, 7 : 7, 8 : 8, 9 : 9, 10 : 10,
Map에 대한 효과적인 반복 솔루션은 Java 5에서 Java 7까지의 'for Each' 루프입니다.여기있어:
for (String key : phnMap.keySet()) {
System.out.println("Key: " + key + " Value: " + phnMap.get(key));
}
Java 8에서는 람다 표현식을 사용하여 맵을 반복할 수 있습니다.향상된 'forEach'입니다.
phnMap.forEach((k,v) -> System.out.println("Key: " + k + " Value: " + v));
람다에 대한 조건문을 작성하려면 다음과 같이 작성할 수 있습니다.
phnMap.forEach((k,v)->{
System.out.println("Key: " + k + " Value: " + v);
if("abc".equals(k)){
System.out.println("Hello abc");
}
});
예, 많은 사람들이 동의했듯이 이것이 반복하는 가장 좋은 방법입니다. Map.
하지만 던질 기회는 있다 nullpointerexception 지도가 있다면 null.넣는 것을 잊지 마세요 null .체크인.
|
|
- - - -
|
|
for (Map.Entry<String, Object> entry : map.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
}
package com.test;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class Test {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("ram", "ayodhya");
map.put("krishan", "mathura");
map.put("shiv", "kailash");
System.out.println("********* Keys *********");
Set<String> keys = map.keySet();
for (String key : keys) {
System.out.println(key);
}
System.out.println("********* Values *********");
Collection<String> values = map.values();
for (String value : values) {
System.out.println(value);
}
System.out.println("***** Keys and Values (Using for each loop) *****");
for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println("Key: " + entry.getKey() + "\t Value: "
+ entry.getValue());
}
System.out.println("***** Keys and Values (Using while loop) *****");
Iterator<Entry<String, String>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
Map.Entry<String, String> entry = (Map.Entry<String, String>) entries
.next();
System.out.println("Key: " + entry.getKey() + "\t Value: "
+ entry.getValue());
}
System.out
.println("** Keys and Values (Using java 8 using lambdas )***");
map.forEach((k, v) -> System.out
.println("Key: " + k + "\t value: " + v));
}
}
이를 수행하는 방법에는 여러 가지가 있습니다.다음은 몇 가지 간단한 단계입니다.
다음과 같은 지도가 하나 있다고 가정해 보겠습니다.
Map<String, Integer> m = new HashMap<String, Integer>();
그런 다음 아래와 같은 작업을 수행하여 지도 요소를 반복할 수 있습니다.
// ********** Using an iterator ****************
Iterator<Entry<String, Integer>> me = m.entrySet().iterator();
while(me.hasNext()){
Entry<String, Integer> pair = me.next();
System.out.println(pair.getKey() + ":" + pair.getValue());
}
// *********** Using foreach ************************
for(Entry<String, Integer> me : m.entrySet()){
System.out.println(me.getKey() + " : " + me.getValue());
}
// *********** Using keySet *****************************
for(String s : m.keySet()){
System.out.println(s + " : " + m.get(s));
}
// *********** Using keySet and iterator *****************
Iterator<String> me = m.keySet().iterator();
while(me.hasNext()){
String key = me.next();
System.out.println(key + " : " + m.get(key));
}
