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<? extends E> 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<? extends E> 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 表达式可以使代码更简洁，更易读，并有助于实现函数式编程的风格。