Java 容器框架 (JCF)

🔄 数组 ↔ 集合

// 数组 → 集合
String[] array = {"张三", "李四", "王五"};

// 方式1: Arrays.asList()（长度固定）
List<String> list1 = Arrays.asList(array);
// list1.add("新元素"); // 抛出异常

// 方式2: new ArrayList<>()（可修改）
List<String> list2 = new ArrayList<>(Arrays.asList(array));

// 集合 → 数组
List<String> list = Arrays.asList("A", "B", "C");

// 方式1: toArray(T[] array)
String[] array1 = list.toArray(new String[0]);

// 方式2: toArray()（返回Object[]）
Object[] array2 = list.toArray();
                        

🔄 List ↔ Set

List<String> list = Arrays.asList("张三", "李四", "张三", "王五");

// List → Set（自动去重）
Set<String> set = new HashSet<>(list);
System.out.println(set); // [张三, 李四, 王五]

// Set → List
List<String> uniqueList = new ArrayList<>(set);

// 实际应用：快速去重
public static <T> List<T> removeDuplicates(List<T> list) {
    return new ArrayList<>(new HashSet<>(list));
}

// 使用示例
List<String> names = Arrays.asList("张三", "李四", "张三");
List<String> uniqueNames = removeDuplicates(names);
                        

📊 排序与打乱

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

// 排序（升序）
Collections.sort(numbers); // [1, 1, 3, 4, 5, 9]

// 降序排序
Collections.sort(numbers, Collections.reverseOrder());

// 打乱顺序
Collections.shuffle(numbers);

// 反转
Collections.reverse(numbers);

// 旋转（将后面元素移到前面）
Collections.rotate(numbers, 2);
                        

🔍 查找与统计

List<String> names = Arrays.asList(
    "张三", "李四", "王五", "张三");

// 查找最大最小值
String max = Collections.max(names);
String min = Collections.min(names);

// 二分查找（需要先排序）
List<Integer> sorted = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
int index = Collections.binarySearch(sorted, 3); // 2

// 统计出现次数
int count = Collections.frequency(names, "张三"); // 2

// 替换所有元素
List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
Collections.fill(list, "默认值");
                        

🔧 创建特殊集合

// 不可变集合
List<String> immutable = Collections.unmodifiableList(
    new ArrayList<>(Arrays.asList("A", "B")));

// 单元素集合
List<String> single = Collections.singletonList("OnlyOne");

// 空集合
List<String> empty = Collections.emptyList();

// 同步集合（线程安全）
List<String> syncList = Collections.synchronizedList(
    new ArrayList<>());
                        

💡 实际应用案例

// 案例1：洗牌算法
public static <T> void shuffleList(List<T> list) {
    Collections.shuffle(list, new Random());
}

// 案例2：查找Top N元素
public static List<Integer> getTopN(List<Integer> list, int n) {
    List<Integer> copy = new ArrayList<>(list);
    Collections.sort(copy, Collections.reverseOrder());
    return copy.subList(0, Math.min(n, copy.size()));
}
                        

📊 ArrayList vs 普通数组

// 普通数组 - 容量固定
String[] array = new String[5];
// array[6] = "越界"; // 数组越界异常

// ArrayList - 自动扩容
List<String> list = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
    list.add("元素" + i); // 自动扩容
}

// ArrayList内部维护一个Object[]数组
// transient Object[] elementData;
// private int size;
                        

⚡ 扩容机制详解

// ArrayList扩容源码分析
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5倍扩容

    if (newCapacity - minCapacity < 0) {
        newCapacity = minCapacity;
    }

    elementData = Arrays.copyOf(elementData, newCapacity);
}

// 扩容过程：
// 1. 创建新数组（1.5倍大小）
// 2. 复制旧数组到新数组
// 3. 丢弃旧数组
                        

⚡ ArrayList vs LinkedList

// 性能对比测试
public class ListPerformanceTest {

    public static void main(String[] args) {
        final int COUNT = 100000;

        // 测试随机访问
        List<Integer> arrayList = new ArrayList<>();
        List<Integer> linkedList = new LinkedList<>();

        // 填充数据
        for (int i = 0; i < COUNT; i++) {
            arrayList.add(i);
            linkedList.add(i);
        }

        // 随机访问测试
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            arrayList.get(new Random().nextInt(COUNT));
        }
        long arrayListTime = System.currentTimeMillis() - start;

