集合类

Iterable (接口)
    └── Collection (接口)
            ├── List (接口)
            │     ├── ArrayList
            │     ├── LinkedList
            │     └── Vector
            │           └── Stack
            ├── Set (接口)
            │     ├── HashSet
            │     │     └── LinkedHashSet
            │     └── TreeSet
            └── Queue (接口)
                  ├── LinkedList
                  ├── PriorityQueue
                  └── ArrayDeque

Map (接口)
    ├── HashMap
    │     └── LinkedHashMap
    ├── TreeMap
    ├── Hashtable
    │     └── Properties
    └── ConcurrentHashMap

import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {
  public static void main(String[] args) {
    List<String> arrayList = new ArrayList<>();
    arrayList.add("Apple");
    arrayList.add("Banana");
    arrayList.add("Cherry");

    System.out.println("ArrayList: " + arrayList); // 输出: [Apple, Banana, Cherry]
    System.out.println("Element at index 1: " + arrayList.get(1)); // 输出: Banana
  }
}

import java.util.LinkedList;
import java.util.List;

public class LinkedListExample {
  public static void main(String[] args) {
    LinkedList<String> linkedList = new LinkedList<>();
    linkedList.add("Apple");
    linkedList.add("Banana");
    linkedList.add("Cherry");

    System.out.println("LinkedList: " + linkedList); // 输出: [Apple, Banana, Cherry]
    System.out.println("First Element: " + linkedList.getFirst()); // 输出: Apple
    System.out.println("Last Element: " + linkedList.getLast()); // 输出: Cherry
    
    // 作为栈使用
    linkedList.push("Durian"); // 等同于 addFirst
    System.out.println("Stack pop: " + linkedList.pop()); // 等同于 removeFirst
    
    // 作为队列使用
    linkedList.offer("Elderberry"); // 等同于 add/addLast
    System.out.println("Queue poll: " + linkedList.poll()); // 等同于 removeFirst
  }
}

import java.util.Vector;

public class VectorExample {
  public static void main(String[] args) {
    Vector<String> vector = new Vector<>();
    vector.add("Apple");
    vector.add("Banana");
    
    System.out.println("Vector: " + vector);
    
    // Stack 是 Vector 的子类
    java.util.Stack<String> stack = new java.util.Stack<>();
    stack.push("A");
    stack.push("B");
    System.out.println("Stack pop: " + stack.pop()); // 输出: B
  }
}

import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListExample {
  public static void main(String[] args) {
    CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
    list.add("Apple");
    list.add("Banana");

    System.out.println("List: " + list); // 输出: [Apple, Banana]
    
    // 适合并发遍历
    list.forEach(System.out::println);
  }
}

import java.util.ArrayList;
import java.util.List;

public class ForLoopExample {
  public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("Apple");
    list.add("Banana");

    for (int i = 0; i < list.size(); i++) {
      System.out.println(list.get(i));
    }
  }
}

import java.util.ArrayList;
import java.util.List;

public class ForEachLoopExample {
  public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("Apple");
    list.add("Banana");

    for (String item : list) {
      System.out.println(item);
    }
  }
}

import java.util.ArrayList;
import java.util.List;

public class ForEachExample {
  public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("Apple");
    list.add("Banana");

    list.forEach(System.out::println);
  }
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorExample {
  public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("Apple");
    list.add("Banana");

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

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListIteratorExample {
  public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("Apple");
    list.add("Banana");
    list.add("Cherry");

    // 正向遍历
    ListIterator<String> iterator = list.listIterator();
    while (iterator.hasNext()) {
      System.out.println("Index " + iterator.nextIndex() + ": " + iterator.next());
    }

    // 反向遍历
    System.out.println("\nReverse traversal:");
    while (iterator.hasPrevious()) {
      System.out.println("Index " + iterator.previousIndex() + ": " + iterator.previous());
    }
  }
}

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

public class SortExample {
  public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("Banana");
    list.add("Apple");
    list.add("Cherry");

    Collections.sort(list); // 默认按自然顺序排序
    System.out.println("Sorted List: " + list); // 输出: [Apple, Banana, Cherry]
  }
}

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class CustomSortExample {
  public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("Banana");
    list.add("Apple");
    list.add("Cherry");

    list.sort(Comparator.reverseOrder()); // 按降序排序
    System.out.println("Reverse Sorted List: " + list); // 输出: [Cherry, Banana, Apple]
  }
}

