Java 复习笔记 - 集合进阶篇：Collection集合

---

单双列集合

在Java中，单列集合和双列集合是两种常见的集合类型。

1. 单列集合：
   单列集合是指只能存储一种类型元素的集合，例如List和Set。它们可以存储任意类型的元素，但每个元素都必须是同一种类型。

   • List（列表）：List是一个有序集合，可以存储重复元素。它提供了按索引访问元素的方法，并且可以插入、删除和替换元素。常见的List实现有ArrayList、LinkedList等。
   • Set（集合）：Set是一个无序集合，不能存储重复元素。它提供了快速的元素查找和添加操作。常见的Set实现有HashSet、TreeSet等。

2. 双列集合：
   双列集合是指可以存储两种类型元素的集合，例如Map。双列集合中的元素由键和值组成，键和值都可以是任意类型的对象。

   • Map（映射）：Map是一个键值对映射的集合。它允许使用键来快速查找值。常见的Map实现有HashMap、TreeMap等。

这些集合类型提供了丰富的操作和数据结构，可以根据具体的需求选择适合的集合类型来存储和处理数据。

Collection 接口

（一）Set 集合的特点

Set是Java的一种集合，继承自Collection接口，主要有两个常用的实现类HashSet类和TreeSet类，它具有以下特点：

1. Set集合中的元素都是唯一的，不会有重复的元素，即使是null值也只能有一个。
2. Set集合是无序的，不能记住元素的添加顺序，因为没有索引值，所以Set集合中的对象不会按特定的方式排序，它只是简单地把对象放到集合中。
3. Set集合不能包含相同的元素，如果尝试将两个相同的元素添加到同一个Set集合中，则添加失败，add()方法返回false，且新元素不会被添加。
4. HashSet类按Hash算法来存储集合的元素，因此具有很好的存取和查找功能，但是HashSet不是线程安全的。
5. Set集合不能记住元素的添加顺序，其元素排列顺序也是无序的。

请注意，虽然Set集合具有许多有用的特性，但是由于其无序的特性，在处理某些特定的数据结构和算法问题时可能会有限制。

（二）List 集合的特点

List集合是Java中的一种有序集合，它可以存储多个元素，并且允许元素重复。以下是List集合的一些主要特点：

1. 有序性：List中的元素是有序的，可以根据索引值来访问对应位置的元素。
2. 可重复性：List允许存储重复元素。
3. 可变性：List是Java中一种可变的数据类型，可以添加、删除或修改其中的元素。

常见的List实现有ArrayList和LinkedList。ArrayList基于数组实现，具有快速查询的特点，但在增删操作时较慢。LinkedList基于链表实现，具有快速增删的特点，但在查询操作时较慢。

（三）Collection 接口概述

Java中的Collection是一个接口，它定义了一些基本的操作来管理一组对象。Collection接口是Java中所有集合类（如List、Set等）的根接口。它提供了一些基本的操作方法，如添加元素、删除元素、遍历元素等。

以下是Collection接口中定义的一些常用方法：

方法名	描述
size()	返回集合中元素的数量。
isEmpty()	判断集合是否为空。如果集合中没有元素，返回 true；否则返回 false。
contains(Object o)	判断集合是否包含指定元素。如果集合中存在一个或多个与指定元素相同的元素，返回 true；否则返回 false。
iterator()	返回一个迭代器，用于遍历集合中的元素。通过迭代器可以访问集合中的每个元素。
toArray()	返回一个包含集合中所有元素的数组。可以用来获取集合中的所有元素。
add(E e)	将指定元素添加到集合中。如果添加成功，返回 true；否则返回 false。对于某些集合（如Set），添加元素失败可能是因为元素已经存在于集合中或者其他原因。
remove(Object o)	从集合中移除指定元素。如果移除成功，返回 true；否则返回 false。对于某些集合（如Set），移除元素失败可能是因为元素不存在于集合中或者其他原因。
containsAll(Collection c)	判断集合是否包含指定集合中的所有元素。如果集合包含指定集合中的所有元素，返回 true；否则返回 false。
addAll(Collection c)	将指定集合中的所有元素添加到集合中。如果添加成功，返回 true；否则返回 false。
removeAll(Collection c)	从集合中移除指定集合中的所有元素。如果移除成功，返回 true；否则返回 false。
retainAll(Collection c)	仅保留集合中与指定集合中的元素相同的元素。如果保留成功，返回 true；否则返回 false。
clear()	清空集合中的所有元素。没有返回值。