        start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            linkedList.get(new Random().nextInt(COUNT));
        }
        long linkedListTime = System.currentTimeMillis() - start;

        System.out.println("ArrayList随机访问: " + arrayListTime + "ms");
        System.out.println("LinkedList随机访问: " + linkedListTime + "ms");
        // 结果：ArrayList快数百倍
    }
}
                        

📊 基本数据结构

// HashMap核心字段
public class HashMap<K,V> {
    // 哈希桶数组
    transient Node<K,V>[] table;

    // 键值对数量
    transient int size;

    // 扩容阈值 = 容量 * 加载因子
    int threshold;

    // 加载因子（默认0.75）
    final float loadFactor;

    // Node节点结构
    static class Node<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
    }
}
                        

🔢 哈希计算过程

// 1. 计算Key的哈希值
static final int hash(Object key) {
    int h;
    // 高16位异或低16位，减少哈希冲突
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

// 2. 计算数组索引位置
// n = table.length 必须是2的幂
int index = (n - 1) & hash;

// 示例：容量16，hash值为5
// n = 16, n-1 = 15 (二进制1111)
// hash = 5 (二进制0101)
// index = 15 & 5 = 5
                        

🔗 Java 7: 链表法

// 哈希冲突时使用链表连接
// 时间复杂度：O(n)

// 插入过程：
// 1. 计算hash和索引
// 2. 遍历链表检查是否已存在
// 3. 不存在则在链表头部插入
// 4. 存在则更新value

// 查找过程：
// 1. 计算hash和索引
// 2. 遍历链表查找目标key
// 3. 找到返回value，未找到返回null

// 缺点：链表过长时性能急剧下降
                        

🌳 Java 8: 链表 + 红黑树

// 链表长度超过8时转换为红黑树
static final int TREEIFY_THRESHOLD = 8;

// 红黑树节点
static final class TreeNode<K,V> extends Node<K,V> {
    TreeNode<K,V> parent;
    TreeNode<K,V> left;
    TreeNode<K,V> right;
    boolean red;
}

// 时间复杂度优化：
// - 链表：O(n)
// - 红黑树：O(log n)

// 转换条件：
// 1. 链表长度 >= 8
// 2. 桶数组容量 >= 64
                        

⚖️ 加载因子选择

// 默认加载因子0.75的权衡：
// - 0.75：时间和空间的平衡
// - 更大：减少扩容但增加冲突
// - 更小：减少冲突但增加扩容

// 内存敏感场景：0.5
Map<K, V> map1 = new HashMap<>(capacity, 0.5f);

// 性能优先场景：0.9
Map<K, V> map2 = new HashMap<>(capacity, 0.9f);

// 一般场景：使用默认0.75
Map<K, V> map3 = new HashMap<>(capacity);
                        

🔤 Comparable：自然排序

// 定义在类内部，实现自然排序规则
public class Student implements Comparable<Student> {
    private String name;
    private int age;
    private double gpa;

    public Student(String name, int age, double gpa) {
        this.name = name;
        this.age = age;
        this.gpa = gpa;
    }

    // ✅ 实现compareTo方法
    @Override
    public int compareTo(Student other) {
        // 按年龄升序排序
        return Integer.compare(this.age, other.age);

        // 其他比较方式：
        // return this.name.compareTo(other.name); // 按姓名
        // return Double.compare(this.gpa, other.gpa); // 按GPA
    }

    // getter和setter方法...
}

// 使用方式
List<Student> students = Arrays.asList(
    new Student("张三", 20, 3.5),
    new Student("李四", 18, 3.8),
    new Student("王五", 22, 3.2)
);

Collections.sort(students); // 直接排序，使用自然排序规则
                        

🛠️ Comparator：自定义排序

// 定义在外部，灵活的排序规则
public class StudentComparator {

    // 按姓名排序
    public static Comparator<Student> byName() {
        return Comparator.comparing(Student::getName);
    }

      // 按GPA降序排序
    public static Comparator<Student> byGpaDescending() {
        return Comparator.comparing(Student::getGpa)
                           .reversed();
    }

    // 多条件排序：先按GPA降序，再按年龄升序
    public static Comparator<Student> complexSorting() {
        return Comparator.comparing(Student::getGpa)
                           .reversed()
                           .thenComparing(Student::getAge);
    }
}

// 使用方式
List<Student> students = new ArrayList<>();

// 方式1: 使用Comparator排序
Collections.sort(students, StudentComparator.byName());

// 方式2: Java 8 Lambda表达式
students.sort(Comparator.comparing(Student::getAge));

// 方式3: 复杂排序
students.sort(StudentComparator.complexSorting());
                        

🌳 TreeSet和TreeMap的排序

// 使用Comparable的自然排序
public class Person implements Comparable<Person> {
    private String name;
    private int age;

    @Override
    public int compareTo(Person other) {
        // 按姓名排序
        return this.name.compareTo(other.name);
    }
}

// TreeSet自动排序
Set<Person> people = new TreeSet<>();
people.add(new Person("张三", 20));
people.add(new Person("李四", 18));
people.add(new Person("王五", 22));

// 输出是按姓名排序的
people.forEach(System.out::println);

// ❌ 如果Person没有实现Comparable
// ClassCastException异常
                        

// 方式1: 构造时传入Comparator
Set<Student> students = new TreeSet<>(
    Comparator.comparing(Student::getGpa)
              .reversed() // GPA降序
              .thenComparing(Student::getAge) // GPA相同时按年龄
);

// 方式2: 使用匿名内部类
Set<Student> students2 = new TreeSet<>(new Comparator<Student>() {
    @Override
    public int compare(Student s1, Student s2) {
        return s1.getAge() - s2.getAge();
    }
});

// 方式3: 自定义Comparator类
class StudentAgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        return Integer.compare(s1.getAge(), s2.getAge());
    }
}

