java集合（超详细）

hi，我是程序员王也，一个资深Java开发工程师，平时十分热衷于技术副业变现和各种搞钱项目的程序员~，如果你也是，可以一起交流交流。

今天我们来聊聊Java集合~

1. Java集合框架基础

集合与数组的区别

在Java中，数组是一种固定大小的数据结构，用于存储具有相同类型的对象。与之相比，集合是更灵活的数据结构，它们可以增长和收缩，并且提供了更多的操作和算法。

案例源码：

// 数组示例
String[] names = new String[3];
names[0] = "Alice";
names[1] = "Bob";
names[2] = "Charlie";

// 集合示例
List<String> namesList = new ArrayList<>();
namesList.add("Alice");
namesList.add("Bob");
namesList.add("Charlie");

数组的大小固定，适合在元素数量已知且不变时使用。而集合则提供了更大的灵活性，允许动态地添加和移除元素。集合的接口和实现类提供了丰富的方法，使得集合操作更加方便和直观。

集合框架的主要接口

Java集合框架由多个接口组成，这些接口定义了集合的基本操作。

• Collection：集合的最基本接口，代表任何不允许重复的一组对象。
• List：继承自Collection，是一个有序的集合，可以包含重复元素。
• Set：也继承自Collection，是一个不允许重复的集合。
• Map：不是Collection的子接口，代表键值对的集合，每个键只能映射到一个值。

案例源码：

// 使用List
List<String> list = new ArrayList<>();
list.add("Java");
list.add(1, "Kotlin"); // 插入指定位置

// 使用Set
Set<String> set = new HashSet<>();
set.add("Java");
set.add("Kotlin");

// 使用Map
Map<String, String> map = new HashMap<>();
map.put("Java", "JVM");
map.put("Kotlin", "JVM");

选择合适的集合接口对于编写高效和可读的代码至关重要。List、Set和Map各自适用于不同的场景，例如，当需要保持元素顺序时使用List，当需要唯一性时使用Set，而当需要存储键值对时使用Map。

泛型在集合中的使用

泛型允许在集合中指定存储对象的类型，从而提供了编译时的类型检查。

案例源码：

// 泛型集合
List<String> stringList = new ArrayList<>();
stringList.add("Hello"); // 正确
// stringList.add(1); // 编译错误，因为集合指定了String类型

Map<String, Integer> map = new HashMap<>();
map.put("One", 1); // 正确
// map.put("Two", "2"); // 编译错误，因为值的类型被指定为Integer

泛型是Java类型系统的重要组成部分，它提高了集合使用的安全性。通过在集合声明时指定具体的类型参数，可以避免运行时的类型转换错误，同时也使得代码的意图更加清晰。然而，泛型也带来了一些限制，如在某些情况下无法使用泛型数组，这要求开发者在使用时做出适当的权衡。

第二部分：常用集合类实现

1. ArrayList 和 LinkedList

ArrayList是基于动态数组实现的，而LinkedList是基于双向链表实现的。它们都实现了List接口。

案例源码：

// 使用ArrayList
List<String> arrayList = new ArrayList<>();
arrayList.add("Java");
arrayList.add(1, "Kotlin"); // 插入特定位置

// 使用LinkedList
List<String> linkedList = new LinkedList<>();
linkedList.add("Java");
linkedList.add(0, "Kotlin"); // 插入特定位置

ArrayList适合随机访问，而LinkedList适合插入和删除操作。在选择列表实现时，需要根据实际的用例来决定。如果应用场景中包含大量的插入和删除操作，LinkedList可能是更好的选择。相反，如果需要频繁地随机访问元素，ArrayList将提供更好的性能。

2. HashSet、LinkedHashSet 和 TreeSet

HashSet是基于哈希表实现的，不保证元素的顺序。LinkedHashSet也是基于哈希表，但它维护了一个链表来保证插入顺序。TreeSet是基于红黑树实现的，可以保持元素的排序。

案例源码：

// 使用HashSet
Set<String> hashSet = new HashSet<>();
hashSet.add("Java");
hashSet.add("Kotlin");

// 使用LinkedHashSet
Set<String> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add("Java");
linkedHashSet.add("Kotlin");

