Java泛型

Java 泛型初相识

在 Java 的世界里，泛型就像是一把神奇的钥匙，为我们打开了代码灵活性和安全性的大门。简单来说，Java 泛型是一种参数化类型机制，允许我们在定义类、接口或方法时使用类型参数。这些类型参数就像是占位符，在使用时才会被具体的类型所替换。比如，我们定义一个简单的泛型类Box：

public class Box<T> {

   private T value;

   public void setValue(T value) {
       this.value = value;
   }

   public T getValue() {
       return value;
   }
}

这里的<T>就是类型参数，它可以在后续创建Box对象时被具体的类型替换，如Box<Integer>、Box<String>等 。通过这种方式，我们可以用相同的代码逻辑处理不同类型的数据，大大提高了代码的复用性。

Java 泛型是在 JDK 5.0 中引入的，这一特性的出现，让 Java 程序员们可以编写出更通用、类型安全且易于维护的代码。在泛型出现之前，我们在处理集合类时，往往需要进行繁琐的类型转换，而且容易在运行时出现ClassCastException异常。例如，在没有泛型的情况下使用ArrayList：

ArrayList list = new ArrayList();

list.add("hello");

String s = (String) list.get(0);

在这段代码中，从ArrayList中获取元素时，需要将Object类型强制转换为String类型。如果在添加元素时不小心加入了其他类型的数据，那么在运行时就会抛出ClassCastException异常。而有了泛型，我们可以这样写：

ArrayList<String> list = new ArrayList<>();

list.add("hello");

String s = list.get(0);

这样，编译器会在编译时就检查类型的正确性，确保集合中只添加String类型的元素，从而避免了运行时的类型转换错误，提高了代码的安全性。

泛型语法大揭秘

（一）泛型类

泛型类的定义格式非常简洁明了，在类名后面加上尖括号<>，里面放置类型参数。例如，我们定义一个简单的泛型类GenericClass：

public class GenericClass<T> {

   private T data;

   public GenericClass(T data) {
       this.data = data;
   }

   public T getData() {
       return data;
   }
}

在这个例子中，<T>就是类型参数，它可以代表任何引用类型。当我们使用这个泛型类时，就需要确定类型参数T的具体类型 。比如：

GenericClass<Integer> intClass = new GenericClass<>(10);

GenericClass<String> stringClass = new GenericClass<>("hello");

这样，intClass中的data就是Integer类型，stringClass中的data就是String类型。通过这种方式，我们可以使用相同的类结构来处理不同类型的数据，大大提高了代码的复用性。

（二）泛型接口

泛型接口的定义语法和泛型类类似，在接口名后加上类型参数。例如，定义一个泛型接口Generator：

public interface Generator<T> {
   T generate();
}

实现泛型接口有两种方式。一种是实现类也是泛型类，实现类和接口的泛型类型要一致。比如：

public class StringGenerator<T> implements Generator<T> {

   @Override
   public T generate() {
       // 这里假设返回一个默认的字符串，实际应用中根据需求实现
       return (T) "default string";
   }
}

另一种是实现类不是泛型类，此时接口要明确数据类型。例如：

public class IntegerGenerator implements Generator<Integer> {

   @Override
   public Integer generate() {
       return 1;
   }
}

第一种方式适用于需要在实现类中继续使用泛型的场景，而第二种方式则适用于实现类只针对特定类型实现接口的情况。

（三）泛型方法

泛型方法的定义规则是在方法返回类型前加上<>，里面声明类型参数。例如，定义一个泛型方法printArray：

