【Java 基础】17 集合

集合框架（Collection Framework）是一组 用于存储和操作数据的类和接口。它提供了一种灵活、高效的数据结构，适用于各种编程场景。

1.基本概念

集合就是把分散的 “东西” 聚集到一起。

集合框架就是为集合提供了一套通用的操作方式供使用。

Java 集合框架的设计目标是提供一组通用的、类型安全的接口和实现，使得我们能够轻松地操作和管理数据。

2.核心接口

集合框架的常用核心接口：

接口名称	功能描述	常见实现
Collection	表示一组对象，除 Map 外所有集合的根接口，定义了基本的集合操作，如添加、删除、遍历等	-
List	表示一个有序的集合，允许重复元素	ArrayList、LinkedList 和 Vector等
Set	表示一个不包含重复元素的集合	HashSet、LinkedHashSet 和 TreeSet等
Queue	表示一个有序的集合，是一个先进先出的队列	ArrayDeque等
Map	表示键值对的集合，每个键都唯一	HashMap、LinkedHashMap、TreeMap等

3.常见实现

1）List 接口的实现类

ArrayList

基于动态数组实现，支持快速随机访问。

public static void main(String[] args) {
	List<String> arrayList = new ArrayList<>();
	arrayList.add("b");
    arrayList.add("a");
    arrayList.add("a");
	System.out.println(arrayList);
}

输出结果：[b, a, a]

LinkedList

基于双向链表实现，适合插入和删除操作。

public static void main(String[] args) {
	List<String> linkedList = new LinkedList<>();
	linkedList.add("b");
    linkedList.add("a");
    linkedList.add("a");
	System.out.println(linkedList);
}

输出结果：[b, a, a]

Vector

类似于 ArrayList，但是是线程安全的。

public static void main(String[] args) {
	List<String> vector = new Vector<>();
	vector.add("b");
    vector.add("a");
    vector.add("a");
	System.out.println(vector);
}

输出结果：[b, a, a]

这样简单的存储操作，结果都是相同的，只不过内部的实现方式不同而已。

2）Set 接口的实现类

HashSet

基于哈希表实现，无序且不允许重复元素。

public static void main(String[] args) {
    Set<String> hashSet = new HashSet<>();
    hashSet.add("b");
    hashSet.add("a");
    hashSet.add("a");
    System.out.println(hashSet);
}

输出结果：[a, b]

LinkedHashSet

基于哈希表和链表实现，有序且不允许重复元素。

public static void main(String[] args) {
    Set<String> linkedHashSet = new LinkedHashSet<>();
    linkedHashSet.add("b");
    linkedHashSet.add("a");
    linkedHashSet.add("a");
    System.out.println(linkedHashSet);
}

输出结果：[b, a]

TreeSet

基于红黑树实现，有序且不允许重复元素（ 有序是指可以按照元素的大小顺序自动排序 ）。

public static void main(String[] args) {
    Set<String> treeSet = new TreeSet<>();
    treeSet.add("b");
    treeSet.add("a");
    treeSet.add("a");
    System.out.println(treeSet);
}

输出结果：[a, b]

3）Queue 接口的实现类

ArrayQueue

双端队列，是一种具有队列和栈的性质的数据结构 。 双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。

• 将其用作栈

  public static void main(String[] args) {
      Deque<Integer> stack = new ArrayDeque<>();
      stack.push(0);
      stack.push(1);
      stack.push(2);
      System.out.println(stack);
      System.out.println(stack.pop());
      System.out.println(stack);
  }
  

  输出结果：

  [2, 1, 0]
  2
  [1, 0]

• 将其用作队列

  public static void main(String[] args) {
      Deque<Integer> deque = new ArrayDeque<>();
      deque.offer(0);
      deque.offer(1);
      deque.offer(2);
      System.out.println(deque);
      System.out.println(deque.poll());
      System.out.println(deque);
  }
  

  输出结果：

  [0, 1, 2]
  0
  [1, 2]

4）Map 接口的实现类

HashMap

基于哈希表实现，键值对无序。

public static void main(String[] args) {
    Map<String, String> hashMap = new HashMap<>();
    hashMap.put("b", "bb");
    hashMap.put("a", "aa");
    hashMap.put("a", "aa");
    System.out.println(hashMap);
}

输出结果：{a=aa, b=bb}

LinkedHashMap

基于哈希表和链表实现，键值对有序。

public static void main(String[] args) {
    Map<String, String> linkedHashMap = new LinkedHashMap<>();
    linkedHashMap.put("b", "bb");
    linkedHashMap.put("a", "aa");
    linkedHashMap.put("a", "aa");
    System.out.println(linkedHashMap);
}

输出结果：{b=bb, a=aa}

TreeMap

基于红黑树实现，键值对有序（ 有序是指可以按照元素的大小顺序自动排序 ）。

public static void main(String[] args) {
    Map<String, String> treeMap = new TreeMap<>();
    treeMap.put("b", "bb");
    treeMap.put("a", "aa");
    treeMap.put("a", "aa");
    System.out.println(treeMap);
}

输出结果：{a=aa, b=bb}

4.最佳实践

• 选择合适的集合类型： 根据需求选择不同的集合类型

  例如：需要有序且不允许重复元素，可以选择 TreeSet 或 LinkedHashSet。

• 遍历集合： 使用增强型 for 循环或迭代器进行集合遍历，提高代码的可读性。

  for (String item : list) {
      System.out.println(item);
  }
  

• 使用泛型： 在集合中使用泛型能够提高代码的类型安全性，避免在运行时出现类型转换错误。

• 注意线程安全性： 根据程序的多线程需求选择合适的集合实现

  例如：需要线程安全的集合可以选择 Vector 或使用 Collections.synchronizedList。

• 使用 stream： Java 8 引入了一些便利的集合处理方法

  例如： stream()、filter()、map() 等，可以简化集合操作。

  public static void main(String[] args) {
      List<String> list = new ArrayList<>();
      list.add("Test");
      list.add("Hello world");
      System.out.println("list: " + list);
      List<String> helloList = list.stream()
          .filter(s -> s.startsWith("Hello")).collect(Collectors.toList());
      System.out.println("helloList: " + helloList);
  }
  

  输出结果：

  list: [Test, Hello world]
  helloList: [Hello world]

• 注意集合的性能： 根据集合的使用场景选择合适的实现

  例如：需要高性能的随机访问可以选择 ArrayList，而频繁插入和删除操作可以选择 LinkedList。

• 谨慎使用原始类型： 尽量避免在集合中使用原始类型，使用泛型可以提高代码的可维护性和可读性。

集合框架为我们提供了丰富的工具和选项，能够满足不同场景下的数据存储和操作需求。了解不同集合的特性和使用场景，合理选择和使用集合框架，将有助于编写出高效、可维护的 Java 代码。