Java集合详解

Java 集合是用于存储、处理和操作对象集合的一组框架和接口。Java 集合由接口、类和算法组成。本文将从多个方面对 Java 集合进行详细的阐述，包括集合框架的概述、数据结构、常用的集合接口、常用的集合类、算法等。

一、Java 集合框架概述

Java 集合框架是一个体系结构，它包括了一组接口、实现这些接口的类和算法，用于存储和操作对象集合。Java 集合框架定义了一些接口，包括了：

• List：有序的元素集合，元素可以重复。实现类有 ArrayList、LinkedList、Vector。
• Set：无序的元素集合，元素不可以重复。实现类有 HashSet、TreeSet、LinkedHashSet。
• Map：构成键值对的对象集合，键唯一，值不唯一。实现类有 HashMap、HashTable、TreeMap。
• Queue：一种先进先出的数据结构，实现类有 LinkedList、PriorityQueue。

Java 集合框架的接口和实现类如下图所示：

                 +-------+   Implement   +-----------+
   Collections   | List  | +-----------+ | ArrayList |
     Interfaces  +-------+               +-----------+
                     ^
                     | Extends
                     |
  +-----------+  +-------+  +-----------+
  | Collection|  | Queue |  | Set |  |
  +-----------+  +-------+  +-----------+
                /          |
               /           |
              /            |
  +-----------+      +-----------+
  |    Map    |      | Deque |  |
  +-----------+      +-----------+

Java 集合框架的主要优点有：

• 提供了一组通用的算法，避免了手动实现算法造成的错误。
• 提供了一组可重用的数据结构，避免了重复编写代码。
• 提供了一组标准接口，可以直接使用现成的接口，无需手动实现。

Java 集合框架也有一些缺点，例如性能问题、空间浪费等。但这些缺点并不是无法避免的，需要根据具体情况进行选择和优化。

二、Java 集合数据结构

Java 集合框架的实现依赖于不同的数据结构。常见的数据结构有：

• 数组：ArrayList 和 Vector 基于动态数组实现，具有较好的随机访问性能，但插入和删除操作效率不高，需要移动元素。
• 链表：LinkedList 基于双向链表实现，具有较好的插入和删除操作效率，但随机访问性能不好。
• 散列表：HashMap 和 HashSet 基于散列表实现，可以快速地插入和查找数据，但元素的顺序是无序的。
• 树：TreeMap 和 TreeSet 基于树结构实现，可以对元素进行排序，但插入和删除操作相对较慢。

三、常用的集合接口

Java 集合框架定义了一些常用的接口，包括 Collection、List、Set、Map、Queue 等。下面我们详细介绍这些接口的功能和用法。

1. Collection 接口

Collection 接口是所有集合接口的根接口。它包含了一组通用的操作，例如添加、删除、查询等。常用的实现类有 ArrayList、LinkedList、HashSet、TreeSet 等。

Collection 接口定义了以下常用方法：

• boolean add(E e)：向集合中添加元素。
• boolean addAll(Collection c)：将另一个集合中的元素添加到当前集合中。
• boolean remove(Object o)：从集合中删除指定元素。
• boolean removeAll(Collection c)：从集合中删除另一个集合中包含的所有元素。
• void clear()：从集合中删除所有元素。
• boolean contains(Object o)：判断集合是否包含指定元素。
• boolean containsAll(Collection c)：判断集合是否包含另一个集合中的所有元素。
• boolean isEmpty()：判断集合是否为空。
• int size()：返回集合中元素的个数。
• Object[] toArray()：将集合转换为数组。

2. List 接口

List 接口是有序的元素集合，元素可以重复。它继承自 Collection 接口，增加了一些与位置有关的操作。常用的实现类有 ArrayList、LinkedList、Vector 等。

List 接口定义了以下常用方法：

• void add(int index, E element)：在指定位置插入一个元素。
• boolean addAll(int index, Collection c)：在指定位置插入另一个集合中的元素。
• E get(int index)：返回指定位置的元素。
• E set(int index, E element)：将指定位置的元素替换为新的元素。
• E remove(int index)：删除指定位置的元素。
• int indexOf(Object o)：返回指定元素在集合中第一次出现的位置。
• int lastIndexOf(Object o)：返回指定元素在集合中最后一次出现的位置。
• List subList(int fromIndex, int toIndex)：返回从 fromIndex 到 toIndex 的子列表。