public class GenericMethod {

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

在调用泛型方法时，编译器会根据传入的参数类型来确定类型参数T的具体类型。比如：

Integer[] intArray = {1, 2, 3};

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

GenericMethod.printArray(intArray);

GenericMethod.printArray(stringArray);

这里，当调用printArray(intArray)时，T被确定为Integer类型；当调用printArray(stringArray)时，T被确定为String类型。需要注意的是，泛型方法不仅可以在泛型类中使用，在非泛型类中同样可以定义和使用，这使得我们可以在不创建泛型类的情况下，为方法提供类型参数化的功能。

泛型优势深度剖析

（一）类型安全保障

在 Java 开发中，类型安全是至关重要的。泛型为我们提供了强大的类型安全保障，这主要体现在编译期的类型检查上。让我们通过一个具体的例子来深入理解。

假设我们有一个简单的ArrayList，在没有使用泛型时，代码可能是这样的：

ArrayList list = new ArrayList();

list.add("hello");

list.add(10); // 这里可以添加任意类型的数据，编译不会报错

String s = (String) list.get(1); // 运行时会抛出ClassCastException异常

在这段代码中，ArrayList没有指定元素类型，因此可以添加任意类型的数据。当我们从列表中获取元素并尝试将其转换为String类型时，如果实际存储的是其他类型的数据，就会在运行时抛出ClassCastException异常 。这种错误在运行时才被发现，给调试带来了很大的困难。

而使用泛型后，代码就变得更加安全可靠：

ArrayList<String> list = new ArrayList<>();

list.add("hello");

// list.add(10); // 编译时错误，不允许添加非String类型的数据

String s = list.get(0); // 无需显式类型转换，且类型安全

在这个例子中，ArrayList<String>明确指定了列表中只能存储String类型的数据。编译器会在编译时检查类型的正确性，如果尝试添加非String类型的数据，就会报错。这样一来，我们可以在编译阶段就发现类型错误，而不是等到运行时才出现异常，大大提高了代码的稳定性和可维护性。

（二）代码复用提升

泛型的另一个显著优势是极大地提升了代码的复用性。它允许我们编写通用的代码，这些代码可以适用于多种数据类型，而不需要为每种数据类型都编写专门的实现。以集合类为例，Java 集合框架中的List、Set、Map等接口和它们的实现类，如ArrayList、HashSet、HashMap等，都是泛型的典型应用。

List<Integer> intList = new ArrayList<>();

intList.add(1);

intList.add(2);

List<String> stringList = new ArrayList<>();

stringList.add("one");

stringList.add("two");

在这个例子中，我们使用同一个ArrayList类创建了两个不同类型的列表：一个存储Integer类型的数据，另一个存储String类型的数据。ArrayList类的实现代码是通用的，它通过泛型参数<E>来表示列表中元素的类型。在使用时，我们只需要指定具体的类型参数，就可以得到适用于该类型的列表。这种方式避免了为不同数据类型编写重复的集合类代码，大大提高了代码的复用性和开发效率。

（三）可读性增强

泛型还能显著增强代码的可读性。通过在代码中明确指定类型信息，我们可以更直观地了解代码的功能和数据流向，减少了对注释的依赖，使代码逻辑更加清晰，方便他人理解和维护。

// 没有泛型的情况
List list = new ArrayList();
list.add("hello");
Object obj = list.get(0);

if (obj instanceof String) {
   String s = (String) obj;
   System.out.println(s.length());
}

// 使用泛型的情况
List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0);
System.out.println(s.length());

在没有泛型的代码中，我们需要通过instanceof检查和类型转换来处理从集合中获取的元素，而且从代码中很难直接看出集合中存储的具体类型。而使用泛型后，List<String>明确表示这是一个存储String类型元素的列表，代码的意图一目了然。在获取元素时，也无需进行类型检查和转换，代码更加简洁明了。这样，无论是自己阅读代码还是团队成员之间协作开发，都能更容易理解代码的含义和功能，提高了代码的可读性和可维护性。

通配符与边界探索

（一）通配符基础

通配符?在 Java 泛型中扮演着重要的角色，它代表着未知类型。当我们需要处理一些类型不确定的集合时，通配符就派上了用场。比如，我们有一个方法，需要打印出任何类型集合中的元素，这时就可以使用通配符。

import java.util.List;

public class WildcardExample {

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

   public static void main(String[] args) {
       List<Integer> intList = List.of(1, 2, 3);
       List<String> stringList = List.of("a", "b", "c");
       printList(intList);
       printList(stringList);
   }
}

