Java Map의 각 엔트리에 대해 효율적으로 반복하려면 어떻게 해야 합니까?

programing

Java Map의 각 엔트리에 대해 효율적으로 반복하려면 어떻게 해야 합니까?

prostudy 2022. 7. 29. 22:15

Java Map의 각 엔트리에 대해 효율적으로 반복하려면 어떻게 해야 합니까?

「」를 실장하고 있는 가 있는 .Map자바에서 인터페이스를 사용하고 그 안에 포함된 모든 쌍에 대해 반복하고 싶습니다. 맵을 통과하는 가장 효율적인 방법은 무엇입니까?

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

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

Java 10+의 경우:

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

foreach와 Map을 사용합니다.엔트리

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

Java 8에서 각 for Each 사용

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

및 맵에 사용.엔트리

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

ItableMap 사용방법Apache Collections

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

이클립스(CS) 컬렉션의 MutableMap 사용

final long[] i = {0};
mutableMap.forEachKeyValue((key, value) -> {
    i[0] += key + value;
});

성능 테스트 (모드 = 평균 시간, 시스템 = Windows 8.1 64비트, 인텔 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에서 진행됩니다.

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★★★★★★★★★★★★★★★★★★.

간단해!

네, 순서는 특정 맵 구현에 따라 달라집니다.

@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 "Natural Overything"은 "Natural Overything"입니다.또는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엄밀히 말하면, 주문 보장은 없습니다.따라서 어떤 구현이든 주어진 순서에 의존해서는 안 됩니다.단, 인터페이스는 확장됩니다.Map또, 고객이 원하는 것을 정확하게 제공할 수 있습니다.실장에서는 항상 일관된 정렬 순서가 부여됩니다.

NavigableMap 또 하나의 편리한 확장입니다.이것은SortedMap키 세트의 순서 위치에 따라 엔트리를 검색하는 추가 방법을 제공합니다. 수 을 알 수 거예요.을 사용법entry 후 입니다.higherEntry,lowerEntry,ceilingEntry , 「」floorEntry★★★★★★★★★★★★★★★★★.descendingMapmethod는 트래버설 순서를 반전하는 명시적인 메서드도 제공합니다.

지도상에서 반복하는 방법에는 몇 가지가 있습니다.

다음은 지도에 백만 개의 키 값 쌍을 저장하여 지도에 저장된 공통 데이터 세트에 대한 성능 비교입니다. 지도에서 반복됩니다.

사용 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 밀리초

을 참조했습니다.

「」를 사용할 수도 있습니다.map.keySet() ★★★★★★★★★★★★★★★★★」map.values()지도의 키/값에만 관심이 있고 다른 키/값에는 관심이 없는 경우.

올바른 방법은 가장 효율적이기 때문에 승인된 답변을 사용하는 것입니다.다음 코드가 좀 더 깔끔해 보입니다.

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

Java 8에서는 Each 식과 lamda 식을 사용하여 Map을 반복할 수 있습니다.

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

이클립스 컬렉션에서는forEachKeyValue에 의해 상속되는 인터페이스상의 메서드MutableMap ★★★★★★★★★★★★★★★★★」ImmutableMap인터페이스와 그 실장.

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의 커밋입니다.

이론적으로 가장 효율적인 방법은 맵의 어떤 구현에 따라 달라집니다. 방법은 '아까부터'라고 하는 입니다.map.entrySet()Map.Entry즉, 키와 값)이 되어 있습니다entry.getKey() ★★★★★★★★★★★★★★★★★」entry.getValue()를 참조해 주세요.

에서는, 「」, 「」, 「」, 「」의 어느쪽인가를 에 따라 가 생기는 가 있습니다.map.keySet(),map.entrySet() 왜 이 안 나요.★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★대부분의 경우 퍼포먼스에 차이가 없습니다.

또한 순서는 구현 순서와 삽입 순서 및 제어하기 어려운 기타 요인에 따라 달라집니다.

[] 쓰다valueSet(), entrySet()사실 정답입니다.

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

엔트리에 반복(각 및 스트림에 사용):

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()abovedisclossible을 합니다.

forEachOrdered 스트림과 비교합니까?그forEach 조우 순서되어 있는 경우)에 따르지 않고, 입니다.이 경우, (조우 순서는 정의되어 있는 경우)는 인 것입니다.forEachOrdered 그래서.forEach주문이 유지된다는 보장은 없습니다.자세한 내용은 이 항목도 확인하십시오.

람다 표현 Java 8

Java 1.8(Java 8)에서는 반복 가능한 인터페이스의 반복기와 유사한 Aggregate 작업(Stream 작업)의 각 메서드를 사용함으로써 이 작업이 훨씬 쉬워졌습니다.

아래 문장을 코드에 복사하여 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.

다음은 람다 익스프레션을 사용해 본 샘플 코드입니다.이 물건들 정말 멋지다.시도해야 한다.

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에 대한 문서 링크 포함.Lambda에 대한 자세한 내용은 이 링크로 이동하여 Aggregate Operations를 읽어야 하며, 스플리테이터의 경우 이 링크로 이동하십시오.

Java 8:

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

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

자세한 내용은 다음을 참조하십시오.

에서는, 「 over 」를 할 수 .keys "/"/"values "/"/"both (e.g., entrySet)이치노

지도에서 반복합니다.

 Map<String, Object> map = ...;

 for (String key : map.keySet()) {
     //your Business logic...
 }

지도에서 반복합니다.

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

지도에서 반복합니다.

 for (Map.Entry<String, Object> entry : map.entrySet()) {
     String key = entry.getKey();
     Object value = entry.getValue();
     //your Business logic...
 }

