Java 8 核心新特性实战指南_Java

java 8 是 java 发展史上最具里程碑意义的版本之一。它引入了函数式编程思想，极大地简化了代码编写，提升了开发效率和系统性能。本教程将带你深入掌握 java 8 的核心特性，并通过实战示例让你快速上手。

一、 lambda 表达式：开启函数式编程之门

lambda 表达式是 java 8 最核心的特性，它允许你将代码视为数据，使代码更加简洁、可读。

什么是 lambda 表达式？

lambda 表达式本质上是一个匿名函数，它可以作为参数传递，或作为方法的返回值。它极大地简化了函数式接口（只有一个抽象方法的接口）的实现。

基本语法

(parameters) -> expression 或 (parameters) -> { statements; }

示例：从匿名类到 lambda

假设我们要对一个字符串列表进行排序。

java 7 及之前（使用匿名类）

list<string> names = arrays.aslist("steve", "tim", "lucy", "patricia", "ella");
collections.sort(names, new comparator<string>() {
    @override
    public int compare(string a, string b) {
        return b.compareto(a); // 降序
    }
});

java 8（使用 lambda 表达式）

list<string> names = arrays.aslist("steve", "tim", "lucy", "patricia", "ella");
collections.sort(names, (a, b) -> b.compareto(a));
// 或者更简洁地使用方法引用
collections.sort(names, comparator.reverseorder());

可以看到，lambda 表达式让代码变得极其简洁。

四大核心函数式接口

java 8 在 java.util.function 包中定义了四个最常用的函数式接口，它们是 lambda 编程的基石。

接口	描述	抽象方法
`predicate<t>`	断言，用于判断	`boolean test(t t)`
`consumer<t>`	消费，用于执行操作	`void accept(t t)`
`function<t, r>`	函数，用于转换	`r apply(t t)`
`supplier<t>`	供给，用于提供值	`t get()`

示例

// predicate: 判断字符串是否以'a'开头
predicate<string> predicate = s -> s.startswith("a");
system.out.println(predicate.test("apple")); // true
// consumer: 打印字符串
consumer<string> consumer = s -> system.out.println(s);
consumer.accept("hello, lambda!"); // hello, lambda!
// function: 将字符串转换为大写
function<string, string> function = s -> s.touppercase();
system.out.println(function.apply("hello")); // hello
// supplier: 提供一个随机数
supplier<double> supplier = () -> math.random();
system.out.println(supplier.get());

二、 stream api：声明式数据处理

stream api 是 java 8 引入的用于处理集合数据的强大工具。它允许你以声明式的方式对数据进行过滤、映射、排序、聚合等操作，代码更清晰、更易于并行化。

核心概念

声明式：你只需告诉程序“做什么”，而不是“怎么做”。
管道：stream 操作分为中间操作（如 filter, map）和终止操作（如 collect, foreach）。中间操作会返回一个新的 stream，可以链式调用；终止操作会消费 stream 并产生结果。
惰性求值：中间操作不会立即执行，只有当终止操作被调用时，整个处理流程才会真正开始。

创建 stream

// 从集合创建
list<string> list = arrays.aslist("apple", "banana", "orange");
stream<string> streamfromlist = list.stream();
// 从数组创建
string[] array = {"cat", "dog", "mouse"};
stream<string> streamfromarray = arrays.stream(array);
// 使用 stream.of()
stream<string> streamofvalues = stream.of("red", "green", "blue");

常用操作实战

让我们通过一个订单处理的例子来体验 stream 的强大。

