[자료구조] 자바의 List, Set, Map

자바의 컬렉션은 크게 세 가지로 나뉜다. 리스트, 셋, 맵이 바로 그것들이다.

 

List는 데이터를 순서에 맞게 일렬로 구성한다. 이로 인해 인덱스가 부여되고, 인덱스로 검색을 할 수 있기에 순서가 중요하다. 또한 중복을 허용한다.

 

List의 클래스로 사용되는 대표적인 두 가지는 ArrayList와 LinkedList가 있다.

ArrayList는 평범한 리스트라고 볼 수 있다. 단방향 포인터 구조이고, 순차적인 접근이 좋기 때문에 검색이 빠르다.

LinkedList는 양방향 포인터 구조이기에 데이터의 삽입과 삭제가 빠르다. 단, 검색이 느린 경향이 있다.

 

 

Set은 데이터의 중복을 허용하지 않으며 순서가 중요하지 않은 리스트이다.

 

Set의 클래스로 사용되는 대표적인 세 가지는 HashSet, LinkedHashSet, TreeSet이 있다.

HashSet은 가장 빠른 임의 접근 속도를 보여준다. 즉, 임의 접근이기에 순서의 예측이 불가능하다.

LinkedHashSet은 추가된 순서 또는 가장 최근에 접근한 순서대로 접근이 가능하다.

TreeSet은 트리 기반이기에 정렬을 하여 보관하며, 정렬 방법을 임의로 지정할 수 있다.

 

 

Map은 키-값 쌍으로 데이터를 저장한다. 파이썬에서는 dict라고 부른다.

 

Map의 클래스로는 HashMap, LinkedHashMap, TreeMap이 있는데, 각 클래스에 대한 설명은 Set과 동일하다.

 

 

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.TreeMap;
import java.util.Iterator;

public class HelloWorld{

     public static void main(String []args){
        ////////////////LIST//////////////////
        //-------------------------------------
        System.out.println("-----ArrayList-----");
        ArrayList<Integer> arr1 = new ArrayList<Integer>();
        //추가
        arr1.add(1);
        arr1.add(2);
        //삭제
        arr1.remove(1); //1이 아니라 1번째 인덱스 삭제
        //수정
        arr1.set(0, 2); //0번째 인덱스 2로 변경
        //조회
        for(int i=0; i<arr1.size(); i++) System.out.println(arr1.get(i));
        
        
        //-------------------------------------
        System.out.println("-----LinkedList-----");
        LinkedList<Integer> arr2 = new LinkedList<Integer>();
        //추가
        arr2.add(1);
        arr2.add(2);
        //삭제
        arr2.remove(1); //1이 아니라 1번째 인덱스 삭제
        //수정
        arr2.set(0, 2); //0번째 인덱스 2로 변경
        //조회
        for(int i=0; i<arr2.size(); i++) System.out.println(arr2.get(i));
        
        
        ////////////////SET//////////////////
        //-------------------------------------
        System.out.println("-----HashSet-----");
        HashSet<Integer> set1 = new HashSet<Integer>();
        //추가
        set1.add(1);
        set1.add(1); //중복이라 추가 안됨.
        set1.add(2);
        set1.add(3);
        set1.add(4);
        //삭제
        set1.remove(1); //값을 기준으로 삭제
        //조회
        Iterator<Integer> it = set1.iterator();
        while(it.hasNext()) System.out.println(it.next());
        
        
        //-------------------------------------
        System.out.println("-----LinkedHashSet-----");
        LinkedHashSet<Integer> set2 = new LinkedHashSet<Integer>();
        //추가
        set2.add(1);
        set2.add(2);
        set2.add(3);
        set2.add(4);
        //삭제
        set2.remove(2); //값을 기준으로 삭제
        //조회
        Iterator<Integer> it2 = set2.iterator();
        while(it2.hasNext()) System.out.println(it2.next());
        
        
        
        //-------------------------------------
        System.out.println("-----TreeSet-----");
        TreeSet<Integer> set3 = new TreeSet<Integer>();
        //추가
        set3.add(1);
        set3.add(8);
        set3.add(2);
        set3.add(4); //자동정렬됨
        //삭제
        set3.remove(2); //값을 기준으로 삭제
        //조회
        Iterator<Integer> it3 = set3.iterator();
        while(it3.hasNext()) System.out.println(it3.next());
        
        
        ////////////////LIST//////////////////
        //-------------------------------------
        System.out.println("-----HashMap-----");
        HashMap<String, Integer> map1 = new HashMap<String, Integer>();
        //추가
        map1.put("a", 1);
        map1.put("b", 2);
        //삭제
        map1.remove("a");
        //조회
        Iterator<String> it4 = map1.keySet().iterator();
        while(it4.hasNext()) {
            String key = it4.next();
            System.out.println(key + " : " + map1.get(key));
        }
        
        //-------------------------------------
        System.out.println("-----LinkedHashMap-----");
        LinkedHashMap<String, Integer> map2 = new LinkedHashMap<String, Integer>();
        //추가
        map2.put("a", 1);
        map2.put("b", 2);
        //삭제
        map2.remove("a");
        //조회
        Iterator<String> it5 = map2.keySet().iterator();
        while(it5.hasNext()) {
            String key = it5.next();
            System.out.println(key + " : " + map2.get(key));
        }
        
        //-------------------------------------
        System.out.println("-----TreeMap-----");
        TreeMap<String, Integer> map3 = new TreeMap<String, Integer>();
        //추가
        map3.put("a", 1);
        map3.put("c", 2);
        map3.put("b", 2); //키 값 기준 정렬
        //삭제
        map3.remove("a");
        //조회
        Iterator<String> it6 = map3.keySet().iterator();
        while(it6.hasNext()) {
            String key = it6.next();
            System.out.println(key + " : " + map3.get(key));
        }
     }
}