import java.util.ArrayList;
import java.util.Collections;

ArrayList<String> list = new ArrayList<>();  // 기본 용량 10

// 추가
list.add("Java");
list.add("Python");
list.add("C++");
list.add(1, "Kotlin");  // 인덱스 1에 삽입

// 조회
String lang = list.get(0);               // "Java"
int idx = list.indexOf("Python");         // 2
boolean has = list.contains("C++");       // true

// 수정
list.set(0, "Java 17");

// 삭제
list.remove(0);             // 인덱스로 삭제
list.remove("C++");         // 객체로 삭제

// 크기
int size = list.size();

// 정렬
Collections.sort(list);

ArrayList<Integer> list = new ArrayList<>(100);  // 초기 용량 지정

list.trimToSize();          // 빈 공간 제거 (size == capacity)
list.ensureCapacity(200);   // 최소 용량 200 확보

// 단방향 노드
class Node {
    Object data;
    Node next;       // 다음 노드 참조
}

// 양방향 노드 (실제 LinkedList)
class Node {
    Object data;
    Node next;       // 다음 노드 참조
    Node previous;   // 이전 노드 참조
}

// 상황별 선택 가이드
// 데이터 조회가 빈번 → ArrayList
ArrayList<String> readHeavy = new ArrayList<>();

// 데이터 삽입/삭제가 빈번 → LinkedList
LinkedList<String> writeHeavy = new LinkedList<>();

Stack<String> stack = new Stack<>();
stack.push("A");
stack.push("B");
stack.push("C");

stack.peek();   // "C" (제거 안 함)
stack.pop();    // "C" (제거)
stack.pop();    // "B"

// Queue는 인터페이스 → LinkedList로 구현
Queue<String> queue = new LinkedList<>();
queue.offer("A");
queue.offer("B");
queue.offer("C");

queue.peek();    // "A" (제거 안 함)
queue.poll();    // "A" (제거)
queue.poll();    // "B"

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.offer(3);
pq.offer(1);
pq.offer(2);

pq.poll();   // 1 (가장 작은 값)
pq.poll();   // 2
pq.poll();   // 3

Deque<String> deque = new ArrayDeque<>();
deque.offerFirst("A");  // 앞에 추가
deque.offerLast("B");   // 뒤에 추가
deque.pollFirst();      // 앞에서 꺼냄 → "A"
deque.pollLast();       // 뒤에서 꺼냄 → "B"

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    System.out.println(s);
}

Map<String, Integer> map = new HashMap<>();
map.put("Java", 1);
map.put("Python", 2);

// 방법 1: keySet()
Iterator<String> it = map.keySet().iterator();
while (it.hasNext()) {
    String key = it.next();
    System.out.println(key + "=" + map.get(key));
}

// 방법 2: entrySet()
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + "=" + entry.getValue());
}

ListIterator<String> li = list.listIterator();

// 정방향
while (li.hasNext()) {
    System.out.println(li.next());
}
// 역방향
while (li.hasPrevious()) {
    System.out.println(li.previous());
}

int[] arr = {3, 1, 4, 1, 5};

// 정렬
Arrays.sort(arr);                     // [1, 1, 3, 4, 5]

// 이진 검색 (정렬 후 사용)
int idx = Arrays.binarySearch(arr, 3); // 2

// 출력
System.out.println(Arrays.toString(arr));  // [1, 1, 3, 4, 5]

// 복사
int[] copy = Arrays.copyOf(arr, 3);   // [1, 1, 3]

// 채우기
Arrays.fill(arr, 0);                  // [0, 0, 0, 0, 0]

// asList()가 반환한 List는 크기 변경 불가
List<Integer> fixed = Arrays.asList(1, 2, 3);
// fixed.add(4);  // UnsupportedOperationException!
fixed.set(0, 10); // 값 변경은 가능

// 크기 변경 가능한 List가 필요하면 새 ArrayList로 감싸기
List<Integer> mutable = new ArrayList<>(Arrays.asList(1, 2, 3));
mutable.add(4);  // OK

public class Student implements Comparable<Student> {
    String name;
    int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public int compareTo(Student other) {
        // 점수 오름차순 (작은 것이 앞)
        return this.score - other.score;
    }
}

List<Student> students = new ArrayList<>();
students.add(new Student("Kim", 85));
students.add(new Student("Lee", 92));
students.add(new Student("Park", 78));

Collections.sort(students);  // 78, 85, 92 순

// 이름 기준 정렬
Comparator<Student> byName = (s1, s2) ->
    s1.name.compareTo(s2.name);

// 점수 내림차순 정렬
Comparator<Student> byScoreDesc = (s1, s2) ->
    s2.score - s1.score;