import java.math.bigdecimal;
import java.util.*;
import java.util.stream.collectors;
class order {
    private long userid;
    private bigdecimal orderamount;
    private int orderstatus; // 1: paid, 0: unpaid
    private date createtime;
    private string orderno;
    // 构造函数、getter 和 setter 省略
    public order(long userid, bigdecimal orderamount, int orderstatus, date createtime, string orderno) {
        this.userid = userid;
        this.orderamount = orderamount;
        this.orderstatus = orderstatus;
        this.createtime = createtime;
        this.orderno = orderno;
    }
    public long getuserid() { return userid; }
    public bigdecimal getorderamount() { return orderamount; }
    public int getorderstatus() { return orderstatus; }
    public date getcreatetime() { return createtime; }
    public string getorderno() { return orderno; }
}
public class streamexample {
    private static final list<order> order_list = arrays.aslist(
        new order(1l, new bigdecimal("100.00"), 1, new date(), "ord001"),
        new order(2l, new bigdecimal("250.50"), 0, new date(), "ord002"),
        new order(1l, new bigdecimal("80.00"), 1, new date(), "ord003"),
        new order(3l, new bigdecimal("500.00"), 1, new date(), "ord004")
    );
    public static void main(string[] args) {
        // 1. 筛选与映射：获取所有已付款订单的订单号
        list<string> paidordernos = order_list.stream()
                .filter(order -> order.getorderstatus() == 1) // 筛选已付款
                .map(order::getorderno)                     // 映射为订单号
                .collect(collectors.tolist());              // 收集到列表
        system.out.println("已付款订单号: " + paidordernos);
        // 2. 聚合统计：计算订单总金额
        bigdecimal totalamount = order_list.stream()
                .map(order::getorderamount)
                .reduce(bigdecimal.zero, bigdecimal::add);
        system.out.println("订单总金额: " + totalamount);
        // 3. 分组统计：按用户id分组，统计每个用户的订单数量
        map<long, long> userordercountmap = order_list.stream()
                .collect(collectors.groupingby(order::getuserid, collectors.counting()));
        system.out.println("用户订单数量统计: " + userordercountmap);
        // 4. 排序：按订单金额降序排序
        list<order> sortedorderlist = order_list.stream()
                .sorted(comparator.comparing(order::getorderamount).reversed())
                .collect(collectors.tolist());
        system.out.println("按金额降序排序的订单: " + sortedorderlist.stream().map(order::getorderno).collect(collectors.tolist()));
    }
}

三、全新的日期时间 api (java.time)

旧的 java.util.date 和 java.util.calendar 存在线程不安全、设计混乱等问题。java 8 引入了全新的 java.time 包，提供了清晰、不可变且线程安全的日期时间类。

核心类

localdate: 表示日期，不含时区（如 2026-04-02）。
localtime: 表示时间，不含时区（如 16:19:58）。
localdatetime: 表示日期和时间，不含时区（如 2026-04-02t16:19:58）。
zoneddatetime: 表示带时区的日期和时间。
datetimeformatter: 用于格式化和解析日期时间，线程安全，替代了旧的 simpledateformat。

示例

import java.time.localdate;
import java.time.localdatetime;
import java.time.format.datetimeformatter;
public class datetimeexample {
    public static void main(string[] args) {
        // 获取当前日期和时间
        localdate date = localdate.now();
        localtime time = localtime.now();
        localdatetime datetime = localdatetime.now();
        system.out.println("当前日期: " + date);
        system.out.println("当前时间: " + time);
        system.out.println("当前日期时间: " + datetime);
        // 格式化日期时间
        datetimeformatter formatter = datetimeformatter.ofpattern("yyyy-mm-dd hh:mm:ss");
        string formatteddatetime = datetime.format(formatter);
        system.out.println("格式化后: " + formatteddatetime);
        // 解析日期时间
        localdatetime parseddatetime = localdatetime.parse("2026-04-02 16:19:58", formatter);
        system.out.println("解析后: " + parseddatetime);
    }
}

四、接口默认方法与静态方法

java 8 允许在接口中定义带有方法体的默认方法和静态方法，这为接口的演进提供了极大的灵活性，解决了接口升级会破坏实现类的难题。

默认方法 (default method)

使用 default 关键字修饰，为接口方法提供默认实现。实现类可以选择性地重写它。

interface vehicle {
    default void start() {
        system.out.println("车辆正在启动...");
    }
}
class car implements vehicle {
    // 可以重写，也可以不重写
}
public class defaultmethodtest {
    public static void main(string[] args) {
        car mycar = new car();
        mycar.start(); // 输出: 车辆正在启动...
    }
}