import java.util.ArrayList;
import java.util.List;

public class StreamExample {
  public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("Apple");
    list.add("Banana");
    list.add("Cherry");

    // 过滤以 'A' 开头的元素并转换为大写
    List<String> result = list.stream()
      .filter(s -> s.startsWith("A"))
      .map(String::toUpperCase)
      .toList();

    System.out.println(result); // 输出: [APPLE]
  }
}

import java.util.LinkedList;
import java.util.Queue;

public class LinkedListQueueExample {
  public static void main(String[] args) {
    Queue<String> queue = new LinkedList<>();
    queue.offer("A");
    queue.offer("B");
    queue.offer("C");

    System.out.println("Queue: " + queue); // 输出: [A, B, C]
    System.out.println("Poll: " + queue.poll()); // 输出: A
    System.out.println("Peek: " + queue.peek()); // 输出: B
  }
}

import java.util.PriorityQueue;
import java.util.Queue;

public class PriorityQueueExample {
  public static void main(String[] args) {
    // 默认最小堆（元素按从小到大排序）
    Queue<Integer> queue = new PriorityQueue<>();
    queue.offer(5);
    queue.offer(1);
    queue.offer(3);

    System.out.println("PriorityQueue: " + queue);
    
    // 按优先级取出元素
    while (!queue.isEmpty()) {
      System.out.println(queue.poll());
    }
    // 输出顺序: 1, 3, 5
    
    // 自定义比较器：最大堆
    Queue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);
    maxHeap.offer(5);
    maxHeap.offer(1);
    maxHeap.offer(3);
    
    System.out.println("\nMax Heap:");
    while (!maxHeap.isEmpty()) {
      System.out.println(maxHeap.poll());
    }
    // 输出顺序: 5, 3, 1
  }
}

import java.util.ArrayDeque;
import java.util.Deque;

public class ArrayDequeExample {
  public static void main(String[] args) {
    // 作为栈使用
    Deque<String> stack = new ArrayDeque<>();
    stack.push("A");
    stack.push("B");
    stack.push("C");
    
    System.out.println("Stack pop: " + stack.pop()); // 输出: C
    System.out.println("Stack peek: " + stack.peek()); // 输出: B
    
    // 作为队列使用
    Deque<String> queue = new ArrayDeque<>();
    queue.offer("A");
    queue.offer("B");
    queue.offer("C");
    
    System.out.println("\nQueue poll: " + queue.poll()); // 输出: A
    System.out.println("Queue peek: " + queue.peek()); // 输出: B
  }
}

import java.util.HashSet;
import java.util.Set;

public class HashSetExample {
  public static void main(String[] args) {
    Set<String> set = new HashSet<>();
    set.add("Apple");
    set.add("Banana");
    set.add("Cherry");
    set.add("Apple"); // 重复元素，不会被添加

    System.out.println("HashSet: " + set); // 输出顺序可能不同
    System.out.println("Contains 'Apple': " + set.contains("Apple")); // 输出: true
    System.out.println("Size: " + set.size()); // 输出: 3
  }
}

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetExample {
  public static void main(String[] args) {
    Set<String> set = new LinkedHashSet<>();
    set.add("Apple");
    set.add("Banana");
    set.add("Cherry");

    System.out.println("LinkedHashSet: " + set); // 输出: [Apple, Banana, Cherry]，保持插入顺序
  }
}

import java.util.TreeSet;
import java.util.Set;

public class TreeSetExample {
  public static void main(String[] args) {
    Set<String> set = new TreeSet<>();
    set.add("Banana");
    set.add("Apple");
    set.add("Cherry");

    System.out.println("TreeSet: " + set); // 输出: [Apple, Banana, Cherry]，按字母顺序排序
    
    // 自定义比较器
    Set<String> reverseSet = new TreeSet<>((a, b) -> b.compareTo(a));
    reverseSet.add("Banana");
    reverseSet.add("Apple");
    reverseSet.add("Cherry");
    
    System.out.println("Reverse TreeSet: " + reverseSet); // 输出: [Cherry, Banana, Apple]
  }
}

import java.util.EnumSet;
import java.util.Set;

