如何在Java程序中使用泛型

泛型可以使你的代码更灵活、更易读，并能帮助你在运行时避免ClassCastExceptions。让我们通过这篇结合Java集合框架的泛型入门指南，开启你的泛型之旅。

Java 5引入的泛型增强了代码的类型安全性并提升了可读性。它能帮助你避免诸如ClassCastException（当尝试将对象强制转换为不兼容类型时引发的异常）这类运行时错误。

本教程将解析泛型概念，通过三个结合Java集合框架的实例演示其应用。同时我们将介绍原始类型（raw types），探讨选择使用原始类型而非泛型的场景及其潜在风险。

Java编程中的泛型

• 为何使用泛型？
• 如何利用泛型保障类型安全
• Java集合框架中的泛型应用
• Java泛型类型示例
• 原始类型与泛型对比

为何使用泛型？

泛型在Java集合框架中被广泛用于java.util.List、java.util.Set和java.util.Map等接口。它们也存在于Java其他领域，如java.lang.Class、java.lang.Comparable 和java.lang.ThreadLocal。

在泛型出现前，Java代码常缺乏类型安全保障。以下是非泛型时代Java代码的典型示例：

List integerList = new ArrayList();
integerList.add(1);
integerList.add(2);
integerList.add(3);

for (Object element : integerList) {
    Integer num = (Integer) element; // 必须显式类型转换
    System.out.println(num);
}

这段代码意图存储Integer对象，但没有任何机制阻止你添加其他类型（如字符串）：

integerList.add("Hello");

当尝试将String强制转换为Integer时，这段代码会在运行时抛出ClassCastException。

利用泛型保障类型安全

为解决上述问题并避免ClassCastExceptions，我们可以使用泛型指定列表允许存储的对象类型。此时无需手动类型转换，代码更安全且更易理解：

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

integerList.add(1);
integerList.add(2);
integerList.add(3);

for (Integer num : integerList) {
    System.out.println(num);
}

List表示"存储Integer对象的列表"。基于此声明，编译器确保只有Integer对象能被添加至列表，既消除了类型转换需求，也预防了类型错误。

Java集合框架中的泛型

泛型深度集成于Java集合框架，提供编译时类型检查并消除显式类型转换需求。当使用带泛型的集合时，你需指定集合可容纳的元素类型。Java编译器基于此规范确保你不会意外插入不兼容对象，从而减少错误并提升代码可读性。

为演示泛型在Java集合框架中的使用，让我们观察几个实例。

List和ArrayList的泛型应用

前例已简要展示ArrayList的基本用法。现在让我们通过List接口的声明深入理解这一概念：

public interface List<E> extends SequencedCollection<E> { … }

此处声明泛型变量为"E"，该变量可被任何对象类型替代。注意变量E代表元素（Element）。

接下来演示如何用具体类型替换变量。下例中将替换为：

List<String> list = new ArrayList<>();
list.add("Java");
list.add("Challengers");
// list.add(1); // 此行会导致编译时错误

List声明该列表仅能存储String对象。如代码最后一行所示，尝试添加Integer将引发编译错误。

Set和HashSet的泛型应用

Set接口与List类似：

public interface Set<E> extends Collection<E> { … }

我们将用替换，使集合只能存储Double值：

Set<Double> doubles = new HashSet<>();
doubles.add(1.5);
doubles.add(2.5);
// doubles.add("three"); // 编译时错误

double sum = 0.0;
for (double d : doubles) {
    sum += d;
}

Set确保只有Double值能被添加至集合，防止因错误类型转换引发的运行时错误。

Map和HashMap的泛型应用

我们可以声明任意数量的泛型类型。以键值数据结构Map为例，K代表键（Key），V代表值（Value）：

public interface Map<K, V> { … }

现在用String替换K作为键类型，用Integer替换V作为值类型：

Map<String, Integer> map = new HashMap<>();
map.put("Duke", 30);
map.put("Juggy", 25);
// map.put(1, 100); // 此行会导致编译时错误

此例展示将String键映射到Integer值的HashMap。添加Integer类型的键将不被允许并导致编译错误。

泛型命名规范

