240423 TIL 2일차

1. 얕은 복사 & 깊은 복사

1) 얕은 복사

// 얕은 복사

int[] a = { 1, 2, 3, 4 };
int[] b = a; 

b[0] = 3;

System.out.println(a[0]);

결과

 3

얕은 복사는 주소값만 복사가 되어 변수명은 서로 달라도 같은 값을 공유하고 있다
→ 얕은 복사를 한 변수가 변경이 되면 원래 변수 또한 변경이 된다.

 

 

2) 깊은 복사

// 깊은 복사

int[] a = { 1, 2, 3, 4 };
int[] b = new int[a.length]; 

for (int i = 0; i < a.length; i++) {
    b[i] = a[i]; 
}

b[0] = 3; 

System.out.println(a[0]);

 

결과

1

 

깊은 복사는 '같은 값을 가지고 새로운 주소를 가진' 새로운 배열을 만든다.
→ 깊은 복사를 한 배열을 변경한 경우 원래의 배열에는 영향이 가지 않는다.

 

• 깊은 복사 메서드
  1. clone() 메서드 : 2차원 이상 배열에서는 얕은 복사로 동작  
  2. Arrays.copyOf() 메서드

 

---

 

2. 컬렉션

컬렉션은 배열보다 참조형 데이터를 더 쉽고 효과적으로 처리하는 기능이 많다
ex) 크기 자동 조정 / 추가 / 수정 / 삭제 / 반복 / 필터 ...

종류 :  List, Set, Queue, Map

 

1) List

순서가 있는 데이터의 집합

 

(1) ArrayList

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

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

• 값 추가 : add({추가할 값})
• 값 삭제 : remove({삭제할 순번})
• 값 수정 : set({수정할 순번}, {수정할 값})
• 전체 출력 : toString()
• 전체 제거 : clear()

 

(2) LinkedList

메모리에 남는 공간을 요청해서 여기저기 나누어 실제 값을 담아 놓고, 실제 값이 있는 주소값으로 목록을 구성하고 저장
→ 조회 속도는 느리지만, 값 추가/삭제는 빠르다.

 

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

• 값 추가 : add({추가할 값})
• 값 중간에 추가 : add({추가할 순번}, {추가할 값})
• 값 삭제 : remove({삭제할 순번})
• 값 수정 : set({수정할 순번}, {수정할 값})
• 전체 출력 : toString()
• 전체 제거 : clear()

 

(3) Stack

FIFO의 형식을 가짐

 

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

 

• 추가 : push({추가할 값})
• 조회 : peek() → 맨 위 값을 조회
• 꺼내기 : pop() →  맨 위 값을 꺼냄 (꺼내고 난 후 삭제)

 

2) Queue

- FIFO 형식
- 생성자 없는 껍데기라 바로 생성 불가능 → LinkedList 사용

 

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

 

• 선언 : Queue<Integer> intQueue
• 생성 : new LinkedList<Integer>();
• 추가 : add() → 맨 위에 추가
• 조회 : peek() → 맨 아래 값 조회
• 꺼내기 : poll() → 맨 아래 값 꺼냄 (꺼내고 삭제) 

 

3) Set

- 순서가 없고 중복 없는 배열
- 생성자가 없는 껍데기 → HashSet 이용

 

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

 

• 선언 : Set<Integer> intSet
• 생성 : new HashSet<Integer>();
• 추가 : add()
• 삭제 : remove()
• 포함 확인 : contains() → boolean값으로 응답

 

4) Map

- key-value 형태로 데이터 저장
- key 값 단위로 중복을 허용하지 않는 기능이 있다.

 

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

 

• 선언 : Map<String, Integer> intMap → Key, Value 타입 지정
• 생성 : new HashMap<>();
• 추가 : put({Key}, {Value})
• 조회 : get({조회할  Key 값}) → Key에 있는 value값 조회
• 전체 key 조회 : keyset() 
• 전체 value 조회 : values()
• 삭제 : remove({삭제할 key 값})

 

HashMap & TreeMap

• HashMap : 중복을 허용하지 않고 순서를 보장하지 않음, 키와 값으로 null이 허용
• TreeMap : key 값을 기준으로 정렬을 할 수 있다. 다만, 저장 시 정렬을 하여 저장이 오래 걸림