Java (자바) JCF(Java Collection Framework) - List, Set, Map

 

자바에서 자료구조는 크게 3가지 구조로 나눌 수 있다.

public class ExecClass {
	public static void main(String[] args) {
		// 1. List
//		ListTest listTest = new ListTest();
//		listTest.doAction();
		
		// 2. Set
//		SetTest setTest = new SetTest();
//		setTest.doAction();
		
		// 3. Map
//		MapTest mapTest = new MapTest();
//		mapTest.doAction();

	}
}

 

 

1. List

가변 배열이라 볼 수 있다.

List	인덱스 접근	순서 O	중복 O	ArrayList	배열과 유사하다. 순서대로 메모리에 배정
				LinkedList	배열과 달리 메모리 주소를 순서대로 연결

 

무엇이 다를까?

Array (배열) : 처음 만들 때부터 메모리 공간에 필요한 공간 만큼 만들어 사용한다. (연속적) 첫 번째 주소 하나만 알고 있고 그 안에서 인덱스로 접근한다. (메모리 사용은 적지만 활용이 불편함)

List (리스트) : 처음 만들 때 메모리 공간에 하나만 만들고, 추가가 되면 그때 새로운 메모리 공간에 하나를 만들고 메모리 앞뒤 메모리 주소끼리 연결을 해준다. (불연속적이어도 상관 없음) 각각의 메모리 공간을 각각의 메모리 주소로 접근한다. (메모리 사용이 많음) (체인 구조로 연결되기 때문에 데이터가 많아지면 시간이 오래 걸린다. 50번을 찾으려면 1번에서 2번으로 가서 2번에서 3번으로 가서... 50번을 가야한다.)

자료의 삽입, 삭제가 빈번히 일어나는 곳에서는 LinkedList는 사용하면 안 된다! 왠만하면 안 쓰는게 좋음! 삽입, 삭제 비용이 매우 큼.

따라서 현재는 대부분 순서대로 메모리에 배정되는 배열과 유사한 ArrayList를 사용한다.

import java.util.Arrays;
import java.util.ArrayList;
import java.util.LinkedList;

public class ListTest {
	public void doAction() {
		System.out.println("Array 배열");
//		int[] arr = new int[5];
//		arr[0] = 7;
		int[] arr = {7,9,14,16,31};
		System.out.println("arr : " + Arrays.toString(arr));
		System.out.println("arr[2] : " + arr[2]);
		
		System.out.println("\n ArrayList 리스트");
		ArrayList<Integer> al = new ArrayList<Integer>();
		al.add(7);
		al.add(9);
		al.add(14);
		al.add(16);
		al.add(31);
		
		System.out.println("al : " + al);
		System.out.println("al.equals(14) : " + al.equals(14) + "   <- equals로는 값의 비교가 되지 않는다.");
		System.out.println("al.indexOf(2) : " + al.indexOf(2));		// 2가 없기 때문에 -1(false)를 반환.
		System.out.println("al.indexOf(14) : " + al.indexOf(14));	// 14가 있기 때문에 14의 인덱스 2를 반환.
		System.out.println("al.size()) : " + al.size());
		al.add(14);
		System.out.println("al.size()) : " + al.size() + " 중복 허용 O [7, 16, 14, 31, 9] 이 입력된 상태에서 al.add(16)을 한 번 더 하였더니 추가.");
		
		System.out.println("\n LinkedList 리스트");
		LinkedList<Integer> ll = new LinkedList<Integer>();
		ll.add(7);
		ll.add(9);
		ll.add(14);
		ll.add(16);
		ll.add(31);
		
		System.out.println("ll : " + ll);
	}

}


결과 :

Array 배열
arr : [7, 9, 14, 16, 31]
arr[2] : 14

 ArrayList 리스트
al : [7, 9, 14, 16, 31]
al.equals(14) : false   <- equals로는 값의 비교가 되지 않는다.
al.indexOf(2) : -1
al.indexOf(14) : 2
al.size()) : 5
al.size()) : 6 중복 허용 O [7, 16, 14, 31, 9] 이 입력된 상태에서 al.add(16)을 한 번 더 하였더니 추가.

 LinkedList 리스트
ll : [7, 9, 14, 16, 31]

 

 

2. Set

속도가 빠르지만 단순 집합 개념으로 정렬 시 별도의 처리가 필요하다. TreeSet은 정렬로 인해 저장하는데 시간이 오래 걸린다.

Set	인덱스 접근	순서 X	중복 X	HsahSet	입력된 값을 무작위로 담는다
				LinkedHashSet	입력된 순서대로 담는다
				TreeSet	값을 정렬해서 담는다

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;

public class SetTest {
	public void doAction( ) {
		System.out.println("HashSet");
		HashSet<Integer> hs = new HashSet<Integer>();
		hs.add(7);
		hs.add(16);
		hs.add(14);
		hs.add(31);
		hs.add(9);
		
		System.out.println("hs : " + hs + " 무작위로 담는다.");
		System.out.println("hs.equals(14) : " + hs.equals(14) + "   <- equals로는 값의 비교가 되지 않는다.");		
		System.out.println("Set에는 .indexOf()가 존재하지 않는다.");
		hs.add(16);
		System.out.println("hs.size() : " + hs.size() + " 중복 허용 X [7, 16, 14, 31, 9] 이 입력된 상태에서 hs.add(16)을 한 번 더 하였으나 추가되지 않음.");
		
		System.out.println("\n LinkedHashSet");
		LinkedHashSet<Integer> lhs = new LinkedHashSet<Integer>();
		lhs.add(7);
		lhs.add(16);
		lhs.add(14);
		lhs.add(31);
		lhs.add(9);
		
		System.out.println("lhs : " + lhs + " 입력된 순서대로 담는다.");
		
		System.out.println("\n TreeSet");
		TreeSet<Integer> ts = new TreeSet<Integer>();
		ts.add(7);
		ts.add(16);
		ts.add(14);
		ts.add(31);
		ts.add(9);
		
		System.out.println("ts : " + ts + " 값을 정렬해서 담는다.");
	
		
		// Set to Array
		System.out.println("\n Set to Array");
		Object[] o1 = hs.toArray();
		System.out.println(Arrays.toString(o1));
		
	}

}


