No error , No gain

Question 1

Map 인터페이스를 구현하는 객체가 있고 그 안에 포함된 모든 쌍을 반복하려는 경우 지도를 통과하는 가장 효율적인 방법은 무엇입니까?

요소의 순서는 인터페이스에 대해 가지고 있는 특정 맵 구현에 따라 달라집니까?

Question 2

Map<String, String> map = ... for (Map.Entry<String, String> entry : map.entrySet()) { System.out.println(entry.getKey() + "/" + entry.getValue()); }

자바 10 이상:

 for (var entry : map.entrySet()) { System.out.println(entry.getKey() + "/" + entry.getValue()); }

Question 3

다른 답변을 요약하고 내가 아는 것과 결합하기 위해 10가지 주요 방법을 찾았습니다(아래 참조). 또한 몇 가지 성능 테스트를 작성했습니다(아래 결과 참조). 예를 들어 맵의 모든 키와 값의 합을 찾으려면 다음과 같이 작성할 수 있습니다.

반복자 와 Map.Entry 사용

 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(); }

foreach 및 Map.Entry 사용

 long i = 0; for (Map.Entry<Integer, Integer> pair : map.entrySet()) { i += pair.getKey() + pair.getValue(); }

Java 8에서 forEach 사용

 final long[] i = {0}; map.forEach((k, v) -> i[0] += k + v);

keySet 및 foreach 사용

 long i = 0; for (Integer key : map.keySet()) { i += key + map.get(key); }

keySet 및 반복자 사용

 long i = 0; Iterator<Integer> itr2 = map.keySet().iterator(); while (itr2.hasNext()) { Integer key = itr2.next(); i += key + map.get(key); }

for 및 Map.Entry 사용

 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(); }

Java 8 스트림 API 사용

 final long[] i = {0}; map.entrySet().stream().forEach(e -> i[0] += e.getKey() + e.getValue());

Java 8 Stream API 병렬 사용

 final long[] i = {0}; map.entrySet().stream().parallel().forEach(e -> i[0] += e.getKey() + e.getValue());

Apache Collections IterableMap 사용

 long i = 0; MapIterator<Integer, Integer> it = iterableMap.mapIterator(); while (it.hasNext()) { i += it.next() + it.getValue(); }

Eclipse(CS) 컬렉션의 MutableMap 사용

 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/op

10000개의 요소가 있는 맵의 경우 점수 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/op

100000개의 요소가 있는 맵의 경우 점수 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 에 있습니다.

Question 4

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

쉬워요!

Question 5

예, 순서는 특정 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(); // ... }

Question 6

맵을 반복하는 일반적인 코드는 다음과 같습니다.

 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 때마다 업데이트됩니다.

Question 7

반복자와 제네릭을 사용하는 예:

 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(); // ... }

Question 8

이것은 두 부분으로 된 질문입니다.

지도 항목을 반복하는 방법 - @ScArcher2가 완벽하게 답변했습니다.

반복 순서는 무엇입니까 Map 만 사용하는 경우 엄밀히 말하면 순서 보장 이 없습니다. 따라서 구현에서 제공한 순서에 실제로 의존해서는 안 됩니다. 그러나 SortedMap 인터페이스 Map 확장하고 원하는 것을 정확히 제공합니다. 구현은 일관된 정렬 순서를 제공할 것입니다.

NavigableMap 은 또 다른 유용한 확장 입니다. 이것은 키 세트에서 정렬된 위치로 항목을 찾는 추가 방법이 있는 SortedMap 따라서 잠재적으로 이것은 처음부터 반복할 필요를 제거할 수 있습니다 higherEntry , lowerEntry , ceilingEntry 또는 floorEntry 메소드를 사용한 후에 entry descendingMap 방법은 순회 순서 를 역전시키는 명시적 방법도 제공합니다.

Question 9

맵을 반복하는 방법에는 여러 가지가 있습니다.

다음은 맵에 백만 개의 키 값 쌍을 저장하여 맵에 저장된 공통 데이터 세트에 대한 성능을 비교한 것이며 맵을 반복합니다.

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 사용

 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 사용

 Iterator itr2 = testMap.keySet().iterator(); while(itr2.hasNext()) { String key = itr2.next(); testMap.get(key); }

75밀리초

this link 참조했습니다.

Question 10

참고로 맵의 키/값에만 관심이 있고 다른 하나에는 관심이 없는 경우 map.keySet() 및 map.values() 를 사용할 수도 있습니다.

Question 11

이를 수행하는 올바른 방법은 가장 효율적이므로 허용된 답변을 사용하는 것입니다. 다음 코드가 좀 더 깔끔해 보입니다.

 for (String key: map.keySet()) { System.out.println(key + "/" + map.get(key)); }

Question 12

Java 8 에서는 forEach 및 람다 식을 사용하여 Map을 반복할 수 있습니다.

 map.forEach((k, v) -> System.out.println((k + ":" + v)));

Question 13

