2018-4-16 JAVA collection Frameworks - Map

Map<K, V>

  • Key는 지표이므로 중복될 수 없다. 반면 Key가 다르면 Value는 중복되어도 상관없다.
  • Map<K, V>를 구현하는 대표클래스로 HashMap<K, V>, TreeMap<K, V>가 있다. 둘의 차이는 TreeMap은 정렬을 유지한다. 정렬의 대상은 Key가 아니라, Value이다.
package yoon;

import java.util.HashMap;

public class HashMapCollection {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();

        map.put(45, "Brown");
        map.put(37, "James");
        map.put(23, "Matrin");

        System.out.println("23 번 : " + map.get(23));
        System.out.println("37 번 : " + map.get(37));
        System.out.println("45 번 : " + map.get(45));
        System.out.println();

        // delete data
        map.remove(37);

        // 데이터 삭제 확인
        System.out.println(map.get(37));
    }
}
//result
23 번 : Matrin
37 번 : James
45 번 : Brown

null
  • HashMap에서는 Iterable<T>인터페이스를 구현하지 않아서, public Set<K> keySet()이 존재한다.
package yoon;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class HashMapIteration {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(45, "Brown");
        map.put(37, "James");
        map.put(23, "Matrin");

        // Key만 담고 있는 컬렉션 인스턴스 생성
        Set<Integer> ks = map.keySet();

        // 전체 Key출력(for-each문 기반)
        for(Integer n : ks)
            System.out.print(n.toString() + "\t");
        System.out.println();

        // 전체 Value 출력(for-each)
        for (Integer n : ks)
            System.out.print(map.get(n).toString() + "\t");
        System.out.println();

        // 전체 Value출력(반복자 기반)
        for (Iterator<Integer> itr = ks.iterator(); itr.hasNext(); )
            System.out.print(map.get(itr.next()) + "\t");
        System.out.println();
    }
}
//result
37	23	45
James	Matrin	Brown
James	Matrin	Brown

TreeMap기반

package yoon;

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

public class TreeMapIteration {
    public static void main(String[] args) {
        TreeMap<Integer, String> map = new TreeMap<>();
        map.put(45, "Brown");
        map.put(37, "James");
        map.put(23, "Matrin");

        // Key만 담고 있는 컬렉션 인스턴스 생성
        Set<Integer> ks = map.keySet();

        // 전체 Key출력(for-each문 기반)
        for(Integer n : ks)
            System.out.print(n.toString() + "\t");
        System.out.println();

        // 전체 Value 출력(for-each)
        for (Integer n : ks)
            System.out.print(map.get(n).toString() + "\t");
        System.out.println();

        // 전체 Value출력(반복자 기반)
        for (Iterator<Integer> itr = ks.iterator(); itr.hasNext(); )
            System.out.print(map.get(itr.next()) + "\t");
        System.out.println();
    }
}
//result
23	37	45
Matrin	James	Brown
Matrin	James	Brown

// ComparatorTreeMap
package yoon;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;

class AgeComparator implements Comparator<Integer> {
    public int compare(Integer n1, Integer n2) {
        return n2.intValue() - n1.intValue();
    }
}

public class ComparatorTreeMap {
    public static void main(String[] args) {
        TreeMap<Integer, String> map = new TreeMap<>(new AgeComparator());
        map.put(45, "Brown");
        map.put(37, "James");
        map.put(23, "Martin");

        // Key만 담고 있는 컬렉션 인스턴스
        Set<Integer> ks = map.keySet();

        // print whole key(based for-each)
        for (Integer n : ks)
            System.out.print(n.toString() + "\t");
        System.out.println();

        // print whole value
        for (Integer n : ks)
            System.out.print(map.get(n).toString() + "\t");
        System.out.println();

        // print whole value(based Iterator)
        for (Iterator<Integer> itr = ks.iterator(); itr.hasNext(); )
            System.out.print(map.get(itr.next()) + "\t");
        System.out.println();
    }
}
//result
45	37	23
Brown	James	Martin
Brown	James	Martin

정렬

  • public static <T> void sort(List<T> list) : 메소드 호출 시점에 T가 결정되므로 List<T>의 인스턴스는 모두 전달 가능하다.
  • public static <T extends Comparable<T» void sort(List<T> list) : T는 Comparable<T> 인터페이스를 구현한 상태여야한다.

public static <T extends Comparable<T» void sort(List<T> list)

  1. 인자로 List<T>의 인스턴스 모두 전달 가능
  2. 단, T는 Comparable<T> 인터페이스를 구현한 상태여야한다.
public static void main(String [] args) {
	List\<String> list = ...;
    Collections.sort(list); // List\<T>의 인스턴스가 인자 전달
}
  • String은 Comparable<String>을 구현한다. 따라서 인자로 전달이 가능하다.
package yoon;

import java.util.*;

public class SortCollections {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Toy", "Box", "Robot", "Weapon");
        list = new ArrayList<>(list);

        // 정렬 이전 출력
        for (Iterator<String> itr = list.iterator(); itr.hasNext(); )
            System.out.print(itr.next() + "\t");
        System.out.println();

        // sorting
        Collections.sort(list);

        // 정렬 이후 출력
        for (Iterator<String> itr = list.iterator(); itr.hasNext(); )
            System.out.print(itr.next() + "\t");
        System.out.println();
    }
}
//result
Toy	Box	Robot	Weapon
Box	Robot	Toy	Weapon

package yoon;

import java.util.*;

class Car implements Comparator<Car> {
    protected int disp; // 배기량

    public Car(int d) {
        disp = d;
    }

    @Override
    public String toString() {
        return "cc" + disp;
    }

    @Override
    public int compareTo(Car o) {
        return disp - o.disp;
    }
}

class ECar extends Car {
    private int battery;

    public ECar(int d, int b) {
        super(d);
        battery = b;
    }

    @Override
    public String toString() {
        return "cc: " + disp + ", ba: " + battery;
    }
}

public class ECarSortCollections {
    public static void main(String[] args) {
        List<ECar> list = new ArrayList<>();
        list.add(new ECar(1200, 99));
        list.add(new ECar(3000, 55));
        list.add(new ECar(1800, 87));
        Collections.sort(list);

        for (Iterator<ECar> itr = list.iterator(); itr.hasNext(); )
            System.out.println(itr.next().toString() + "\t");
    }
}
Written on April 16, 2018