Java Language
지도

소개

비고

요소 추가

1. 부가

Map<Integer, String> map = new HashMap<>();
map.put(1, "First element."); 
System.out.println(map.get(1));

출력 : First element.

2. 보수

Map<Integer, String> map = new HashMap<>();
map.put(1, "First element.");
map.put(1, "New element.");
System.out.println(map.get(1));

출력 : New element.

HashMap 이 예제로 사용됩니다. Map 인터페이스를 구현하는 다른 구현도 사용할 수 있습니다.

여러 항목 추가

V put(K key,V value) 사용할 수 있습니다.

이 맵 내의 지정된 키에 지정된 값을 관련 짓습니다 (옵션). 지도에 이전에 키에 대한 매핑이 포함 된 경우 이전 값이 지정된 값으로 대체됩니다.

String currentVal;
Map<Integer, String> map = new TreeMap<>();
currentVal = map.put(1, "First element.");
System.out.println(currentVal);// Will print null
currentVal = map.put(2, "Second element.");
System.out.println(currentVal); // Will print null yet again    
currentVal = map.put(2, "This will replace 'Second element'");
System.out.println(currentVal); // will print Second element.
System.out.println(map.size()); // Will print 2 as key having
// value 2 was replaced.

Map<Integer, String> map2 = new HashMap<>();
map2.put(2, "Element 2");
map2.put(3, "Element 3");

map.putAll(map2);

System.out.println(map.size());  

산출:

3

많은 항목을 추가하려면 다음과 같은 내부 클래스를 사용할 수 있습니다.

Map<Integer, String> map = new HashMap<>() {{
    // This is now an anonymous inner class with an unnamed instance constructor
    put(5, "high");
    put(4, "low");
    put(1, "too slow");
}};

익명의 내부 클래스를 만드는 것은 항상 효율적이지는 않으며 메모리 누수가 발생할 수 있으므로 가능한 경우 초기화 도구 블록을 사용하십시오.

static Map<Integer, String> map = new HashMap<>();

static {
    // Now no inner classes are created so we can avoid memory leaks
    put(5, "high");
    put(4, "low");
    put(1, "too slow");
}

위의 예는지도를 정적으로 만듭니다. 또한 모든 static 항목을 제거하여 비 정적 컨텍스트에서 사용할 수도 있습니다.

그 외에도 대부분의 구현은 putAll 지원합니다. putAll 은 한 맵의 모든 항목을 다음과 같이 다른 맵에 추가 할 수 있습니다.

another.putAll(one);

Java 8에서 Map의 기본 메소드 사용하기

맵 인터페이스의 Java 8에 도입 된 기본 메소드 사용의 예

1. getOrDefault 사용 하기

키에 매핑 된 값을 반환하거나 키가 없으면 기본값을 반환합니다.

Map<Integer, String> map = new HashMap<>();
map.put(1, "First element");
map.get(1);                                 // => First element
map.get(2);                                 // => null
map.getOrDefault(2, "Default element");     // => Default element

2. forEach 사용하기

각지도 엔트리에서 '동작'에 지정된 작업을 수행 할 수 있습니다.

  Map<Integer, String> map = new HashMap<Integer, String>();
  map.put(1, "one");
  map.put(2, "two");
  map.put(3, "three");
  map.forEach((key, value) -> System.out.println("Key: "+key+ " :: Value: "+value));

   // Key: 1 :: Value: one
   // Key: 2 :: Value: two
   // Key: 3 :: Value: three

3. replaceAll을 사용하여

키가있는 경우에만 새 값으로 대체됩니다.

 Map<String, Integer> map = new HashMap<String, Integer>();
 map.put("john", 20);
 map.put("paul", 30);
 map.put("peter", 40);
 map.replaceAll((key,value)->value+10);   //{john=30, paul=40, peter=50}

4. putIfAbsent 사용하기