// 使用TreeSet
Set<String> treeSet = new TreeSet<>();
treeSet.add("Java");
treeSet.add("Kotlin");

选择Set实现时，需要考虑对元素顺序的需求。如果不需要考虑顺序，HashSet通常提供最好的性能。如果需要保持插入顺序，LinkedHashSet是一个好选择。如果需要自然排序或根据某些属性进行排序，TreeSet是合适的选择。

3. HashMap、LinkedHashMap 和 TreeMap

HashMap是基于哈希表实现的，不保证映射的顺序。LinkedHashMap也是基于哈希表，但它维护了一个双向链表来保持插入顺序。TreeMap是基于红黑树实现的，可以保持键的排序。

案例源码：

// 使用HashMap
Map<String, String> hashMap = new HashMap<>();
hashMap.put("Java", "JVM");
hashMap.put("Kotlin", "JVM");

// 使用LinkedHashMap
Map<String, String> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("Java", "JVM");
linkedHashMap.put("Kotlin", "JVM");

// 使用TreeMap
Map<String, String> treeMap = new TreeMap<>();
treeMap.put("Java", "JVM");
treeMap.put("Kotlin", "JVM");

HashMap是最常用的映射实现，提供快速的查找和更新操作。如果需要保持映射的插入顺序，可以使用LinkedHashMap。如果需要根据键排序，TreeMap是必要的选择。在选择映射实现时，还需要考虑线程安全性和性能因素。

4. EnumMap 和 EnumSet

EnumMap和EnumSet是专门为枚举类型设计的集合类。

案例源码：

// 使用EnumMap
enum Color { RED, GREEN, BLUE }
Map<Color, String> enumMap = new EnumMap<>(Color.class);
enumMap.put(Color.RED, "Ruby");
enumMap.put(Color.GREEN, "Emerald");

// 使用EnumSet
Set<Color> enumSet = EnumSet.of(Color.RED, Color.BLUE);

EnumMap和EnumSet提供了一种紧凑且高效的方式来处理枚举类型的集合。它们在内部使用数组而不是哈希表，这使得它们在处理枚举类型时比普通的HashMap或HashSet更节省内存且性能更好。

第三部分：集合操作与算法

1. 集合的遍历、搜索和排序

Java集合框架提供了多种方法来遍历集合、搜索元素以及对元素进行排序。

遍历

可以使用增强型for循环、迭代器或Java 8的流（Stream）来遍历集合。

案例源码：

// 使用增强型for循环遍历List
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Kotlin");
for (String language : list) {
    System.out.println(language);
}

// 使用迭代器遍历Set
Set<String> set = new HashSet<>();
set.add("Java");
set.add("Kotlin");
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

// 使用Java 8 Stream遍历Map
Map<String, String> map = new HashMap<>();
map.put("Java", "JVM");
map.put("Kotlin", "JVM");
map.forEach((key, value) -> System.out.println(key + " runs on " + value));

增强型for循环提供了一种简洁的方式来遍历集合，尤其适合简单场景。迭代器模式则更安全，可以避免在遍历过程中修改集合。Java 8的流提供了一种强大的数据处理方式，允许进行复杂的操作，如过滤、映射和聚合。

搜索

可以使用List的indexOf和lastIndexOf方法来搜索特定元素。

案例源码：

List<String> list = Arrays.asList("Java", "Kotlin", "Scala", "Groovy");
int index = list.indexOf("Kotlin"); // 返回1

搜索操作在集合中非常常见，尤其是在List中。选择合适的搜索算法可以提高查找效率，特别是在大型数据集中。

排序

可以使用Collections类或Java 8的流来对集合进行排序。

案例源码：

// 使用Collections.sort()对List进行排序
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Kotlin");
Collections.sort(list);

// 使用Java 8 Stream对List进行自定义排序
List<String> sortedList = list.stream()
    .sorted((s1, s2) -> s1.compareTo(s2))
    .collect(Collectors.toList());

排序是集合操作中的一个基本功能。Collections.sort()方法适用于对List进行自然排序，而Java 8的流允许进行更复杂的排序逻辑，包括自定义比较器。

2. 集合的转换和不可变集合

Java集合框架允许将一种类型的集合转换为另一种类型。