public class EnumSetExample {
  enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }
  
  public static void main(String[] args) {
    Set<Day> weekend = EnumSet.of(Day.SATURDAY, Day.SUNDAY);
    Set<Day> weekdays = EnumSet.range(Day.MONDAY, Day.FRIDAY);
    
    System.out.println("Weekend: " + weekend); // 输出: [SATURDAY, SUNDAY]
    System.out.println("Weekdays: " + weekdays); // 输出: [MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY]
  }
}

import java.util.HashSet;
import java.util.Set;

public class SetOperationsExample {
  public static void main(String[] args) {
    Set<Integer> set1 = new HashSet<>();
    Set<Integer> set2 = new HashSet<>();
    
    // 添加元素
    set1.add(1);
    set1.add(2);
    set1.add(3);
    
    set2.add(2);
    set2.add(3);
    set2.add(4);
    
    // 并集
    Set<Integer> union = new HashSet<>(set1);
    union.addAll(set2);
    System.out.println("Union: " + union); // 输出: [1, 2, 3, 4]
    
    // 交集
    Set<Integer> intersection = new HashSet<>(set1);
    intersection.retainAll(set2);
    System.out.println("Intersection: " + intersection); // 输出: [2, 3]
    
    // 差集
    Set<Integer> difference = new HashSet<>(set1);
    difference.removeAll(set2);
    System.out.println("Difference: " + difference); // 输出: [1]
  }
}

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

class Student {
  private String id;
  private String name;
  
  public Student(String id, String name) {
    this.id = id;
    this.name = name;
  }
  
  // 必须重写 equals() 和 hashCode() 方法
  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return Objects.equals(id, student.id);
  }
  
  @Override
  public int hashCode() {
    return Objects.hash(id);
  }
  
  @Override
  public String toString() {
    return "Student{id='" + id + "', name='" + name + "'}";
  }
}

public class CustomObjectSetExample {
  public static void main(String[] args) {
    Set<Student> students = new HashSet<>();
    students.add(new Student("001", "张三"));
    students.add(new Student("002", "李四"));
    students.add(new Student("001", "王五")); // 不会添加，因为 id 相同
    
    System.out.println("Students: " + students);
  }
}

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
  public static void main(String[] args) {
    Map<String, Integer> map = new HashMap<>();
    map.put("Apple", 10);
    map.put("Banana", 20);
    map.put("Cherry", 30);
    map.put("Apple", 15); // 替换旧值

    System.out.println("Map: " + map);
    System.out.println("Value of 'Apple': " + map.get("Apple")); // 输出: 15
    System.out.println("Contains key 'Banana': " + map.containsKey("Banana")); // 输出: true
    System.out.println("Size: " + map.size()); // 输出: 3
    
    // Java 8+ 新方法
    System.out.println("Value of 'Date': " + map.getOrDefault("Date", 0)); // 输出: 0
    map.putIfAbsent("Banana", 25); // 不会替换，因为键已存在
    map.putIfAbsent("Date", 40); // 会添加
    System.out.println("After putIfAbsent: " + map);
  }
}

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
  public static void main(String[] args) {
    // 按插入顺序
    Map<String, Integer> map = new LinkedHashMap<>();
    map.put("Apple", 10);
    map.put("Banana", 20);
    map.put("Cherry", 30);

    System.out.println("LinkedHashMap: " + map); // 输出: {Apple=10, Banana=20, Cherry=30}，保持插入顺序
    
    // 按访问顺序（可用于实现 LRU 缓存）
    Map<String, Integer> lruMap = new LinkedHashMap<>(16, 0.75f, true);
    lruMap.put("A", 1);
    lruMap.put("B", 2);
    lruMap.put("C", 3);
    
    lruMap.get("A"); // 访问 A
    System.out.println("LRU Map: " + lruMap); // 输出: {B=2, C=3, A=1}，A 移到最后
  }
}

import java.util.Map;
import java.util.TreeMap;