키가 없거나 null로 매핑 된 경우 키 - 값 쌍이 맵에 추가됩니다.

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    map.putIfAbsent("kelly", 50);     //{john=20, paul=30, peter=40, kelly=50}

5. 제거 사용

   지정된 값에 관련 지을 수 있고있는 경우에게만 키를 삭제합니다.

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    map.remove("peter",40); //{john=30, paul=40}
   

6. 바꾸기 사용

   키가있는 경우 값은 새 값으로 대체됩니다. 키가 없으면 아무 것도하지 않습니다.

Map<String, Integer> map = new HashMap<String, Integer>();
map.put("john", 20);
map.put("paul", 30);
map.put("peter", 40);
map.replace("peter",50); //{john=20, paul=30, peter=50}
map.replace("jack",60); //{john=20, paul=30, peter=50}

7. computeIfAbsent 사용 하기

이 메소드는 맵에 항목을 추가합니다. 키는 함수에 지정되고 값은 맵핑 함수의 적용 결과입니다

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    map.computeIfAbsent("kelly", k->map.get("john")+10); //{john=20, paul=30, peter=40, kelly=30}
    map.computeIfAbsent("peter", k->map.get("john")+10); //{john=20, paul=30, peter=40, kelly=30} //peter already present

8. computeIfPresent 사용 하기

이 메소드는 항목을 추가하거나 맵의 기존 항목을 수정합니다. 그 키를 가지는 엔트리가 존재하지 않는 경우는 아무것도 실시하지 않습니다.

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    map.computeIfPresent("kelly", (k,v)->v+10); //{john=20, paul=30, peter=40} //kelly not present
    map.computeIfPresent("peter", (k,v)->v+10); //{john=20, paul=30, peter=50} // peter present, so increase the value 

9. 계산 사용

이 메소드는 키 값을 새로 계산 된 값으로 대체합니다.

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    map.compute("peter", (k,v)->v+50); //{john=20, paul=30, peter=90} //Increase the value 

10. 병합 사용

키가 존재하지 않는지, 키의 값이 null의 경우, 맵에 키와 값의 페어를 추가합니다. 키가 존재하는 경우, 값을 새롭게 계산 된 값으로 옮겨 놓습니다. 계산 된 새로운 값이 null의 경우, 맵으로부터 키가 삭제됩니다.

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    
    //Adds the key-value pair to the map, if key is not present or value for the key is null
    map.merge("kelly", 50 , (k,v)->map.get("john")+10); // {john=20, paul=30, peter=40, kelly=50}
    
    //Replaces the value with the newly computed value, if the key is present
    map.merge("peter", 50 , (k,v)->map.get("john")+10); //{john=20, paul=30, peter=30, kelly=50}
   
    //Key is removed from the map , if new value computed is null
    map.merge("peter", 30 , (k,v)->map.get("nancy")); //{john=20, paul=30, kelly=50}

지도 지우기

Map<Integer, String> map = new HashMap<>();

map.put(1, "First element.");
map.put(2, "Second element.");
map.put(3, "Third element.");

map.clear();

System.out.println(map.size());   // => 0

지도의 내용 반복하기

지도는지도의 키, 값 또는 키 - 값 쌍에 컬렉션으로 액세스 할 수있는 메소드를 제공합니다. 이러한 컬렉션을 반복 할 수 있습니다. 예를 들어 다음과 같은지도가 주어진다 :

Map<String, Integer> repMap = new HashMap<>();
repMap.put("Jon Skeet", 927_654);
repMap.put("BalusC", 708_826);
repMap.put("Darin Dimitrov", 715_567);

지도 키 반복하기 :

for (String key : repMap.keySet()) {
    System.out.println(key);
}

인쇄물:

다린 디미트로프
존 스켓
발루 스 C

keySet() 은 맵의 키를 Set 으로 제공합니다. 키는 중복 값을 포함 할 수 없기 때문에 Set 이 사용됩니다. 집합을 반복하면 각 키가 순서대로 산출됩니다. HashMaps는 순서 붙일 수 있지 않기 때문에,이 예에서는 키가 임의의 순서로 돌려 주어질 가능성이 있습니다.

