在Java开发中，泛型是一个超级重大的特性，它让代码更加安全、简洁和可读。不过，对于许多初学者来说，泛型中的那些字母符号——T、E、K、V、?——常常让人困惑。为什么是这些字母？它们有什么区别？什么时候该用哪个？

Java泛型：T、E、K、V、?，这些字母符号代表什么，该怎么用？

一、泛型是什么？

在Java中，泛型是JDK 5引入的重大特性，它提供了一种编译时类型安全检测机制，让开发者可以在编译时就检查类型是否匹配，避免运行时出现ClassCastException异常。

让我们通过一个简单的例子来理解泛型的重大性：

// 非泛型写法（存在类型转换风险）
List list1 = new ArrayList();
list1.add("a");
Integer num = (Long) list1.get(0); // 运行时抛出 ClassCastException

// 泛型写法（编译时检查类型）
List<String> list2 = new ArrayList<>();
list2.add("a");
String str = list2.get(0); // 无需强制转换

在非泛型的写法中，我们使用List list1，这意味着它可以存储任何类型的对象。当我们从列表中获取元素时，需要进行强制类型转换，如果转换类型不匹配，就会在运行时抛出异常。而使用泛型后，编译器会在编译时检查类型，确保类型安全，避免了运行时的类型转换错误。

二、T：Type（类型）——万能的”占位符”

T是泛型中最常用的符号，它代表”Type”（类型）。T是一个通用的类型参数，表明”任意类型”。当你不知道具体类型，但需要一个可以处理多种类型的类或方法时，就可以使用T。

适用场景

通用工具类
不确定具体类型但需要类型安全的场景
类型参数只有一个的泛型类或方法

代码示例

public class Box<T> {
    private T content;
    
    public void setContent(T content) {
        this.content = content;
    }
    
    public T getContent() {
        return content;
    }
}

// 使用示例
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello, Java泛型!");
String content = stringBox.getContent(); // 无需强制转换

Box<Integer> intBox = new Box<>();
intBox.setContent(100);
Integer number = intBox.getContent(); // 无需强制转换

Box<User> userBox = new Box<>();
userBox.setContent(new User("张三", 25));
User user = userBox.getContent(); // 无需强制转换

在这个例子中，Box类是一个通用的容器类，可以存储任何类型的对象。当我们创建Box时，它只能存储String类型；创建Box时，它只能存储Integer类型。编译器在编译时会检查类型，确保类型安全。

三、E：Element（元素）——集合的专属符号

E是”Element”（元素）的缩写，专门用于集合框架中，表明集合中的元素类型。虽然E和T在功能上没有本质区别，但使用E能让代码的意图更加清晰，符合”最小惊讶原则”。

适用场景

集合类（List、Set、Queue等）中的元素类型
需要明确表明”集合中的元素”的场景

代码示例

// JDK源码中的List接口
public interface List<E> extends Collection<E> {
    boolean add(E e);
    E get(int index);
    // ...其他方法
}

// 自定义集合类
public class MyCollection<E> {
    private List<E> elements = new ArrayList<>();
    
    public void add(E element) {
        elements.add(element);
    }
    
    public E get(int index) {
        return elements.get(index);
    }
    
    public int size() {
        return elements.size();
    }
}

// 使用示例
MyCollection<String> stringCollection = new MyCollection<>();
stringCollection.add("Java");
stringCollection.add("泛型");
stringCollection.add("T、E、K、V");

// 编译器会检查类型，确保只能添加String
// stringCollection.add(123); // 编译错误

String firstItem = stringCollection.get(0);
System.out.println("第一个元素: " + firstItem);

在这个例子中，我们创建了一个自定义的集合类MyCollection，它使用E表明集合中的元素类型。当我们创建MyCollection时，编译器会确保我们只能添加String类型的对象，这使得代码更加清晰和安全。

四、K和V：Key和Value——键值对的搭档

K和V是专门为Map接口设计的符号，K代表Key（键），V代表Value（值）。在Map中，K和V是成对出现的，表明键的类型和值的类型。

适用场景

Map、HashMap、TreeMap等映射类
需要表明键值对关系的场景

代码示例

// JDK源码中的Map接口
public interface Map<K, V> {
    V put(K key, V value);
    V get(Object key);
    // ...其他方法
}

// 使用示例
Map<String, Integer> ageMap = new HashMap<>();
ageMap.put("张三", 25);
ageMap.put("李四", 30);
ageMap.put("王五", 28);

// 获取张三的年龄
Integer zhangSanAge = ageMap.get("张三");
System.out.println("张三的年龄: " + zhangSanAge);

// 使用K和V的自定义Map
public class MyMap<K, V> {
    private Map<K, V> internalMap = new HashMap<>();
    
    public void put(K key, V value) {
        internalMap.put(key, value);
    }
    
    public V get(K key) {
        return internalMap.get(key);
    }
}

// 使用自定义Map
MyMap<String, String> userMap = new MyMap<>();
userMap.put("张三", "Java开发者");
userMap.put("李四", "前端工程师");
userMap.put("王五", "产品经理");