静态方法 (static method)

接口中的静态方法只能通过接口名调用，不能被实现类继承。

interface vehicle {
    static void stop() {
        system.out.println("车辆正在停止...");
    }
}
public class staticmethodtest {
    public static void main(string[] args) {
        vehicle.stop(); // 直接通过接口名调用
    }
}

五、 optional 类：优雅地处理空指针

nullpointerexception 是 java 中最常见的异常。optional 是一个容器类，它可以包含一个非空的值，或者为空。它强制你显式地处理值为空的情况，从而避免空指针异常。

常用方法

of(t value): 创建一个包含非空值的 optional。
ofnullable(t value): 创建一个可能为空的 optional。
ispresent(): 判断值是否存在。
ifpresent(consumer<? super t> action): 如果值存在，则执行给定的操作。
orelse(t other): 如果值存在则返回值，否则返回 other。
map(function<? super t, ? extends u> mapper): 如果值存在，则对其进行转换。

示例

import java.util.optional;
public class optionalexample {
    public static void main(string[] args) {
        string str = null;
        // 传统方式
        if (str != null) {
            system.out.println(str.length());
        }
        // 使用 optional
        optional<string> optionalstr = optional.ofnullable(str);
        optionalstr.ifpresent(s -> system.out.println(s.length())); // 值存在才执行
        int length = optionalstr.map(string::length).orelse(-1); // 提供默认值
        system.out.println("字符串长度: " + length); // 输出: 字符串长度: -1
    }
}

六、生产环境最佳实践与避坑指南

掌握了基本用法后，了解如何在生产环境中正确使用这些特性至关重要。

1. 严格区分流的适用场景

简单遍历：对于简单的循环，使用传统的 for 循环可能性能更高，因为 stream 有初始化开销。
复杂集合操作：当需要进行多步骤的过滤、映射、聚合时，stream 能极大提升代码可读性。
cpu 密集型、大数据量：使用并行流 (parallelstream()) 可以充分利用多核 cpu 的性能。
io 密集型、阻塞型操作：禁止使用并行流，因为它会阻塞 forkjoinpool 的公共线程池，影响整个应用的性能。

2. 避免自动装箱拆箱的性能损耗

处理基本数据类型（如 int, long）时，优先使用 intstream, longstream, doublestream 等原始类型流，避免频繁的装箱和拆箱操作。

// 错误示例：会产生大量的 integer 对象
long count = orderlist.stream().map(order::getid).count();
// 正确示例：使用原始类型流，性能更高
long count = orderlist.stream().maptolong(order::getid).count();

3. 禁止流的复用

stream 是一次性的。调用终止操作后，stream 就会被消费掉，再次使用会抛出 illegalstateexception。

// 错误示例
stream<order> orderstream = orderlist.stream();
orderstream.count();
orderstream.foreach(system.out::println); // 会抛出异常
// 正确示例：每次使用时重新创建流
orderlist.stream().count();
orderlist.stream().foreach(system.out::println);

4. 并行流的线程安全规范

在并行流中，禁止向非线程安全的集合（如 arraylist）中添加元素，这会导致数据丢失或并发修改异常。应始终使用 collect 方法来安全地收集结果。

// 错误示例：线程不安全
list<long> useridlist = new arraylist<>();
orderlist.parallelstream().foreach(order -> useridlist.add(order.getuserid()));
// 正确示例：使用 collect，线程安全
list<long> useridlist = orderlist.parallelstream()
                                 .map(order::getuserid)
                                 .collect(collectors.tolist());

5. 自定义并行流线程池

并行流默认使用全局的 forkjoinpool，其线程数等于 cpu 核心数。长时间运行的任务会阻塞这个公共池。对于关键任务，可以创建自定义的 forkjoinpool 来实现线程隔离。

forkjoinpool custompool = new forkjoinpool(4); // 自定义线程数
custompool.submit(() -> 
    orderlist.parallelstream()
             .collect(collectors.groupingby(order::getuserid))
).join();

到此这篇关于java 8 核心新特性实战指南的文章就介绍到这了,更多相关java 8 核心新特性内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！