📦 Java集合框架全解析

一、集合框架概述

Java集合框架（Java Collections Framework）是一套用于存储和操作对象集合的统一架构。它提供了一系列接口和实现类，使得我们可以方便地处理各种数据结构。

二、List接口

List是有序的集合，允许重复元素，可以通过索引访问元素。常用实现类有ArrayList和LinkedList。

2.1 ArrayList

ArrayList基于动态数组实现，支持随机访问，适合频繁读取的场景。

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

public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建ArrayList
        List<String> fruits = new ArrayList<>();
        
        // 添加元素
        fruits.add("苹果");
        fruits.add("香蕉");
        fruits.add("橙子");
        fruits.add("苹果");  // 允许重复
        
        // 访问元素
        System.out.println("第一个水果：" + fruits.get(0));
        
        // 修改元素
        fruits.set(1, "葡萄");
        
        // 删除元素
        fruits.remove("橙子");
        fruits.remove(0);  // 按索引删除
        
        // 遍历
        System.out.println("所有水果：");
        for (String fruit : fruits) {
            System.out.println("  - " + fruit);
        }
        
        // 大小
        System.out.println("水果数量：" + fruits.size());
        
        // 判断是否包含
        System.out.println("是否包含葡萄：" + fruits.contains("葡萄"));
    }
}

2.2 LinkedList

LinkedList基于双向链表实现，适合频繁插入和删除的场景。

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> queue = new LinkedList<>();
        
        // 作为队列使用
        queue.offer("任务1");
        queue.offer("任务2");
        queue.offer("任务3");
        
        // 获取并移除队首元素
        System.out.println("处理：" + queue.poll());  // 任务1
        System.out.println("处理：" + queue.poll());  // 任务2
        
        // 作为栈使用
        LinkedList<String> stack = new LinkedList<>();
        stack.push("底部");
        stack.push("中间");
        stack.push("顶部");
        
        System.out.println("弹出：" + stack.pop());  // 顶部
    }
}

三、Set接口

Set是不允许重复元素的集合。常用实现类有HashSet、LinkedHashSet和TreeSet。

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;
import java.util.Set;

public class SetDemo {
    public static void main(String[] args) {
        // HashSet - 无序
        Set<String> hashSet = new HashSet<>();
        hashSet.add("Java");
        hashSet.add("Python");
        hashSet.add("Java");  // 重复元素，不会被添加
        hashSet.add("C++");
        System.out.println("HashSet: " + hashSet);
        
        // LinkedHashSet - 保持插入顺序
        Set<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("第一");
        linkedHashSet.add("第二");
        linkedHashSet.add("第三");
        System.out.println("LinkedHashSet: " + linkedHashSet);
        
        // TreeSet - 自然排序
        Set<Integer> treeSet = new TreeSet<>();
        treeSet.add(30);
        treeSet.add(10);
        treeSet.add(20);
        System.out.println("TreeSet: " + treeSet);  // [10, 20, 30]
    }
}

四、Map接口

Map存储键值对（key-value），键不能重复。常用实现类有HashMap、LinkedHashMap和TreeMap。

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.TreeMap;
import java.util.Map;

public class MapDemo {
    public static void main(String[] args) {
        // HashMap
        Map<String, Integer> scores = new HashMap<>();
        
        // 添加键值对
        scores.put("张三", 85);
        scores.put("李四", 92);
        scores.put("王五", 78);
        
        // 获取值
        System.out.println("张三的分数：" + scores.get("张三"));
        
        // 修改值
        scores.put("张三", 90);  // 键已存在，更新值
        
        // 判断键是否存在
        if (scores.containsKey("李四")) {
            System.out.println("李四在名单中");
        }
        
        // 遍历Map
        System.out.println("\n所有成绩：");
        for (Map.Entry<String, Integer> entry : scores.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
        
        // 遍历键
        System.out.println("\n所有学生：");
        for (String name : scores.keySet()) {
            System.out.println("  - " + name);
        }
        
        // 遍历值
        System.out.println("\n所有分数：");
        for (Integer score : scores.values()) {
            System.out.println("  - " + score);
        }
        
        // getOrDefault - 获取值，不存在则返回默认值
        int score = scores.getOrDefault("赵六", 0);
        System.out.println("\n赵六的分数：" + score);
        
        // 删除
        scores.remove("王五");
        System.out.println("删除后大小：" + scores.size());
    }
}

五、集合工具类

Java提供了Collections工具类，包含许多操作集合的静态方法。

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

public class CollectionsDemo {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(3);
        numbers.add(1);
        numbers.add(4);
        numbers.add(1);
        numbers.add(5);
        
        // 排序
        Collections.sort(numbers);
        System.out.println("排序后：" + numbers);
        
        // 反转
        Collections.reverse(numbers);
        System.out.println("反转后：" + numbers);
        
        // 打乱
        Collections.shuffle(numbers);
        System.out.println("打乱后：" + numbers);
        
        // 最大值和最小值
        System.out.println("最大值：" + Collections.max(numbers));
        System.out.println("最小值：" + Collections.min(numbers));
        
        // 二分查找（需要先排序）
        Collections.sort(numbers);
        int index = Collections.binarySearch(numbers, 4);
        System.out.println("4的位置：" + index);
        
        // 填充
        Collections.fill(numbers, 0);
        System.out.println("填充后：" + numbers);
    }
}

六、Stream API（Java 8+）

Java 8引入的Stream API提供了函数式编程风格来处理集合。

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

public class StreamDemo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        
        // 过滤偶数
        List<Integer> evenNumbers = numbers.stream()
            .filter(n -> n % 2 == 0)
            .collect(Collectors.toList());
        System.out.println("偶数：" + evenNumbers);
        
        // 映射：每个数乘以2
        List<Integer> doubled = numbers.stream()
            .map(n -> n * 2)
            .collect(Collectors.toList());
        System.out.println("乘以2：" + doubled);
        
        // 求和
        int sum = numbers.stream()
            .reduce(0, Integer::sum);
        System.out.println("总和：" + sum);
        
        // 链式操作：过滤、映射、求和
        int result = numbers.stream()
            .filter(n -> n > 5)      // 大于5的数
            .map(n -> n * n)          // 平方
            .reduce(0, Integer::sum); // 求和
        System.out.println("大于5的数的平方和：" + result);
        
        // 字符串处理
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
        String joined = names.stream()
            .filter(name -> name.length() > 3)
            .map(String::toUpperCase)
            .collect(Collectors.joining(", "));
        System.out.println("处理后：" + joined);
    }
}

七、总结

Java集合框架是日常开发中最常用的API之一。选择合适的集合类型对于程序性能至关重要：

• 需要有序且可重复 → ArrayList
• 频繁插入删除 → LinkedList
• 不允许重复 → HashSet
• 需要排序的不重复集合 → TreeSet
• 键值对存储 → HashMap
• 有序的键值对 → LinkedHashMap 或 TreeMap