如何在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