我们可以在任何类中声明泛型类型。虽然可以使用任意名称，但建议遵循命名规范：

• E 代表元素（Element）
• K 代表键（Key）
• V 代表值（Value）
• T 代表类型（Type）

应避免使用无意义的"X"、"Y"或"Z"等名称。

Java泛型类型使用示例

现在通过更多示例深入演示Java中泛型类型的声明与使用。

创建通用对象容器

我们可以在自定义类中声明泛型类型，不必局限于集合类型。下例中，Box类通过声明泛型类型E来操作任意元素类型。注意泛型类型E声明于类名之后，随后即可作为属性、构造器、方法参数和返回类型使用：

// 定义带泛型参数E的Box类
public class Box<E> {
    private E content; // 存储E类型对象

    public Box(E content) { this.content = content; }
    public E getContent() { return content; }
    public void setContent(E content) { 
        this.content = content;
    }

    public static void main(String[] args) {
        // 创建存储Integer的Box
        Box<Integer> integerBox = new Box<>(123);
        System.out.println("整数盒内容：" + integerBox.getContent());

        // 创建存储String的Box
        Box<String> stringBox = new Box<>("Hello World");
        stringBox.setContent("Java Challengers");
        System.out.println("字符串盒内容：" + stringBox.getContent());
    }
}

输出结果：

整数盒内容：123
字符串盒内容：Java Challengers

代码要点：

• Box类使用类型参数E作为容器存储对象的占位符，允许Box处理任意对象类型
• 构造器初始化Box实例时接受指定类型对象，确保类型安全
• getContent返回与实例创建时指定的泛型类型匹配的对象，无需类型转换
• setContent通过类型参数E确保只能设置正确类型的对象
• main方法创建了存储Integer和String的Box实例
• 每个Box实例操作特定数据类型，展现泛型在类型安全方面的优势

此例展示了Java泛型的基础实现，演示了如何以类型安全方式创建和操作任意类型对象。

处理多数据类型

我们可以声明多个泛型类型。以下Pair类包含<K, V>泛型值。如需更多泛型参数，可扩展为<K, V, V1, V2, V3>等，代码仍可正常编译。

Pair类示例：

class Pair<K, V> {
    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 void setKey(K key) { this.key = key; }
    public void setValue(V value) { this.value = value; }
}

public class GenericsDemo {
    public static void main(String[] args) {
        Pair<String, Integer> person = new Pair<>("Duke", 30);

        System.out.println("姓名：" + person.getKey());
        System.out.println("年龄：" + person.getValue());

        person.setValue(31);
        System.out.println("更新后年龄：" + person.getValue());
    }
}

输出结果：

姓名：Duke
年龄：30
更新后年龄：31

代码要点：

• Pair<K, V>类包含两个类型参数，适用于任意数据类型组合
• 构造器与方法使用类型参数实现严格类型检查
• 创建存储String（姓名）和Integer（年龄）的Pair对象
• 访问器和修改器方法操作Pair数据
• Pair类可存储管理关联信息而不受特定类型限制，展现泛型的灵活性与强大功能

此例展示泛型如何创建支持多数据类型的可复用类型安全组件，提升代码复用性和可维护性。

让我们再看一个示例。

方法级泛型声明

泛型类型可直接在方法中声明，无需在类级别定义。若某个泛型类型仅用于特定方法，可在方法签名返回类型前声明：

public class GenericMethodDemo {

    // 声明泛型类型<T>并打印指定类型数组
    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};
        printArray(intArray);

        String[] stringArray = {"Java", "Challengers"};
        printArray(stringArray);
    }
}

输出结果：

1 2 3 4
Java Challengers

原始类型与泛型对比

原始类型指未指定类型参数的泛型类或接口名称。在Java 5引入泛型前，原始类型被广泛使用。现今开发者通常仅在与遗留代码兼容或与非泛型API交互时使用原始类型。即使使用泛型，仍需了解如何识别和处理原始类型。

典型原始类型示例——未指定类型参数的List声明：

 List rawList = new ArrayList();

此处List rawList声明了一个未指定泛型参数的列表。rawList可存储任意类型对象（Integer、String、Double等）。由于未指定类型，编译器不会对添加至列表的对象类型进行检查。