public class TreeMapExample {
  public static void main(String[] args) {
    Map<String, Integer> map = new TreeMap<>();
    map.put("Banana", 20);
    map.put("Apple", 10);
    map.put("Cherry", 30);

    System.out.println("TreeMap: " + map); // 输出: {Apple=10, Banana=20, Cherry=30}，按键排序
    
    // 导航方法
    TreeMap<String, Integer> treeMap = new TreeMap<>(map);
    System.out.println("First key: " + treeMap.firstKey()); // 输出: Apple
    System.out.println("Last key: " + treeMap.lastKey()); // 输出: Cherry
    System.out.println("Lower key of 'Banana': " + treeMap.lowerKey("Banana")); // 输出: Apple
    System.out.println("Higher key of 'Banana': " + treeMap.higherKey("Banana")); // 输出: Cherry
  }
}

import java.util.Hashtable;
import java.util.Map;

public class HashtableExample {
  public static void main(String[] args) {
    Map<String, Integer> map = new Hashtable<>();
    map.put("Apple", 10);
    map.put("Banana", 20);
    map.put("Cherry", 30);

    System.out.println("Hashtable: " + map);
  }
}

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
  public static void main(String[] args) {
    Map<String, Integer> map = new ConcurrentHashMap<>();
    map.put("Apple", 10);
    map.put("Banana", 20);
    map.put("Cherry", 30);

    System.out.println("ConcurrentHashMap: " + map);
    
    // 线程安全的操作
    map.computeIfAbsent("Date", k -> 40);
    System.out.println("After computeIfAbsent: " + map);
  }
}

import java.util.HashMap;
import java.util.Map;

public class MapTraversalExample {
  public static void main(String[] args) {
    Map<String, Integer> map = new HashMap<>();
    map.put("Apple", 10);
    map.put("Banana", 20);
    map.put("Cherry", 30);

    // 遍历键
    System.out.println("Keys:");
    for (String key : map.keySet()) {
      System.out.println(key);
    }

    // 遍历值
    System.out.println("\nValues:");
    for (Integer value : map.values()) {
      System.out.println(value);
    }

    // 遍历键值对（推荐）
    System.out.println("\nEntries:");
    for (Map.Entry<String, Integer> entry : map.entrySet()) {
      System.out.println(entry.getKey() + " = " + entry.getValue());
    }

    // Java 8+ forEach 方法
    System.out.println("\nUsing forEach:");
    map.forEach((key, value) -> System.out.println(key + " = " + value));
  }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

class Person {
  private String id;
  private String name;
  
  public Person(String id, String name) {
    this.id = id;
    this.name = name;
  }
  
  // 必须重写 equals() 和 hashCode() 方法
  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Person person = (Person) o;
    return Objects.equals(id, person.id);
  }
  
  @Override
  public int hashCode() {
    return Objects.hash(id);
  }
  
  @Override
  public String toString() {
    return "Person{id='" + id + "', name='" + name + "'}";
  }
}

public class CustomKeyMapExample {
  public static void main(String[] args) {
    Map<Person, String> map = new HashMap<>();
    map.put(new Person("001", "张三"), "工程师");
    map.put(new Person("002", "李四"), "设计师");
    map.put(new Person("001", "王五"), "教师"); // 替换旧值，因为 id 相同
    
    System.out.println("Map:");
    map.forEach((person, job) -> System.out.println(person + " -> " + job));
  }
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class IteratorExample {
  public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("A");
    list.add("B");
    list.add("C");
    
    // 使用 Iterator 遍历并删除元素
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
      String element = iterator.next();
      if ("B".equals(element)) {
        iterator.remove(); // 安全删除
      }
    }
    System.out.println("After remove: " + list); // 输出: [A, C]
    
    // 使用 ListIterator 遍历并修改元素
    ListIterator<String> listIterator = list.listIterator();
    while (listIterator.hasNext()) {
      String element = listIterator.next();
      listIterator.set(element.toLowerCase());
    }
    System.out.println("After set: " + list); // 输出: [a, c]
    
    // 反向遍历
    System.out.println("\nReverse:");
    while (listIterator.hasPrevious()) {
      System.out.println(listIterator.previous());
    }
  }
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ConcurrentModificationExample {
  public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("A");
    list.add("B");
    list.add("C");
    
    // 错误：在迭代过程中通过集合方法修改
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
      String element = iterator.next();
      if ("B".equals(element)) {
        // list.remove(element); // 抛出 ConcurrentModificationException
      }
    }
    
    // 正确：使用迭代器的 remove 方法
    iterator = list.iterator();
    while (iterator.hasNext()) {
      String element = iterator.next();
      if ("B".equals(element)) {
        iterator.remove(); // 安全
      }
    }
  }
}

