Java 之泛型详解

1. 泛型是什么？

泛型是 Java 中一种强大的机制，它允许你编写可以与多种数据类型一起工作的代码，而无需在编译时指定具体的类型。这样可以提高代码的灵活性、可读性和安全性。

2. 为什么要使用泛型？泛型可以帮助我们编写更安全、更灵活、更易于维护的代码。具体来说，它带来的优势有：

类型安全： 泛型可以帮助你在编译阶段就发现类型错误，例如将字符串放入整数类型的容器中。这避免了运行时出现类型转换错误，提高了程序的稳定性和可靠性。

代码重用： 泛型可以让你编写一次代码，就可以适用于多种数据类型。例如，我们可以编写一个通用的排序算法，它可以对任何类型的数组进行排序，而无需编写多个版本的排序算法。

可读性： 泛型可以使代码更易于理解，因为你能够明确地知道容器中存放的是什么类型的对象。例如，List 比 List 更能清晰地表明该列表存放的是字符串类型。

3. 泛型如何使用？3.1 定义泛型类

代码语言：javascript代码运行次数：0运行复制// 定义一个泛型类，类型参数为 T

public class GenericClass {

private T data;

// 构造函数

public GenericClass(T data) {

this.data = data;

}

// 获取数据的方法

public T getData() {

return data;

}

}3.2 使用泛型类

代码语言：javascript代码运行次数：0运行复制// 使用 Integer 类型创建 GenericClass 实例

GenericClass integerGeneric = new GenericClass<>(10);

// 使用 String 类型创建 GenericClass 实例

GenericClass stringGeneric = new GenericClass<>("Hello");

// 获取数据

System.out.println("Integer data: " + integerGeneric.getData()); // 输出：Integer data: 10

System.out.println("String data: " + stringGeneric.getData()); // 输出：String data: Hello3.3 定义泛型方法

代码语言：javascript代码运行次数：0运行复制public class GenericMethods {

// 定义一个泛型方法，类型参数为 T

public static 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};

String[] strArray = {"a", "b", "c"};

// 使用泛型方法打印数组

GenericMethods.printArray(intArray); // 输出：1 2 3

GenericMethods.printArray(strArray); // 输出：a b c

}4. 泛型使用场景 集合类： 常见的集合类如 ArrayList、HashMap 等都使用了泛型，可以存放特定类型的对象。例如，ArrayList 用于存放字符串，HashMap 用于存放键值对，其中键是字符串类型，值是整数类型。

代码语言：javascript代码运行次数：0运行复制// 使用 ArrayList 存储字符串

List names = new ArrayList<>();

names.add("John");

names.add("Jane");

names.add("Peter");

// 使用 HashMap 存储键值对

Map ages = new HashMap<>();

ages.put("John", 30);

ages.put("Jane", 25);

ages.put("Peter", 28); 工具类： 泛型可以用来编写通用的工具类，例如数据转换、比较等。例如，我们可以编写一个通用的排序算法，它可以对任何类型的数组进行排序，而无需编写多个版本的排序算法。

代码语言：javascript代码运行次数：0运行复制public class SortUtils {

public static > void sort(T[] array) {

// 使用冒泡排序算法对数组进行排序

for (int i = 0; i < array.length - 1; i++) {

for (int j = 0; j < array.length - i - 1; j++) {

if (array[j].compareTo(array[j + 1]) > 0) {

T temp = array[j];

array[j] = array[j + 1];

array[j + 1] = temp;

}

}

}

}

} 自定义数据结构： 在实现自定义数据结构时，可以使用泛型来提高代码的可读性和可维护性。例如，我们可以使用泛型来实现一个简单的栈数据结构：

代码语言：javascript代码运行次数：0运行复制public class GenericStack {

private T[] data;

private int top;

public GenericStack(int capacity) {

this.data = (T[]) new Object[capacity];

this.top = -1;

}

public void push(T element) {

if (top == data.length - 1) {

throw new StackOverflowError();

}

data[++top] = element;

}

public T pop() {

if (top == -1) {

throw new EmptyStackException();

}

return data[top--];

}

public T peek() {

if (top == -1) {

throw new EmptyStackException();

}

return data[top];

}

public boolean isEmpty() {

return top == -1;

}

}5. 泛型的好处 类型安全: 泛型可以帮助我们在编译阶段就发现类型错误，例如将字符串放入整数类型的容器中。这避免了运行时出现类型转换错误，提高了程序的稳定性和可靠性。因为在编译阶段就能发现类型错误，所以可以避免运行时出现异常，使得程序更加稳定。

