안에 - list map string string in java

Java 8 사용 :

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

Java 8에서는 link 을 허용하는 forEach 메서드가 있습니다. stream 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() 을 사용하기 만하면됩니다.

Java 8에서는 새로운 lambdas 기능을 사용하여 빠르고 깨끗하게 처리 할 수 ​​있습니다.

 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 를 사용할 필요가 없습니다.

쉬워요!

반복자 및 제네릭 사용 예제 :

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

순서는 항상 특정 맵 구현에 따라 다릅니다. Java 8을 사용하면 다음 중 하나를 사용할 수 있습니다.

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

또는:

map.entrySet().forEach((e) -> {
            System.out.println(e.getKey() + " : " + e.getValue());
        });

결과는 동일합니다 (동일한 순서). 동일한 순서를 얻으므로 entrySet은 맵에 의해 뒷받침됩니다. 두 번째 방법은 람다 (lambda)를 사용할 수 있기 때문에 편리합니다. 예를 들어 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, # 9, # 9, # 8, # 8, # 7, # 7 : 7,6 (# 6) : 6, 5 1, 0 (# = 1) : 0, # 1, # 2, # 3,

LinkedHashMap (2) :

10 : 10, 9 : 9, 8 : 8, 7 : 7, 6 : 6, 5 : 5, 4 : 4, 3 : 3, 2 : 2, 1 : 1,

HashMap (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) :

1 : 1, 2 : 2, 3 : 3, 4 : 4, 5 : 5, 6 : 6, 7 : 7,8 : 8,9 : 9,10 :

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

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

맵의 엔트리를 반복하는 방법 - @ ScArcher2가 완벽하게 answered 했습니다.

반복의 순서는 무엇입니까 - 당신이 Map 만을 사용하고 있다면 엄밀히 말하면 주문 보증 은 없습니다 . 따라서 어떤 구현에 의해 주어진 순서에 실제로 의존해서는 안됩니다. 그러나 SortedMap 인터페이스는 Map 확장하고 사용자가 찾고있는 것을 정확하게 제공합니다. 구현은 일관된 정렬 순서를 제공합니다.

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

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

다음과 같이 하나의지도가 있다고 가정 해보십시오.

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 (String key: map.keySet()) {
   System.out.println(key + "/" + map.get(key));
}

자바 1.4에서 이것을 사용해보십시오 :

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

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

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

지도를 반복하는 일반적인 코드는 다음과 같습니다.

Map<String,Thing> map = ...;
for (Map.Entry<String,Thing> entry : map.entrySet()) {
    String key = entry.getKey();
    Thing thing = entry.getValue();
    ...
}

HashMap 는 표준지도 구현이며 보장하지 않습니다 (또는 변형 작업이 수행되지 않으면 순서를 변경하면 안 됨). SortedMap 는 키의 자연 순서 SortedMap Comparator 제공된 경우)를 기반으로 항목을 리턴합니다. LinkedHashMap 는, 작성 방법에 응해, 삽입 순서 또는 액세스 순서로 엔트리를 돌려줍니다. EnumMap 은 자연 순서로 항목을 반환합니다.

(Update : 더 이상 사실이 아닙니다. ) 참고로, IdentityHashMap entrySet iterator는 현재 entrySet 모든 항목에 대해 동일한 Map.Entry 인스턴스를 반환하는 고유 한 구현을 가지고 있습니다! 그러나 이터레이터가 새로운 것이 될 때마다 Map.Entry 가 업데이트됩니다.

지도에서 keys 및 / 또는 values 및 / 또는 both (eg, entrySet) 대한 반복 both (eg, entrySet) 은 관심있는 in_에 따라 달라질 수 있습니다. 좋아요 :

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

Eclipse Collections (이전의 GS Collections )에서는 MapIterable 인터페이스에서 forEachKeyValue 메소드를 사용합니다.이 메소드는 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 Collections에 대한 커미터입니다.

Java 8 :

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

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

자세한 내용은 다음을 참조 this .

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

            }

    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<String, String> map = ...
for (Map.Entry<String, String> entry : map.entrySet())
{
    System.out.println(entry.getKey() + "/" + 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));
    }
}