import java.util.ArrayList;
import java.util.List;

public class ForEachLimitationExample {
  public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("A");
    list.add("B");
    list.add("C");
    
    // 错误：会抛出 ConcurrentModificationException
    for (String element : list) {
      if ("B".equals(element)) {
        // list.remove(element); // 错误
      }
    }
    
    // 正确：使用迭代器或 removeIf（Java 8+）
    list.removeIf(element -> "B".equals(element));
    System.out.println("After removeIf: " + list); // 输出: [A, C]
  }
}

import java.util.*;

public class SynchronizedCollectionExample {
  public static void main(String[] args) {
    // 同步的 List
    List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());
    
    // 同步的 Set
    Set<String> synchronizedSet = Collections.synchronizedSet(new HashSet<>());
    
    // 同步的 Map
    Map<String, Integer> synchronizedMap = Collections.synchronizedMap(new HashMap<>());
    
    // 注意：迭代时需要手动同步
    synchronized (synchronizedList) {
      for (String element : synchronizedList) {
        System.out.println(element);
      }
    }
  }
}

import java.util.*;
import java.util.concurrent.*;

public class ConcurrentCollectionExample {
  public static void main(String[] args) {
    // 并发的 List
    List<String> copyOnWriteArrayList = new CopyOnWriteArrayList<>();
    
    // 并发的 Set
    Set<String> copyOnWriteArraySet = new CopyOnWriteArraySet<>();
    
    // 并发的 Map
    Map<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();
    
    // 并发的 Queue
    Queue<String> concurrentLinkedQueue = new ConcurrentLinkedQueue<>();
    
    // 阻塞队列
    BlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(10);
    BlockingQueue<String> linkedBlockingQueue = new LinkedBlockingQueue<>();
  }
}

import java.util.*;

public class SynchronizedBlockExample {
  private List<String> list = new ArrayList<>();
  
  public void add(String element) {
    synchronized (list) {
      list.add(element);
    }
  }
  
  public String get(int index) {
    synchronized (list) {
      return list.get(index);
    }
  }
}

import java.util.Arrays;
import java.util.List;

public class ArraysExample {
  public static void main(String[] args) {
    // asList：数组转 List
    String[] array = {"A", "B", "C"};
    List<String> list = Arrays.asList(array);
    System.out.println("List: " + list);
    
    // 注意：asList 返回的 List 大小固定，不能添加或删除元素
    // list.add("D"); // 抛出 UnsupportedOperationException
    
    // 如果需要可变 List，需要用 new ArrayList<>(Arrays.asList(array))
    
    // sort：排序
    int[] numbers = {3, 1, 4, 1, 5, 9};
    Arrays.sort(numbers);
    System.out.println("Sorted: " + Arrays.toString(numbers));
    
    // binarySearch：二分查找
    int index = Arrays.binarySearch(numbers, 4);
    System.out.println("Index of 4: " + index);
    
    // fill：填充
    int[] filled = new int[5];
    Arrays.fill(filled, 10);
    System.out.println("Filled: " + Arrays.toString(filled));
    
    // copyOf：复制
    int[] copied = Arrays.copyOf(numbers, 3);
    System.out.println("Copied: " + Arrays.toString(copied));
    
    // equals：比较
    int[] a = {1, 2, 3};
    int[] b = {1, 2, 3};
    System.out.println("Equals: " + Arrays.equals(a, b)); // 输出: true
  }
}

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

public class CollectionsExample {
  public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    list.add(3);
    list.add(1);
    list.add(4);
    list.add(2);
    
    System.out.println("Original list: " + list);
    
    // 排序
    Collections.sort(list);
    System.out.println("Sorted list: " + list);
    
    // 反转
    Collections.reverse(list);
    System.out.println("Reversed list: " + list);
    
    // 洗牌
    Collections.shuffle(list);
    System.out.println("Shuffled list: " + list);
    
    // 查找最大值和最小值
    System.out.println("Max: " + Collections.max(list));
    System.out.println("Min: " + Collections.min(list));
    
    // 查找元素索引（列表必须有序）
    Collections.sort(list);
    System.out.println("Binary search: " + Collections.binarySearch(list, 3));
    
