Java 之集合框架的详细介绍

Java 集合框架提供了一组实现常见数据结构（如列表、集合、映射等）的类和接口，使得数据的存储、检索、操作更加方便和高效。集合框架主要包括以下核心接口和类：

总的介绍

1. Collection 接口

Collection 接口是集合框架的根接口，它定义了一组通用的方法，适用于所有集合类。主要有：

• add(E e): 将指定的元素添加到集合中。
• remove(Object o): 从集合中移除指定的元素。
• size(): 返回集合中的元素数量。
• isEmpty(): 判断集合是否为空。
• contains(Object o): 判断集合是否包含指定的元素。
• iterator(): 返回一个迭代器，用于遍历集合中的元素。

2. List 接口

List 接口继承自 Collection 接口，表示有序的集合，允许重复元素。主要特点是可以通过索引访问元素。常用的实现类有 ArrayList、LinkedList、Vector。

3. Set 接口

Set 接口继承自 Collection 接口，表示不允许重复元素的集合。主要特点是不维护元素的顺序。常用的实现类有 HashSet、LinkedHashSet、TreeSet。

4. Map 接口

Map 接口表示键值对的集合，每个键关联一个值。键不能重复，但值可以。主要方法包括：

• put(K key, V value): 将指定的键值对存储到 Map 中。
• get(Object key): 返回与指定键关联的值。
• remove(Object key): 从 Map 中移除指定键的映射。
• containsKey(Object key): 判断 Map 中是否包含指定的键。
• containsValue(Object value): 判断 Map 中是否包含指定的值。

5. HashMap、LinkedHashMap、TreeMap

• HashMap: 基于哈希表实现，提供快速的检索性能，无固定顺序。
• LinkedHashMap: 在 HashMap 基础上，保持元素插入顺序。
• TreeMap: 基于红黑树实现，按键有序存储。

6. Queue 接口

Queue 接口表示一种先进先出（FIFO）的数据结构，通常用于处理任务调度。主要方法包括 offer(E e)、poll()、peek()。

7. Deque 接口

Deque 接口是 Queue 接口的扩展，表示一种双端队列。可以在两端插入和删除元素。主要方法包括 addFirst(E e)、addLast(E e)、removeFirst()、removeLast()。

ArrayList 类

当使用 ArrayList 类时，您可以执行许多常见的操作，例如添加、获取、修改、删除元素以及其他一些集合操作。以下是 ArrayList 类的详细使用说明：

1. 创建 ArrayList：

import java.util.ArrayList;

public class ArrayListUsage {
    public static void main(String[] args) {
        // 创建一个 ArrayList
        ArrayList<String> cityList = new ArrayList<>();
    }
}
1
2
3
4
5
6
7
8

2. 添加元素：

使用 add 方法向 ArrayList 中添加元素。

cityList.add("Beijing");
cityList.add("Shanghai");
cityList.add("Guangzhou");
1
2
3

3. 插入元素：

使用 add 方法的指定索引位置，将元素插入 ArrayList。

cityList.add(1, "Chengdu");
1

4. 获取元素：

使用 get 方法通过索引获取元素。

String city = cityList.get(0);
1

5. 修改元素：

使用 set 方法通过索引修改元素。

cityList.set(1, "Nanjing");
1

6. 删除元素：

使用 remove 方法通过元素值或索引删除元素。

cityList.remove("Guangzhou");
cityList.remove(0);
1
2

7. 查找元素：

使用 contains 方法判断 ArrayList 中是否包含某个元素。

boolean containsChengdu = cityList.contains("Chengdu");
1

8. 获取大小：

使用 size 方法获取 ArrayList 的大小。

int cityCount = cityList.size();
1

9. 遍历 ArrayList：

使用 for-each 循环遍历 ArrayList。

for (String city : cityList) {
    System.out.println(city);
}
1
2
3

完整示例：

import java.util.ArrayList;

