[Java] 기초 문법 - 컬렉션 (Collection)

컬렉션 (Collection)

컬렉션의 종류로는

List, Set, Queue, Map 이 있다.

 

List	순서가 있는 데이터의 집합 (데이터 중복 허용, 배열과 비슷)
Queue	한쪽에서 데이터를 넣고 반대쪽에서 데이터를 추출할 수 있는 집합 FIFO (First In First Out)
Set	순서가 없는 데이터의 집합 (데이터 중복 허용 안함, 순서, 중복이 없는 배열)
Map	순서가 없는 (Key, Value) 쌍으로 이루어진 데이터의 집합 (Key 값 중복 허용 안함)

컬렉션은 참조형 변수를 저장한다. (Integer, Long, Double, String)

 

List

ArrayList

- 배열처럼 일렬로 데이터를 저장하고 조회하여 인덱스로 값을 하나씩 조회한다.

- 배열처럼 크기가 정해져 있지 않고 필요할 때마다 크기가 점점 늘어난다.

 

Array	메모리에 연속된 공간을 요청한 사이즈만큼 받아서 실제 값을 저장하는 기본형 변수로 저장 -> 정적 배열
ArrayList	작은 연속된 공간을 요청해서 참조형 변수들을 담아 놓고, 값이 추가될 때 더 큰 공간이 필요하면 공간을 받아서 저장 -> 동적 배열

 

// 선언
ArrayList<Integer> intList

// 생성
new ArrayList<Integer>();

// 초기화 - 사이즈를 지정하지 않기 때문에 필요x

// 값 추가
intList.add({추가할 값})

// 값 수정
intList.set({수정할 순번}, {수정할 값})

// 값 삭제
intList.remove({삭제할 순번})

// 전체 출력
intList.toString()

// 전체 제거
intList.clear()

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()); // [] 출력
	}
}

 

Linked List

- 노드끼리의 주소 포인터를 서로 가리키며 링크(참조)함으로써 이어지는 구조

- 값을 추가, 삭제시 ArrayList 보다 빠르지만, 조회하는 속도는 느리다.

 

// 선언
LinkedList<Integer> linkedList

// 생성
new LinkedList<Integer>();

// 초기화 - 사이즈를 지정하지 않기 때문에 필요x

// 값 추가
linkedList.add({추가할 값})

// 값 중간에 추가
linkedList.add({추가할 순번}, {추가할 값})

// 값 수정
linkedList.set({수정할 순번}, {수정할 값})

// 값 삭제
linkedList.remove({삭제할 순번})

// 전체 출력
linkedList.toString()

// 전체 제거
linkedList.clear()

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); // [] 출력
	}
}

 

Stack

- 상자에 물건을 쌓아 올리듯이 데이터를 쌓는 자료구조

- LIFO (Last In First Out) 의 형태

 

// 선언
Stack<Integer> intStack

// 생성
new Stack<Integer>();

// 추가
intStack.push({추가할 값})

// 조회
intStack.peek()

// 꺼내기
intStack.pop()

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 출력 (마지막 남은거 하나)
		}
	}
}

 

Queue

- 생성자가 존재하는 클래스인 LinkedList 를 사용하여 Queue 를 생성할 수 있다.

- FIFO (First In First Out) 의 형태

 

// 선언
Queue<Integer> intQueue

// 생성
new LinkedList<Integer>();

// 추가
intQueue.add({추가할 값})

// 조회
intQueue.peek()

// 꺼내기
intQueue.poll()

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 출력 (마지막 남은거 하나)
		}
	}
}

 

Set

- 순서, 중복이 없는 데이터의 집합

- 생성자가 존재하는 클래스인 HashSet 을 사용하여 Set 을 생성하여 받을 수 있다.

 

// 선언
Set<Integer> intSet

// 생성
new HashSet<Integer>();

// 추가
intSet.add({추가할 값})

// 조회
intSet.get({초회할 순번})

// 삭제
intSet.remove({삭제할 값})

// 포함확인
intSet.contains({포함확인 할 값})
// boolean 값으로 리턴

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 출력
		}
	}
}

 

* HashSet 이외에도 다른 Set 사용 가능

HashSet	가장 빠르며 순서를 전혀 예측할 수 없음
TreeSet	정렬된 순서대로 보관하며 정렬 방법을 지정할 수 있음
LinkedHashSet	추가된 순서, 가장 최근에 접근한 순서대로 접근 가능

보통 HashSet 을 사용하지만 순서 보장이 필요하면 LinkedHashSet 을 사용한다.

 

Map

- Key-Value 구조로 구성된 데이터 저장 가능

- Key 값을 기준으로 value 조회 가능 (Key 값은 중복되지 않음)

 

// 선언
Map<String, Integer> intMap

// 생성
new HashMap<>();

// 추가
intMap.put({추가할 Key값},{추가할 Value값})

// 조회
intMap.get({조회할 Key값}) // Key에 있는 Value값을 조회

// 전체 key 조회
intMap.keySet()

// 전체 value 조회
intMap.values()

// 삭제
intMap.remove({삭제할 Key값}) // Key에 있는 Value값을 삭제

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 출력
	}
}

* HashSet 이외에도 TreeMap 사용 가능

HashMap	중복을 허용하지 않고 순서를 보장하지 않음, 키와 값으로 null 허용
TreeMap	key 값을 기준으로 정렬 가능. 단, 오름차순으로 정렬하기 때문에 시간이 다소 소요된다.