Java Collection

Collection 기능

• 크기 자동조정
• 추가
• 수정
• 삭제
• 반복
• 순회
• 필터
• 포함 확인
• 기타

Collection 종류

1. List: 순서가 있는 데이터의 집합
   • 데이터 중복 허용
   • 배열과 비슷
2. Queue: 빨대(위 아래가 뚫린 원기둥)처럼 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합
   • FIFO(First In First Out): 먼저 들어간 순서대로 값을 조회 가능
3. Set: 순서가 없는 데이터의 집합
   • 데이터 중복 허용X
   • 순서 없고 중복없는 배열
4. Map: 순서가 없는(Key, Value) 쌍으로 이루어진 데이터 집합
   • Key값 중복 허용 안함

List

1. ArrayList
   • 동적 배열: 크기가 가변적으로 늘어나는 것
   • 기능
     - 선언 : ArrayList<Integer> intList 형태로 선언
     - 생성 : new ArrayList<Integer>(); 형태로 생성
     - 초기화 : 사이즈를 지정하는것이 없기 때문에 초기화가 필요 없음
     - 값 추가 : intList.add({추가할 값}) 형태로 값을 추가
     - 값 수정 : intList.set({수정할 순번}, {수정할 값}) 형태로 값을 수정
     - 값 삭제 : intList.remove({삭제할 순번}) 형태로 값을 삭제
     - 전체 출력 : intList.toString() 형태로 전체 값을 대괄호[]로 묶어서 출력
     - 전체 제거 : intList.clear() 형태로 전체 값을 삭제
2. LinkedList
   • 기본적인 기능은 ArrayList와 동일
   • 값을 여기 저기 나누어서 조회하는 속도가 느림
   • 값을 추가/삭제할 때는 빠름
   • 기능
     - 선언 : LinkedList<Integer> linkedList 형태로 선언
     - 생성 : new LinkedList<Integer>(); 형태로 생성다.
     - 초기화 : 사이즈를 지정하는것이 없기 때문에 초기화가 필요 없음
     - 값 추가 : linkedList.add({추가할 값}) 형태로 값을 추가
     - 값 중간에 추가 : linkedList.add({추가할 순번}, {추가할 값}) 형태로 값을 중간에 추가
     - 값 수정 : linkedList.set({수정할 순번}, {수정할 값}) 형태로 값을 수정
     - 값 삭제 : linkedList.remove({삭제할 순번}) 형태로 값을 삭제
     - 전체 출력 : linkedList.toString() 형태로 전체 값을 대괄호[]로 묶어서 출력
     - 전체 제거 : linkedList.clear() 형태로 전체 값을 삭제

Stack

• 특징
  • 상자에 물건을 넣고 빼는것처럼 밑에서 위로 쌓고, 꺼낼때는 위에서 부터 꺼내는 형식
  • 그렇기 때문에 넣는
    1. 기능(push())
    2. 조회(peek())
    3. 꺼내는(pop()) 기능만 존재
  • 이렇게 불편하게 쓰는 이유는 최근 저장된 데이터를 나열하고 싶거나 데이터의 중복처리를 막고싶을때 사용
• 기능
  • 선언 : Stack<Integer> intStack 형태로 선언
  • 생성 : new Stack<Integer>(); 형태로 생성
  • 추가 : intStack.push({추가할 값}) 형태로 값을 추가
  • 조회 : intStack.peek() 형태로 맨 위값을 조회
  • 꺼내기 : intStack.pop() 형태로 맨 위값을 꺼냄 (꺼내고나면 삭제됨)

Queue

• 특징
  • FIFO(First In First Out) : 먼저들어간 순서대로 값을 조회가능
  • 그렇기 때문에
    1. 넣는 기능(add())
    2. 조회(peek())
    3. 꺼내는(poll()) 기능만 존재
  • Queue 는 생성자가 없는 껍데기라서 바로 생성할수 없음
    • (껍데기 = 인터페이스)
  • 생성자가 존재하는 클래스인 LinkedList 를 사용하여 Queue 를 생성해서 받을 수 있음
• 기능
  • 선언 : Queue<Integer> intQueue 형태로 선언
  • 생성 : new LinkedList<Integer>(); 형태로 생성
  • 추가 : intQueue.add({추가할 값}) 형태로 값을 맨 위에 추가
  • 조회 : intQueue.peek() 형태로 맨 아래값을 조회
  • 꺼내기 : intQueue.poll() 형태로 맨 아래값을 꺼냄 (꺼내고나면 삭제됨)

Set

• 특징
  • 순서가 보장되지 않는 대신 중복을 허용하지 않도록 유지가능
  • Set 은 그냥 Set으로 쓸수도있지만 HashSet, TreeSet 등으로 응용하여 사용할 수 있음
  • Set 는 생성자가 없는 껍데기라서 바로 생성할수는 없음
    • (껍데기 = 인터페이스)
  • 생성자가 존재하는 클래스인 HashSet 를 사용하여 Set 를 생성해서 받을 수 있음
• 기능
  • 선언 : Set<Integer> intSet 형태로 선언
  • 생성 : new HashSet<Integer>(); 형태로 생성
  • 추가 : intSet.add({추가할 값}) 형태로 값을 맨 위에 추가
  • 조회 : intSet.get({초회할 순번}) 형태로 순번에 있는 값을 조회
  • 삭제 : intSet.remove({삭제할 값}) 형태로 삭제할 값을 직접 지정
  • 포함확인 : intSet.contains({포함확인 할 값}) 형태로 해당값이 포함되어있는지 boolean 값으로 응답 받음

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

Map

• key-value 구조
• key는 unique(중복x)한 값
• 기능
  • 선언 : Map<String, Integer> intMap 형태로 Key타입과 Value타입을 지정해서 선언
  • 생성 : new HashMap<>(); 형태로 생성
  • 추가 : intMap.put({추가할 Key값},{추가할 Value값}) 형태로 Key에 Value값을 추가
  • 조회 : intMap.get({조회할 Key값}) 형태로 Key에 있는 Value값을 조회
  • 전체 key 조회 : intMap.keySet() 형태로 전체 key 값들을 조회
  • 전체 value 조회 : intMap.values() 형태로 전체 value 값들을 조회
  • 삭제 : intMap.remove({삭제할 Key값}) 형태로 Key에 있는 Value값을 삭제

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

자주쓰는 참조형 변수

• Collection은 참조형 변수를 저장함(기본형X)
  1. Integer: int의 참조형 변수
  2. Long: long의 참조형 변수
  3. Double: double의 참조형 변수
  4. String은 원래부터 참조형 변수