3. Set 接口

Set 接口是无序的元素集合，元素不可以重复。它继承自 Collection 接口。常用的实现类有 HashSet、TreeSet、LinkedHashSet 等。

Set 接口定义了以下常用方法：

• boolean add(E e)：向集合中添加元素。
• boolean addAll(Collection c)：将另一个集合中的元素添加到当前集合中。
• boolean remove(Object o)：从集合中删除指定元素。
• boolean removeAll(Collection c)：从集合中删除另一个集合中包含的所有元素。
• void clear()：从集合中删除所有元素。
• boolean contains(Object o)：判断集合是否包含指定元素。
• boolean containsAll(Collection c)：判断集合是否包含另一个集合中的所有元素。
• boolean isEmpty()：判断集合是否为空。
• int size()：返回集合中元素的个数。
• Object[] toArray()：将集合转换为数组。

4. Map 接口

Map 接口是一种键值对映射，键唯一，值不唯一。它提供了以键值为索引的数据结构。常用的实现类有 HashMap、TreeMap、HashTable、ConcurrentHashMap 等。

Map 接口定义了以下常用方法：

• V put(K key, V value)：将键值对存储到 Map 中。
• void putAll(Map m)：将另一个 Map 中的键值对存储到当前 Map 中。
• V get(Object key)：返回指定键对应的值。
• boolean containsKey(Object key)：判断 Map 是否包含指定的键。
• boolean containsValue(Object value)：判断 Map 是否包含指定的值。
• Set > entrySet()：返回 Map 中的所有键值对。
• Set keySet()：返回 Map 中的所有键。
• Collection values()：返回 Map 中的所有值。
• V remove(Object key)：从 Map 中删除指定的键及其对应的值。
• boolean isEmpty()：判断 Map 是否为空。
• int size()：返回 Map 中键值对的数量。
• void clear()：从 Map 中删除所有的键值对。

5. Queue 接口

Queue 接口是一种先进先出的数据结构，它定义了一组插入和删除元素的方法。常用的实现类有 LinkedList、PriorityQueue 等。

Queue 接口定义了以下常用方法：

• boolean add(E e)：向队列中添加元素。
• boolean offer(E e)：在队列尾部插入一个元素。
• E remove()：删除队列头部的元素。
• E poll()：删除并返回队列头部的元素。
• E element()：获取队列头部的元素，但不删除。
• E peek()：获取队列头部的元素，但不删除，如果队列为空返回 null。

四、常用的集合类

Java 集合框架提供了一些常用的类，这些类实现了集合框架定义的接口，可以直接使用。

1. ArrayList 类

ArrayList 类是一个基于动态数组实现的列表，它可以动态地增加和缩小数组的容量。它继承自 AbstractList 类，实现了 List 接口。

ArrayList 类的主要方法与 List 接口的方法相同，例如 add、get、set、remove 等。下面是 ArrayList 类的示例代码：

import java.util.ArrayList;

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("Alice");
        list.add("Bob");
        list.add("Charlie");
        System.out.println(list.get(0));
        System.out.println(list.size());
        list.remove("Bob");
        System.out.println(list.size());
    }
}

  

2. HashSet 类

HashSet 类是基于散列表实现的集合，它不能保证元素的顺序，但可以快速的添加、删除和查询元素。它继承自 AbstractSet 类，实现了 Set 接口。

HashSet 类的主要方法与 Set 接口的方法相同，例如 add、remove、contains 等。下面是 HashSet 类的示例代码：

import java.util.HashSet;

public class HashSetTest {
    public static void main(String[] args) {
        HashSet set = new HashSet<>();
        set.add("Alice");
        set.add("Bob");
        set.add("Charlie");
        System.out.println(set.contains("Bob"));
        set.remove("Bob");
        System.out.println(set.size());
    }
}

  

3. HashMap 类

HashMap 类是一种基于散列表实现的 Map，它使用键值对存储数据。它继承自 AbstractMap 类，实现了 Map 接口。

HashMap 类