Java 문법 정리 5. 컬렉션(List, Stack, Queue, Set, Map)

Java에서 컬렉션은 배열보다 다수의 참조형 데이터를 더 쉽고 효과적으로 처리할 수 있는 기능을 많이 가지고 있다.

 

1.  List : 순서가 있는 데이터의 집합 (데이터 중복 허용)

   

   1) ArrayList : 배열처럼 일렬로 데이터를 저장하고 조회하여 인덱스로 값을 하나씩 조회함

• ArrayList(동적 배열)는 Array(정적 배열)와 다르게 크기가 가변적으로 늘어남
• ArrayList는 생성시점에 작은 연속된 공간을 요청해서 참조형 변수들을 담아놓고, 값이 추가될 때 더 큰 공간이 필요하면 더 큰 공간을 받아서 저장함.
• 사용하기 위해서는 java.util.ArrayList를 추가해야 함.
• 기능 : 
  • 선언 : ArrayList<Integer> intList
  • 생성 : new ArrayList<Integer>();
  • 초기화 : 사이즈를 지정하는 것이 없기 때문에 초기화가 필요 없다.
  • 값 추가 : intList.add({추가할 값})
  • 값 수정 : intList.set({수정할 순번}, {수정할 것})
  • 값 삭제 : intList.remove({삭제할 순번)}
  • 전체 출력 : intList.toString() << toString 메서드는 객체가 가지고 있는 정보나 값들을 문자열로 만들어 리턴한다. (추후에 다시 설명)
  • 전체 제거 : intList.clear()
• 예시 :

// ArrayList 
// (사용하기 위해선 import java.util.ArrayList; 를 추가해야합니다.)
import java.util.ArrayList;

public class Main {

	public static void main(String[] args) {
		ArrayList<Integer> intList = new ArrayList<Integer>(); // 선언 및 생성
		
		intList.add(1);
		intList.add(2);
		intList.add(3);
		
		System.out.println(intList.get(0)); // 1 출력
		System.out.println(intList.get(1)); // 2 출력
		System.out.println(intList.get(2)); // 3 출력
		System.out.println(intList.toString()); // [1,2,3] 출력
		
		intList.set(1, 10); // 1번순번의 값을 10으로 수정합니다.
		System.out.println(intList.get(1)); // 10 출력
		
		
		intList.remove(1); // 1번순번의 값을 삭제합니다.
		System.out.println(intList.toString()); // [1,3] 출력
		
		intList.clear(); // 전체 값을 삭제합니다.
		System.out.println(intList.toString()); // [] 출력
	}
}

2. LinkedList : 메모리에 남는 공간을 요청해서 여기저기 나누어 실제 값을 담아놓고, 실제 값이 있는 주소값으로 목록을 구성하고 저장한다. 

• 데이터의 추가/삽입 및 삭제는 빠르지만 순차적으로 탐색해야 하기 때문에 탐색 속도는 떨어진다.
• 사용하기 위해서는 java.util.LinkedList를 추가해야 함.
• 기능:
  
  • 선언 : LinkedList<Integer> linkedList
  • 생성 : new LinkedList<Integer>();
  • 초기화 : 사이즈를 지정하는 것이 없기 때문에 초기화 필요 없다.
  • 값 추가 : linkedList.add({추가할 값})
  • 값 중간에 추가 : linkedlist.add({추가할 순번}, {추가할 값})
  • 값 수정 : linkedList.set({수정할 순번}, {수정할 값})
  • 값 삭제 : linkedList.remove({삭제할 순번})
  • 전체 출력 : linkedList.toString()
  • 전체 제거 : linkedList.clear()
• 예시:

// LinkedList 
// (사용하기 위해선 import java.util.LinkedList; 를 추가해야합니다.)
import java.util.LinkedList;

public class Main {

	public static void main(String[] args) {
		LinkedList<Integer> linkedList = new LinkedList<>(); // 선언 및 생성

		linkedList.add(1);
		linkedList.add(2);
		linkedList.add(3);

		System.out.println(linkedList.get(0)); // 1 출력
		System.out.println(linkedList.get(1)); // 2 출력
		System.out.println(linkedList.get(2)); // 3 출력
		System.out.println(linkedList.toString()); // [1,2,3] 출력 (속도 느림)

		linkedList.add(2, 4); // 2번 순번에 4 값을 추가합니다.
		System.out.println(linkedList); // [1,2,4,3] 출력

		linkedList.set(1, 10); // 1번순번의 값을 10으로 수정합니다.
		System.out.println(linkedList.get(1)); // 10 출력

		linkedList.remove(1); // 1번순번의 값을 삭제합니다.
		System.out.println(linkedList); // [1,4,3] 출력

		linkedList.clear(); // 전체 값을 삭제합니다.
		System.out.println(linkedList); // [] 출력
	}
}

