集合框架的作用

1. 集合特点：动态的存储对象
2. 提供统一的访问方式：集合框架定义了一套统一的接口和方法
3. 提供多种数据结构，如：List，Set，Queue，Map每种结构都有其特定的用途
4. 支持并发操作:可以在多线程环境中安全的使用
5. 支持泛型，使得集合可以存储任意类型的对象

集合框架的组成(3部分)

1. 集合接口：定义了储存和操作一组对象的标准方法，且所有集合接口都是泛型接口（接口多用于方法的参数类型）
2. 集合实现：实现了对应集合接口的具体类，本质上是可重用的数据结构（实现类可以创建具体的对象）
3. 集合算法：对实现了集合接口的对象执行具体计算（如查找，排序等）的方法。相同的方法在相似的接口上有着不同的实现

集合与数组的区别

1. 存储类型和长度：

   1. 集合：对象类型，可以同一集合可以存储不同类型，长度可变
   2. 数组：基本和对象类型，一个数组一种类型，且数目长度都不可变

2. 存储方式：

   1. 数组：在内存中占用一块连续的空间，因此可以高效地通过索引访问数组中的元素
   2. 集合：不一定在内存中占用连续的空间，元素的存储位置由集合的内部实现决定。访问集合中的元素通常比访问数组中的元素慢

3. 方法支持：

   1. 数组：提供了基本的操作，如访问、修改和遍历数组中的元素。但是，数组本身不提供搜索、排序、插入或删除元素等高级功能。
   2. 集合：提供了丰富的API来操作元素，如添加、删除、搜索、排序等。Java的集合框架还提供了许多接口和实现类，可以根据需要选择最适合的集合类型。

4. 用途：

   1. 集合框架中的不同接口和实现类提供了不同的功能和性能特性，可以根据具体需求选择最合适的集合类型。

   2. 存储固定数目且类型相同的元素，如一组整数

   3. 存储动态数目的元素，并支持对元素进行各种操作。

集合的接口与实现类

内部关系

集合关键关系图片

具体解析

1. Collection接口：

   1. 这是集合框架的根接口。它定义了集合的基本操作，如添加、删除、检查元素是否存在、获取集合的大小以及迭代集合中的元素。

2. List 接口：

   1. 继承自 Collection 接口。它表示一个有序可重复的元素集合（即每个元素都有一个索引）。除了 Collection 接口的方法外，List 还提供了按索引访问、插入和删除元素的方法。
   2. 常见的 List 实现类有 ArrayList、LinkedList 和 Vector。

3. Set 接口：

   1. 继承自 Collection 接口。它表示无序不重复元素的集合。除了 Collection 接口的方法外，Set 接口没有定义额外的方法（但具体的实现类可能会添加额外的功能）。
   2. 常见的 Set 实现类有 HashSet、LinkedHashSet、TreeSet 和 EnumSet。

4. Queue 接口：

   • 虽然 Queue 接口没有直接继承自 Collection 接口，但它扩展了 Collection 接口的功能，并添加了队列（先进后出）特有的方法，如 add（添加元素到队列的尾部）、poll（移除并返回队列的头部元素，如果队列为空则返回null）和 peek（查看队列的头部元素但不移除）。
   • 常见的 Queue 实现类有 LinkedList、PriorityQueue

5. Map 接口：

   • Map 不是一个集合，但它包含了类似于集合的键值对。Map 接口定义了存储键值对（常称映射）的集合，并提供了基于键来检索值的方法。
   • 常见的 Map 实现类有 HashMap、LinkedHashMap、TreeMap

6. SortedMap 接口：

   • 继承自 Map 接口。它表示一个按键升序排序的映射。除了 Map 接口的方法外，SortedMap 还提供了基于键的排序视图。
   • 常见的 SortedMap 实现类有 TreeMap。

7. NavigableMap 接口：

   • 继承自 SortedMap 接口。它提供了在排序映射上进行导航的方法，如查找最小和最大的键，以及小于、大于或等于给定键的键。
   • 常见的 NavigableMap 实现类有 TreeMap。

集合算法

集合的算法通常是作为java.util.Collections类中的静态方法(static)提供的，且第一参数都为执行操作的集合。这些算法可以对集合进行各种操作，如排序、搜索、替换、复制等。

排序：

sort(List<T> list): 对列表中的元素进行自然排序。