这些方法是Java中Collection接口的基本操作，可以帮助您对Java中的集合进行常用的操作和操作数据。

需要注意的是，Collection接口是一个泛型接口，可以使用不同的类型参数来定义集合中的元素类型。此外，Java还提供了一些子接口和实现类来扩展和实现Collection接口，如List、Set、Map等，它们提供了更多特定的方法和特性来满足不同的需求。

（四）6种频繁使用方法的讲解

1，add()

add()方法是Java中Collection接口中的一个常用方法，用于将一个或多个元素添加到集合中。该方法有两种形式：

1. add(E e)：将指定元素添加到集合中。如果添加成功，返回 true；否则返回 false。对于某些集合（如Set），添加元素失败可能是因为元素已经存在于集合中或者其他原因。
2. addAll(Collection c)：将指定集合中的所有元素添加到集合中。如果添加成功，返回 true；否则返回 false。

下面是一个简单的示例，演示如何使用add()方法将一个元素添加到List集合中：

import java.util.*;

public class Example {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("apple");
        list.add("banana");
        list.add("orange");
        System.out.println(list); // 输出 [apple, banana, orange]
    }
}

在这个示例中，首先创建一个空的List对象，然后使用add()方法向其中添加三个字符串元素。最后，使用println()方法将List对象打印出来，以验证元素是否已经添加到集合中。

请注意，在使用add()方法时，如果尝试将null添加到不允许null元素的集合中，将会抛出NullPointerException异常。此外，对于某些集合（如Set），添加元素失败可能是因为元素已经存在于集合中或者其他原因。因此，在使用add()方法时，应该注意集合的特性和实际需求。

2，clear()

clear()方法是Java中Collection接口中的一个常用方法，用于清空集合中的所有元素。该方法没有返回值。

下面是一个简单的示例，演示如何使用clear()方法清空List集合中的元素：

import java.util.*;

public class Example {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("apple");
        list.add("banana");
        list.add("orange");
        System.out.println(list); // 输出 [apple, banana, orange]
        list.clear();
        System.out.println(list); // 输出 []
    }
}

在这个示例中，首先创建一个包含三个字符串元素的List对象，然后使用println()方法将List对象打印出来，以验证元素是否已经添加到集合中。接着，使用clear()方法清空List对象中的所有元素，并再次使用println()方法将List对象打印出来，以验证元素是否已经被清空。

请注意，在使用clear()方法时，将会移除集合中的所有元素，包括null元素。此外，如果集合是一个固定大小的集合，使用clear()方法不会改变集合的大小。因此，在使用clear()方法时，应该注意集合的特性和实际需求。

3，remove()

remove()方法是Java中Collection接口中的一个常用方法，用于从集合中移除一个或多个元素。该方法有两种形式：

1. remove(Object o)：从集合中移除指定元素。如果移除成功，返回 true；否则返回 false。对于某些集合（如Set），移除元素失败可能是因为元素不存在于集合中或者其他原因。
2. removeAll(Collection c)：从集合中移除指定集合中的所有元素。如果移除成功，返回 true；否则返回 false。

下面是一个简单的示例，演示如何使用remove()方法从List集合中移除一个元素：

import java.util.*;

public class Example {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("apple");
        list.add("banana");
        list.add("orange");
        System.out.println(list); // 输出 [apple, banana, orange]
        list.remove("banana");
        System.out.println(list); // 输出 [apple, orange]
    }
}