3. Stack : 나중에 들어간 값이 나중에 나옴 LIFO(Last-in-First-out)

• 넣는 기능(push), 조회(peak), 꺼내는 기능(pop)만 존재.
• 이렇게 불편하게 쓰는 이유는 최근 저장된 데이터를 나열하고 싶거나 데이터의 중복처리를 막고 싶을 때 사용
• 사용하기 위해서는 java.util.Stack을 추가해야 함.
• 기능 :
  • 선언 : Stack<Integer> intStack
  • 생성 : new Stack<Integer>();
  • 추가 : intStack.push({추가할 값})
  • 조회 : intStack.peak() --> 맨 위값 조회
  • 꺼내기 : intStack.pop() --> 맨 위값 꺼냄(삭제) 
• 예시

// Stack 
// (사용하기 위해선 import java.util.Stack; 를 추가해야합니다.)
import java.util.Stack;

public class Main {

	public static void main(String[] args) {
		Stack<Integer> intStack = new Stack<Integer>(); // 선언 및 생성
		
		intStack.push(1);
		intStack.push(2);
		intStack.push(3);

		while (!intStack.isEmpty()) { // 다 지워질때까지 출력
		    System.out.println(intStack.pop()); // 3,2,1 출력
		}

		// 다시 추가
		intStack.push(1);
		intStack.push(2);
		intStack.push(3);
		
		// peek()
		System.out.println(intStack.peek()); // 3 출력
		System.out.println(intStack.size()); // 3 출력 (peek() 할때 삭제 안됬음)
		
		// pop()
		System.out.println(intStack.pop()); // 3 출력
		System.out.println(intStack.size()); // 2 출력 (pop() 할때 삭제 됬음)		
		
		System.out.println(intStack.pop()); // 2 출력
		System.out.println(intStack.size()); // 1 출력 (pop() 할때 삭제 됬음)		

		while (!intStack.isEmpty()) { // 다 지워질때까지 출력
		    System.out.println(intStack.pop()); // 1 출력 (마지막 남은거 하나)
		}
	}
}

 4. Queue : 먼저 들어간 순서대로 값을 조회할 수 있다. FIFO(First-in-First-out)

• 넣는 기능(add), 조회(peak), 꺼내는(poll) 기능만 존재한다.
• 사용하기 위해서는 java.util.LinkedList, jave.util.Queue 를 추가해야 함.
• Queue는 생성자가 없으므로 LinckedList를 사용하여 Queue를 생성해서 받을 수 있다.

EX)
// LinkedList 를 생성하면 Queue 기능을 할 수 있습니다. (Queue 가 부모/ LinkedList 가 자식이기 떄문)
Queue<Integer> intQueue = new LinkedList<Integer>();

• 기능 : 
  • 선언 : Queue<Integer> intQueue
  • 생성 : new LinckedList<Integer>();
  • 추가 : intQueue.add({추가할 값})
  • 조회 : intQueue.peak()
  • 꺼내기 : intQueue.poll() --> 맨 아래값을 꺼냄(삭제)
• 예시 : 

// Queue 
// (사용하기 위해선 java.util.LinkedList; 와 import java.util.Queue; 를 추가해야합니다.)
import java.util.LinkedList;
import java.util.Queue;

public class Main {

	public static void main(String[] args) {
		Queue<Integer> intQueue = new LinkedList<>(); // 선언 및 생성

		intQueue.add(1);
		intQueue.add(2);
		intQueue.add(3);

		while (!intQueue.isEmpty()) { // 다 지워질때까지 출력
			System.out.println(intQueue.poll()); // 1,2,3 출력
		}

		// 다시 추가
		intQueue.add(1);
		intQueue.add(2);
		intQueue.add(3);

		// peek()
		System.out.println(intQueue.peek()); // 1 출력 (맨먼저 들어간값이 1 이라서)
		System.out.println(intQueue.size()); // 3 출력 (peek() 할때 삭제 안됬음)

		// poll()
		System.out.println(intQueue.poll()); // 1 출력
		System.out.println(intQueue.size()); // 2 출력 (poll() 할때 삭제 됬음)

		System.out.println(intQueue.poll()); // 2 출력
		System.out.println(intQueue.size()); // 1 출력 (poll() 할때 삭제 됬음)

		while (!intQueue.isEmpty()) { // 다 지워질때까지 출력
			System.out.println(intQueue.poll()); // 3 출력 (마지막 남은거 하나)
		}
	}
}

