文章目录
- 接口
- 实现（类）
- 算法
- 1. 排序算法
- 2. 查找算法
- 3. 拷贝算法
- 4. 填充算法
- 5. 比较算法
- 6. 随机算法
- 7. 迭代器算法
- 8. 交集、并集、差集
- 9. 分割集合
- 10. 数组和集合的互转
集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：
接口
是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
下面是 Java 集合框架中所有的集合接口及其对应的特点，以表格形式展示：
| 接口 | 描述 |
|---|---|
| Collection | 最基本的集合接口，一个 Collection 代表一组 Object |
| List | 有序的 Collection，使用此接口能够精确的控制每个元素插入的位置 |
| Set | 不保存重复的元素 |
| SortedSet | 继承于 Set，保存有序的集合 |
| Map | 存储一组键值对，提供 key 到 value 的映射 |
| Map.Entry | 描述在一个 Map 中的一个元素（键/值对），是一个 Map 的内部接口 |
| SortedMap | 继承于 Map，使 Key 保持在升序排列 |
| Enumeration | 这是一个传统的接口和定义的方法，已被迭代器所取代 |
以上是 Java 集合框架中所有的集合接口及其对应的特点。在实际开发中，可以根据需求选择适合的集合类型来存储和处理数据。
实现（类）
是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
下面是 Java 集合框架中常用的一些集合实现类及其对应的特点，以表格形式展示：
| 实现类 | 描述 |
|---|---|
| AbstractCollection | 实现了大部分的集合接口 |
| AbstractList | 继承于 AbstractCollection 并且实现了大部分 List 接口 |
| AbstractSequentialList | 继承于 AbstractList，提供了对数据元素的链式访问而不是随机访问 |
| LinkedList | 实现了 List 接口，允许有 null 元素，主要用于创建链表数据结构 |
| ArrayList | 实现了 List 接口，实现了可变大小的数组，提供更好的性能 |
| AbstractSet | 继承于 AbstractCollection 并且实现了大部分 Set 接口 |
| HashSet | 实现了 Set 接口，不允许出现重复元素，不保证集合中元素的顺序 |
| LinkedHashSet | 具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现 |
| TreeSet | 实现了 Set 接口，可以实现排序等功能 |
| AbstractMap | 实现了大部分的 Map 接口 |
| HashMap | 散列表存储键值对映射，根据键的 hashCode 值存储数据，具有快速的访问速度 |
| TreeMap | 继承于 AbstractMap，并使用一颗树实现，支持自动排序 |
| WeakHashMap | 继承于 AbstractMap 类，使用弱密钥的哈希表 |
| LinkedHashMap | 继承于 HashMap，使用元素的自然顺序对元素进行排序 |
| IdentityHashMap | 继承于 AbstractMap 类，比较文档时使用引用相等 |
| Vector | 与 ArrayList 相似，但是是同步的，可以用在多线程的情况 |
| Stack | 是 Vector 的子类，实现了一个标准的后进先出的栈 |
| Dictionary | 是一个抽象类，用来存储键/值对，作用和 Map 类相似 |
| Hashtable | 是 Dictionary 类的子类，位于 java.util 包中 |
| Properties | 继承于 Hashtable，表示一个持久的属性集，属性列表中每个键及其对应值都是一个字符串 |
| BitSet | 创建一种特殊类型的数组来保存位值 |
以上是 Java 集合框架中常用的一些集合实现类及其对应的特点。在实际开发中，可以根据需求选择适合的实现类来存储和处理数据。
算法
是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序，这些算法实现了多态，那是因为相同的方法可以在相似的接口上有着不同的实现。
好的，下面将结合代码详细介绍 Java 集合算法的使用：
1. 排序算法
Java 集合框架中提供了两种排序算法：归并排序和快速排序。其中，Collections.sort() 方法和 Arrays.sort() 方法都已经进行了封装，可以直接使用。
归并排序示例代码：
List<Integer> list = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5);
Collections.sort(list);
System.out.println(list);
以上代码中，我们创建了一个 Integer 类型的 List 集合，并将一些数字添加到其中。然后，我们调用了 Collections.sort() 方法对其进行排序，并输出排序后的结果。
快速排序示例代码：
int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
以上代码中，我们创建了一个 int 类型的数组，并将一些数字添加到其中。然后，我们调用了 Arrays.sort() 方法对其进行排序，并输出排序后的结果。
2. 查找算法
Java 集合框架中提供了二分查找和线性查找两种查找算法。
二分查找示例代码：
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int index = Collections.binarySearch(list, 4);
System.out.println(index);
以上代码中，我们创建了一个 Integer 类型的 List 集合，并将一些数字添加到其中。然后，我们调用了 Collections.binarySearch() 方法进行二分查找，并输出查找结果。
线性查找示例代码：
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int index = -1;
for (int i = 0; i < list.size(); i++) {
if (list.get(i) == 4) {
index = i;
break;
}
}
System.out.println(index);
以上代码中，我们创建了一个 Integer 类型的 List 集合，并将一些数字添加到其中。然后，我们使用 for 循环遍历集合，并进行线性查找，并输出查找结果。
3. 拷贝算法
Java 集合框架中提供了 Collections.copy() 方法和 System.arraycopy() 方法用于拷贝。
Collections.copy() 示例代码：
List<Integer> source = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> target = new ArrayList<>(source.size());
target.addAll(source);
Collections.copy(target, source);
System.out.println(target);
以上代码中，我们创建了一个 Integer 类型的 List 集合 source，并将一些数字添加到其中。然后，我们创建了一个空的 ArrayList 类型的 target 集合，并用 addAll() 方法将 source 集合的元素全部添加到 target 集合中。最后，我们使用 Collections.copy() 方法将 source 集合的元素拷贝到 target 集合中，并输出结果。
System.arraycopy() 示例代码：
int[] source = {1, 2, 3, 4, 5};
int[] target = new int[source.length];
System.arraycopy(source, 0, target, 0, source.length);
System.out.println(Arrays.toString(target));
以上代码中，我们创建了一个 int 类型的数组 source，并将一些数字添加到其中。然后，我们创建了一个空的 int 类型的数组 target，并使用 System.arraycopy() 方法将 source 数组的元素全部拷贝到 target 数组中，并输出结果。
4. 填充算法
Java 集合框架中提供了 Collections.fill() 方法和 Arrays.fill() 方法用于填充。
Collections.fill() 示例代码：
List<Integer> list = Arrays.asList
Integer[] arr = new Integer[5];
Collections.fill(Arrays.asList(arr), 0);
System.out.println(Arrays.toString(arr));
以上代码中，我们创建了一个长度为 5 的 Integer 类型的数组 arr，并使用 Arrays.asList() 将其转换为 List 集合。然后，我们使用 Collections.fill() 方法将该集合中所有元素都设置为 0，并输出结果。
Arrays.fill() 示例代码：
int[] arr = new int[5];
Arrays.fill(arr, 0);
System.out.println(Arrays.toString(arr));
以上代码中，我们创建了一个长度为 5 的 int 类型的数组 arr，并使用 Arrays.fill() 方法将其所有元素都设置为 0，并输出结果。
5. 比较算法
Java 集合框架中提供了 Collections.max() 和 Collections.min() 方法用于比较。
示例代码：
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int max = Collections.max(list);
int min = Collections.min(list);
System.out.println("最大值：" + max);
System.out.println("最小值：" + min);
以上代码中，我们创建了一个 Integer 类型的 List 集合，并将一些数字添加到其中。然后，我们使用 Collections.max() 方法和 Collections.min() 方法找出该集合中的最大值和最小值，并输出结果。
6. 随机算法
Java 集合框架中提供了 Collections.shuffle() 方法用于随机操作。
示例代码：
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Collections.shuffle(list);
System.out.println(list);
以上代码中，我们创建了一个 Integer 类型的 List 集合，并将一些数字添加到其中。然后，我们使用 Collections.shuffle() 方法对该集合进行随机排序，并输出结果。
7. 迭代器算法
Java 集合框架中提供了 Iterator 接口和 ListIterator 接口用于迭代操作。
示例代码：
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
ListIterator<Integer> listIterator = list.listIterator();
while (listIterator.hasNext()) {
System.out.println(listIterator.next());
}
以上代码中，我们创建了一个 Integer 类型的 List 集合，并将一些数字添加到其中。然后，我们使用 iterator() 方法获取列表的迭代器对象，并使用 hasNext() 和 next() 方法对其进行遍历。接着，我们使用 listIterator() 方法获取列表的列表迭代器对象，并使用 hasNext()、next()、hasPrevious()、previous() 等方法对其进行遍历。
除了以上介绍的常见集合算法，Java 集合框架中还提供了其他一些算法，下面也简单介绍一下：
8. 交集、并集、差集
Java 集合框架中提供了 retainAll() 方法和 removeAll() 方法分别用于求两个集合的交集和差集。
示例代码：
List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> list2 = Arrays.asList(3, 4, 5, 6, 7);
// 求交集
list1.retainAll(list2);
System.out.println(list1);
// 求差集
list1 = Arrays.asList(1, 2, 3, 4, 5);
list2 = Arrays.asList(3, 4, 5, 6, 7);
list1.removeAll(list2);
System.out.println(list1);
以上代码中，我们创建了两个 Integer 类型的 List 集合 list1 和 list2，并将一些数字添加到其中。然后，我们使用 retainAll() 方法对 list1 集合和 list2 集合进行求交集操作，并输出结果；接着，我们使用 removeAll() 方法对 list1 集合和 list2 集合进行求差集操作，并输出结果。
9. 分割集合
Java 集合框架中提供了 subList() 方法用于分割集合。
示例代码：
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> subList = list.subList(1, 4);
System.out.println(subList);
以上代码中，我们创建了一个 Integer 类型的 List 集合，并将一些数字添加到其中。然后，我们使用 subList() 方法获取该集合的子集合，从下标 1 开始，到下标 4 前一个元素为止（即下标 1、2、3 的元素），并输出结果。
10. 数组和集合的互转
Java 集合框架中提供了 Arrays.asList() 方法和 Collection.toArray() 方法用于数组和集合之间的转换。
示例代码：
Integer[] arr = {1, 2, 3, 4, 5};
List<Integer> list = Arrays.asList(arr);
System.out.println(list);
list = Arrays.asList(6, 7, 8, 9, 10);
arr = list.toArray(new Integer[list.size()]);
System.out.println(Arrays.toString(arr));
以上代码中，我们创建了一个 Integer 类型的数组 arr，并将一些数字添加到其中。然后，我们使用 Arrays.asList() 方法将该数组转换为 List 集合，并输出结果；接着，我们将另一个 List 集合转换为 Integer 类型的数组，并输出结果。
这些算法是 Java 集合框架中常见的算法，可以帮助我们进行更加高效、便捷的集合操作和处理。在实际开发过程中，我们可以根据具体需求选择合适的算法来实现需要的功能。
