Java 随笔记: 集合与泛型

1. 集合框架概述

Java 集合框架提供了一套用于存储和管理对象的标准接口和实现类。它简化了开发过程，提高了代码的可读性和可维护性。

集合框架的核心概念:

接口 (Interface): 定义集合类的通用行为，例如添加元素、删除元素、遍历元素等。
实现类 (Implementation): 提供对接口的具体实现，例如 ArrayList、HashSet、HashMap 等。
迭代器 (Iterator): 用于遍历集合元素，提供了一种标准方式。

集合框架的主要优势:

代码复用: 提供了统一的接口，可以方便地使用不同的集合类。
类型安全: 泛型机制保证了集合中元素类型的安全。
高效性: 提供了各种高效的实现，满足不同场景的需求。
可扩展性: 可以根据需要创建新的集合类。

2. 集合接口

Java 集合框架中定义了几个主要的接口，这些接口定义了集合类的基本操作。

2.1 Collection 接口

Collection 是所有集合类的根接口，定义了集合类的基本操作，例如添加、删除、清空、判断大小等。

常用方法:

add(E e): 添加元素到集合中。

Collection<String> collection = new ArrayList<>();
collection.add("Apple");

remove(Object o): 从集合中删除元素。
```
collection.remove("Apple");
```
contains(Object o): 判断集合中是否包含指定元素。
```
boolean containsApple = collection.contains("Apple");
```
size(): 返回集合的大小。
```
int size = collection.size();
```

isEmpty(): 判断集合是否为空。

boolean isEmpty = collection.isEmpty();

iterator(): 返回迭代器，用于遍历集合元素。
```
Iterator<String> iterator = collection.iterator();
```

2.2 List 接口

List 接口继承自 Collection 接口，它表示有序的集合，允许重复元素。

常用方法:

get(int index): 获取指定索引位置的元素。
```
String element = list.get(1);
```
set(int index, E element): 将指定索引位置的元素替换为新的元素。
```
list.set(1, "Banana");
```
add(int index, E element): 在指定索引位置插入元素。
```
list.add(1, "Orange");
```
remove(int index): 删除指定索引位置的元素。
```
list.remove(1);
```
indexOf(Object o): 返回指定元素在列表中的第一个索引位置。
```
int index = list.indexOf("Banana");
```

2.3 Set 接口

Set 接口继承自 Collection 接口，它表示无序的集合，不允许重复元素。

常用方法:

add(E e): 添加元素到集合中，如果元素已存在，则不添加。

Set<String> set = new HashSet<>();
boolean added = set.add("Apple");

2.4 Map 接口

Map 接口不继承自 Collection 接口，它表示键值对的映射关系，键不能重复，值可以重复。

常用方法:

put(K key, V value): 将键值对添加到映射关系中。
```
map.put("Apple", 1);
```
get(Object key): 获取指定键对应的值。
```
int value = map.get("Apple");
```
remove(Object key): 删除指定键的键值对。
```
map.remove("Apple");
```
containsKey(Object key): 判断映射关系中是否包含指定键。
```
boolean containsKey = map.containsKey("Apple");
```
containsValue(Object value): 判断映射关系中是否包含指定值。
```
boolean containsValue = map.containsValue(1);
```

3. 集合的常用操作

Java 集合框架提供了多种操作集合的方法，包括添加元素、删除元素、遍历元素、判断集合大小以及判断集合是否为空。以下是对这些常用操作的详细说明和示例代码。

3.1 添加元素

使用 add() 方法可以将元素添加到集合中。对于 List 接口的实现类，元素将按添加的顺序排列；对于 Set 接口的实现类，不允许重复元素。

示例代码:

// 创建一个 ArrayList 集合
List<String> list = new ArrayList<>();

// 添加元素
list.add("Java");
list.add("Python");
list.add("C++");

System.out.println("集合中的元素：" + list);

输出结果:

集合中的元素：[Java, Python, C++]

3.2 删除元素

使用 remove() 方法可以删除指定的元素。对于 List 接口的实现类，可以根据索引位置或元素值删除；对于 Set 接口的实现类，只能根据元素值删除。

示例代码:

// 删除元素
list.remove("Python");

System.out.println("集合中的元素：" + list);

输出结果:

集合中的元素：[Java, C++]

3.3 遍历元素

使用迭代器或增强型 for 循环可以遍历集合中的元素。

示例代码:

// 遍历元素
for (String language : list) {
    System.out.println(language);
}