지도 값 반복 :

for (Integer value : repMap.values()) {
    System.out.println(value);
}

인쇄물:

715567
927654
708826

values() 는지도 값을 Collection 으로 반환합니다. 컬렉션을 반복하면 차례대로 각 값이 산출됩니다. 다시, 값은 임의의 순서로 리턴 될 수 있습니다.

키와 값을 함께 반복하기

for (Map.Entry<String, Integer> entry : repMap.entrySet()) {
    System.out.printf("%s = %d\n", entry.getKey(), entry.getValue());
}

인쇄물:

다린 디미트로프 = 715567
Jon Skeet = 927654
BalusC = 708826

entrySet() 은 Map.Entry 객체의 컬렉션을 반환합니다. Map.Entry는 각 항목의 키와 값에 대한 액세스를 제공합니다.

지도 병합, 결합 및 작성

putAll 을 사용하여지도의 모든 구성원을 다른지도에 배치하십시오. 지도에 이미있는 키는 해당 값을 덮어 씁니다.

Map<String, Integer> numbers = new HashMap<>();
numbers.put("One", 1)
numbers.put("Three", 3)
Map<String, Integer> other_numbers = new HashMap<>();
other_numbers.put("Two", 2)
other_numbers.put("Three", 4)

numbers.putAll(other_numbers)

그러면 numbers 다음과 같은 매핑이 생성 numbers .

"One" -> 1
"Two" -> 2
"Three" -> 4 //old value 3 was overwritten by new value 4

값을 덮어 쓰는 대신 값을 결합하려는 경우 사용자 제공 BiFunction 을 사용하여 중복 키 값을 병합하는 Java 8에서 추가 된 Map.merge 를 사용할 수 있습니다. merge 은 개별 키와 값에서 작동하므로 루프 또는 Map.forEach 를 사용해야합니다. 여기에 중복 된 키에 대한 문자열을 연결합니다.

for (Map.Entry<String, Integer> e : other_numbers.entrySet())
    numbers.merge(e.getKey(), e.getValue(), Integer::sum);
//or instead of the above loop
other_numbers.forEach((k, v) -> numbers.merge(k, v, Integer::sum));

제약 조건을 적용하려면 중복 키가 없으면 AssertionError 를 throw하는 병합 함수를 사용할 수 있습니다.

mapA.forEach((k, v) ->
    mapB.merge(k, v, (v1, v2) ->
        {throw new AssertionError("duplicate values for key: "+k);}));

Map <X, Y>와 Map <Y, Z>의 합성에 의해 Map <X, Z>

두 개의 매핑을 작성하려는 경우 다음과 같이 수행 할 수 있습니다.

    Map<String, Integer> map1 = new HashMap<String, Integer>();
    map1.put("key1", 1);
    map1.put("key2", 2);
    map1.put("key3", 3);
    
    Map<Integer, Double> map2 = new HashMap<Integer, Double>();
    map2.put(1, 1.0);
    map2.put(2, 2.0);
    map2.put(3, 3.0);

    Map<String, Double> map3 = new new HashMap<String, Double>();
    map1.forEach((key,value)->map3.put(key,map2.get(value)));

그러면 다음 매핑이 생성됩니다.

    "key1" -> 1.0
    "key2" -> 2.0
    "key3" -> 3.0

키가 있는지 확인하십시오.

Map<String, String> num = new HashMap<>();
num.put("one", "first");

if (num.containsKey("one")) {
    System.out.println(num.get("one")); // => first
}

지도에는 null 값이 포함될 수 있습니다.

지도의 경우 "열쇠 포함"과 "가치있는"을 혼동하지 않도록주의해야합니다. 예를 들어, HashMap 에는 null가 포함될 수가 있습니다. 이것은, 이하가 완전하게 정상적으로 동작하고있는 것을 나타냅니다.