使用原始类型的编译警告

Java编译器会对原始类型使用发出警告，提醒开发者可能存在的类型安全隐患。当使用泛型时，编译器会检查集合（如List、Set）中存储的对象类型、方法返回类型和参数是否匹配声明类型，从而预防如ClassCastException的常见错误。

使用原始类型时，由于未指定存储对象类型，编译器无法进行类型检查，因此会发出警告提示你绕过了泛型提供的类型安全机制。

编译警告示例

以下代码演示编译器如何对原始类型发出警告：

List list = new ArrayList(); // 警告：原始使用参数化类'List'
list.add("hello");
list.add(1);

编译时通常会显示：

注意：SomeFile.java使用了未经检查或不安全的操作。
注意：使用-Xlint:unchecked重新编译以获取详细信息。

使用-Xlint:unchecked参数编译将显示更详细警告：

warning: [unchecked] unchecked call to add(E) as a member of the raw type List
    list.add("hello");
            ^
  where E is a type-variable:
    E extends Object declared in interface List

若确信使用原始类型不会引入风险，或处理无法重构的遗留代码，可使用@SuppressWarnings("unchecked")注解抑制警告。但需谨慎使用，避免掩盖真实问题。

使用原始类型的后果

尽管原始类型有助于向后兼容，但存在两大缺陷：类型安全性缺失和维护成本增加。

• 类型安全性缺失：泛型的核心优势是类型安全，使用原始类型将丧失这一优势。编译器不进行类型正确性检查，可能导致运行时ClassCastException。
• 维护成本增加：使用原始类型的代码缺乏泛型提供的明确类型信息，维护难度加大，易产生仅在运行时暴露的错误。

类型安全问题示例：使用原始类型List而非泛型List时，编译器允许添加任意类型对象。当从列表检索元素并尝试强制转换为String时，若实际为其他类型将导致运行时错误。

泛型知识要点回顾

泛型以高度灵活性提供类型安全保障。以下回顾关键要点：

泛型是什么？为何使用？

• code.Java 5引入泛型以提升代码类型安全性和灵活性
• 主要优势在于帮助避免ClassCastException等运行时错误
• 泛型广泛应用于Java集合框架，也见于Class、Comparable、ThreadLocal等组件
• 通过阻止不兼容类型插入实现类型安全

Java集合中的泛型

• List和ArrayList：List允许指定元素类型E，确保列表类型专一
• Set和HashSet：Set限定元素为类型E，保持一致性
• Map和HashMap：Map<K,V>定义键值类型，提升类型安全性和代码清晰度

泛型使用优势

• 通过阻止不兼容类型插入减少错误
• 明确类型关联提升代码可读性和可维护性
• 便于以类型安全方式创建和管理集合等数据结构

• 【注】本文译自： How to use generics in your Java programs | InfoWorld

Java Stream API：每个开发者都应该知道的 3 件事

Java Stream API 通过惰性求值、并行处理和函数式编程简化了集合处理。使用它可以编写更简洁、高效和可扩展的代码。

时间飞逝！我记得 Java 8 曾经是一个标杆，每个人都把它当作一种全新且革命性的东西来谈论。老实说，它确实是全新且革命性的。但现在，使用 Java 8 的项目可能被称为“遗留”项目。即使 Java 8 本身已经成为遗留版本，它引入的特性仍然具有实际意义。今天，我们来聊聊其中一个特性——Stream API。

如果你还不了解，Java Stream API 是一个强大的工具，它允许程序员以函数式编程风格编写 Java 代码。它通过支持过滤、转换和聚合操作，使得集合的处理更加简单。

尽管 Stream API 被广泛使用，但我仍然发现许多开发者对其深层知识的掌握存在不足。在本文中，我将探讨 Stream API 的三个关键方面，这些方面对于深入理解它至关重要：

1. 惰性求值：帮助我们优化操作链的执行。
2. 并行流：通过利用多核处理器，深入探讨如何增加数据处理的并行性。
3. Lambda 变量作用域：了解在使用 Stream 时如何正确地将变量传递给 Lambda。

我希望通过本文，你能更好地理解这些概念。

