new TreeSet<>(comparing(String::length).thenComparing(naturalOrder()))

comparing(Person::age, reverseOrder()).thenComparing(Person::name, reverseOrder())
IntStream.of(5, 3, 1).boxed().sorted(reverseOrder()).mapToInt(Integer::intValue).toArray()

// 1: 값→키로 뒤집기 (키 중복 시 첫 값 유지)
m.entrySet().stream().collect(toMap(
    Map.Entry::getValue, Map.Entry::getKey, (a, b) -> a, TreeMap::new));

// 2: 값 기준 내림차순 정렬
m.entrySet().stream().sorted(Map.Entry.comparingByValue(reverseOrder()));

// 3: 정렬 결과를 LinkedHashMap으로 (순서 유지)
.sorted(comparingByValue()).collect(toMap(
    getKey, getValue, (a, b) -> a, LinkedHashMap::new));

// 1: Iterator.remove()로 순회 중 안전하게 삭제
var it = l.iterator();
while (it.hasNext()) if (it.next() == 2) it.remove();

// 2: 역순 인덱스 루프로 인덱스 밀림 방지
for (int i = l.size() - 1; i >= 0; i--) if (l.get(i) == 2) l.remove(i);

record Person(String name, int age, String city) {}
List<Person> people = List.of(new Person("Kim", 30, "Seoul"), new Person("Lee", 25, "Busan"),
                              new Person("Park", 30, "Seoul"), new Person("Choi", 25, "Seoul"));

// 수동
Map<String, List<String>> byCity = new TreeMap<>();
for (Person p : people) byCity.computeIfAbsent(p.city(), k -> new ArrayList<>()).add(p.name());
// 출력: {Busan=[Lee], Seoul=[Kim, Park, Choi]}

// 스트림
people.stream().collect(Collectors.groupingBy(Person::city, TreeMap::new,
        Collectors.mapping(Person::name, Collectors.toList())));
// 출력: {Busan=[Lee], Seoul=[Kim, Park, Choi]}

Map<String, Integer> count = new TreeMap<>();
for (String w : "a b a c b a".split(" ")) count.merge(w, 1, Integer::sum);
// 출력: {a=3, b=2, c=1}

// 스트림 버전
Stream.of("a b a c b a".split(" "))
      .collect(Collectors.groupingBy(w -> w, TreeMap::new, Collectors.counting()));
// 출력: {a=3, b=2, c=1}   (값 타입은 Long)

new ArrayList<>(new LinkedHashSet<>(List.of(3, 1, 3, 2, 1)));
// 출력: [3, 1, 2]
List.of(3, 1, 3, 2, 1).stream().distinct().toList();
// 출력: [3, 1, 2]

// 나이(age)가 같은 사람은 처음 한 명만
Set<Integer> seen = new HashSet<>();
people.stream().filter(p -> seen.add(p.age())).map(Person::name).toList();
// 출력: [Kim, Lee]

List<Integer> a = List.of(1, 2, 3, 4), b = List.of(3, 4, 5);

var diff = new ArrayList<>(a); diff.removeAll(b);          // 출력: [1, 2]
var inter = new ArrayList<>(a); inter.retainAll(b);        // 출력: [3, 4]
var union = new LinkedHashSet<>(a); union.addAll(b);       // 출력: [1, 2, 3, 4, 5]

var sym = new TreeSet<>(a); sym.addAll(b);
var both = new TreeSet<>(a); both.retainAll(b);
sym.removeAll(both);                                       // 출력: [1, 2, 5]

// 대용량: Set으로 O(n + m)
Set<Integer> bSet = new HashSet<>(b);
a.stream().filter(x -> !bSet.contains(x)).toList();        // 출력: [1, 2]

static class LruCache<K, V> extends LinkedHashMap<K, V> {
    private final int capacity;
    LruCache(int capacity) { super(16, 0.75f, true); this.capacity = capacity; }
    @Override protected boolean removeEldestEntry(Map.Entry<K, V> eldest) { return size() > capacity; }
}