Collections.sort(students, byName);       // 이름 순
Collections.sort(students, byScoreDesc);  // 점수 역순

String[] arr = {"cat", "Dog", "lion", "tiger"};

// 기본 정렬: 유니코드 순서 (대문자 < 소문자)
Arrays.sort(arr);
// [Dog, cat, lion, tiger]

// 대소문자 무시 정렬
Arrays.sort(arr, String.CASE_INSENSITIVE_ORDER);
// [cat, Dog, lion, tiger]

// 역순 정렬
Arrays.sort(arr, Collections.reverseOrder());
// [tiger, lion, cat, Dog]

Set<String> set = new HashSet<>();
set.add("Java");
set.add("Python");
set.add("Java");      // 중복 → false 반환, 추가 안 됨
set.add(null);        // null 저장 가능

System.out.println(set.size());  // 3
System.out.println(set);         // 순서 보장 안 됨

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // equals()와 hashCode() 반드시 오버라이딩
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Person) {
            Person p = (Person) obj;
            return name.equals(p.name) && age == p.age;
        }
        return false;
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

Set<Person> set = new HashSet<>();
set.add(new Person("Kim", 25));
set.add(new Person("Kim", 25));  // 중복 → 추가 안 됨
System.out.println(set.size());   // 1

Set<Integer> setA = new HashSet<>(Arrays.asList(1, 2, 3, 4));
Set<Integer> setB = new HashSet<>(Arrays.asList(3, 4, 5, 6));

// 교집합
Set<Integer> intersection = new HashSet<>(setA);
intersection.retainAll(setB);     // [3, 4]

// 합집합
Set<Integer> union = new HashSet<>(setA);
union.addAll(setB);               // [1, 2, 3, 4, 5, 6]

// 차집합
Set<Integer> diff = new HashSet<>(setA);
diff.removeAll(setB);             // [1, 2]

TreeSet<Integer> set = new TreeSet<>();
set.add(10); set.add(30); set.add(50);
set.add(20); set.add(40);

System.out.println(set);             // [10, 20, 30, 40, 50]
System.out.println(set.headSet(30)); // [10, 20]
System.out.println(set.tailSet(30)); // [30, 40, 50]
System.out.println(set.subSet(20, 40)); // [20, 30]
System.out.println(set.first());     // 10
System.out.println(set.last());      // 50

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

// 저장
map.put("Java", 1);
map.put("Python", 2);
map.put("Java", 10);     // 기존 값 1 → 10으로 덮어쓰기

// 조회
int val = map.get("Java");            // 10
boolean hasKey = map.containsKey("Java");   // true
boolean hasVal = map.containsValue(2);      // true

// 기본값 지정 조회
int score = map.getOrDefault("C++", 0);     // 0

// 삭제
map.remove("Python");

// 전체 순회
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + " = " + entry.getValue());
}

// 설정 파일 읽기
Properties prop = new Properties();
prop.load(new FileInputStream("config.properties"));

String host = prop.getProperty("db.host");
String port = prop.getProperty("db.port", "3306");  // 기본값

// 설정 파일 쓰기
prop.setProperty("db.host", "localhost");
prop.store(new FileOutputStream("config.properties"),
           "DB Configuration");

// 시스템 속성 읽기
Properties sysProp = System.getProperties();
System.out.println(sysProp.getProperty("java.version"));
System.out.println(sysProp.getProperty("os.name"));

List<Integer> list = new ArrayList<>(Arrays.asList(3, 1, 4, 1, 5));

Collections.sort(list);                    // 오름차순 정렬
Collections.sort(list, Collections.reverseOrder()); // 내림차순
Collections.shuffle(list);                 // 무작위 섞기
Collections.reverse(list);                 // 순서 뒤집기
Collections.swap(list, 0, 1);             // 위치 교환

int max = Collections.max(list);
int min = Collections.min(list);
int freq = Collections.frequency(list, 1); // 1의 등장 횟수

List<String> syncList = Collections.synchronizedList(new ArrayList<>());
Map<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>());
Set<String> syncSet = Collections.synchronizedSet(new HashSet<>());

List<String> unmodList = Collections.unmodifiableList(list);
// unmodList.add("X");  // UnsupportedOperationException!

// Java 9+ 팩토리 메서드
List<String> immutable = List.of("A", "B", "C");
Map<String, Integer> immutableMap = Map.of("A", 1, "B", 2);
Set<Integer> immutableSet = Set.of(1, 2, 3);

List<String> checked = Collections.checkedList(
    new ArrayList<>(), String.class);
checked.add("OK");
// checked.add(123);  // ClassCastException!