컬렉션(Collection) 🧬

• 컬렉션(Collection)이란 많은 수의 데이터를 그 사용 목적에 적합한 자료구조로 묶어 하나로 그룹화한 객체
• JCF(Java Collections Framework)는 이러한 데이터, 자료구조인 컬렉션과 이를 구현하는 클래스를 정의하는 인터페이스를 제공
• 컬렉션은 배열보다 다수의 참조형 데이터를 더 쉽고 효과적으로 처리할 수 있는 기능을 많이 가지고 있음.
• 컬렉션 기능 : 크기 자동조정/ 추가/ 수정/ 삭제/ 반복/ 순회/ 필터/ 포함확인 등

컬렉션 인터페이스의 특징

• Collection 인터페이스는 List, Set, Queue로 크게 3가지 상위 인터페이스로 분류
• Map의 경우 Collection 인터페이스를 상속받고 있지 않지만 Collection으로 분류됨

인터페이스	구현클래스	특징
List	LinkedList, Vector, ArrayList	순서가 있는 데이터의 집합으로 데이터의 중복을 허용
Queue	LinkedList, PriorityQueue	List와 유사
Set	HashSet, TreeSet	순서가 없는 데이터의 집합으로 데이터의 중복을 허용하지 않음
Map	Hashtable, HashMap, TreeMap	키(Key), 값(Value)의 쌍으로 이루어진 데이터의 집합으로, 순서는 유지되지 않으며 키(Key)의 중복을 허용하지 않으나 값(Value)의 중복은 허용

List 인터페이스

순서가 있는 데이터의 집합 (데이터 중복 허용) - 배열과 비슷

ArrayList 클래스

ArrayList는 배열(Array)처럼 일렬로 데이터를 저장하고 조회하여 순번값(인덱스)로 값을 하나씩 조회

특징

배열(Array)처럼 크기가 정해져 있지않고 필요할때마다 크기가 점점 더 늘어남

사용법

import

import java.util.ArrayList;

생성

List<Integer> arr = new ArrayList<>(); // 생성
List<Integer> arr = new ArrayList<>(n); // 초기 용량 설정
List<Integer> arr = new ArrayList<>(arr2); // 다른 Collection값으로 초기화
List<Integer> arr = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5)); //  Arrays.asList()

추가/수정/삭제/접근/크기

arr.add(1); 	// 맨끝에 추가
arr.add(0, 1);	// 주어진 인덱스에 추가
arr.set(0, 1);	// 주어진 인덱스값 수정
arr.get(i);		// 인덱스i에 해당하는 값 반환
arr.size();		// 크기 반환
arr.remove(1);	// 해당값 삭제
arr.clear();	// 전체값 삭제

순회

// for-each loop
for (Integer e : arr) {
	System.out.print(e + "  ");
}

// for loop
for (int i = 0; i < arr.size(); ++i) {
	System.out.print(arr.get(i) + "  ");
}


// using iterator
Iterator<Integer> iterator = arr.iterator();
while (iterator.hasNext()) {
	System.out.print(iterator.next() + "  ");
}

// using listIterator
ListIterator<Integer> listIterator = arr.listIterator(arr.size());
while (listIterator.hasPrevious()) {
	System.out.print(listIterator.previous() + "  ");
}

값 존재 유무

arr.contains(3); // true or false 반환
arr.indexOf(3);  // 해당값의 인덱스 or -1 반환

리스트 정렬

List<String> list = new ArrayList<>(Arrays.asList("C", "A", "B", "a"));

Collections.sort(list);
Collections.sort(list, Collections.reverseOrder());

// java 8이후
list.sort();
list.sort(Comparator.reverseOrder());

LinkedList 클래스

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

특징

• 기본적인 기능은 ArrayList 와 동일하지만 LinkedList 는 값을 나누어 담기 때문에 모든값을 조회하는 속도가 느림
• 대신에, 값을 중간에 추가하거나 삭제할때는 속도가 빠름
• 중간에 값을 추가하는 기능 있음(속도 빠름)
• 사이즈를 지정하는것이 없기 때문에 초기화가 필요 없음

기능