Map<String, String> map = new HashMap<>();
map.put("one", null);
if (map.containsKey("one")) {
    System.out.println("This prints !"); // This line is reached 
}
if (map.get("one") != null) {
    System.out.println("This is never reached !"); // This line is never reached 
}

보다 공식적으로 map.contains(key) <=> map.get(key)!=null 이라는 보장은 없습니다 map.contains(key) <=> map.get(key)!=null

효율적으로 맵 엔트리 반복하기

이 절에서는 Map<Integer, Integer> 의 항목을 반복하고 Integer 값의 합계를 생성하는 10 개의 고유 한 예제 구현에 대한 코드 및 벤치 마크를 제공합니다. 모든 예제는 알고리즘의 복잡성이 Θ(n) 이지만 벤치 마크는 "실제"환경에서 어떤 구현이 더 효율적인지에 대한 통찰력을 제공하는 데 여전히 유용합니다.

1. Map.Entry 사용하는 Iterator 를 사용한 구현

    Iterator<Map.Entry<Integer, Integer>> it = map.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry<Integer, Integer> pair = it.next();
        sum += pair.getKey() + pair.getValue();
    }

2. Map.Entry 사용하여 for 를 사용하여 구현

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

3. Map.forEach (Java 8 이상)를 사용하여 구현

    map.forEach((k, v) -> sum[0] += k + v);

4. for 와 함께 Map.keySet 을 사용하여 구현

    for (Integer key : map.keySet()) {
        sum += key + map.get(key);
    }

5. Iterator 사용하여 Map.keySet 을 사용하여 구현

    Iterator<Integer> it = map.keySet().iterator();
    while (it.hasNext()) {
        Integer key = it.next();
        sum += key + map.get(key);
    }

6. for Iterator 및 Map.Entry 사용한 구현

    for (Iterator<Map.Entry<Integer, Integer>> entries = 
             map.entrySet().iterator(); entries.hasNext(); ) {
        Map.Entry<Integer, Integer> entry = entries.next();
        sum += entry.getKey() + entry.getValue();
    }

7. Stream.forEach (Java 8 이상)를 사용하여 구현

    map.entrySet().stream().forEach(e -> sum += e.getKey() + e.getValue());

8. Stream.forEach 를 Stream.parallel (Java 8 이상)과 함께 사용하여 구현

    map.entrySet()
       .stream()
       .parallel()
       .forEach(e -> sum += e.getKey() + e.getValue());

9. Apache 컬렉션 에서 IterableMap 을 사용하여 구현

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

10. 이클립스 컬렉션 에서 MutableMap 을 사용하여 구현

     mutableMap.forEachKeyValue((key, value) -> {
         sum += key + value;
     });

성능 테스트 ( Github에서 사용 가능한 코드 )
테스트 환경 : Windows 8.1 64 비트, Intel i7-4790 3.60GHz, 16GB

1. 10 가지 시도 (100 가지 요소)의 평균 성능 최고 : 308 ± 21ns / op

   Benchmark                           Score     Error  Units
   test3_UsingForEachAndJava8            308  ±     21  ns/op
   test10_UsingEclipseMutableMap         309  ±      9  ns/op
   test1_UsingWhileAndMapEntry           380  ±     14  ns/op
   test6_UsingForAndIterator             387  ±     16  ns/op
   test2_UsingForEachAndMapEntry         391  ±     23  ns/op
   test7_UsingJava8StreamAPI             510  ±     14  ns/op
   test9_UsingApacheIterableMap          524  ±      8  ns/op
   test4_UsingKeySetAndForEach           816  ±     26  ns/op
   test5_UsingKeySetAndIterator          863  ±     25  ns/op
   test8_UsingJava8StreamAPIParallel    5552  ±    185  ns/op
   