5. Set : 순서가 없는 데이터의 집합 (데이터의 중복 허용 안 함) - 순서 없고 중복 없는 배열

• 순서가 보장되지 않는 대신 중복을 허용하지 않도록 유지할 수 있음
• Set 은 생성자가 없어 HashSet 을 사용하여 Set을 생성할 수 있다.
• HashSet 외에도 TreeSet, LinckedHashSet 이 있다.
  • HashSet : 가장 빠르며 순서를 전혀 예측할 수 없음
  • Treeset : 정렬된 순서대로 보관하며 정렬 방법을 지정할 수 있음
  • LinckedHashSet : 추가된 순서, 또는 가장 최근에 접근한 순서대로 접근 가능
  • 즉, 보통 HashSet 을 쓰는데 순서보장이 필요하면 LinckedHashSet 을 주로 사용

• 기능 :
  • 선언 : Set<Integer> intSet
  • 생성 : new HashSet<Integer>();
  • 추가 : intSet.add({추가할 값})
  • 조회 : intSet.get({조회할 순번})
  • 삭제 : intSet.remove({삭제할 값})
  • 포함확인 : intSet.contains({포함확인 할 값})
• 예시 : 

// Set 
// (사용하기 위해선 import java.util.Set; 와 java.util.HashSet; 를 추가해야합니다.)
import java.util.HashSet;
import java.util.Set;

public class Main {

	public static void main(String[] args) {
		Set<Integer> intSet = new HashSet<Integer>(); // 선언 및 생성

		intSet.add(1);
		intSet.add(2);
		intSet.add(3);
		intSet.add(3); // 중복된 값은 덮어씁니다.
		intSet.add(3); // 중복된 값은 덮어씁니다.

		for (Integer value : intSet) {
			System.out.println(value); // 1,2,3 출력
		}

		// contains()
		System.out.println(intSet.contains(2)); // true 출력
		System.out.println(intSet.contains(4)); // false 출력

		// remove()
		intSet.remove(3); // 3 삭제

		for (Integer value : intSet) {
			System.out.println(value); // 1,2 출력
		}
	}
}

6. Map : Key - Value 구조로 구성된 데이터를 저장

• Key 값을 기준으로 value를 조회할 수 있다.
• HashMap, TreeMap으로 사용할 수도 있다.
  • HashMap : 중복을 허용하지 않고 순서를 보장해주지 않음, 키와 값으로 null이 허용
  • TreeMap : key 값을 기준으로 정렬할 수 있다. 다만, 저장 시 정렬(오름차순)을 하기 때문에 저장시간이 다소 오래 걸린다.
• 기능 :
  • 선언 : Map<String, Integer> intMap // key-value 형태
  • 생성 : new HashMap<>();
  • 추가 : intMap.put({추가할 key값}, {추가할 value값})
  • 조회 : intMap.get({조회할 Key값})
  • 전체 key 조회 : intMap.keySet()
  • 전체 value 조회 : intMap.values()
  • 삭제 : intMap.remove({삭제할 Key값)}
• 예시 :

// Map 
// (사용하기 위해선 import java.util.Map; 를 추가해야합니다.)
import java.util.Map;

public class Main {

	public static void main(String[] args) {
		Map<String, Integer> intMap = new HashMap<>(); // 선언 및 생성

		//          키 , 값
		intMap.put("일", 11);
		intMap.put("이", 12);
		intMap.put("삼", 13);
		intMap.put("삼", 14); // 중복 Key값은 덮어씁니다.
		intMap.put("삼", 15); // 중복 Key값은 덮어씁니다.

		// key 값 전체 출력
		for (String key : intMap.keySet()) {
			System.out.println(key); // 일,이,삼 출력
		}

		// value 값 전체 출력
		for (Integer key : intMap.values()) {
			System.out.println(key); // 11,12,15 출력
		}

		// get()
		System.out.println(intMap.get("삼")); // 15 출력
	}
}