在这个示例中，首先创建一个包含三个字符串元素的List对象，然后使用println()方法将List对象打印出来，以验证元素是否已经添加到集合中。接着，使用remove()方法从List对象中移除一个元素，并再次使用println()方法将List对象打印出来，以验证元素是否已经被移除。

请注意，在使用remove()方法时，如果尝试从不允许null元素的集合中移除null元素，将会抛出NullPointerException异常。此外，对于某些集合（如Set），移除元素失败可能是因为元素不存在于集合中或者其他原因。因此，在使用remove()方法时，应该注意集合的特性和实际需求。

4，contains()

contains()方法是Java中Collection接口中的一个常用方法，用于判断集合中是否包含指定元素。该方法有两种形式：

1. contains(Object o)：判断集合是否包含指定元素。如果集合中存在一个或多个与指定元素相同的元素，返回 true；否则返回 false。
2. containsAll(Collection c)：判断集合是否包含指定集合中的所有元素。如果集合包含指定集合中的所有元素，返回 true；否则返回 false。

下面是一个简单的示例，演示如何使用contains()方法判断List集合中是否包含指定元素：

import java.util.*;

public class Example {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("apple");
        list.add("banana");
        list.add("orange");
        System.out.println(list.contains("banana")); // 输出 true
        System.out.println(list.contains("grape")); // 输出 false
    }
}

在这个示例中，首先创建一个包含三个字符串元素的List对象，然后使用contains()方法判断List对象中是否包含指定元素。最后，使用println()方法将判断结果打印出来。

请注意，在使用contains()方法时，如果集合中不存在指定元素，将会遍历整个集合以查找元素。因此，对于大型集合，使用contains()方法可能会影响性能。此外，对于某些集合（如Set），contains()方法可能会更快，因为它使用哈希表来存储元素。因此，在使用contains()方法时，应该考虑集合的特性和实际需求。

5，isEmpty()

isEmpty()方法是Java中Collection接口中的一个常用方法，用于判断集合是否为空。如果集合中没有元素，返回 true；否则返回 false。

下面是一个简单的示例，演示如何使用isEmpty()方法判断List集合是否为空：

import java.util.*;

public class Example {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        System.out.println(list.isEmpty()); // 输出 true
        list.add("apple");
        System.out.println(list.isEmpty()); // 输出 false
    }
}

在这个示例中，首先创建一个空的List对象，然后使用isEmpty()方法判断List对象是否为空。接着，向List对象中添加一个元素，并再次使用isEmpty()方法判断List对象是否为空。最后，使用println()方法将判断结果打印出来。

请注意，在使用isEmpty()方法时，如果集合中没有元素，将会返回true。此外，对于某些集合（如Set），isEmpty()方法可能会更快，因为它使用哈希表来存储元素。因此，在使用isEmpty()方法时，应该考虑集合的特性和实际需求。

6，size()

size()方法是Java中Collection接口中的一个常用方法，用于返回集合中元素的数量。该方法返回一个整数，表示集合中元素的数量。

下面是一个简单的示例，演示如何使用size()方法获取List集合中元素的数量：

import java.util.*;

public class Example {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("apple");
        list.add("banana");
        list.add("orange");
        System.out.println(list.size()); // 输出 3
    }
}

在这个示例中，首先创建一个包含三个字符串元素的List对象，然后使用size()方法获取List对象中元素的数量。最后，使用println()方法将元素数量打印出来。

请注意，在使用size()方法时，如果集合中没有元素，将会返回0。此外，对于某些集合（如Set），size()方法可能会更快，因为它使用哈希表来存储元素。因此，在使用size()方法时，应该考虑集合的特性和实际需求。

Collection 遍历方式

（一）迭代器

迭代器（Iterator）是一种设计模式，它是一个遍历容器特别是列表的方法。在Java、C++、Python等多种编程语言中，迭代器都是常见的工具。