1. Java Stream API 中的惰性求值

惰性求值是理解如何有效使用流的核心概念。但在深入探讨惰性求值之前，我们先来了解流管道中的两种主要操作类型：中间操作和终端操作。

1. 中间操作：中间操作是将输入流转换为另一个流的操作，但不会产生不可变的结果。例如，filter()、map() 和 flatMap() 都是中间操作，因为它们接受一个输入流并返回另一个流。这些操作不会立即消耗输入流中的所有元素，而是创建一个包含所需元素的新流。

2. 终端操作：终端操作是消耗流中元素的操作，它们要么返回一个结果，要么通过副作用修改某些状态。例如，forEach()、findFirst() 和 collect() 都是终端操作，因为它们最终会消耗流中的所有元素以产生结果。

什么是惰性求值？它是如何工作的？

在 Stream API 中，惰性求值意味着中间操作不会立即执行，直到我们调用一个终端操作。这意味着我们可以在代码的任何地方定义一个流及其所有操作，但只有在调用终端操作时才会执行。

当我们调用终端操作时，流会逐个处理数据元素，依次应用所有中间操作。这种方法通过避免不必要的计算来优化性能。

让我们通过一个实际例子来看看惰性求值如何影响执行：

import java.util.stream.Stream;

public class LazyEvaluationExample {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5)
            .filter(num -> {
                System.out.println("Filtering: " + num);
                return num % 2 == 0;
            })
            .map(num -> {
                System.out.println("Mapping: " + num);
                return num * 2;
            });

        System.out.println("Stream pipeline defined, no execution yet.");

        // 终端操作触发执行
        stream.forEach(System.out::println);
    }
}

输出：

Stream pipeline defined, no execution yet.
Filtering: 1
Filtering: 2
Mapping: 2
4
Filtering: 3
Filtering: 4
Mapping: 4
8
Filtering: 5

让我们试着理解为什么会有这样的输出。我们可以看到，filter() 和 map() 操作是惰性的。这意味着即使我们编写了这些代码，它们也不会在调用终端操作 forEach() 之前执行。这解释了为什么我们首先看到输出 Stream pipeline defined, no execution yet。

只有当调用 forEach() 终端操作时，流才会开始逐个处理元素。

2. 并行流

Java Stream API 最有用和最强大的功能之一是对并行流的支持。并行性是指通过利用多个 CPU 核心同时处理两个或多个操作的能力。在 Stream API 中，这意味着我们可以同时处理流中的多个元素的中间或终端操作。

这种功能可以显著提高计算密集型任务的性能，但为了更好地理解它以达到最佳效果，我们需要深入了解它。

什么是并行流？

并行流是一种将其元素分成多个块，然后通过不同线程并行处理的流。与普通流（逐个处理元素）不同，并行流在底层使用 ForkJoinPool 来实现并行性。

创建并行流非常简单。你可以使用以下两种方法之一：

• 对于现有集合，可以使用 parallelStream() 方法。
• 你可以通过在现有流上调用 parallel() 方法来使其并行。

何时使用并行流？

并行流可以在特定场景中提升性能，但它们并不总是最佳选择。以下是一些关键考虑因素：

1. 适合的场景：

   • 大数据集：当处理大量数据时，并行性效果最好。
   • CPU 密集型任务：对于大量使用 CPU 的计算任务（如数学运算或数据转换），并行流是理想选择。

2. 避免使用并行流的场景：

   • IO 密集型任务：如果你的任务涉及大量读写操作（如磁盘/网络操作），并行流可能不是最佳选择。
   • 小数据集：你需要记住，Java 虚拟机在底层仍然需要管理线程切换等操作。因此，在处理小数据集时，管理线程的开销可能会超过性能提升。

性能对比代码的解释

下面的代码将帮助我们通过求和操作来比较 Java 中顺序流和并行流的性能。我们将运行两个测试：

• 第一个测试：范围从 1 到 1,000,000。
• 第二个测试：范围从 1 到 100,000,000。

我们的主要目标是比较顺序流和并行流的处理时间，从而帮助我们理解使用并行流的优缺点。

int rangeLimit = 1_000_000;