    // 替换所有元素
    Collections.replaceAll(list, 3, 10);
    System.out.println("After replaceAll: " + list);
    
    // 填充
    Collections.fill(list, 0);
    System.out.println("After fill: " + list);
    
    // 创建不可修改的集合
    List<Integer> unmodifiableList = Collections.unmodifiableList(new ArrayList<>(list));
    // unmodifiableList.add(5); // 抛出 UnsupportedOperationException
    
    // 创建同步的集合
    List<Integer> synchronizedList = Collections.synchronizedList(list);
    
    // 创建单元素集合
    List<Integer> singletonList = Collections.singletonList(1);
    System.out.println("Singleton list: " + singletonList);
    
    // 创建空集合
    List<Integer> emptyList = Collections.emptyList();
    System.out.println("Empty list: " + emptyList);
  }
}

import java.util.ArrayList;
import java.util.List;

public class GenericCollectionExample {
  public static void main(String[] args) {
    // 使用泛型指定集合中存储的元素类型
    List<String> stringList = new ArrayList<>();
    stringList.add("Hello");
    stringList.add("World");
    // stringList.add(123); // 编译错误，不能添加非 String 类型的元素
    
    // 泛型方法
    List<Integer> intList = createList(1, 2, 3);
    System.out.println("Integer list: " + intList);
  }
  
  // 泛型方法
  @SafeVarargs
  public static <T> List<T> createList(T... items) {
    List<T> list = new ArrayList<>();
    for (T item : items) {
      list.add(item);
    }
    return list;
  }
}

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Java8CollectionFeatures {
  public static void main(String[] args) {
    List<String> list = Arrays.asList("Apple", "Banana", "Cherry", "Date");
    
    // 过滤和转换
    List<String> filtered = list.stream()
      .filter(s -> s.length() > 5)
      .map(String::toUpperCase)
      .collect(Collectors.toList());
    
    System.out.println("Filtered list: " + filtered);
    
    // 分组
    Map<Integer, List<String>> groupedByLength = list.stream()
      .collect(Collectors.groupingBy(String::length));
    
    System.out.println("Grouped by length: " + groupedByLength);
    
    // 求和、平均值等
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    int sum = numbers.stream().mapToInt(Integer::intValue).sum();
    double average = numbers.stream().mapToInt(Integer::intValue).average().orElse(0);
    
    System.out.println("Sum: " + sum);
    System.out.println("Average: " + average);
    
    // 并行流
    int parallelSum = numbers.parallelStream().mapToInt(Integer::intValue).sum();
    System.out.println("Parallel sum: " + parallelSum);
  }
}

import java.util.Arrays;
import java.util.List;

public class AsListPitfall {
  public static void main(String[] args) {
    String[] array = {"A", "B", "C"};
    List<String> list = Arrays.asList(array);
    
    // list.add("D"); // 抛出 UnsupportedOperationException
    // list.remove(0); // 抛出 UnsupportedOperationException
    
    // 正确做法：创建新的 ArrayList
    List<String> mutableList = new ArrayList<>(Arrays.asList(array));
    mutableList.add("D"); // 正常
    System.out.println(mutableList);
  }
}

import java.util.ArrayList;
import java.util.List;

public class ArrayListCapacityExample {
  public static void main(String[] args) {
    // 如果知道元素数量，建议指定初始容量，避免多次扩容
    List<String> list = new ArrayList<>(1000); // 初始容量 1000
    
    // 添加 1000 个元素不会触发扩容
    for (int i = 0; i < 1000; i++) {
      list.add("Element" + i);
    }
  }
}

import java.util.ArrayList;
import java.util.List;

public class SubListPitfall {
  public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
      list.add(i);
    }
    
    List<Integer> subList = list.subList(0, 5);
    
    // 修改 subList 会影响原列表
    subList.set(0, 100);
    System.out.println("Original list: " + list); // 原列表也被修改
    
    // 删除 subList 的元素也会影响原列表
    subList.clear();
    System.out.println("After clear: " + list); // 原列表的前 5 个元素被删除
    
    // 注意：如果对原列表进行结构性修改（添加/删除），subList 的操作会抛出异常
  }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

class Student {
  private String id;
  private String name;
  
  public Student(String id, String name) {
    this.id = id;
    this.name = name;
  }
  