public class ArrayListUsage {
    public static void main(String[] args) {
        // 创建一个 ArrayList
        ArrayList<String> cityList = new ArrayList<>();

        // 添加元素
        cityList.add("Beijing");
        cityList.add("Shanghai");
        cityList.add("Guangzhou");

        // 插入元素
        cityList.add(1, "Chengdu");

        // 获取元素和修改元素
        String firstCity = cityList.get(0);
        cityList.set(1, "Nanjing");

        // 删除元素
        cityList.remove("Guangzhou");
        cityList.remove(0);

        // 查找元素
        boolean containsChengdu = cityList.contains("Chengdu");

        // 获取大小
        int cityCount = cityList.size();

        // 遍历 ArrayList
        System.out.println("遍历城市列表:");
        for (String city : cityList) {
            System.out.println(city);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

这个示例演示了如何使用 ArrayList 进行添加、获取、修改、删除元素以及其他一些集合操作。

set接口以及实现类

HashSet 类

明白了，以下是更简洁的介绍：

创建 HashSet：

Set<String> hashSet = new HashSet<>();
1

添加元素：

hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Orange");
1
2
3

查找元素：

boolean containsBanana = hashSet.contains("Banana");
1

删除元素：

hashSet.remove("Orange");
1

获取大小：

int setSize = hashSet.size();
1

遍历 HashSet：

for (String fruit : hashSet) {
    System.out.println(fruit);
}
1
2
3

这些简单的代码片段展示了 HashSet 的基本操作，包括创建、添加、查找、删除、获取大小和遍历。

用Set 对象实现集合运算

1. 并集（Union）：

Set<Integer> unionSet = new HashSet<>(set1);
unionSet.addAll(set2);
1
2

2. 交集（Intersection）：

Set<Integer> intersectionSet = new HashSet<>(set1);
intersectionSet.retainAll(set2);
1
2

3. 差集（Difference）：

Set<Integer> differenceSet = new HashSet<>(set1);
differenceSet.removeAll(set2);
1
2

判断是否为子集：

boolean isSubset = set1.containsAll(set2);
1

这行代码判断 set2 是否为 set1 的子集，如果是，则 isSubset 为 true。

TreeSet 类

创建 TreeSet：

Set<String> treeSet = new TreeSet<>();
1

添加元素：

treeSet.add("Apple");
treeSet.add("Banana");
treeSet.add("Orange");
1
2
3

查找第一个元素：

String firstElement = ((TreeSet<String>) treeSet).first();
1

删除元素：

treeSet.remove("Orange");
1

获取大小：

int treeSetSize = treeSet.size();
1

遍历 TreeSet：

for (String fruit : treeSet) {
    System.out.println(fruit);
}
1
2
3

这些简洁的代码片段展示了 TreeSet 的基本操作，包括创建、添加、查找、删除、获取大小和遍历。

对象顺序

在 Java 中，对象的顺序通常涉及到两个方面：插入顺序和排序顺序。

1. 插入顺序（Insertion Order）： 插入顺序指的是元素被添加到集合的顺序。例如，如果你按照顺序添加元素 A、B、C 到集合中，那么在遍历集合时，元素的顺序将是 A、B、C。

   示例：

   Set<String> insertionOrderSet = new HashSet<>();
   insertionOrderSet.add("Apple");
   insertionOrderSet.add("Banana");
   insertionOrderSet.add("Orange");
   
   for (String fruit : insertionOrderSet) {
       System.out.println(fruit);
   }
   1
   2
   3
   4
   5
   6
   7
   8

   输出可能是：

   Apple
   Banana
   Orange
   1
   2
   3

2. 排序顺序（Sorting Order）： 排序顺序指的是元素按照一定的顺序排列。在有序的集合中，元素通常按照升序或降序排列。TreeSet 就是一个有序集合的例子，它使用红黑树数据结构来保持元素的顺序。

   示例：

   Set<String> sortingOrderSet = new TreeSet<>();
   sortingOrderSet.add("Apple");
   sortingOrderSet.add("Banana");
   sortingOrderSet.add("Orange");
   
   for (String fruit : sortingOrderSet) {
       System.out.println(fruit);
   }
   1
   2
   3
   4
   5
   6
   7
   8

   输出可能是：

   Apple
   Banana
   Orange
   1
   2
   3

需要注意的是，有些集合类（如 HashSet）并不保证元素的排序，而有些集合类（如 TreeSet）则明确保持元素的排序。在选择集合类时，可以根据对顺序的需求来选择合适的实现。