Eclipse Collections를 MutableMap 및 ImmutableMap 인터페이스와 해당 구현에서 상속되는 MapIterable forEachKeyValue 메소드를 사용할 수 있습니다.

 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);

익명 내부 클래스를 사용하여 다음과 같이 코드를 작성할 수 있습니다.

 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);

참고: 저는 Eclipse Collections의 커미터입니다.

Question 14

이론적으로 가장 효율적인 방법은 Map의 구현에 따라 다릅니다. 이를 수행하는 공식적인 방법은 각각 키와 값( entry.getKey() 및 entry.getValue() ) Map.Entry 세트를 반환하는 map.entrySet()

map.keySet() , map.entrySet() 또는 다른 것을 사용하는지 여부에 따라 약간의 차이가 있을 수 있습니다. 하지만 누군가가 왜 그렇게 쓰는지 이유를 생각할 수 없습니다. 대부분의 경우 수행하는 작업에 차이가 없습니다.

그리고 예, 순서는 구현과 (아마도) 삽입 순서 및 기타 제어하기 어려운 요소에 따라 달라집니다.

[편집] valueSet() 작성했지만 물론 entrySet() 이 실제로 답입니다.

Question 15

자바 8

우리는 람다 식 을 받아들이 forEach 메소드를 가지고 있습니다. 스트림 API도 있습니다. 지도를 고려하십시오.

 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); });

스트림의 장점은 원하는 경우 쉽게 병렬화할 수 있다는 것입니다. 위의 stream() parallelStream() 을 사용하기만 하면 됩니다.

forEachOrdered 대 스트림이 있는 forEach forEach 는 만남 순서를 따르지 않으며(정의된 경우) forEachOrdered 처럼 본질적으로 비결정적입니다. 따라서 forEach 는 주문이 유지될 것이라고 보장하지 않습니다. 또한 이것을 더 확인하십시오.

Question 16

람다 표현식 자바 8

Java 1.8(Java 8)에서는 Iterable Interface의 iterator와 비슷하게 보이는 Aggregate operations( Stream operations )의 forEach 메소드를 사용하여 훨씬 쉬워졌습니다.

아래 명령문을 코드에 복사하고 HashMap 변수의 이름을 hm 에서 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.

다음은 Lambda Expression을 사용하여 시도한 샘플 코드입니다. 이 물건은 너무 멋져요. 꼭 해봐.

 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 를 사용할 수 있습니다.

 Spliterator sit = hm.entrySet().spliterator();

업데이트

Oracle Docs에 대한 문서 링크를 포함합니다. Lambda 에 대한 자세한 내용은 이 링크 로 이동하고 Aggregate Operations 를 읽어야 하며 Spliterator의 경우 이 링크 로 이동하십시오.

Question 17

자바 8:

람다 표현식을 사용할 수 있습니다.

 myMap.entrySet().stream().forEach((entry) -> { Object currentKey = entry.getKey(); Object currentValue = entry.getValue(); });

자세한 내용은 다음과 이 .

Question 18

Map에서 keys 및/또는 values 및/또는 both (eg, entrySet) 에 대한 반복은 관심 대상에 따라 달라질 수 있습니다.

맵 keys -> keySet() 을 반복합니다.

 Map<String, Object> map = ...; for (String key : map.keySet()) { //your Business logic... }

맵 values -> values() 를 반복합니다.

 for (Object value : map.values()) { //your Business logic... }

맵의 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); }

Question 19