Set<Student> students3 = new TreeSet<>(new StudentAgeComparator());
                        

🔧 Comparator 高级用法

// Java 8 Comparator的强大功能

// 1. 基本比较
Comparator<Student> byAge = Comparator.comparing(Student::getAge);

// 2. 逆序
Comparator<Student> byAgeDesc = Comparator.comparing(Student::getAge)
                                                   .reversed();

// 3. 多条件排序
Comparator<Student> complex = Comparator.comparing(Student::getGpa)
                                         .reversed()
                                         .thenComparing(Student::getAge)
                                         .thenComparing(Student::getName);

// 4. 处理null值
Comparator<Student> nullSafe = Comparator.comparing(Student::getName,
                                                   Comparator.nullsFirst(naturalOrder()));

// 5. 自定义比较逻辑
Comparator<Student> custom = Comparator.comparing(student -> {
    if (student.getGpa() >= 4.0) return "A";
    if (student.getGpa() >= 3.0) return "B";
    return "C";
});

// 实际应用示例
List<Student> students = getStudentList();

// 复杂排序：先按成绩等级，再按具体成绩，最后按姓名
students.sort(
    Comparator.comparing((Student s) -> {
        if (s.getGpa() >= 4.0) return 3;
        if (s.getGpa() >= 3.5) return 2;
        if (s.getGpa() >= 3.0) return 1;
        return 0;
    }).reversed()
     .thenComparing(Student::getGpa).reversed()
     .thenComparing(Student::getName)
);
                    

📚 实战应用案例

public class StudentSorter {

    public static void sortStudents(List<Student> students, String criteria) {
        switch (criteria) {
            case "name":
                students.sort(Comparator.comparing(Student::getName));
                break;
            case "age":
                students.sort(Comparator.comparing(Student::getAge));
                break;
            case "gpa":
                students.sort(Comparator.comparing(Student::getGpa).reversed());
                break;
            case "comprehensive":
                students.sort(
                    Comparator.comparing(Student::getGpa).reversed()
                             .thenComparing(Student::getAge)
                             .thenComparing(Student::getName)
                );
                break;
        }
    }
}
                        

public class MapSorter {

    // 按Key排序
    public static <K, V> Map<K, V> sortByKey(Map<K, V> map, Comparator<K> comparator) {
        return map.entrySet().stream()
                .sorted(Map.Entry.comparingByKey(comparator))
                .collect(Collectors.toMap(
                    Map.Entry::getKey,
                    Map.Entry::getValue,
                    (oldValue, newValue) -> oldValue,
                    LinkedHashMap::new
                ));
    }

    // 按Value排序
    public static <K, V extends Comparable<V>> Map<K, V> sortByValue(Map<K, V> map) {
        return map.entrySet().stream()
                .sorted(Map.Entry.comparingByValue())
                .collect(Collectors.toMap(
                    Map.Entry::getKey,
                    Map.Entry::getValue,
                    (oldValue, newValue) -> oldValue,
                    LinkedHashMap::new
                ));
    }
}