  // 必须重写 equals() 和 hashCode()
  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return Objects.equals(id, student.id);
  }
  
  @Override
  public int hashCode() {
    return Objects.hash(id);
  }
}

public class CustomKeyPitfall {
  public static void main(String[] args) {
    Map<Student, Integer> map = new HashMap<>();
    Student s1 = new Student("001", "张三");
    Student s2 = new Student("001", "张三");
    
    map.put(s1, 100);
    System.out.println("Value: " + map.get(s2)); // 如果不重写 equals 和 hashCode，输出 null
  }
}

import java.util.HashMap;
import java.util.Map;

public class StringComparisonPitfall {
  public static void main(String[] args) {
    Map<String, Integer> map = new HashMap<>();
    map.put("key", 1);
    
    String key = new String("key");
    System.out.println(map.get(key)); // 输出: 1，因为 HashMap 使用 equals 比较
    
    // 错误：使用 == 比较字符串
    String a = "hello";
    String b = new String("hello");
    System.out.println(a == b); // 输出: false
    System.out.println(a.equals(b)); // 输出: true
  }
}

import java.util.HashMap;
import java.util.Map;

public class WordFrequencyExample {
  public static void main(String[] args) {
    String text = "hello world hello java world";
    
    // 统计单词频率
    Map<String, Integer> frequency = new HashMap<>();
    for (String word : text.split(" ")) {
      frequency.merge(word, 1, Integer::sum); // Java 8+ 方法
    }
    
    System.out.println("Word frequency: " + frequency);
    // 输出: {hello=2, world=2, java=1}
    
    // 找出出现次数最多的单词
    frequency.entrySet().stream()
      .max(Map.Entry.comparingByValue())
      .ifPresent(entry -> System.out.println("Most frequent: " + entry.getKey()));
  }
}

import java.util.LinkedHashMap;
import java.util.Map;

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

public class LRUCacheExample {
  public static void main(String[] args) {
    LRUCache<String, Integer> cache = new LRUCache<>(3);
    
    cache.put("A", 1);
    cache.put("B", 2);
    cache.put("C", 3);
    System.out.println("Initial: " + cache);
    
    cache.get("A"); // 访问 A
    cache.put("D", 4); // 添加 D，B 被淘汰
    System.out.println("After adding D: " + cache); // 输出: {C=3, A=1, D=4}
  }
}

import java.util.PriorityQueue;
import java.util.Queue;

class Task implements Comparable<Task> {
  private String name;
  private int priority;
  
  public Task(String name, int priority) {
    this.name = name;
    this.priority = priority;
  }
  
  @Override
  public int compareTo(Task other) {
    return Integer.compare(this.priority, other.priority); // 优先级小的先执行
  }
  
  @Override
  public String toString() {
    return "Task{name='" + name + "', priority=" + priority + "}";
  }
}

public class TaskSchedulerExample {
  public static void main(String[] args) {
    Queue<Task> taskQueue = new PriorityQueue<>();
    
    taskQueue.offer(new Task("Low priority task", 3));
    taskQueue.offer(new Task("High priority task", 1));
    taskQueue.offer(new Task("Medium priority task", 2));
    
    // 按优先级执行任务
    while (!taskQueue.isEmpty()) {
      System.out.println("Executing: " + taskQueue.poll());
    }
    // 输出顺序: High priority task -> Medium priority task -> Low priority task
  }
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

class Counter {
  private ConcurrentMap<String, Integer> counters = new ConcurrentHashMap<>();
  
  public void increment(String key) {
    counters.merge(key, 1, Integer::sum);
  }
  
  public int get(String key) {
    return counters.getOrDefault(key, 0);
  }
  
  public void printAll() {
    counters.forEach((k, v) -> System.out.println(k + ": " + v));
  }
}

public class CounterExample {
  public static void main(String[] args) throws InterruptedException {
    Counter counter = new Counter();
    
    // 模拟多线程环境
    Runnable task = () -> {
      for (int i = 0; i < 1000; i++) {
        counter.increment("key");
      }
    };
    
    Thread[] threads = new Thread[10];
    for (int i = 0; i < 10; i++) {
      threads[i] = new Thread(task);
      threads[i].start();
    }
    
    for (Thread thread : threads) {
      thread.join();
    }
    
    counter.printAll(); // 输出: key: 10000
  }
}