要求列表中的元素必须实现Comparable接口，以便它们能够彼此进行比较。自然排序是基于元素类实现的compareTo方法的。

List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5);  
Collections.sort(numbers);  
System.out.println(numbers); // 输出 [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

sort(List<T> list, Comparator<? super T> c): 使用指定的比较器对列表中的元素进行排序。

搜索

binarySearch(List<? extends Comparable<? super T>> list, T key): 使用二分搜索算法在已排序的列表中搜索指定的元素。

这个方法在已排序的列表中搜索指定的元素。列表必须已按元素的自然顺序（通过实现 Comparable 接口的元素的 compareTo 方法）进行排序。如果列表未排序，结果将是未定义的。如果列表包含指定的元素，则返回该元素的索引（从0开始）；如果列表不包含该元素，则返回 -(insertion point) - 1，其中 insertion point 是将元素插入列表后它将处于的位置（即第一个大于该元素的位置的索引）。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7);  
int index = Collections.binarySearch(numbers, 4);  
System.out.println(index); // 输出 3

binarySearch(List<? extends T> list, T key, Comparator<? super T> c): 使用指定的比较器和二分搜索算法在列表中搜索指定的元素。

这个方法在已排序的列表中搜索指定的元素，但允许你提供一个自定义的比较器来定义排序顺序。如果列表未根据提供的比较器排序，结果将是未定义的。

替换

replaceAll(List<T> list, T oldVal, T newVal): 使用指定的新值替换列表中出现的所有旧值。

这个方法接受三个参数：

• list：要修改的列表。
• oldVal：要替换的旧值。
• newVal：用于替换的新值。

方法会遍历列表，并比较列表中的每个元素与 oldVal。如果找到匹配项，则将该元素替换为 newVal。方法最后返回一个布尔值，指示是否至少替换了一个元素。如果列表中没有找到任何 oldVal 的实例，则返回 false。

import java.util.ArrayList;  
import java.util.Collections;  
import java.util.List;  
  
public class ReplaceAllExample {  
    public static void main(String[] args) {  
        List<String> list = new ArrayList<>();  
        list.add("apple");  
        list.add("banana");  
        list.add("apple");  
        list.add("cherry");  
  
        System.out.println("Original list: " + list);  
  
        boolean replaced = Collections.replaceAll(list, "apple", "orange");  
  
        System.out.println("List after replacement: " + list);  
        System.out.println("Was at least one element replaced? " + replaced);  
    }  
}

//输出：
Original list: [apple, banana, apple, cherry]
List after replacement: [orange, banana, orange, cherry]
Was at least one element replaced? true

在这个示例中，我们创建了一个包含字符串的列表，并使用 Collections.replaceAll 方法将所有 “apple” 替换为 “orange”。然后，我们打印出修改后的列表，并检查是否至少有一个元素被替换。

复制

使用流（Java 8 及以上）：来复制集合

List<String> src = Arrays.asList("a", "b", "c");  
List<String> dest = src.stream().collect(Collectors.toList()); // 使用流复制列表

注意，使用流复制列表时，新列表的类型可能与原始列表不同（例如，如果原始列表是 LinkedList，则新列表可能是 ArrayList）。

翻转

reverse(List<?> list): 反转列表中元素的顺序。

这个方法接受一个 List 类型的参数（可以是任何类型的列表，因为使用了泛型通配符 ?），并且会原地（in-place）反转列表中的元素顺序。这意味着列表本身会被修改，而不是创建一个新的反转后的列表。

import java.util.ArrayList;  
import java.util.Collections;  
import java.util.List;  
  
public class ReverseListExample {  
    public static void main(String[] args) {  
        List<Integer> list = new ArrayList<>();  
        list.add(1);  
        list.add(2);  
        list.add(3);  
        list.add(4);  
        list.add(5);  
  
        System.out.println("Original list: " + list);  
  
        Collections.reverse(list);  
  
        System.out.println("Reversed list: " + list);  
    }  
}
//输出
Original list: [1, 2, 3, 4, 5]  
Reversed list: [5, 4, 3, 2, 1]

在这个示例中，我们首先创建了一个包含整数的 ArrayList。然后，我们使用用 Collections.reverse 方法来反转列表中的元素顺序。最后，我们打印出原始列表和反转后的列表以验证结果。