代码重用: 泛型可以让你编写一次代码，就可以适用于多种数据类型。例如，我们可以编写一个通用的排序算法，它可以对任何类型的数组进行排序，而无需编写多个版本的排序算法。这使得代码更简洁，更容易维护，也减少了重复代码。

可读性: 泛型可以使代码更易于理解，因为你能够明确地知道容器中存放的是什么类型的对象。例如，List 比 List 更能清晰地表明该列表存放的是字符串类型。这使得代码更容易被理解和维护。

代码维护性: 由于泛型可以有效地提高代码的可读性和可维护性，因此可以减少代码的维护成本。

6. 泛型特点 类型参数可以是任何类型，包括基本数据类型和自定义类型。

类型参数只能在类定义和方法定义中使用。

编译器会对泛型代码进行类型检查，确保类型安全。

泛型类型擦除： 在编译过程中，泛型类型会被擦除，这意味着在运行时，泛型类型信息将不可用。

7. 泛型应用示例7.1 编写一个简单的泛型 Pair 类代码语言：javascript代码运行次数：0运行复制public class Pair {

private K key;

private V value;

public Pair(K key, V value) {

this.key = key;

this.value = value;

}

public K getKey() {

return key;

}

public V getValue() {

return value;

}

public static void main(String[] args) {

// 创建一个字符串键值对

Pair stringPair = new Pair<>("name", "John Doe");

System.out.println("Key: " + stringPair.getKey() + ", Value: " + stringPair.getValue());

// 创建一个整数键值对

Pair integerPair = new Pair<>(1, 2);

System.out.println("Key: " + integerPair.getKey() + ", Value: " + integerPair.getValue());

}

}7.2 使用泛型实现一个简单的缓存代码语言：javascript代码运行次数：0运行复制import java.util.HashMap;

import java.util.Map;

public class GenericCache {

private Map cache = new HashMap<>();

public V get(K key) {

return cache.get(key);

}

public void put(K key, V value) {

cache.put(key, value);

}

public static void main(String[] args) {

// 创建一个字符串缓存

GenericCache stringCache = new GenericCache<>();

stringCache.put("name", "John Doe");

System.out.println("Name: " + stringCache.get("name")); // 输出：Name: John Doe

// 创建一个整数缓存

GenericCache integerCache = new GenericCache<>();

integerCache.put(1, 2);

System.out.println("Value: " + integerCache.get(1)); // 输出：Value: 2

}

}7.3 泛型方法示例这段代码是一个泛型方法，用于根据给定的 id 在 personList 中查找并返回对应的对象。

代码语言：javascript代码运行次数：0运行复制/**

* 根据给定的 ID 查找 personList 中的对象。

*

* @param id 要查找的对象 ID

* @return 找到的对象，如果未找到则返回 null

* @throws IllegalAccessException 如果访问字段时出现非法访问异常

*/

public T findById(int id) throws IllegalAccessException {

// 遍历 personList 中的每一个元素

for (int i = 0; i < personList.size(); i++) {

// 将当前元素强制转换为泛型 T

T person = (T) personList.get(i);

// 获取当前对象的类类型

Class clazz = person.getClass();

// 获取该类的所有字段列表

List allFieldList = getAllField(clazz);

// 遍历所有字段

for (Field field : allFieldList) {

// 设定字段可访问

field.setAccessible(true);

// 检查字段的值是否等于传入的 ID

if (field.get(personList.get(i)).equals(id)) {

// 找到匹配的对象，返回它

return person;

}

}

}

// 如果没有找到，返回 null

return null;

}总结： 泛型是 Java 中一个强大的工具，它可以使你的代码更灵活、更安全、更易于阅读和维护。通过泛型，你可以编写一次代码，就可以适用于多种数据类型，从而减少代码冗余和错误。希望这篇文章能够帮助各位看官理解泛型的概念和应用，并将其应用到你的 Java 开发中。感谢各位看官的观看，下期见，谢谢~