// 使用迭代器遍历元素
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

输出结果:

Java
C++
Java
C++

3.4 判断大小

使用 size() 方法可以获取集合的大小，即集合中包含的元素数量。

示例代码:

System.out.println("集合的大小：" + list.size());

输出结果:

集合的大小：2

3.5 判断是否为空

使用 isEmpty() 方法可以判断集合是否为空。如果集合为空，该方法返回 true；否则返回 false。

示例代码:

System.out.println("集合是否为空：" + list.isEmpty());

输出结果:

集合是否为空：false

4. 迭代器

迭代器 (Iterator) 是 Java 集合框架中的一个重要概念，它提供了一种遍历集合元素的标准方式，而无需关心集合的具体实现。

4.1 迭代器的作用

提供标准的遍历方式: 迭代器统一了遍历不同集合类的接口，无论集合是 ArrayList、LinkedList 还是 HashSet，都可以使用相同的 Iterator 接口进行遍历。
隐藏集合实现细节: 使用迭代器可以屏蔽集合内部的实现细节，用户只需要关注如何迭代元素，而无需关心元素是如何存储和管理的。
支持元素的删除: 迭代器提供 remove() 方法，可以在遍历过程中删除元素。

4.2 迭代器的使用

使用迭代器遍历集合的步骤如下：

获取迭代器: 通过调用集合的 iterator() 方法获取迭代器对象。
循环遍历: 使用 hasNext() 方法判断是否还有下一个元素，如果还有则调用 next() 方法获取下一个元素。
删除元素: 调用 remove() 方法删除当前元素。

示例代码:

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

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

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

        // 循环遍历
        while (iterator.hasNext()) {
            String fruit = iterator.next();
            System.out.println(fruit);

            // 删除元素
            if (fruit.equals("Banana")) {
                iterator.remove();
            }
        }

        // 输出修改后的集合
        System.out.println(list);
    }
}

输出结果:

Apple
Banana
Cherry
[Apple, Cherry]

4.3 迭代器与增强 for 循环

Java 中的增强 for 循环 (for-each 循环) 也能够方便地遍历集合，其底层实际上就是使用迭代器实现的。

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

4.4 迭代器的注意事项

迭代器只能单向遍历，不能向后移动。
在使用迭代器遍历集合时，不要直接修改集合，否则会导致迭代器失效。
如果需要在遍历过程中删除元素，只能使用 iterator.remove() 方法，不能直接调用集合的 remove() 方法。

5. 泛型概述

泛型是 Java 中的一种机制，它允许编写与类型无关的代码，从而提高代码的可重用性和安全性。通过使用泛型，我们可以编写能够处理各种数据类型的代码，而无需显式地指定数据类型。

泛型带来的优势:

类型安全: 泛型可以帮助我们避免类型转换错误，因为编译器会进行类型检查。
代码可重用: 泛型可以让我们编写一次代码，然后在不同的数据类型上重复使用。
提高可读性: 泛型代码更易于理解，因为它明确地指定了数据类型。

泛型使用符号:

<T>: 表示一个类型参数，T 可以是任何类型。
E: 表示元素类型，通常用于集合。
K: 表示键类型，通常用于 Map。
V: 表示值类型，通常用于 Map。

6. 泛型类

泛型类是带有类型参数的类。我们可以在类的声明中使用类型参数，然后在类的定义中使用这些参数来代替具体的类型。

示例代码:

// 定义泛型类 GenericBox，<T> 表示类型参数
public class GenericBox<T> {
    // 私有变量，存储内容
    private T content;

    // 设置内容
    public void setContent(T content) {
        this.content = content;
    }

    // 获取内容
    public T getContent() {
        return content;
    }

    public static void main(String[] args) {
        // 创建 GenericBox<String> 实例并设置内容
        GenericBox<String> stringBox = new GenericBox<>();
        stringBox.setContent("Hello");
        System.out.println(stringBox.getContent());

        // 创建 GenericBox<Integer> 实例并设置内容
        GenericBox<Integer> integerBox = new GenericBox<>();
        integerBox.setContent(123);
        System.out.println(integerBox.getContent());
    }
}

输出结果:

Hello
123

7. 泛型方法

泛型方法是在方法定义中引入类型参数。这些类型参数可以用于方法的参数列表和返回类型。

示例代码:

public class GenericMethodExample {