import java.util.LinkedList;
List<Integer> linkedList = new LinkedList<Integer>(); // 선언&생성
linkedList.add({추가할 값}); // 추가
linkedList.add({추가할 순번}, {추가할 값}); // 값 중간에 추가
linkedList.get({순번}); // 값 조회
linkedList.set({수정할 순번}, {수정할 값}); // 값 수정
linkedList.remove({삭제할 순번}); // 값 삭제
linkedList.toString(); // 전체 값을 대괄호`[]`로 묶어서 출력
linkedList.clear(); // 전체 제거

Stack 클래스

Stack은 값을 수직으로 쌓아놓고 넣었다가 빼서 조회하는 형식으로 데이터를 관리한다. 이걸 “Last-In-First-out” 성질을 가졌다고 표현하며, 주로 상자와 비유해서 설명한다.

특징

• 상자에 물건을 넣고 빼는것처럼 밑에서 위로 쌓고, 꺼낼때는 위에서 부터 꺼내는 형식
• 그렇기 때문에 넣는 기능(push()) 과 조회(peek()), 꺼내는(pop()) 기능만 존재합
• 최근 저장된 데이터를 나열하고 싶거나 데이터의 중복처리를 막고싶을때 사용

기능

import java.util.Stack;
Stack<Integer> stack = new Stack<>(); // 선언&생성
stack.push({추가할 값}); // 추가
stack.pop();  // 삭제, top 반환
stack.size(); // 크기 반환
stack.isEmpty(); // 비었는지 확인, boolean값 반환
stack.peek(); // top 반환

Queue 인터페이스

Queue는 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합

특징

• First In First Out : 먼저들어간 순서대로 값을 조회
• 그래서 추가(add()), 조회(peek()), 삭제(poll()) 기능만 존재
• Queue 는 생성자가 없는 껍데기라서 바로 생성불가 (껍데기 = 인터페이스)
• 생성자가 존재하는 클래스인 LinkedList 를 사용
  

기능

import java.util.Queue;
import java.util.LinkedList;
Queue<Integer> q = new LinkedList<>(); // 선언&생성
q.offer({추가할 값}); q.add({추가할 값});  // 추가
q.poll(); q.remove();  // 삭제, rear 반환
q.size(); // 크기 반환
q.isEmpty(); // 비었는지 확인, boolean값 반환
q.peek(); // front 반환

Deque 인터페이스

java에서 deque는 인터페이스로 구현되었고
ArrayDeque외에도 LinkedBlockingDeque, ConcurrentLinkedDeque, LinkedList 등의 구현클래스가 있다.

Deque<Integer> deque = new ArrayDeque<>();
deque.addFirst(x); // .offerFirst(x);
deque.addLast(x); // .offerLast(x);
deque.removeFirst(x); // .pollFirst(x);
deque.removeLast(x); // .pollLast(x);
deque.pop();
deque.size();
deque.isEmpty();
deque.getFirst(); // .peekFirst();
deque.getLast(); // .peekLast();

PriorityQueue 클래스

힙은 PriorityQueue로 구현할 수 있고 기본적으로 오름차순이다.
Collections.reverseOrder()을 통해 내림차순을 줄 수 있다.

PriorityQueue<Integer> pq = new PriorityQueue<Integer>(); // 최소힙
PriorityQueue<Integer> pq = new PriorityQueue<Integer>(Collections.reverseOrder()); // 최대힙
pq.add(x);
pq.poll();
pq.remove(3);
pq.peek();
Iterator<Integer> itr = pq.iterator();
while (itr.hasNext())
	System.out.println(itr.next());
boolean b = pq.contains(3);

Set 인터페이스

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

특징

• 순서가 보장되지 않는 대신 중복 불허
• Set 은 그냥 Set으로 쓸수도있지만 HashSet, TreeSet 등으로 응용하여 사용가능
• Set 는 생성자가 없는 껍데기라서 바로 생성불가 (껍데기 = 인터페이스)
• 생성자가 존재하는 클래스인 HashSet 를 사용

🔎 구현체에는 HashSet 외에도 TreeSet, LinkedHashSet도 있음

• HashSet : 가장 빠르며 순서를 전혀 예측할 수 없음
• TreeSet : 정렬된 순서대로 보관하며 정렬 방법을 지정할 수 있음
• LinkedHashSet : 추가된 순서, 또는 가장 최근에 접근한 순서대로 접근 가능
  즉, 보통 HashSet 을 쓰는데 순서보장이 필요하면 LinkedHashSet 을 주로 사용