2. 10 가지 시도 (10000 가지 요소)의 평균 성능 최고 : 37.606 ± 0.790μs / op

   Benchmark                           Score     Error  Units
   test10_UsingEclipseMutableMap       37606  ±    790  ns/op
   test3_UsingForEachAndJava8          50368  ±    887  ns/op
   test6_UsingForAndIterator           50332  ±    507  ns/op
   test2_UsingForEachAndMapEntry       51406  ±   1032  ns/op
   test1_UsingWhileAndMapEntry         52538  ±   2431  ns/op
   test7_UsingJava8StreamAPI           54464  ±    712  ns/op
   test4_UsingKeySetAndForEach         79016  ±  25345  ns/op
   test5_UsingKeySetAndIterator        91105  ±  10220  ns/op
   test8_UsingJava8StreamAPIParallel  112511  ±    365  ns/op
   test9_UsingApacheIterableMap       125714  ±   1935  ns/op
   

3. 10 가지 시도 (100000 요소)의 평균 성능 최고 : 1184.767 ± 332.968 μs / op

   Benchmark                            Score       Error  Units
   test1_UsingWhileAndMapEntry       1184.767  ±  332.968  μs/op
   test10_UsingEclipseMutableMap     1191.735  ±  304.273  μs/op
   test2_UsingForEachAndMapEntry     1205.815  ±  366.043  μs/op
   test6_UsingForAndIterator         1206.873  ±  367.272  μs/op
   test8_UsingJava8StreamAPIParallel 1485.895  ±  233.143  μs/op
   test5_UsingKeySetAndIterator      1540.281  ±  357.497  μs/op
   test4_UsingKeySetAndForEach       1593.342  ±  294.417  μs/op
   test3_UsingForEachAndJava8        1666.296  ±  126.443  μs/op
   test7_UsingJava8StreamAPI         1706.676  ±  436.867  μs/op
   test9_UsingApacheIterableMap      3289.866  ± 1445.564  μs/op
   

4. 맵 크기에 따른 성능 변화 비교

       x: Size of Map
    f(x): Benchmark Score (μs/op)

                 100      600     1100     1600     2100
        ---------------------------------------------------
        10  |   0.333    1.631    2.752    5.937    8.024
         3  |   0.309    1.971    4.147    8.147   10.473
         6  |   0.372    2.190    4.470    8.322   10.531
         1  |   0.405    2.237    4.616    8.645   10.707
Tests    2  |   0.376    2.267    4.809    8.403   10.910
 f(x)    7  |   0.473    2.448    5.668    9.790   12.125
         9  |   0.565    2.830    5.952    13.22   16.965
         4  |   0.808    5.012    8.813    13.939  17.407
         5  |   0.81     5.104    8.533    14.064  17.422
         8  |   5.173   12.499   17.351    24.671  30.403

사용자 지정 개체를 키로 사용

자신의 객체를 키로 사용하기 전에 객체의 hashCode () 및 equals () 메서드를 재정의해야합니다.

간단한 경우에는 다음과 같이됩니다.

