[자바 공부] 컬렉션(5) Map

Map

• 키와 값이 한쌍으로 이루어진 자료구조
• Collection 인터페이스를 구현한 클래스와는 다르게 동작한다.
• 요소들을 반복 처리할 때 Map에 따라 추가 / 접근시간에 있어 약간의 차이가 있다.

Map 종류

HashMap	순서를 보장하지 않는 Hashing 방식의 Map
TreeMap	정렬에 따른 순서를 보장하는 RedBlack Tree 형태의 Map
LinkedHashMap	추가대로 입력되는 순서를 보장하는 LinkedList 형태의 Map

HashMap 예시

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class HashMapStudy {
    public static void main(String[] args) {
        HashMap<String,String> mapH = new HashMap<String,String>(); // 타입 지정
        // HashMap mapH = new HashMap(); // 디폴트는 Object타입의 키와 값

        // 요소 추가
        mapH.put("키1","값1");
        mapH.put("키2","값2");
        mapH.put("키3","값3");
        // 요소 접근
        System.out.print("키1 값에 접근 : ");
        System.out.println((String)mapH.get("키1"));
        mapH.put("키1","값4"); // 동일한 키로 저장하면 값을 덮어버린다.
        System.out.print("키1 값에 접근 : ");
        System.out.println((String)mapH.get("키1"));
       
        // 반복 처리1
        System.out.println("반복 처리1");
        Iterator iterator = mapH.keySet().iterator();

        while(iterator.hasNext()){
            Object key = iterator.next();
            Object value = mapH.get(key);
            System.out.println(key +" "+ value);
        }

        // 요소 제거
        mapH.remove("키2");

        // 반복 처리2
        System.out.println("반복 처리2");
        for(Object key : mapH.keySet()){
            Object value = mapH.get(key);
            System.out.println(key +" "+ value);
        }
        
        // 반복 처리3
        System.out.println("반복 처리3");
        for(Map.Entry<String,String> entry : mapH.entrySet()){
            Object key = entry.getKey();
            Object value = entry.getValue();
            System.out.println(key +" "+ value);
        }
    }
}

결과 :

순서 보장 X

사용자 정의 클래스의 HashMap 키

import java.util.HashMap;

public class HashMapStudy2 {
    public static void main(String[] args) {
        HashMap mapH = new HashMap();

        mapH.put(new Cat(50), "1");
        mapH.put(new Cat(30), "2");
        mapH.put(new Cat(20), "3");
        mapH.put(new Cat(60), "4");

        for(Object o : mapH.keySet()){
            System.out.println(mapH.get(o));
        }
    }
}
class Cat implements Comparable{
    int size;

    public Cat(int s){
        size = s;
    }

    public String toString(){
        return size + " ";
    }
    public int hashCode(){
        return size % 100;
    }

    public boolean equals(Object ob){
        Cat other = (Cat) ob;
        return other.size == this.size ? true : false;
    }

    @Override
    public int compareTo(Object o) {
        return size - ((Cat) o).size;
    }
}

- 별도의 해시 방법, 동일 해시 값을 갖는 객체 구별법을 지정할 수 있다.

---

TreeMap 예시

import java.util.Set;
import java.util.TreeMap;

public class TreeMapStudy {
    public static void main(String[] args) {
        TreeMap<String,String> mapT =  new TreeMap<String,String>();
        mapT.put("a","1");
        mapT.put("b","2");
        mapT.put("d","3");
        mapT.put("c","4");

        System.out.println("기본적으로 키값을 기준으로 정렬");
        for(Object s : mapT.keySet()) {
            System.out.println(s);
        }

        System.out.println("사용자 정의 클래스 키값을 기준으로 정렬");
        // Comparable or Comparator 구현
        TreeMap<Cat,String> trMap = new TreeMap<Cat,String>();
        trMap.put(new Cat(50),"Fat");
        trMap.put(new Cat(30),"Normal");
        trMap.put(new Cat(20),"Slim");

        Set<Cat> ks = trMap.keySet();

        for(Cat key : ks) {
                System.out.println(key + "==>" + trMap.get(key));
        }
    } 
}
class Cat implements Comparable{
    int size;

    public Cat(int s){
        size = s;
    }

    public String toString(){
        return size + " ";
    }
    public int hashCode(){
        return size % 100;
    }

    public boolean equals(Object ob){
        Cat other = (Cat) ob;
        return other.size == this.size ? true : false;
    }

    @Override
    public int compareTo(Object o) {
        return size - ((Cat) o).size;
    }
}

결과 :

기준에 따라 정렬

---

LinkedHashMap 예시

import java.util.LinkedHashMap;
import java.util.Set;

public class LinkedHashMapStudy {
    public static void main(String[] args) {
        LinkedHashMap<Cat,String> lhmap = new LinkedHashMap<Cat,String>();

        lhmap.put(new Cat(50),"Fat");
        lhmap.put(new Cat(30),"Normal");
        lhmap.put(new Cat(20),"Slim");
        lhmap.put(new Cat(60),"Big");

        Set<Cat> ks = lhmap.keySet();

        for(Cat key : ks){
            System.out.println(key + "==>" + lhmap.get(key));
        }
    }
}

결과 :

들어온 순서대로

---

정리

• HashMap : 처리 순서를 예측하기 힘들지만 배열과 해시 함수를 통해서 구현되기에 검색 및 추가 성능이 좋다.
• TreeMap : 키 값에 따라 정렬되기 때문에 순서대로 반복 처리할 경우 유리하다.
                   그러나, 요소 추가 시에 순서를 유지한 형태로 추가되므로 많은 요소를 추가할 경우 성능이 낮아진다.
• LinkedHashMap : 입력 순서로 저장되므로 입력 순서가 중요한 경우 유리하다.