기능

import java.util.HashSet;
import java.util.Set;
Set<Integer> intSet = new HashSet<Integer>(); // 선언&생성
intSet.add({추가할 값}); // 추가
intSet.get({초회할 순번}); // 조회
intSet.remove({삭제할 값}); // 삭제
intSet.contains({포함확인 할 값}); // 포함 여부 확인, boolean값 반환
// 전체 조회
Iterator<String> it = intSet.iterator();
while (it.hasNext()) {
	System.out.println(it.next());
}

Map 인터페이스

Map은 key-value 구조로 구성된 데이터를 저장

특징

• key-value 형태로 데이터를 저장하기 때문에 기존에 순번으로만 조회하던 방식에서, key 값을 기준으로 빠른 조회 👉🏻 O(1)
• key 값 단위로 중복 불허
• Map 은 그냥 Map으로 쓸수도있지만 HashMap, TreeMap등으로 응용하여 사용 가능
• Map으로 쓸수도있지만 HashSet, TreeSet 등으로 응용 사용 가능

🔎 HashMap vs TreeMap

• HashMap : 중복을 허용하지 않고 순서를 보장하지 않음 , 키와 값으로 null이 허용
• TreeMap : key 값을 기준으로 정렬을 할 수 있습니다. 다만, 저장시 정렬(오름차순)을 하기 때문에 저장시간이 다소 오래 걸림
  주로 HashMap을 사용

사용법

import

import java.util.HashMap;

생성

Map<String, Integer> map = new HashMap<>();

추가

map.put("a", 0);			// 키-값 추가
map.putIfAbsent("a", 0);	// 존재하면 값 반환, 없으면 null로 반환후 map에 저장
map.computeIfAbsent("a", (k, v) -> v + 1);	// 존재하면 값 반환, 없으면 함수 수행후 map에 저장

수정

map.replace("a", 2);						// 값 수정
map.compute("a", (k, v) -> v + 1);			// 존재하면 함수 수행 후 값 수정, 없으면 null 에러
map.computeIfPresent("a", (k, v) -> v + 1);	// 존재하면 함수 수행후 값 수정, 없으면 null 반환
map.merge()

접근

map.get("a");				// 값 반환
map.getOrDefault("b", 1);	// 존재하면 값 반환, 없으면 기본값 반환
map.keySet();				// 키 Set 반환
map.values();				// 값 Set 반환
map.EntrySet(); 			// 키-값 Set 반환

삭제/접근/크기

map.get("a");			// 값 반환
map.keySet();			// 키 Set 반환
map.values();			// 값 Set 반환
map.size();				// 키에 대한 크기 반환
map.remove("people");  	// 키에 대한 값 삭제후 반환
map.clear();			// 전체 삭제

순회

for (String i : map.keySet()) {
	System.out.println(i);
}

for (String i : map.values()) {
	System.out.println(i);
}

값 존재 유무

map.containsKey("people");	  // true
map.containsValue("원숭이");	// false

해시 정렬

비교 함수 comparator 필요함!

key 정렬

List<String> keyList = new ArrayList<>(map.keySet());
keyList.sort((s1, s2) -> s1.compareTo(s2)); // 오름차순
keyList.sort((s1, s2) -> s2.compareTo(s1)); // 내림차순

value 정렬

List<String> valueList = new ArrayList<>(map.values());
valueList.sort((s1, s2) -> s1.compareTo(s2));
// valueList.sort(String::compareTo); 동일한 코드

entry 정렬

List<Entry<String, Integer>> entryList = new ArrayList<>(map.entrySet());
entryList.sort((e1, e2) -> e1.getValue().compareTo(e2.getValue())); // 값 기준 오름차순 정렬
entryList.sort((e1, e2) -> e2.getValue().compareTo(e1.getValue())); // 값 기준 내림차순 정렬

👀 length vs length() vs size()

1.length

• arrays(int[], double[], String[])
• length: 배열의 길이 조회

2. length()

• String related Object(String, StringBuilder etc)
• length(): 문자열의 길이 조회 (ex. “ABCD”.length() == 4)

3. size()

• Collection Object(ArrayList, Set etc)
• size(): 컬렉션 타입목록의 길이 조회

Reference

🔗 스파르타코딩클럽 Java 문법 종합반