java集合详细讲解

Java 8 集合框架详解

Java集合框架是Java中最重要、最常用的API之一，Java 8对其进行了多项增强。下面我将全面讲解Java 8中的集合框架。

一、集合框架概述

Java集合框架主要分为两大类：

1. Collection - 单列集合

   • List：有序可重复
   • Set：无序不重复
   • Queue：队列

2. Map - 双列集合（键值对）

二、List接口及实现类

1. ArrayList

List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

// Java 8新增方法
list.removeIf(s -> s.length() > 4);  // 移除长度大于4的元素
list.replaceAll(String::toUpperCase); // 所有元素转为大写
list.sort(Comparator.naturalOrder()); // 自然排序

2. LinkedList

LinkedList<String> linkedList = new LinkedList<>();
linkedList.addFirst("First");
linkedList.addLast("Last");

// Java 8新增方法
linkedList.removeIf(s -> s.startsWith("F"));

3. Vector (线程安全但性能较低)

三、Set接口及实现类

1. HashSet

Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
set.add(3);

// Java 8新增
set.removeIf(i -> i % 2 == 0);

2. LinkedHashSet (保持插入顺序)

3. TreeSet (自然排序)

TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("Banana");
treeSet.add("Apple");
treeSet.add("Orange");

// Java 8方法
String first = treeSet.first();  // Apple
String last = treeSet.last();    // Orange

四、Queue接口及实现类

1. PriorityQueue

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.add(3);
pq.add(1);
pq.add(2);

pq.poll(); // 1 (最小元素)

2. ArrayDeque

Deque<String> deque = new ArrayDeque<>();
deque.offerFirst("First");
deque.offerLast("Last");

五、Map接口及实现类

1. HashMap

Map<String, Integer> map = new HashMap<>();
map.put("Java", 1);
map.put("Python", 2);
map.put("C++", 3);

// Java 8新增方法
map.compute("Java", (k, v) -> v == null ? 1 : v + 1); // 值+1
map.computeIfAbsent("JavaScript", k -> 4); // 不存在则添加
map.computeIfPresent("Java", (k, v) -> v + 10); // 存在则更新

map.merge("Java", 1, Integer::sum); // 合并值

// 遍历
map.forEach((k, v) -> System.out.println(k + ": " + v));

2. LinkedHashMap (保持插入顺序)

3. TreeMap (按键排序)

TreeMap<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Banana", 1);
treeMap.put("Apple", 2);
treeMap.put("Orange", 3);

// Java 8方法
Map.Entry<String, Integer> first = treeMap.firstEntry();
Map.Entry<String, Integer> last = treeMap.lastEntry();

4. ConcurrentHashMap (线程安全)

ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("One", 1);
concurrentMap.put("Two", 2);

// Java 8新增方法
concurrentMap.forEach(2, (k, v) -> System.out.println(k + ": " + v)); // 并行遍历

六、Java 8集合新特性

1. Stream API

List<String> languages = Arrays.asList("Java", "Python", "C++", "JavaScript");

// 过滤
List<String> filtered = languages.stream()
    .filter(s -> s.startsWith("J"))
    .collect(Collectors.toList());

// 映射
List<Integer> lengths = languages.stream()
    .map(String::length)
    .collect(Collectors.toList());

// 排序
List<String> sorted = languages.stream()
    .sorted(Comparator.reverseOrder())
    .collect(Collectors.toList());

// 聚合操作
long count = languages.stream().count();
Optional<String> max = languages.stream().max(Comparator.naturalOrder());

// 并行流
long countParallel = languages.parallelStream().count();

2. 新的集合方法

Map<String, List<String>> map = new HashMap<>();

// 传统方式
if (!map.containsKey("key")) {
    map.put("key", new ArrayList<>());
}
map.get("key").add("value");

// Java 8方式
map.computeIfAbsent("key", k -> new ArrayList<>()).add("value");

3. 增强的迭代方式

List<String> list = Arrays.asList("a", "b", "c");

// 传统方式
for (String s : list) {
    System.out.println(s);
}

// Java 8方式
list.forEach(System.out::println);

七、集合工具类 Collections

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

// 排序
Collections.sort(numbers);

// Java 8新增
Collections.replaceAll(numbers, 1, 10); // 替换所有1为10

// 不可变集合
List<Integer> immutableList = Collections.unmodifiableList(numbers);

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

八、最佳实践

1. 选择正确的集合类型：

   • 需要快速随机访问 → ArrayList
   • 频繁插入删除 → LinkedList
   • 需要去重 → HashSet
   • 需要键值对 → HashMap

2. 初始化时指定容量（特别是大型集合）

   new ArrayList<>(1000);
   new HashMap<>(16, 0.75f);
   

3. 使用不可变集合（线程安全）

   List<String> list = Collections.unmodifiableList(new ArrayList<>());
   

4. 优先使用Java 8新方法：

   • forEach()
   • removeIf()
   • computeIfAbsent()
   • merge()

5. 考虑并行流处理大数据集

   bigList.parallelStream().filter(...).collect(...);
   

Java 8的集合框架通过这些新特性，使集合操作更加简洁、高效和功能强大。