Java 컬렉션 주요 함수

배열 관련 함수

1. 배열 선언 & 초기화

int[] arr = new int[5];               // 크기 5짜리 int 배열 (0으로 초기화)
int[] arr2 = {1, 2, 3, 4, 5};         // 리터럴 초기화
String[] names = new String[]{"a","b","c"};
arr2.length;		// 5

---

2. java.util.Arrays 주요 함수들

(1) 출력/문자열 변환

System.out.println(Arrays.toString(arr));   // [1, 2, 3, 4, 5]
System.out.println(Arrays.deepToString(twoD)); // 2차원 배열 [[1,2],[3,4]]

(2) 정렬

Arrays.sort(arr);                   		// 오름차순 정렬
Arrays.sort(arr, 2, 5);             		// 부분 정렬 (index 2~4)
Arrays.sort(strArr, Comparator.reverseOrder()); // 내림차순 (객체 배열)

// 오름차순 정렬 후
for (int i = 0; i < arr.length / 2; i++) {	// 기본형 내림차순
    int tmp = arr[i];
    arr[i] = arr[mats.length - 1 - i];
    arr[arr.length - 1 - i] = tmp;
}

(3) 이진 탐색

int idx = Arrays.binarySearch(arr, 3);  // arr이 정렬된 상태여야 함

(4) 복사

int[] copy = Arrays.copyOf(arr, arr.length);    // 전체 복사
int[] part = Arrays.copyOfRange(arr, 1, 4);     // index 1~3 복사

(5) 채우기

Arrays.fill(arr, 7);              // arr 전체를 7로 채움
Arrays.fill(arr, 2, 4, 9);        // index 2~3을 9로 채움

(6) 비교

boolean eq = Arrays.equals(arr1, arr2);         // 같은 내용?
boolean eq2d = Arrays.deepEquals(twoD1, twoD2); // 2차원 배열 비교

---

3. Stream을 활용한 배열 처리

int sum = Arrays.stream(arr).sum();               // 합계
int max = Arrays.stream(arr).max().getAsInt();    // 최대값
int[] squared = Arrays.stream(arr).map(x -> x*x).toArray(); // 제곱 배열

---

4. 다차원 배열

int[][] grid = new int[3][4];
grid[0][1] = 5;
System.out.println(Arrays.deepToString(grid)); // [[0,5,0,0],[0,0,0,0],[0,0,0,0]]

---

컬렉션 관련 함수

1. 공통 (Collections 유틸)

Collections.sort(list);                           // 오름차순 정렬
Collections.sort(list, Comparator.reverseOrder()); // 내림차순
Collections.reverse(list);                        // 리스트 뒤집기
Collections.shuffle(list);                        // 무작위 섞기
Collections.max(list);                            // 최대값
Collections.min(list);                            // 최소값
Collections.frequency(list, "a");                 // 특정 원소 개수 세기
Collections.fill(list, 0);                        // 모든 원소 0으로 채우기
Collections.copy(dest, src);                      // 복사 (주의: 크기 같아야 함)

2. List 관련 (ArrayList, LinkedList)

List<Integer> list = new ArrayList<>();

list.add(10);            // 끝에 추가
list.add(1, 20);         // index 1에 삽입
list.get(0);             // index 0 원소 반환
list.set(0, 99);         // index 0 원소 수정
list.remove(1);          // index 1 원소 삭제
list.remove(Integer.valueOf(20)); // 값으로 삭제
list.contains(99);       // 포함 여부
list.size();             // 길이
list.isEmpty();          // 비어있는지
list.clear();            // 전체 삭제
list.subList(1, 3);      // 부분 리스트 (1 <= idx < 3)

3. Set 관련 (HashSet, TreeSet)

Set<String> set = new HashSet<>();

set.add("apple");         // 추가
set.add("banana");
set.remove("apple");      // 삭제
set.contains("banana");   // 포함 여부
set.size();               // 크기
set.isEmpty();            // 비어있는지
set.clear();              // 초기화

// 집합 연산
Set<Integer> a = new HashSet<>(Arrays.asList(1,2,3));
Set<Integer> b = new HashSet<>(Arrays.asList(3,4,5));

Set<Integer> union = new HashSet<>(a); union.addAll(b);        // 합집합
Set<Integer> inter = new HashSet<>(a); inter.retainAll(b);     // 교집합
Set<Integer> diff = new HashSet<>(a); diff.removeAll(b);       // 차집합

4. Map 관련 (HashMap, TreeMap)

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

map.put("a", 1);               // 삽입
map.put("b", 2);
map.get("a");                  // 값 반환 (없으면 null)
map.getOrDefault("c", 0);      // 값 반환 (없으면 기본값)
map.containsKey("a");          // 키 존재 여부
map.containsValue(2);          // 값 존재 여부
map.remove("b");               // 삭제
map.size();                    // 크기
map.clear();                   // 초기화

// 순회
for (String key : map.keySet()) {
    System.out.println(key + " -> " + map.get(key));
}
for (Map.Entry<String,Integer> e : map.entrySet()) {
    System.out.println(e.getKey() + " " + e.getValue());
}

5. Queue / Deque (LinkedList, ArrayDeque)

Queue<Integer> q = new LinkedList<>();
q.add(1); q.offer(2);      // 삽입
q.poll();                  // 앞에서 꺼내기 (없으면 null)
q.remove();                // 앞에서 꺼내기 (없으면 예외)
q.peek();                  // 맨 앞 원소 보기
q.isEmpty();               // 비었는지

Deque<Integer> dq = new ArrayDeque<>();
dq.addFirst(1); dq.addLast(2);   // 앞/뒤 삽입
dq.pollFirst(); dq.pollLast();   // 앞/뒤 꺼내기
dq.peekFirst(); dq.peekLast();   // 앞/뒤 확인

6. Stack

Stack<Integer> st = new Stack<>();
st.push(10);             // 넣기
st.pop();                // 꺼내기
st.peek();               // 맨 위 확인
st.isEmpty();            // 비었는지

---