long start = System.currentTimeMillis();
LongStream.rangeClosed(1, rangeLimit)
    .reduce(0L, Long::sum);
long end = System.currentTimeMillis();

System.out.println("Sequential Stream Time: " + (end - start) + " ms");

start = System.currentTimeMillis();
LongStream.rangeClosed(1, rangeLimit)
    .parallel()
    .reduce(0L, Long::sum);
end = System.currentTimeMillis();

System.out.println("Parallel Stream Time: " + (end - start) + " ms");

首先，我们创建了两个流：顺序流和并行流。并行流是通过在现有流上调用 .parallel() 方法创建的。两者都包含从 1 到 1,000,000 的数字，使用 LongStream.rangeClosed() 方法生成。

其次，我们对两个流执行了 .reduce(0L, Long::sum) 方法，该方法对输入流中的所有元素求和。由于 reduce 是一个终端操作，流会在调用该方法时立即开始处理。

我们能够测量此操作所花费的时间。这些信息通过 System.currentTimeMillis() 命令记录并存储在变量 start 和 end 中。结果以毫秒为单位打印出来。

让我们执行代码两次，更新 rangeLimit 变量。第一次执行时，将其设置为 1,000,000，如代码所示。第二次执行时，将其设置为 100,000,000。

对于范围从 1 到 1,000,000：

Sequential Stream Time: 9 ms
Parallel Stream Time: 12 ms

我们可以看到，在这种情况下，并行流比顺序流稍慢。这是一个很好的例子，展示了对于像我们示例中使用的小数据集，管理多个线程可能会导致性能损失。

接下来，我们将范围增加到 100,000,000，结果如下：

Sequential Stream Time: 57 ms
Parallel Stream Time: 12 ms

最终，我们可以看到并行流的优势。在这里，并行流明显优于顺序流。较大的数据集能够通过利用多个 CPU 核心来加速计算过程。

重要注意事项：处理大数据集

我们需要记住一点：Java 中的 Long 类型的最大值是 2^63-1。因此，在我们的示例中，当我们测试较大的范围时，求和结果可能会超过此限制，从而导致不正确的结果。

由于本示例的主要目的是展示并行流的行为并比较效率，我们可以忽略结果可能不正确的事实。如果需要精确求和，你可能需要使用更大范围的类型，例如 BigInteger。

3. Lambda 中的变量作用域

让我们简单讨论一下 Lambda。Lambda 表达式在 Stream API 中被广泛使用。老实说，我认为有很多开发者只在流中使用 Lambda。因此，我认为在本文中讨论一些与 Lambda 相关的点也是合理的。

我们应该意识到，Lambda 与变量的交互方式有其特殊性，作为 Java 开发者，理解 Lambda 如何捕获和使用变量至关重要。

让我们探讨一下变量作用域在 Lambda 表达式中是如何工作的，以及它与传统方法的区别。

在 Lambda 中捕获变量

假设你在 Lambda 的外部作用域中初始化了一个变量，并计划在 Lambda 函数中使用这个变量。你能这样做吗？

这取决于情况。我们只能使用从外部作用域捕获的变量，前提是它们是 final 或有效 final 的。那么，“有效 final”是什么意思呢？

简而言之，如果一个变量在初始化后其值从未改变，则它被认为是有效 final 的。因此，要在 Lambda 中使用变量，你有两种方法：

1. 像往常一样初始化变量，并确保其值在初始化后不会改变。
2. 在初始化时通过添加 final 关键字使变量成为 final。

int factor = 2;  

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

numbers.stream()
    .map(n -> n * factor)  
    .forEach(System.out::println);

在上面的示例中，我们可以看到 factor 变量是有效 final 的，因为我们在初始化后没有更新它。这意味着这个变量可以在我们的 Lambda 中使用。你可以尝试在初始化后重新赋值 factor，看看会发生什么。

结论

Stream API 是一套强大且易于理解的工具，用于处理元素序列。如果正确使用，它可以帮助减少大量不必要的代码，使程序更具可读性，并提高应用程序的性能。但正如我所提到的，正确使用它以从性能和代码简洁性方面获得最佳结果至关重要。

【注】本文译自：Java Stream API: 3 Things Every Developer Should Know About