Java 容器集合框架详解

Iterable (根接口，提供 for-each 支持)
│
└── Collection
     ├── List
     ├── Set
     └── Queue
Map (独立分支)

transient Object[] elementData;   // 存储元素的数组
private int size;                 // 实际元素个数

// 无参构造：初始为空数组，第一次 add 时扩容到 10
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 指定初始容量
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
    }
}

private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5 倍
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;
    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

transient int size = 0;
transient Node<E> first;
transient Node<E> last;

Deque<String> stack = new LinkedList<>();
stack.push("A");     // 压栈
String top = stack.pop();   // 弹栈
Deque<String> queue = new LinkedList<>();
queue.offer("A");    // 入队
String head = queue.poll(); // 出队

public class HashSet<E> extends AbstractSet<E> implements Set<E>, ... {
    private transient HashMap<E,Object> map;
    private static final Object PRESENT = new Object();
    public boolean add(E e) {
        return map.put(e, PRESENT) == null;
    }
}

Set<String> treeSet = new TreeSet<>();          // 自然排序
Set<String> treeSet2 = new TreeSet<>(Comparator.reverseOrder()); // 倒序

// 扩容后重新分配元素（简化示意）
if ((e.hash & oldCap) == 0) {
    // 保持原位置
} else {
    // 移动到 oldIndex + oldCap
}

// 构造 accessOrder=true 表示按访问顺序排序
LinkedHashMap<K,V> lru = new LinkedHashMap<K,V>(16, 0.75f, true);

// 正确删除
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if (it.next().equals("B")) {
        it.remove();
    }
}
// Java 8 推荐的删除方式
list.removeIf(s -> s.equals("B"));

public class Employee implements Comparable<Employee> {
    private int salary;
    @Override
    public int compareTo(Employee o) {
        return Integer.compare(this.salary, o.salary);
    }
}

Comparator<Employee> byName = (e1, e2) -> e1.getName().compareTo(e2.getName());
Comparator<Employee> bySalaryDesc = (e1, e2) -> Integer.compare(e2.getSalary(), e1.getSalary());
// 链式排序
Comparator<Employee> chain = Comparator.comparing(Employee::getDept)
                                       .thenComparing(Employee::getSalary);

Properties props = new Properties();
// 从类路径加载
try (InputStream in = Thread.currentThread().getContextClassLoader()
        .getResourceAsStream("config.properties")) {
    props.load(in);
}
// 从文件系统加载
try (FileInputStream fis = new FileInputStream("config.properties")) {
    props.load(fis);
}
// 读取属性，提供默认值
String dbUrl = props.getProperty("db.url", "jdbc:mysql://localhost:3306/test");

props.setProperty("app.name", "MyApp");
try (FileOutputStream out = new FileOutputStream("config.properties")) {
    props.store(out, "Application Configuration");
}

// 加载 XML
props.loadFromXML(in);
// 存储为 XML
props.storeToXML(out, "Comment");

class Person {
    String name;
    int age;
    // 构造器、getter、toString 省略
}
List<Person> persons = Arrays.asList(
    new Person("张三", 20),
    new Person("李四", 18),
    new Person("张三", 22)
);
persons.sort(Comparator.comparing(Person::getName)
                       .thenComparingInt(Person::getAge));

String text = "hello world hello java";
Map<String, Integer> freq = new HashMap<>();
for (String word : text.split(" ")) {
    freq.merge(word, 1, Integer::sum);
}
System.out.println(freq);  // {hello=2, world=1, java=1}

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