迭代器的基本模式包括：

1. 创建一个迭代器对象，通常是通过调用容器对象的某个方法（如Java中的iterator()方法）。
2. 使用迭代器对象的方法来遍历容器中的元素。这些方法通常包括next()（返回当前元素并将迭代器向下移动一个元素），hasNext()(检查是否还有更多元素)，remove()(移除迭代器最后一次返回的元素)。

下面是一个Java中使用迭代器的例子：

import java.util.ArrayList;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // 获取迭代器
        Iterator<String> it = list.iterator();

        // 遍历列表
        while(it.hasNext()){
            String fruit = it.next();
            System.out.println(fruit);
        }
    }
}

在这个例子中，首先创建了一个包含三个元素的ArrayList。然后，通过调用list的iterator()方法获取了一个迭代器。最后，使用while循环和迭代器的hasNext()和next()方法来遍历列表并打印出每个元素。

（二）增强for

“增强for遍历"是Java中的一个特性，也被称为"for-each循环"或"for-in循环”。在Java 5.0（2004年）引入该功能，使得在遍历数组或集合时，代码更加简洁和易读。

在增强for遍历中，你不需要知道集合的大小或者索引，只需要简单地指定要遍历的集合和每次循环中使用的变量。

以下是增强for循环的基本语法：

for (ElementType element : collection) {
    // 在此处使用element
}

这里，ElementType是集合中元素的类型，collection是你想要遍历的集合（数组或实现了Iterable接口的集合）。

以下是增强for循环的一个示例，用于遍历数组：

int[] numbers = {1, 2, 3, 4, 5};

for (int number : numbers) {
    System.out.println(number);
}

在这个例子中，numbers是一个包含五个整数的数组。通过增强for循环，我们可以遍历数组中的每个元素，并打印出每个元素的值。

同样，也可以用增强for循环遍历实现了Iterable接口的集合类（如ArrayList，LinkedList等）：

import java.util.ArrayList;
import java.util.List;

List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");

for (String fruit : fruits) {
    System.out.println(fruit);
}

在这个例子中，fruits是一个包含三个字符串的ArrayList。通过增强for循环，可以遍历列表中的每个元素，并打印出每个元素的值。

（三）Lambda 表达式

Lambda 表达式（也称为匿名函数或闭包）是一种在函数式编程中常见的编程构造，可用于创建简洁的、一次性的函数。这种表达式在 Python、JavaScript、Java 等多种编程语言中都有应用。

在遍历（或迭代）过程中，Lambda 表达式非常有用，可以用来处理集合或列表中的每个元素。

以下是使用 Lambda 表达式进行遍历的一些示例：

1. Python：

在 Python 中，可以使用内置的 map 函数和 Lambda 表达式来遍历一个列表并应用一个函数。例如，我们可以使用 Lambda 表达式来将列表中的每个元素都翻倍：

numbers = [1, 2, 3, 4, 5]
doubled_numbers = list(map(lambda x: x * 2, numbers))
print(doubled_numbers)  # 输出：[2, 4, 6, 8, 10]

2. JavaScript：

在 JavaScript 中，可以使用数组的 map 方法和 Lambda 表达式来遍历数组并应用一个函数。以下是一个示例，其中我们使用 Lambda 表达式将数组中的每个元素都翻倍：

let numbers = [1, 2, 3, 4, 5];
let doubledNumbers = numbers.map(x => x * 2);
console.log(doubledNumbers);  // 输出：[2, 4, 6, 8, 10]

3. Java：

在 Java 中，Lambda 表达式主要用于简化集合框架中的操作。以下是一个示例，其中我们使用 Lambda 表达式遍历一个列表并打印出每个元素：

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        numbers.forEach(x -> System.out.println(x));
    }
}

这些示例展示了如何使用 Lambda 表达式在不同的编程语言中进行遍历。Lambda 表达式可以使代码更简洁，更易读，并有助于实现函数式编程的风格。