Java 1.4에서 이것을 시도하십시오.

 for( Iterator entries = myMap.entrySet().iterator(); entries.hasNext();){ Entry entry = (Entry) entries.next(); System.out.println(entry.getKey() + "/" + entry.getValue()); //... }

Question 20

순서는 항상 특정 지도 구현에 따라 달라집니다. 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, HashMap (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, HashMap (2): 0 : 0, 1 : 1, 2 : 2, 3 : 3, 4 : 4, 5 : 5, 6 : 6, 7 : 7, 8 : 8, 9 : 9, 10 : 10,

Question 21

Java 8에서 가장 컴팩트함:

 map.entrySet().forEach(System.out::println);

Question 22

Java에서 Map 인터페이스를 구현하는 객체가 있고 그 안에 포함된 모든 쌍을 반복하려는 경우 지도를 통과하는 가장 효율적인 방법은 무엇입니까?

키 반복의 효율성이 앱의 우선 순위인 경우 키를 원하는 순서로 유지 Map

요소의 순서는 인터페이스에 대해 가지고 있는 특정 맵 구현에 따라 달라집니까?

네 그럼요.

일부 Map 구현은 특정 반복 순서를 약속하지만 다른 구현은 그렇지 않습니다.
Map 다른 구현은 키-값 쌍의 다른 순서를 유지합니다.

Java 11과 함께 번들로 제공되는 Map 구현을 요약하여 작성한 이 표를 참조하십시오 . 특히 반복 순서 열을 확인하십시오. 클릭/탭하여 확대/축소합니다.

순서를 유지하는 네 가지 Map 구현이 있음을 볼 수 있습니다.

TreeMap
ConcurrentSkipListMap
LinkedHashMap
EnumMap

`NavigableMap` 인터페이스

그 중 두 가지는 NavigableMap 인터페이스를 TreeMap & ConcurrentSkipListMap .

이전 SortedMap 인터페이스는 새로운 NavigableMap 인터페이스로 효과적으로 대체되었습니다. 그러나 이전 인터페이스만 구현하는 타사 구현을 찾을 수 있습니다.

자연의 질서

키의 "자연 순서"에 따라 쌍을 정렬한 상태로 유지하는 Map TreeMap 또는 ConcurrentSkipListMap . "자연 순서"라는 용어는 Comparable 구현하는 키 클래스를 의미합니다. compareTo 메서드에서 반환된 값은 정렬 비교에 사용됩니다.

맞춤 주문

정렬된 순서를 유지하는 데 사용할 키에 대한 사용자 지정 정렬 루틴을 지정하려면 키 클래스에 적절한 Comparator TreeMap 또는 ConcurrentSkipListMap 사용 Comparator 전달합니다.

원본 게재 신청서

지도 쌍을 지도에 삽입한 원래 순서대로 유지하려면 LinkedHashMap 사용하십시오.

열거형 정의 순서

DayOfWeek 또는 Month 와 같은 열거형을 키로 사용하는 경우 EnumMap 클래스를 사용합니다. 이 클래스는 매우 적은 메모리를 사용하고 매우 빠르게 실행되도록 고도로 최적화되어 있을 뿐만 아니라 열거형에서 정의한 순서대로 쌍을 유지합니다. 들어 DayOfWeek , 예를 들어,의 핵심 DayOfWeek.MONDAY 반복 할 때 먼저 발견 할 것이다, 그리고 키 DayOfWeek.SUNDAY 마지막이 될 것입니다.

기타 고려 사항

Map 구현을 선택할 때 다음 사항도 고려하십시오.

NULL 일부 구현에서는 NULL을 키 및/또는 값으로 금지/허용합니다.
동시성. 스레드 간에 맵을 조작하는 경우 동시성을 지원하는 구현을 사용해야 합니다. Collections::synchronizedMap 맵을 래핑합니다(덜 선호).

이 두 가지 고려 사항은 위의 그래픽 표에서 다룹니다.

Question 23

형식이 지정되지 않은 일반 맵이 있는 경우 다음을 사용할 수 있습니다.

 Map map = new HashMap(); for (Map.Entry entry : ((Set<Map.Entry>) map.entrySet())) { System.out.println(entry.getKey() + "/" + entry.getValue()); }

Question 24

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(); } } }

Question 25

 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()); }

Question 26

제네릭을 사용하여 수행할 수 있습니다.

 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()); }

Question 27

자바 8 사용:

 map.entrySet().forEach(entry -> System.out.println(entry.getValue()));

Question 28

Map에 대한 효과적인 반복 솔루션 for 루프입니다. 여기에는 다음이 있습니다.

 for (String key : phnMap.keySet()) { System.out.println("Key: " + key + " Value: " + phnMap.get(key)); }

Java 8에서는 람다 식을 사용하여 Map을 반복할 수 있습니다. 향상된 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"); } });

Question 29

 //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(); }

Question 30

이를 수행하는 방법에는 여러 가지가 있습니다. 다음은 몇 가지 간단한 단계입니다.

다음과 같은 하나의 맵이 있다고 가정합니다.

 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)); }

Question 31

맵을 반복하는 것은 매우 쉽습니다.

 for(Object key: map.keySet()){ Object value= map.get(key); //Do your stuff }

예를 들어 Map<String, int> data;

 for(Object key: data.keySet()){ int value= data.get(key); }

원격 Git 브랜치를 어떻게 생성합니까? (0)	2021.10.09
어떻게 int를 열거형으로 캐스팅할 수 있습니까? (0)	2021.10.09
JavaScript 객체를 올바르게 복제하려면 어떻게 해야 합니까? (0)	2021.10.07
JavaScript 객체에 키가 있는지 확인하시겠습니까? (0)	2021.10.07
기존 Git 분기가 원격 분기를 추적하도록 하시겠습니까? (0)	2021.10.07

No error , No gain

Java Map의 각 항목을 효율적으로 반복하려면 어떻게 해야 합니까?

자바 8

`NavigableMap` 인터페이스

자연의 질서

맞춤 주문

원본 게재 신청서

열거형 정의 순서

기타 고려 사항

'etc. > StackOverFlow' 카테고리의 다른 글

'etc./StackOverFlow'의 다른글

티스토리툴바

Java Map의 각 항목을 효율적으로 반복하려면 어떻게 해야 합니까?

자바 8

NavigableMap 인터페이스

자연의 질서

맞춤 주문

원본 게재 신청서

열거형 정의 순서

기타 고려 사항

'etc. > StackOverFlow' 카테고리의 다른 글

'etc./StackOverFlow'의 다른글

관련글

티스토리툴바

`NavigableMap` 인터페이스