또한 해시맵을 통해 반복하는 방법에는 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 1.4에서 다음을 시도해 보십시오.

for( Iterator entries = myMap.entrySet().iterator(); entries.hasNext();){

  Entry entry = (Entry) entries.next();

  System.out.println(entry.getKey() + "/" + 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,
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,

Java 8을 탑재한 가장 콤팩트한 제품:

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

자바에서 맵인터페이스를 구현하고 있는 오브젝트가 있고 그 오브젝트에 포함된 모든 페어에 대해 반복하고 싶은 경우 맵을 통과하는 가장 효율적인 방법은 무엇입니까?

인 경우 를 합니다.Map원하는 순서대로 키를 유지하는 구현입니다.

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

네, 물론입니다.

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

이 여러 가지 요.MapJava 11에 번들된 구현입니다.특히 반복 순서 열에 주의하십시오.클릭하여 확대/축소합니다.

오더를 유지하는 실장은 다음 4가지가 있습니다.

TreeMap
ConcurrentSkipListMap
LinkedHashMap
EnumMap

`NavigableMap`

그 중 2개는 인터페이스를 실장합니다.TreeMap&ConcurrentSkipListMap

오래된 인터페이스가 새로운 인터페이스에 의해 실질적으로 대체됩니다.다만, 서드파티제의 실장에서는, 낡은 인터페이스만을 실장하고 있는 경우가 있습니다.

자연질서

키의 "자연 순서"에 따라 쌍을 정렬한 상태로 유지하려면 또는 를 사용합니다."자연질서"란 열쇠 도구의 종류를 말한다.메서드에서 반환되는 값은 정렬 비교에 사용됩니다.

커스텀 오더

정렬된 순서를 유지하는 데 사용할 키의 사용자 지정 정렬 루틴을 지정하려면 키 클래스에 적합한 구현을 전달합니다.또는 를 사용하여 다음 중 하나를 전달합니다.Comparator

원래 삽입 순서

맵 쌍이 맵에 삽입된 원래 순서로 유지되도록 하려면 를 사용합니다.

열거 정의 순서

또는 키와 같은 열거형을 사용하는 경우 클래스를 사용합니다.이 클래스는 메모리를 거의 사용하지 않고 매우 빠르게 실행되도록 고도로 최적화되어 있을 뿐만 아니라 열거형으로 정의된 순서대로 쌍을 유지합니다.위해서DayOfWeek 키 「」, 「」DayOfWeek.MONDAY때 되며, 키 키(키)는 '키(키)'입니다.DayOfWeek.SUNDAY꼴찌가 될 거예요.

기타 고려사항

할 때Map 현,, 다음음음음음음 implement implement implement implement implement implement implement implement implement implement implement implement implement implement implement.

NULL. 일부 구현에서는 NULL을 키 및/또는 값으로 금지/수용합니다.
동시성스레드 전체에서 맵을 조작하는 경우 동시성을 지원하는 구현을 사용해야 합니다.또는 (적절)로 맵을 감습니다.

위의 두 가지 고려사항은 모두 위의 그래픽 표에 설명되어 있습니다.

일반적인 비입력 맵이 있는 경우 다음을 사용할 수 있습니다.

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

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

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

Java 8 사용:

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

맵에 대한 효과적인 반복 솔루션은forJava 5 서로 Java 7 로 java java java 。기기있있있있다다

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

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

            }

이렇게 하는 방법은 여러 가지가 있습니다.다음은 몇 가지 간단한 단계입니다.

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

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

지도를 반복하는 것은 매우 쉽습니다.

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

언급URL : https://stackoverflow.com/questions/46898/how-do-i-efficiently-iterate-over-each-entry-in-a-java-map

저작자표시 (새창열림)

'programing' 카테고리의 다른 글

VueJ가 어레이의 개체에 이 속성이 추가되었음을 감지하는 이유는 무엇입니까? (0)	2022.07.29
_t(언더스코어-t) 뒤에 이어지는 유형은 무엇을 나타냅니까? (0)	2022.07.29
Java의 객체와 같은 구조 (0)	2022.07.29
Vuex 알 수 없는 작업 유형...동작이 로딩되지 않음 (0)	2022.07.29
페이지를 갱신할 때 Vuex 및 VueRouter에서 글로벌 상태가 손실되지 않도록 합니다. (0)	2022.07.28

현재글Java Map의 각 엔트리에 대해 효율적으로 반복하려면 어떻게 해야 합니까?

각종 프로그래밍 정보를 다루는 블로그입니다.

C, 공연, vuejs2, react-hooks, Vue-Router, python-2, Rxjs, react-redux, VUE, react-router, react-native, vuetify, python-3, vuex, java, vue-component, Python, TypeScript, 전시, Reactjs,

Today :
Yesterday :

prostudy

Java Map의 각 엔트리에 대해 효율적으로 반복하려면 어떻게 해야 합니까?

Java Map의 각 엔트리에 대해 효율적으로 반복하려면 어떻게 해야 합니까?

자바 8

`NavigableMap`

자연질서

커스텀 오더

원래 삽입 순서

열거 정의 순서

기타 고려사항

'programing' 카테고리의 다른 글

'programing'의 다른글

티스토리툴바

« 2025/07 »
일	월	화	수	목	금	토
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31

Java Map의 각 엔트리에 대해 효율적으로 반복하려면 어떻게 해야 합니까?

Java Map의 각 엔트리에 대해 효율적으로 반복하려면 어떻게 해야 합니까?

자바 8

NavigableMap

자연질서

커스텀 오더

원래 삽입 순서

열거 정의 순서

기타 고려사항

'programing' 카테고리의 다른 글

'programing'의 다른글

관련글

티스토리툴바

`NavigableMap`