在这个例子中，printList方法接受一个List<?>类型的参数，这意味着它可以接受任何类型的List，无论是List<Integer>还是List<String> 。在方法内部，由于不知道具体的元素类型，所以将元素视为Object类型进行处理。需要注意的是，使用通配符声明的集合，在添加元素时会受到限制，因为编译器无法确定要添加的元素类型是否正确，不过可以添加null，因为null可以赋值给任何引用类型 。

（二）上界限定

上界限定通配符<? extends T>表示未知类型是T类型或T的子类。它在很多场景中都有着重要的应用，比如当我们需要从集合中读取数据，并且希望集合中的元素类型是某个特定类型或其子类时，就可以使用上界限定。

import java.util.List;

public class UpperBoundExample {

   public static double sumList(List<? extends Number> list) {

       double sum = 0;

       for (Number num : list) {
           sum += num.doubleValue();
       }
       return sum;
   }

   public static void main(String[] args) {
       List<Integer> intList = List.of(1, 2, 3);
       List<Double> doubleList = List.of(1.1, 2.2, 3.3);
       System.out.println("Sum of intList: " + sumList(intList));
       System.out.println("Sum of doubleList: " + sumList(doubleList));
   }
}

在这个例子中，sumList方法接受一个List<? extends Number>类型的参数，这表示它可以接受任何元素类型是Number或其子类（如Integer、Double等）的List。在方法内部，可以安全地将集合中的元素当作Number类型来处理，因为它们必定是Number或其子类 。不过，使用上界限定的集合在添加元素时会受到限制，除了null之外，不能添加其他元素，因为编译器无法确定要添加的元素是否是集合中元素类型的子类 。

（三）下界限定

下界限定通配符<? super T>表示未知类型是T类型或T的父类。它通常用于向集合中写入数据的场景。例如，我们有一个方法，需要向集合中添加Integer类型的元素，并且希望这个集合可以是Integer的父类类型（如Number、Object），就可以使用下界限定。

import java.util.List;

public class LowerBoundExample {

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

   public static void main(String[] args) {
       List<Number> numberList = new java.util.ArrayList<>();
       addNumbers(numberList);
       System.out.println(numberList);
   }
}

在这个例子中，addNumbers方法接受一个List<? super Integer>类型的参数，这表示它可以接受任何元素类型是Integer或其父类（如Number、Object）的List。在方法内部，可以安全地向集合中添加Integer类型的元素，因为Integer是Number和Object的子类 。当下界限定集合读取元素时，由于不知道具体的元素类型，所以只能将元素视为Object类型进行处理，如果需要使用具体类型的方法，可能需要进行类型转换 。

泛型应用场景展示

（一）集合类应用

在 Java 集合框架中，泛型的应用无处不在，它为集合类提供了强大的类型安全保障和代码复用能力。以ArrayList和HashMap为例，我们来看看泛型是如何发挥作用的。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class CollectionGenericExample {

   public static void main(String[] args) {
       // 使用泛型的ArrayList，只能存储String类型的元素
       List<String> stringList = new ArrayList<>();
       stringList.add("apple");
       stringList.add("banana");

       // stringList.add(10); // 编译错误，不允许添加非String类型的数据
       for (String fruit : stringList) {
           System.out.println(fruit.length());
       }

       // 使用泛型的HashMap，键为String类型，值为Integer类型
       Map<String, Integer> map = new HashMap<>();
       map.put("one", 1);
       map.put("two", 2);

       // map.put(10, "ten"); // 编译错误，键和值的类型必须符合定义
       for (Map.Entry<String, Integer> entry : map.entrySet()) {
           System.out.println(entry.getKey() + " : " + entry.getValue());
       }
   }
}

在这个例子中，ArrayList<String>明确指定了列表中只能存储String类型的元素，编译器会在编译时检查类型的正确性，确保不会添加非String类型的数据 。同样，HashMap<String, Integer>指定了键的类型为String，值的类型为Integer，这样可以避免在运行时出现类型转换错误，提高了代码的安全性和可读性。

（二）自定义数据结构