String zhangSanRole = userMap.get("张三");
System.out.println("张三的角色: " + zhangSanRole);

在这个例子中，我们看到Map接口使用K和V来表明键和值的类型。当我们创建Map<String, Integer>时，它表明键是String类型，值是Integer类型。同样，自定义的MyMap也使用K和V来表明键和值的类型，使得代码意图超级清晰。

五、?：通配符（未知类型）——灵活的类型处理

?是通配符，表明”未知类型”。它主要用于当类型不重大，或者你不想限制类型时。通配符?有三种形式：无界通配符<?>、上界通配符<? extends T>和下界通配符<? super T>。

1. 无界通配符<?>

表明可以接受任何类型的泛型，但不能向集合中添加元素（除了null），由于类型未知。

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

// 使用示例
List<String> stringList = Arrays.asList("Java", "泛型", "T、E、K、V");
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);

printList(stringList); // 正确
printList(integerList); // 正确

在这个例子中，printList方法可以接受任何类型的List，由于我们使用了通配符<?>。在方法内部，我们只能将元素视为Object类型，由于类型未知。

2. 上界通配符<? extends T>

表明某种类型及其子类。它适合”只读”操作，由于不能向集合中添加元素（除了null）。

public static void printNumbers(List<? extends Number> numbers) {
    for (Number number : numbers) {
        System.out.println(number.doubleValue());
    }
}

// 使用示例
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
List<Double> doubleList = Arrays.asList(1.1, 2.2, 3.3, 4.4, 5.5);

printNumbers(integerList); // 正确
printNumbers(doubleList);  // 正确

在这个例子中，<? extends Number>表明List中的元素可以是Number或Number的子类（如Integer、Double等）。方法内部可以安全地将元素视为Number类型进行操作。

3. 下界通配符<? super T>

表明某种类型及其父类。它适合”写入”操作，由于可以添加T类型或T的子类。

public static void addNumbers(List<? super Integer> numbers) {
    numbers.add(10);
    numbers.add(20);
    numbers.add(30);
}

// 使用示例
List<Number> numberList = new ArrayList<>();
List<Object> objectList = new ArrayList<>();

addNumbers(numberList); // 正确
addNumbers(objectList); // 正确

// 但不能这样使用
// List<Integer> integerList = new ArrayList<>();
// addNumbers(integerList); // 编译错误

Java泛型：T、E、K、V、?，这些字母符号代表什么，该怎么用？

六、实际应用案例

案例1：通用的工具类

public class CollectionUtil {
    // 将一个集合转换为另一个集合
    public static <T, U> List<U> convertList(List<T> source, Function<T, U> converter) {
        List<U> result = new ArrayList<>();
        for (T item : source) {
            result.add(converter.apply(item));
        }
        return result;
    }
    
    // 打印集合
    public static <E> void printCollection(Collection<E> collection) {
        for (E item : collection) {
            System.out.println(item);
        }
    }
}

// 使用示例
List<String> names = Arrays.asList("张三", "李四", "王五");
List<Integer> nameLengths = CollectionUtil.convertList(names, String::length);
CollectionUtil.printCollection(nameLengths); // 输出: 2, 2, 2

在这个例子中，我们使用T和U作为类型参数，表明源集合和目标集合的类型。使用E表明集合中的元素类型。这个工具类可以处理任何类型的集合转换。

案例2：安全的Map操作

public class MapUtil {
    // 获取Map中的值，如果不存在则返回默认值
    public static <K, V> V getOrDefault(Map<K, V> map, K key, V defaultValue) {
        return map.containsKey(key) ? map.get(key) : defaultValue;
    }
    
    // 向Map中添加元素，如果存在则覆盖
    public static <K, V> void putIfAbsent(Map<K, V> map, K key, V value) {
        if (!map.containsKey(key)) {
            map.put(key, value);
        }
    }
}

// 使用示例
Map<String, Integer> ageMap = new HashMap<>();
ageMap.put("张三", 25);
ageMap.put("李四", 30);

int zhangSanAge = MapUtil.getOrDefault(ageMap, "张三", 0);
System.out.println("张三的年龄: " + zhangSanAge); // 25

MapUtil.putIfAbsent(ageMap, "王五", 28);
System.out.println("王五的年龄: " + ageMap.get("王五")); // 28

在这个例子中，我们使用K和V表明Map的键和值类型。这个工具类可以安全地处理任何类型的Map。

七、常见误区与最佳实践

误区1：混淆T和E

许多人会问：”T和E有什么区别？能不能随意替换？”

答案：在功能上，T和E没有区别。但T是通用类型，E是集合元素的专属符号。为了代码的可读性和一致性，提议：

对于通用类、方法使用T
对于集合类、方法使用E

误区2：错误使用通配符

// 错误：不能将List<String>赋值给List<?>，但可以将List<?>赋值给List<String>
List<String> stringList = new ArrayList<>();
List<?> anyList = stringList; // 正确

// 错误：不能将List<?>赋值给List<String>
List<String> anotherStringList = anyList; // 编译错误