转换

可以使用Collections类或Java 8的流来进行集合转换。

案例源码：

// 将List转换为Set
List<String> list = Arrays.asList("Java", "Kotlin", "Java");
Set<String> set = new HashSet<>(list);

// 使用Java 8 Stream将List转换为Map
Map<String, Integer> map = list.stream()
    .collect(Collectors.toMap(
        String::toString, 
        s -> 1, 
        (existing, replacement) -> existing
    ));

集合转换是处理集合数据时的一个常见需求。Java 8的流提供了一种强大且灵活的方式来进行转换，包括收集到不同的集合类型或构建复杂的数据结构。

不可变集合

不可变集合是指一旦创建后就不能被修改的集合，它们提供了更好的线程安全性。

案例源码：

// 创建不可变List
List<String> immutableList = Collections.unmodifiableList(new ArrayList<>(Arrays.asList("Java", "Kotlin")));

// 创建不可变Set
Set<String> immutableSet = Collections.unmodifiableSet(new HashSet<>(Arrays.asList("Java", "Kotlin")));

不可变集合是编写安全并发程序的一个有用工具。它们提供了一种简单的方法来确保集合的状态不会在程序的其他部分被意外地修改。

3. 集合的算法操作

Collections和Arrays类提供了多种静态方法来操作集合和数组。

Collections类

Collections类提供了翻转、排序、二分查找和填充等算法。

案例源码：

List<String> list = Arrays.asList("Java", "Kotlin", "Scala");
Collections.reverse(list); // 翻转List
Collections.shuffle(list); // 随机打乱List

Collections类的方法对于操作集合非常有用，尤其是在需要对集合进行一些常见操作时，如排序或随机打乱。

Arrays类

Arrays类同样提供了排序、二分查找和填充等算法，但它们是针对数组的。

案例源码：

Integer[] array = {3, 1, 4, 1, 5};
Arrays.sort(array); // 排序数组
int index = Arrays.binarySearch(array, 4); // 二分查找

Arrays类的方法对于操作数组非常有用，尤其是当需要对数组进行排序或查找操作时。这些方法通常比手写的算法更高效，因为它们是经过优化的。

第四部分：集合的性能考量

1. 不同集合类型的性能特点

了解不同集合类型的性能特点对于选择合适的数据结构至关重要。

ArrayList vs LinkedList

• ArrayList：提供快速的随机访问，但插入和删除操作可能较慢（需要移动元素）。
• LinkedList：提供快速的插入和删除操作，但随机访问较慢（需要顺序遍历）。

案例源码：

// ArrayList随机访问
List<String> arrayList = new ArrayList<>();
// ... 添加元素到arrayList
String element = arrayList.get(0); // 快速随机访问

// LinkedList插入操作
List<String> linkedList = new LinkedList<>();
// ... 添加元素到linkedList
linkedList.add(0, "New Element"); // 快速插入到列表头部

选择ArrayList或LinkedList取决于操作的性质。如果需要频繁随机访问元素，应选择ArrayList。如果需要在列表中间插入或删除元素，尤其是在大型数据集中，LinkedList可能是更好的选择。

HashSet vs LinkedHashSet vs TreeSet

• HashSet：无序，快速查找，但不支持元素的有序遍历。
• LinkedHashSet：保持插入顺序，查找速度与HashSet相当。
• TreeSet：保持自然排序，查找速度较慢于前两者，但可以进行有序遍历。

案例源码：

// HashSet快速查找
Set<Integer> hashSet = new HashSet<>();
// ... 添加元素到hashSet
boolean contains = hashSet.contains(42); // 快速查找

// LinkedHashSet保持插入顺序
Set<Integer> linkedHashSet = new LinkedHashSet<>();
// ... 添加元素到linkedHashSet
Iterator<Integer> iterator = linkedHashSet.iterator(); // 按插入顺序遍历

// TreeSet自然排序
Set<Integer> treeSet = new TreeSet<>();
// ... 添加元素到treeSet
Integer first = treeSet.first(); // 获取第一个（最小的）元素

选择HashSet、LinkedHashSet还是TreeSet取决于是否需要保持元素的顺序。如果需要保持插入顺序，选择LinkedHashSet；如果需要自然排序，选择TreeSet。