泛型在自定义数据结构中也有着广泛的应用，它可以让我们创建出更加通用和灵活的数据结构。以链表和栈为例，我们来看看如何使用泛型来实现这些数据结构。

// 自定义泛型链表节点类
class ListNode<T> {

   T data;

   ListNode<T> next;

   ListNode(T data) {
       this.data = data;
       this.next = null;
   }
}

// 自定义泛型链表类

class LinkedList<T> {

   ListNode<T> head;

   public void add(T data) {
       ListNode<T> newNode = new ListNode<>(data);
       if (head == null) {
           head = newNode;
       } else {
           ListNode<T> current = head;
           while (current.next != null) {
               current = current.next;
           }
           current.next = newNode;
       }
   }

   public T remove() {
       if (head == null) {
           return null;
       }
       T data = head.data;
       head = head.next;
       return data;
   }
}

// 自定义泛型栈类
class Stack<T> {

   private java.util.ArrayList<T> elements;

   public Stack() {
       elements = new java.util.ArrayList<>();
   }

   public void push(T element) {
       elements.add(element);
   }

   public T pop() {
       if (elements.isEmpty()) {
           return null;
       }
       return elements.remove(elements.size() - 1);
   }

   public boolean isEmpty() {
       return elements.isEmpty();
   }
}

public class CustomDataStructureExample {

   public static void main(String[] args) {
       // 使用自定义泛型链表存储String类型的数据
       LinkedList<String> stringList = new LinkedList<>();
       stringList.add("hello");
       stringList.add("world");
       System.out.println(stringList.remove());

       // 使用自定义泛型栈存储Integer类型的数据
       Stack<Integer> stack = new Stack<>();
       stack.push(1);
       stack.push(2);
       System.out.println(stack.pop());
       System.out.println(stack.isEmpty());
   }
}

在这个例子中，ListNode<T>和LinkedList<T>通过泛型参数<T>实现了通用的链表结构，可以存储任何类型的数据。同样，Stack<T>通过泛型参数<T>实现了通用的栈结构，提高了代码的通用性和可维护性。当我们需要使用不同类型的链表或栈时，只需要在创建对象时指定具体的类型参数即可 。

（三）泛型方法应用

泛型方法允许我们在方法层面实现通用的算法，使其可以适用于不同类型的数据。结合排序、查找等算法，我们可以更好地展示泛型方法的灵活性和可复用性。

import java.util.Arrays;

public class GenericMethodExample {

   // 泛型排序方法，适用于实现了Comparable接口的类型
   public static <T extends Comparable<T>> void sort(T[] array) {
       Arrays.sort(array);
   }

   // 泛型查找方法，适用于实现了Comparable接口的类型
   public static <T extends Comparable<T>> int binarySearch(T[] array, T target) {
       return Arrays.binarySearch(array, target);
   }

   public static void main(String[] args) {

       Integer[] intArray = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
       String[] stringArray = {"banana", "apple", "cherry", "date", "fig"};
       sort(intArray);
       sort(stringArray);
       System.out.println("Sorted intArray: " + Arrays.toString(intArray));
       System.out.println("Sorted stringArray: " + Arrays.toString(stringArray));
       System.out.println("Index of 5 in intArray: " + binarySearch(intArray, 5));
       System.out.println("Index of \\"cherry\\" in stringArray: " + binarySearch(stringArray, "cherry"));
   }
}

在这个例子中，sort方法和binarySearch方法都是泛型方法，它们通过<T extends Comparable<T>>限定了类型参数T必须实现Comparable接口，这样就可以对实现了Comparable接口的任何类型数组进行排序和查找操作。无论是Integer类型的数组还是String类型的数组，都可以使用这两个方法，大大提高了代码的复用性和灵活性。

总结

Java 泛型作为 Java 语言的重要特性，为我们的编程带来了诸多便利和优势。它允许我们在定义类、接口和方法时使用类型参数，从而实现代码的通用性和类型安全。通过使用泛型，我们可以避免在运行时出现类型转换错误，提高代码的稳定性和可靠性。同时，泛型还极大地提升了代码的复用性，减少了重复代码的编写，提高了开发效率。