결과 : 

HashSet
hs : [16, 7, 9, 14, 31] 무작위로 담는다.
hs.equals(14) : false   <- equals로는 값의 비교가 되지 않는다.
Set에는 .indexOf()가 존재하지 않는다.
hs.size() : 5 중복 허용 X [7, 16, 14, 31, 9] 이 입력된 상태에서 hs.add(16)을 한 번 더 하였으나 추가되지 않음.

 LinkedHashSet
lhs : [7, 16, 14, 31, 9] 입력된 순서대로 담는다.

 TreeSet
ts : [7, 9, 14, 16, 31] 값을 정렬해서 담는다.

 Set to Array
[16, 7, 9, 14, 31]

 

 

3. Map

속도가 빠르지만 Key의 검색 속도가 속도를 좌우한다. TreeMap은 정렬로 인해 저장하는데 시간이 오래 걸린다.

Map	Key : Value 접근	순서 X	Key 중복 X Value 중복 O	HashMap	입력된 Key : Value 쌍을 무작위로 담는다.
				LinkedMap	입력된 순서대로 Key: Value 쌍을 담는다.
				TreeMap	Key를 기준으로 정렬해서 담는다.

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.TreeMap;

public class MapTest {
	public void doAction() {
		System.out.println("HashMap");
		HashMap<String, Integer> hm = new HashMap<String, Integer>();
		hm.put("alpha", 7);
		hm.put("gamma", 14);
		hm.put("delta", 31);
		hm.put("beta", 16);
		hm.put("epsilon", 9);
		
		System.out.println("hm : " + hm + " 무작위로 담는다.");
		System.out.println("hm.equals(14) : " + hm.equals(14) + "   <- equals로는 값의 비교가 되지 않는다.");
		System.out.println("Map에는 .indexOf()가 존재하지 않는다.");
		System.out.println("hm.get(\"alpha\") : " + hm.get("alpha") + " Key로 Value를 조회.");
		System.out.println("hm.size() : " + hm.size());
		hm.put("alpha", 25);
		System.out.println("hm.size() : " + hm.size() + " Key 중복 허용 X {epsilon=9, alpha=7, delta=31, beta=16, gamma=14}이 입력된 상태에서 hm.put(\"alpha\", 25)를 한 번 더 하였으나 추가되지 않음.");
		hm.put("zeta", 14);
		System.out.println("hm.size() : " + hm.size() + " Value 중복 허용 O {epsilon=9, alpha=7, delta=31, beta=16, gamma=14}이 입력된 상태에서 hm.put(\"zeta\", 14)를 한 번 더 하였더니 추가.");
		
		System.out.println("\n LinkedHashMap");
		LinkedHashMap<String, Integer> lhm = new LinkedHashMap<String, Integer>();
		lhm.put("alpha", 7);
		lhm.put("gamma", 14);
		lhm.put("delta", 31);
		lhm.put("beta", 16);
		lhm.put("epsilon", 9);
		System.out.println("hm : " + hm + " 입력된 순서대로 담는다.");
		
		System.out.println("\n TreeMap");
		TreeMap<String, Integer> tm = new TreeMap<String, Integer>();
		tm.put("alpha", 7);
		tm.put("gamma", 14);
		tm.put("delta", 31);
		tm.put("beta", 16);
		tm.put("epsilon", 9);
		System.out.println("tm : " + tm + " Key로 정렬해서 담는다. (ABCD순)");

	}

}


결과 :

HashMap
hm : {epsilon=9, alpha=7, delta=31, gamma=14, beta=16} 무작위로 담는다.
hm.equals(14) : false   <- equals로는 값의 비교가 되지 않는다.
Map에는 .indexOf()가 존재하지 않는다.
hm.get("alpha") : 7 Key로 Value를 조회.
hm.size() : 5
hm.size() : 5 Key 중복 허용 X {epsilon=9, alpha=7, delta=31, beta=16, gamma=14}이 입력된 상태에서 hm.put("alpha", 25)를 한 번 더 하였으나 추가되지 않음.
hm.size() : 6 Value 중복 허용 O {epsilon=9, alpha=7, delta=31, beta=16, gamma=14}이 입력된 상태에서 hm.put("zeta", 14)를 한 번 더 하였더니 추가.

 LinkedHashMap
hm : {epsilon=9, zeta=14, alpha=25, delta=31, gamma=14, beta=16} 입력된 순서대로 담는다.

 TreeMap
tm : {alpha=7, beta=16, delta=31, epsilon=9, gamma=14} Key로 정렬해서 담는다. (ABCD순)

 

아래는 자바스크립트 기준인데 비슷하겠지...

• hashmap.size() returns the # of elements in the hashmap
• hashmap.get(<key>) returns the value of the element of the given key
• hashmap.has(<key>) checks to see if the hashmap contains the key that is passed as an argument
• hashmap.set(<key>, <value>) accepts 2 arguments and creates a new element to the hashmap
• hashmap.delete(<key>) deletes the key/value pair that matches the key that is passed in as an argument
• hashmap.clear() clears all elements from the hashmap