2. 线程安全和并发集合

在多线程环境中，线程安全是一个重要的考虑因素。

非线程安全集合

标准集合类（如ArrayList、HashMap等）不是线程安全的。

案例源码：

// 错误的多线程使用示例
List<String> list = new ArrayList<>();
// 在多个线程中修改list，可能导致不可预知的行为

线程安全集合

可以使用同步包装器或并发集合类来实现线程安全。

案例源码：

// 使用同步包装器
List<String> syncList = Collections.synchronizedList(new ArrayList<>());

// 使用并发集合类
BlockingQueue<String> queue = new LinkedBlockingQueue<>();
ConcurrentMap<String, String> concurrentMap = new ConcurrentHashMap<>();

在多线程环境中，直接使用非线程安全的集合类可能会导致数据不一致和并发修改异常。使用同步包装器或并发集合类可以避免这些问题，但可能会影响性能。因此，需要根据具体的并发需求和性能要求来选择合适的线程安全解决方案。

3. 选择合适的集合类型

选择正确的集合类型对于程序的性能至关重要。

案例源码：

// 选择合适的集合类型
Deque<String> deque = new ArrayDeque<>();
// 使用deque作为队列
deque.add("Java");
String poll = deque.poll(); // 从队列头部移除并返回元素

选择集合类型时，应考虑数据结构的特性、预期的操作类型以及性能要求。例如，如果需要一个队列结构，ArrayDeque是一个高效的选择，因为它提供了快速的插入和删除操作。

第五部分：实际应用案例

1. 集合在实际编程中的应用场景

集合在Java编程中有着广泛的应用，从简单的数据存储到复杂的数据处理。

数据存储和检索

集合可以用于存储数据并提供快速的数据检索。

案例源码：

// 使用Map存储用户信息
Map<Integer, String> users = new HashMap<>();
users.put(1, "Alice");
users.get(1); // 检索用户信息

数据集合操作

集合常用于执行数据的添加、删除和搜索等操作。

案例源码：

// 使用List存储购物车商品
List<String> shoppingCart = new ArrayList<>();
shoppingCart.add("Milk");
shoppingCart.remove("Milk"); // 从购物车移除商品

2. 设计模式中集合的使用

在设计模式中，集合经常被用来实现如工厂模式、策略模式等。

工厂模式

使用集合存储不同类型的对象，可以方便地实现工厂模式。

案例源码：

// 工厂模式中使用集合存储对象引用
Map<String, Object> products = new HashMap<>();
products.put("apple", new Apple());
products.put("orange", new Orange());

// 工厂方法根据类型获取对象
Object product = products.get("apple");

策略模式

集合可以存储不同的策略实现，用于策略模式的实现。

案例源码：

// 策略模式中使用集合存储策略
List<Strategy> strategies = new ArrayList<>();
strategies.add(new ConcreteStrategyA());
strategies.add(new ConcreteStrategyB());

// 客户端可以根据需要选择不同的策略
Strategy strategy = strategies.get(0);
strategy.execute();

3. 集合与Java 8 Stream API的结合

Java 8引入的Stream API可以与集合框架一起使用，提供强大的数据处理能力。

数据过滤和映射

使用Stream API可以轻松地对集合中的数据进行过滤和映射。

案例源码：

// 使用Stream对List进行过滤和映射
List<String> words = Arrays.asList("Java", "Kotlin", "Scala", "Groovy");
long count = words.stream()
    .filter(word -> word.startsWith("K"))
    .count(); // 计算以"K"开头的单词数量

数据聚合

Stream API也可以用来对集合中的数据进行聚合操作。

案例源码：

// 使用Stream对Map进行聚合
Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 90);
scores.put("Bob", 85);
int totalScore = scores.values().stream()
    .reduce(0, Integer::sum); // 计算总分

集合与Stream API的结合极大地提高了处理集合数据的灵活性和效率。Stream API的引入，使得对集合数据进行复杂的操作变得更加简洁和直观。然而，过度使用Stream可能会导致代码的可读性降低，特别是在复杂的数据处理场景中。因此，合理地使用Stream API，并结合集合框架的其他特性，可以有效地提升程序的性能和可维护性。