LruCache<String, Integer> c = new LruCache<>(2);
c.put("a", 1); c.put("b", 2);
c.get("a");          // a가 최근 사용으로 이동
c.put("c", 3);       // 용량 초과 → 가장 오래된 b 제거
// 출력: {a=1, c=3}

static <T> List<T> page(List<T> list, int page, int size) {
    int from = Math.min(page * size, list.size());
    int to = Math.min(from + size, list.size());
    return list.subList(from, to);
}
static <T> List<List<T>> chunk(List<T> list, int size) {
    List<List<T>> out = new ArrayList<>();
    for (int i = 0; i < list.size(); i += size)
        out.add(list.subList(i, Math.min(i + size, list.size())));
    return out;
}

List<Integer> data = IntStream.rangeClosed(1, 23).boxed().toList();
page(data, 0, 10);   // 출력: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
page(data, 2, 10);   // 출력: [21, 22, 23]
page(data, 3, 10);   // 출력: []
int totalPages = (data.size() + 10 - 1) / 10;   // 출력: 3
chunk(List.of(1, 2, 3, 4, 5), 2);               // 출력: [[1, 2], [3, 4], [5]]

people.stream().sorted(Comparator.comparingInt(Person::age).reversed()).limit(2).map(Person::name).toList();
// 출력: [Kim, Park]

Map<String, Integer> m = new HashMap<>(Map.of("a", 10, "b", 2, "c", 3, "d", 4));
m.entrySet().stream()
 .sorted(Map.Entry.comparingByValue())
 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (x, y) -> x, LinkedHashMap::new));
// 출력: {b=2, c=3, d=4, a=10}

var l = new ArrayList<>(List.of(10, 20, 30));
l.remove(1);                    // 인덱스 1 삭제 → [10, 30]
l.remove(Integer.valueOf(10));  // 값 10 삭제

List<Integer> l = new ArrayList<>(List.of(1, 2, 3));
for (Integer x : l) if (x == 1) l.remove(x);   // ConcurrentModificationException
for (Integer x : l) if (x == 2) l.remove(x);   // 예외 없이 [1, 3] — 뒤에서 두 번째라 우연히 통과 (버그 은닉)
l.removeIf(x -> x == 1);                        // 올바름

Integer x = 127, y = 127;   x == y;   // true  (-128~127 캐시)
Integer z = 128, w = 128;   z == w;   // false (새 객체)
z.equals(w);                          // true  ← 항상 equals

Map<String, Integer> g = new HashMap<>();
int v = g.get("x");                  // NullPointerException (null 언박싱)
int v = g.getOrDefault("x", 0);      // 0
Integer v = g.get("x");              // null 체크 가능

new HashMap<>(Map.of("banana", 1, "apple", 2, "cherry", 3));  // {banana=1, apple=2, cherry=3} 우연
// 삽입 순서 필요 → LinkedHashMap, 정렬 필요 → TreeMap. HashMap 순서는 리해시 시 바뀔 수 있다.

Set<List<Integer>> s = new HashSet<>();
List<Integer> k = new ArrayList<>(List.of(1));
s.add(k);
k.add(2);              // 해시가 바뀜
s.contains(k);         // false — 들어 있는데 못 찾음 (size는 1)
// 키는 불변 객체(String, record, Integer)로.

List.of(1, 2).equals(List.of(2, 1));   // false
Set.of(1, 2).equals(Set.of(2, 1));     // true

PriorityQueue<Integer> pq = new PriorityQueue<>(List.of(5, 1, 3, 2));
pq.toString();          // [1, 2, 3, 5] — 우연. 큰 데이터에선 힙 배열 순서라 뒤섞임
while (!pq.isEmpty()) pq.poll();   // 정렬된 순서로 꺼내는 유일한 방법

new int[]{1, 2} == new int[]{1, 2};                            // false
Arrays.equals(new int[]{1, 2}, new int[]{1, 2});               // true
Arrays.equals(new int[][]{{1}}, new int[][]{{1}});             // false (내부 배열 참조 비교)
Arrays.deepEquals(new int[][]{{1}}, new int[][]{{1}});         // true