class MyKey {
    private String name;
    MyKey(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {            
        if(obj instanceof MyKey) {
            return this.name.equals(((MyKey)obj).name);
        }
        return false;
    }
    
    @Override
    public int hashCode() {
        return this.name.hashCode();
    }
}

hashCode 는 키가 속한 해시 버킷을 결정하고 equals 는 해시 버킷 안에 어떤 객체를 결정합니다.

이 메소드가 없으면 위의 비교에 오브젝트 참조가 사용되며, 매번 동일한 오브젝트 참조를 사용하지 않으면 작동하지 않습니다.

HashMap의 사용법

HashMap은 키 - 값 쌍에 데이터를 저장하는 데이터 구조를 제공하는 Map 인터페이스의 구현입니다.

1. HashMap 선언하기

Map<KeyType, ValueType> myMap = new HashMap<KeyType, ValueType>();

KeyType 및 ValueType은 String, Integer, Float 또는 Employee, Student 등의 모든 사용자 정의 클래스와 같이 Java에서 유효한 유형이어야합니다.

예 : Map<String,Integer> myMap = new HashMap<String,Integer>();

2. HashMap에 값을 두는 것.

HashMap에 값을 넣으려면 Key와 Value를 매개 변수로 전달하여 HashMap 객체에 put 메서드를 호출해야합니다.

myMap.put("key1", 1);
myMap.put("key2", 2);

Map에 이미있는 Key를 사용하여 put 메소드를 호출하면 메소드는 해당 값을 대체하고 이전 값을 리턴합니다.

3. HashMap에서 값 가져 오기.

HashMap에서 값을 get 키를 매개 변수로 전달하여 get 메서드를 호출해야합니다.

myMap.get("key1");    //return 1 (class Integer)

HashMap에 존재하지 않는 키를 건네주는 경우,이 메소드는 null 를 돌려 null

4. 키가 맵에 있는지 확인하십시오.

myMap.containsKey(varKey);

5. 값이 맵에 있는지 확인하십시오.

myMap.containsValue(varValue);

위의 방법은 반환 boolean 키, 값이지도의 여부 존재하는 경우 true 또는 false 값입니다.

지도 만들기 및 초기화

소개

Maps 에는 키 / 값 쌍이 저장되며 각 키에는 연결된 값이 있습니다. 특정 키가 주어지면 맵은 연관된 값을 매우 빨리 찾을 수 있습니다.

연관 배열이라고도하는 Maps 는 데이터를 키와 값의 형태로 저장하는 객체입니다. Java에서 맵은 콜렉션 인터페이스의 확장이 아닌 맵 인터페이스를 사용하여 표시됩니다.

• 방법 1 : -

   /*J2SE < 5.0*/
   Map map = new HashMap();
   map.put("name", "A");
   map.put("address", "Malviya-Nagar");
   map.put("city", "Jaipur");
   System.out.println(map);
  

• 방법 2 : -

   /*J2SE 5.0+ style (use of generics):*/
   Map<String, Object> map = new HashMap<>();
   map.put("name", "A");
   map.put("address", "Malviya-Nagar");
   map.put("city", "Jaipur");
   System.out.println(map);
  

• 방법 3 : -

    Map<String, Object> map = new HashMap<String, Object>(){{
        put("name", "A");
        put("address", "Malviya-Nagar");
        put("city", "Jaipur");
    }};
    System.out.println(map);
  

• 방법 4 : -

    Map<String, Object> map = new TreeMap<String, Object>();
        map.put("name", "A");
        map.put("address", "Malviya-Nagar");
        map.put("city", "Jaipur");
    System.out.println(map);
  

• 방법 5 : -

    //Java 8
    final Map<String, String> map =
        Arrays.stream(new String[][] {
            { "name", "A" }, 
            { "address", "Malviya-Nagar" }, 
            { "city", "jaipur" },
        }).collect(Collectors.toMap(m -> m[0], m -> m[1]));
    System.out.println(map);
  

• 방법 6 : -

    //This way for initial a map in outside the function
    final static Map<String, String> map;
    static
    {
        map = new HashMap<String, String>();
        map.put("a", "b");
        map.put("c", "d");
    }
  

• Way 7 : - 변경 불가능한 단일 키 - 값지도 만들기.

      //Immutable single key-value map
      Map<String, String> singletonMap = Collections.singletonMap("key", "value");
  

  이러한지도는 수정할 수 없습니다 .

  맵을 변경하려고하면 (자), UnsupportedOperationException가 Throw됩니다.

      //Immutable single key-value pair
      Map<String, String> singletonMap = Collections.singletonMap("key", "value");
      singletonMap.put("newKey", "newValue"); //will throw UnsupportedOperationException
      singletonMap.putAll(new HashMap<>()); //will throw UnsupportedOperationException
      singletonMap.remove("key"); //will throw UnsupportedOperationException
      singletonMap.replace("key", "value", "newValue"); //will throw UnsupportedOperationException
      //and etc