    // 泛型方法
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] stringArray = {"A", "B", "C", "D"};

        // 调用泛型方法
        printArray(intArray);
        printArray(stringArray);
    }
}

输出结果:

1 2 3 4 5 
A B C D

8. 泛型边界

泛型边界允许我们限制类型参数的范围。我们可以使用 extends 关键字来指定上界，或者使用 super 关键字来指定下界。

8.1 上界通配符

上界通配符使用 extends 关键字，可以接受该类型及其子类型。

示例代码:

public static void printList(List<? extends Number> list) {
    for (Number n : list) {
        System.out.println(n);
    }
}

8.2 下界通配符

下界通配符使用 super 关键字，可以接受该类型及其父类型。

示例代码:

public static void addNumber(List<? super Integer> list) {
    list.add(1);
    list.add(2);
}

9. 泛型接口

泛型接口是带有类型参数的接口。我们可以在接口的声明中使用类型参数，然后在接口的定义中使用这些参数来代替具体的类型。

示例代码:

public interface GenericInterface<T> {
    void doSomething(T t);
}

public class GenericInterfaceImpl implements GenericInterface<String> {
    @Override
    public void doSomething(String s) {
        System.out.println(s);
    }

    public static void main(String[] args) {
        GenericInterface<String> generic = new GenericInterfaceImpl();
        generic.doSomething("Hello");
    }
}

输出结果:

Hello

10. 常用集合类

Java 集合框架中包含了许多常用的集合类，每个集合类都有其特定的用途和特点。

10.1 List 接口实现类

List 接口代表有序的集合，元素可以重复出现。

10.1.1 ArrayList

ArrayList 是一个动态数组，它的底层实现是一个可变大小的数组。ArrayList 提供了快速的随机访问能力，但在插入和删除元素时，可能需要移动大量元素。

适用场景: 适用于需要频繁读取元素，而插入和删除操作较少的场景。

示例代码:

List<String> arrayList = new ArrayList<>();
arrayList.add("Apple");
arrayList.add("Banana");
arrayList.add("Cherry");
System.out.println(arrayList);

输出结果:

[Apple, Banana, Cherry]

10.1.2 LinkedList

LinkedList 是一个双向链表，它的底层实现是一个链表结构。LinkedList 在插入和删除元素时性能较好，但随机访问元素的性能较差。

适用场景: 适用于需要频繁插入和删除元素，而读取操作较少的场景。

示例代码:

List<String> linkedList = new LinkedList<>();
linkedList.add("Apple");
linkedList.add("Banana");
linkedList.add("Cherry");
System.out.println(linkedList);

输出结果:

[Apple, Banana, Cherry]

10.2 Set 接口实现类

Set 接口代表无序的集合，元素不能重复出现。

10.2.1 HashSet

HashSet 是一个基于哈希表实现的集合，它不保证集合的迭代顺序，并且不允许重复元素。

适用场景: 适用于需要快速判断元素是否存在，且不关心元素顺序的场景。

示例代码:

Set<String> hashSet = new HashSet<>();
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Cherry");
System.out.println(hashSet);

输出结果:

[Banana, Apple, Cherry]

10.2.2 TreeSet

TreeSet 是一个基于红黑树实现的集合，它保证集合的迭代顺序，并且不允许重复元素。

适用场景: 适用于需要有序集合的场景。

示例代码:

Set<String> treeSet = new TreeSet<>();
treeSet.add("Apple");
treeSet.add("Banana");
treeSet.add("Cherry");
System.out.println(treeSet);

输出结果:

[Apple, Banana, Cherry]

10.3 Map 接口实现类

Map 接口代表键值对集合，每个键对应一个值。

10.3.1 HashMap

HashMap 是一个基于哈希表实现的映射关系，它不保证键值对的迭代顺序，并且允许键为 null。

适用场景: 适用于需要快速访问键值对，且不关心键值对顺序的场景。

示例代码:

Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("Apple", 1);
hashMap.put("Banana", 2);
hashMap.put("Cherry", 3);
System.out.println(hashMap);

输出结果:

{Apple=1, Banana=2, Cherry=3}

10.3.2 TreeMap

TreeMap 是一个基于红黑树实现的映射关系，它保证键值对的迭代顺序，并且不允许键为 null。

适用场景: 适用于需要有序键值对的场景。

示例代码:

Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Apple", 1);
treeMap.put("Banana", 2);
treeMap.put("Cherry", 3);
System.out.println(treeMap);

输出结果:

{Apple=1, Banana=2, Cherry=3}