JDK8新特性

本文章主要介绍 JDK8 新特性。

JDK8 新特性

Lambda 表达式的介绍

使用匿名内部类存在的问题

• 当需要启动一个线程去完成任务的时候，通常会通过 Runnable 接口来定义任务内容，并使用 Thread 类来启动该线程。

• 传统写法，代码如下：

package org.itjing.lambda;

/**
 * @author lijing
 * @date 2021年12月09日 14:19
 * @description
 */
public class LambdaDemo1 {
    public static void main(String[] args) {
        // 使用匿名内部类存在的问题

        // 匿名内部类做了哪些事情
        // ①定义了一个没有名字的类
        // ②这个类实现了Runnable接口
        // ③创建了这个类的对象

        // 其实我们最关注的是run方法和里面要执行的代码。
        // 所以使用匿名内部类语法是很冗余的。
        new Thread(new Runnable() {
            @Override
            public void run()   {
                System.out.println("线程执行啦(*^▽^*)");
            }
        }).start();
    }
}

• 由于面向对象的语法要求，首先创建一个 Runnable 接口的匿名类对象来指定线程要执行的任务内容，再将其交给一个线程来启动。

• 代码分析：对于 Runnable 的匿名内部类用法，可以分析出以下几点内容：

• • Thread 类需要 Runnable 接口作为参数，其中的抽象方法 run 方法是用来指定线程任务内容的核心。
• • 为了指定 run 的方法体，不得不需要 Runnable 接口的实现类。
• • 为了省去定义个 Runnable 实现类的麻烦，不得不使用匿名内部类。
• • 必须覆盖重写 run 方法，所以方法名称，方法参数、方法返回值不得不重写一遍，且不能写错。
• • 实际上，似乎只有 run 方法体才是关键所在。

体验 Lambda

• Lambda 是一个匿名函数，可以理解为一段可以传递的代码。

• Lambda 表达式写法，代码如下：

package org.itjing.lambda;

/**
 * @author lijing
 * @date 2021年12月09日 14:23
 * @description
 */
public class LambdaDemo2 {
    public static void main(String[] args) {
        // Lambda体现的是函数式编程思想，只需要将要执行的代码放到函数中（函数就是类中的方法）
        // Lambda就是一个匿名函数，我们只需要将要执行的代码放到Lambda表达式中即可
        // Lambda表达式的好处：可以简化匿名内部类，让代码更加精简。
        new Thread(() -> {
            System.out.println("线程执行啦(*^▽^*)");
        }).start();
    }
}

这段代码和使用匿名内部类的执行效果是完全一样的，可以在 JDK8 或更高的编译级别下通过。从代码的语义中可以看出：我们启动了一个线程，而线程任务的内容以一种更加简洁的形式被指定。

Lambda 的优点

简化匿名内部类的使用，语法更加简单。

Lambda 的标准格式

Lambda 的标准格式

Lambda 省去了面向对象的条条框框，Lambda 的标准格式由 3 个部分组成：

(参数类型 参数名称) -> {
    代码体;
}

• 格式说明：

• • (参数类型 参数名称)：参数列表。
• • {代码体;}：方法体。
• • ->：箭头，没有实际含义，起到连接的作用。

无参无返回值的 Lambda

示例，定义函数式接口：

package org.itjing.lambda;

/**
 * @author lijing
 * @date 2021年12月09日 14:28
 * @description 定义一个无参无返回值的函数式接口
 */
@FunctionalInterface
public interface Swimmable {
    /**
     * 游泳
     */
    void swimming();
}

package org.itjing.lambda;

/**
 * @author lijing
 * @date 2021年12月09日 14:29
 * @description
 */
public class LambdaDemo3 {

    /**
     * Lambda表达式的标准格式：
     * (参数列表)->{}
     * (参数列表)：参数列表
     * {}：方法体
     * ->：没有实际含义，起到连接的作用
     */
    public static void main(String[] args) {

        goSwimming(new Swimmable() {
            @Override
            public void swimming() {
                System.out.println("我是匿名内部类的游泳");
            }
        });

        goSwimming(() -> {
            System.out.println("我是Lambda的游泳");
        });
    }

    /**
     * 无参数无返回值的Lambda
     *
     * @param swimmable
     */
    public static void goSwimming(Swimmable swimmable) {
        swimmable.swimming();
    }
}

有参数有返回值的 Lambda

示例，定义函数式接口：

package org.itjing.lambda;

/**
 * @author lijing
 * @date 2021年12月09日 14:32
 * @description 定义一个有参有返回值的函数式接口
 */
@FunctionalInterface
public interface Smokeable {
    /**
     * 抽烟
     * @param name
     * @return
     */
    int smoking(String name);
}

package org.itjing.lambda;

/**
 * @author lijing
 * @date 2021年12月09日 14:34
 * @description
 */
public class LambdaDemo4 {
    /**
     * Lambda表达式的标准格式：
     * (参数列表)->{}
     * (参数列表)：参数列表
     * {}：方法体
     * ->：没有实际含义，起到连接的作用
     */
    public static void main(String[] args) {
        goSmoking(new Smokeable() {
            @Override
            public int smoking(String name) {
                System.out.println("匿名内部类：抽了" + name + "的烟");
                return 0;
            }
        });

        goSmoking(name -> {
            System.out.println("Lambda：抽了" + name + "的烟");
            return 0;
        });
    }

    public static void goSmoking(Smokeable smokeable) {
        smokeable.smoking("中华");
    }
}

总结

Lambda 表达式的标准格式：

(参数列表) -> {}

以后我们看到调用的方法其参数是函数式接口就可以考虑使用 Lambda 表达式来替代匿名内部类，但是不是所有的匿名内部类都能使用 Lambda 表达式来替代，Lambda 表达式相当于对函数式接口的抽象方法的重写。

了解 Lambda 的实现原理

package org.itjing.lambda;

/**
 * @author lijing
 * @date 2021年12月09日 14:28
 * @description 定义一个无参无返回值的函数式接口
 */
@FunctionalInterface
public interface Swimmable {
    /**
     * 游泳
     */
    void swimming();
}

package org.itjing.lambda;

/**
 * @author lijing
 * @date 2021年12月09日 14:29
 * @description
 */
public class LambdaDemo3 {

    /**
     * Lambda表达式的标准格式：
     * (参数列表)->{}
     * (参数列表)：参数列表
     * {}：方法体
     * ->：没有实际含义，起到连接的作用
     */
    public static void main(String[] args) {

        goSwimming(new Swimmable() {
            @Override
            public void swimming() {
                System.out.println("我是匿名内部类的游泳");
            }
        });

        /*goSwimming(() -> {
            System.out.println("我是Lambda的游泳");
        });*/
    }

    /**
     * 无参数无返回值的Lambda
     *
     * @param swimmable
     */
    public static void goSwimming(Swimmable swimmable) {
        swimmable.swimming();
    }
}

我们可以看到匿名内部类会在编译后产生一个类：LambdaDemo3$1.class。

使用 XJad 反编译这个类，得到如下的代码：

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space
// Source File Name:   LambdaDemo3.java

package org.itjing.lambda;

import java.io.PrintStream;

// Referenced classes of package org.itjing.lambda:
//			Swimmable, LambdaDemo3

static class LambdaDemo3$1
	implements Swimmable
{

	public void swimming()
	{
		System.out.println("我是匿名内部类的游泳");
	}

	LambdaDemo3$1()
	{
	}
}

我们再看 Lambda 的效果，修改代码如下：

package org.itjing.lambda;

/**
 * @author lijing
 * @date 2021年12月09日 14:29
 * @description
 */
public class LambdaDemo3 {

    /**
     * Lambda表达式的标准格式：
     * (参数列表)->{}
     * (参数列表)：参数列表
     * {}：方法体
     * ->：没有实际含义，起到连接的作用
     */
    public static void main(String[] args) {

        /*goSwimming(new Swimmable() {
            @Override
            public void swimming() {
                System.out.println("我是匿名内部类的游泳");
            }
        });*/

        goSwimming(() -> {
            System.out.println("我是Lambda的游泳");
        });
    }

    /**
     * 无参数无返回值的Lambda
     *
     * @param swimmable
     */
    public static void goSwimming(Swimmable swimmable) {
        swimmable.swimming();
    }
}

运行程序，控制台得到预期结果，但没有生成新的类，也就是说 Lambda 并没有再编译的时候产生新的类。使用 XJad 对这个类进行反编译，发现 XJad 报错。

使用了 Lambda 后 XJad 反编译工具无法反编译。

我们使用 JDK 自带的一个工具：javap，对字节码进行反汇编，查看字节码指令。

javap -c -p 文件名.class

-c：表示对代码进行反编译
-p：显示所有类和成员

反编译的效果如下：

可以看到在类中多了一个私有的静态方法lambda$main$0。这个方法里面存放的是什么内容，我们可以通过断点调试来看看：

可以确认lambda$main$0里面放的就是 Lambda 中的内容，那么我们可以这么理解lambda$main$0方法：

public class LambdaDemo3 {
    public static void main(String[] args) {
		...
    }
    private static void lambda$main$0(){
        System.out.println("Lambda的游泳");
    }
}

关于这个方法lambda$main$0的命名：以 lambda 开头，因为是在 main 函数里面使用了 Lambda 表达式，所以带有$main表示，因为是第一个，所以$0。

如果调用这个方法？其实 Lambda 在运行的时候会生成一个内部类，为了验证是否生成内部类，可以在运行的时候加上-Djdk.internal.lambda.dumpProxyClasses，加上这个参数后，运行时会将生成的内部 class 码输出到一个文件中。其命令如下：

java -Djdk.internal.lambda.dumpProxyClasses 要运行的包名.类名

根据上面的格式，在命令行输入以下的命令：

java -Djdk.internal.lambda.dumpProxyClasses org.itjing.lambda.LambdaDemo3

执行完毕，可以看到生成一个新的类，效果如下：

使用 XJad 反编译LambdaDemo3$$Lambda$1.class这个字节码文件，内容如下：

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space

package org.itjing.lambda;


// Referenced classes of package org.itjing.lambda:
//			Swimmable, LambdaDemo3

final class LambdaDemo3$$Lambda$1
	implements Swimmable
{

	public void swimming()
	{
		LambdaDemo3.lambda$main$0();
	}

	private LambdaDemo3$$Lambda$1()
	{
	}
}

可以看到这个匿名内部类实现了 Swimmable 接口，并且重写了 swimming 方法，swimming 方法调用LambdaDemo3.lambda$main$0()，也就是调用 Lambda 中的内容。最后可以将 Lambda 理解为：

public class LambdaDemo3 {
    public static void main(String[] args) {
        goSwimming(new Swimmable() {
            @Override
            public void swimming() {
                LambdaDemo3.lambda$main$0();
            }
        });
    }
    private static void lambda$main$0(){
        System.out.println("我是Lambda的游泳");
    }
}

Lambda 的省略格式

再 Lambda 标准格式的基础上，使用省略写法的规则是：

• 小括号内的参数类型可以省略。
• 如果小括号内有且仅有一个参数，则小括号可以省略。
• 如果大括号内有且仅有一个语句，则可以同时省略大括号、return 关键字以及语句的分号。

示例：

Lambda 的标准格式：

(int a ) -> {
    return new Person();
}

Lambda 表达式省略后：

a -> new Person()

Lambda 的前提条件

Lambda 的语法非常简洁，但是 Lambda 表达式不是随随便便就能使用的，使用时需要注意以下几个条件：

• 方法的参数或局部变量类型必须为接口时才能使用 Lambda。
• 接口中有且仅有一个抽象方法（函数式接口）。

示例：

package org.itjing.lambda;

/**
 * @author lijing
 * @date 2021年12月09日 15:18
 * @description 只有一个抽象方法的接口称为函数式接口。
 */
@FunctionalInterface // 注解用来检测这个接口是不是只有一个抽象方法，即函数式接口
public interface Flyable {

    void fly();
}

package org.itjing.lambda;

/**
 * @author lijing
 * @date 2021年12月09日 15:19
 * @description
 */
public class LambdaCondition {
    public static void main(String[] args) {

        test(() -> {
            System.out.println("飞");
        });

        // 局部变量类型是接口，可以使用Lambda
        Flyable flyable = () -> {
            System.out.println("飞");
        };
    }

    /**
     * 方法的参数类型，可以使用Lambda
     *
     * @param flyable
     */
    public static void test(Flyable flyable) {
        flyable.fly();
    }
}

函数式接口

函数式接口在 Java 中是指有且仅有一个抽象方法的接口。

函数式接口，即适用于函数式编程场景的接口。

而 Java 中的函数式编程体现就是 Lambda，所以函数式接口就是可以适用于 Lambda 使用的接口。

只有确保接口中有且仅有一个抽象方法，Java 中的 Lambda 才能顺利的进行推导。

Java8 中专门为函数式接口引入了一个新的注解：@FunctionalInterface。

该注解用于接口的定义上。

一旦使用该注解来定义接口，编译器将会强制检查是否确实仅有一个抽象方法，否则将会报错。

不过，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样，加了注解是为了校验接口是否满足函数式接口的定义。

Lambda 和匿名内部类的对比

• 所需的类型不一样：

• • 匿名内部类，需要的类型可以是类、抽象类、接口。
• • Lambda，需要的类型必须是接口。

• 抽象方法数量不一样：

• • 匿名内部类所需接口中的抽象方法的数量随意。
• • Lambda 所需接口中的抽象方法的数量有且仅有一个。

• 实现原理不同：

• • 匿名内部类是在编译后会形成 class 文件。
• • Lambda 是在程序运行的时候动态生成 class 文件。

JDK8 接口新增的两种方法

概述

在 JDK8 以前的接口：

interface 接口名{
    静态常量;
    抽象方法;
}

JDK8 对接口进行了增强，接口还可以有默认方法和静态方法。

interface 接口名{
    静态常量;
    抽象方法;
    默认方法;
    静态方法;
}

####

接口引入默认方法的背景

• 在 JDK8 以前接口中只能有抽象方法。存在如下问题：

• 如果给接口中新增抽象方法，所有实现类都必须重写这个抽象方法。不利于接口的扩展。

package org.itjing.inter;

interface A {
    void test1();

    // 接口新增抽象方法，所有实现类都需要去重写这个方法，非常不利于接口的扩展
    void test2();
}

class B implements A {
    @Override
    public void test1() {
        System.out.println("B test1");
    }

    // 接口新增抽象方法，所有实现类都需要去重写这个方法
    @Override
    public void test2() {
        System.out.println("B test2");
    }
}

例如，JDK8 的时候，Map 接口新增了 forEach 方法：

public interface Map<K,V> {
	...
    void forEach(BiConsumer<? super K, ? super V> action) {}
}

通过 API 可以查询到 Map 接口的实现类：

如果在 Map 接口中增加一个抽象方法，所有的实现类都需要去实现这个方法，那么工程量是巨大的。

因此，在 JDK8 为接口新增了默认方法，效果如下：

public interface Map<K,V> {
	...

    default void forEach(BiConsumer<? super K, ? super V> action) {
        Objects.requireNonNull(action);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
            action.accept(k, v);
     	}
    }
}

接口中的默认方法实现类不必重写，可以直接使用，实现类也可以根据需要重写，这样就方便接口的扩展。

接口默认方法的定义格式

interface 接口名{
    default 返回值类型 方法名(){
        //代码;
    }
}

接口的默认方法的使用

① 实现类可以直接使用接口中的默认方法。

package org.itjing.inter;

public class DefaultFunction {
    public static void main(String[] args) {
        BB bb = new BB();
        bb.show();
    }
}

interface AA {
    default void show() {
        System.out.println("我是AA接口中的默认方法");
    }
}

// 默认方法的使用方式一：实现类可以直接使用
class BB implements AA {

}

② 实现类重写接口中的默认方法

package org.itjing.inter;

public class DefaultFunction {
    public static void main(String[] args) {
        BB bb = new BB();
        bb.show();

        CC cc = new CC();
        cc.show();
    }
}

interface AA {
    default void show() {
        System.out.println("我是AA接口中的默认方法");
    }
}

// 默认方法的使用方式一：实现类可以直接使用
class BB implements AA {

}

// 默认方法的使用方式二：实现类可以重写默认方法
class CC implements AA{
    @Override
    public void show() {
        System.out.println("我是CC类重写的默认方法");
    }
}

接口静态方法的定义格式

interface 接口名{
    static 返回值类型 方法名(){
        //代码
    }
}

接口静态方法的使用

直接使用接口名调用即可：接口名.静态方法名();

接口中的静态方法不能被继承，也不能被重写。

package org.itjing.inter;

/**
 * @author lijing
 * @date 2021年12月09日 15:45
 * @description
 */
public class StaticFunction {

    public static void main(String[] args) {
        AA.show();
    }


    interface AA {
        static void show() {
            System.out.println("我是接口的静态方法");
        }
    }
}

接口中默认方法和静态方法的区别

• 接口中的默认方法是通过实例调用，而接口中的静态方法是通过接口名调用。
• 接口中的默认方法可以被继承，实现类可以直接使用接口中的默认方法，也可以重写接口中的默认方法。
• 接口中的默认方法可以被继承，实现类可以直接使用接口中的默认方法，也可以重写接口中的默认方法。

常用内置函数式接口

内置函数式接口的由来

我们知道使用 Lambda 表达式的前提是需要有函数式接口。

而 Lambda 使用时不关心接口名、抽象方法名，只关系抽象方法的参数列表和返回值类型。

因此为了让我们使用 Lambda 方便，JDK 提供了大量常用的函数式接口。

常用的函数式接口介绍

它们主要在java.util.function包中。

下面是最常用的几个接口：

① Supplier 接口：供给型接口。

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

② Consumer 接口：消费型接口。

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

    /**
     * Returns a composed {@code Consumer} that performs, in sequence, this
     * operation followed by the {@code after} operation. If performing either
     * operation throws an exception, it is relayed to the caller of the
     * composed operation.  If performing this operation throws an exception,
     * the {@code after} operation will not be performed.
     *
     * @param after the operation to perform after this operation
     * @return a composed {@code Consumer} that performs in sequence this
     * operation followed by the {@code after} operation
     * @throws NullPointerException if {@code after} is null
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

③ Function：函数型接口。

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);

    /**
     * Returns a composed function that first applies the {@code before}
     * function to its input, and then applies this function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of input to the {@code before} function, and to the
     *           composed function
     * @param before the function to apply before this function is applied
     * @return a composed function that first applies the {@code before}
     * function and then applies this function
     * @throws NullPointerException if before is null
     *
     * @see #andThen(Function)
     */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    /**
     * Returns a composed function that first applies this function to
     * its input, and then applies the {@code after} function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of output of the {@code after} function, and of the
     *           composed function
     * @param after the function to apply after this function is applied
     * @return a composed function that first applies this function and then
     * applies the {@code after} function
     * @throws NullPointerException if after is null
     *
     * @see #compose(Function)
     */
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    /**
     * Returns a function that always returns its input argument.
     *
     * @param <T> the type of the input and output objects to the function
     * @return a function that always returns its input argument
     */
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

④ Predicate：断言型接口。

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);

    /**
     * Returns a composed predicate that represents a short-circuiting logical
     * AND of this predicate and another.  When evaluating the composed
     * predicate, if this predicate is {@code false}, then the {@code other}
     * predicate is not evaluated.
     *
     * <p>Any exceptions thrown during evaluation of either predicate are relayed
     * to the caller; if evaluation of this predicate throws an exception, the
     * {@code other} predicate will not be evaluated.
     *
     * @param other a predicate that will be logically-ANDed with this
     *              predicate
     * @return a composed predicate that represents the short-circuiting logical
     * AND of this predicate and the {@code other} predicate
     * @throws NullPointerException if other is null
     */
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    /**
     * Returns a predicate that represents the logical negation of this
     * predicate.
     *
     * @return a predicate that represents the logical negation of this
     * predicate
     */
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    /**
     * Returns a composed predicate that represents a short-circuiting logical
     * OR of this predicate and another.  When evaluating the composed
     * predicate, if this predicate is {@code true}, then the {@code other}
     * predicate is not evaluated.
     *
     * <p>Any exceptions thrown during evaluation of either predicate are relayed
     * to the caller; if evaluation of this predicate throws an exception, the
     * {@code other} predicate will not be evaluated.
     *
     * @param other a predicate that will be logically-ORed with this
     *              predicate
     * @return a composed predicate that represents the short-circuiting logical
     * OR of this predicate and the {@code other} predicate
     * @throws NullPointerException if other is null
     */
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    /**
     * Returns a predicate that tests if two arguments are equal according
     * to {@link Objects#equals(Object, Object)}.
     *
     * @param <T> the type of arguments to the predicate
     * @param targetRef the object reference with which to compare for equality,
     *               which may be {@code null}
     * @return a predicate that tests if two arguments are equal according
     * to {@link Objects#equals(Object, Object)}
     */
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

Supplier 接口

java.util.function.Supplier<T>接口，它意味着“供给”，对应的 Lambda 表达式需要对外提供一个符合泛型类型的对象数据。

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

• 供给型接口，通过 Supplier 接口中的 get 方法可以得到一个值，无参有返回值的接口。

• 示例：使用 Lambda 表达式返回数组元素的最大值。

package org.itjing.lambda;

import java.util.Arrays;
import java.util.function.Supplier;

/**
 * @author lijing
 * @date 2021年12月09日 15:56
 * @description
 */
public class LambdaDemo6 {
    public static void main(String[] args) {
        int[] arr = {22, 65, 100, -2};
        printMax(() -> {
            Arrays.sort(arr);
            return arr[arr.length - 1];
        });
    }

    public static void printMax(Supplier<Integer> supplier) {
        Integer max = supplier.get();
        System.out.println("max = " + max);
    }
}

Consumer 接口

java.util.function.Consumer<T>接口正好相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型参数决定。

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

    /**
     * Returns a composed {@code Consumer} that performs, in sequence, this
     * operation followed by the {@code after} operation. If performing either
     * operation throws an exception, it is relayed to the caller of the
     * composed operation.  If performing this operation throws an exception,
     * the {@code after} operation will not be performed.
     *
     * @param after the operation to perform after this operation
     * @return a composed {@code Consumer} that performs in sequence this
     * operation followed by the {@code after} operation
     * @throws NullPointerException if {@code after} is null
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

示例：使用 Lambda 表达式将一个字符串转成大写和小写字符串。

package org.itjing.lambda;

import java.util.function.Consumer;

/**
 * @author lijing
 * @date 2021年12月09日 15:59
 * @description
 */
public class LambdaDemo7 {
    public static void main(String[] args) {
        String str = "hello world";
        test((s) -> {
            String lowerCase = s.toLowerCase();
            System.out.println(lowerCase);

            String upperCase = s.toUpperCase();
            System.out.println(upperCase);
        }, str);
    }

    public static void test(Consumer<String> consumer, String str) {
        consumer.accept(str);
    }
}

示例：使用 Lambda 表达式将一个字符串先转成小写然后在转成大写。

package org.itjing.lambda;

import java.util.function.Consumer;

/**
 * @author lijing
 * @date 2021年12月09日 16:01
 * @description
 */
public class LambdaDemo8 {
    public static void main(String[] args) {
        // 使用Lambda表达式先将一个字符串转成小写，再转成大写
        String str = "hello world";
        test((s) -> {
            System.out.println(s.toLowerCase());
        }, (s) -> {
            System.out.println(s.toUpperCase());
        }, str);
    }

    public static void test(Consumer<String> c1, Consumer<String> c2, String str) {
        c1.andThen(c2).accept(str);
    }
}

Function 接口

java.util.function.Function<T, R>接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。有参数有返回值。

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);

    /**
     * Returns a composed function that first applies the {@code before}
     * function to its input, and then applies this function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of input to the {@code before} function, and to the
     *           composed function
     * @param before the function to apply before this function is applied
     * @return a composed function that first applies the {@code before}
     * function and then applies this function
     * @throws NullPointerException if before is null
     *
     * @see #andThen(Function)
     */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    /**
     * Returns a composed function that first applies this function to
     * its input, and then applies the {@code after} function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of output of the {@code after} function, and of the
     *           composed function
     * @param after the function to apply after this function is applied
     * @return a composed function that first applies this function and then
     * applies the {@code after} function
     * @throws NullPointerException if after is null
     *
     * @see #compose(Function)
     */
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    /**
     * Returns a function that always returns its input argument.
     *
     * @param <T> the type of the input and output objects to the function
     * @return a function that always returns its input argument
     */
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

示例：

package org.itjing.lambda;

import java.util.function.Function;

/**
 * @author lijing
 * @date 2021年12月09日 16:03
 * @description
 */
public class LambdaDemo9 {
    // 使用Lambda表达式将字符串转成数字
    public static void main(String[] args) {
        String str = "10";
        getNumber((s) -> {
            int num = Integer.parseInt(s);
            return num;
        }, str);
    }

    public static void getNumber(Function<String, Integer> function, String str) {
        Integer num = function.apply(str);
        System.out.println("num = " + num);
    }
}

Predicate 接口

有时我们需要对某种类型的数据进行判断，从而得到一个 boolean 值的结果，这时可以使用java.util.function.Predicate<T>接口。

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);

    /**
     * Returns a composed predicate that represents a short-circuiting logical
     * AND of this predicate and another.  When evaluating the composed
     * predicate, if this predicate is {@code false}, then the {@code other}
     * predicate is not evaluated.
     *
     * <p>Any exceptions thrown during evaluation of either predicate are relayed
     * to the caller; if evaluation of this predicate throws an exception, the
     * {@code other} predicate will not be evaluated.
     *
     * @param other a predicate that will be logically-ANDed with this
     *              predicate
     * @return a composed predicate that represents the short-circuiting logical
     * AND of this predicate and the {@code other} predicate
     * @throws NullPointerException if other is null
     */
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    /**
     * Returns a predicate that represents the logical negation of this
     * predicate.
     *
     * @return a predicate that represents the logical negation of this
     * predicate
     */
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    /**
     * Returns a composed predicate that represents a short-circuiting logical
     * OR of this predicate and another.  When evaluating the composed
     * predicate, if this predicate is {@code true}, then the {@code other}
     * predicate is not evaluated.
     *
     * <p>Any exceptions thrown during evaluation of either predicate are relayed
     * to the caller; if evaluation of this predicate throws an exception, the
     * {@code other} predicate will not be evaluated.
     *
     * @param other a predicate that will be logically-ORed with this
     *              predicate
     * @return a composed predicate that represents the short-circuiting logical
     * OR of this predicate and the {@code other} predicate
     * @throws NullPointerException if other is null
     */
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    /**
     * Returns a predicate that tests if two arguments are equal according
     * to {@link Objects#equals(Object, Object)}.
     *
     * @param <T> the type of arguments to the predicate
     * @param targetRef the object reference with which to compare for equality,
     *               which may be {@code null}
     * @return a predicate that tests if two arguments are equal according
     * to {@link Objects#equals(Object, Object)}
     */
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

示例：使用 Lambda 判断一个名称，如果名称超过 3 个字就认为是很长的名称。

package org.itjing.lambda;

import java.util.function.Predicate;

/**
 * @author lijing
 * @date 2021年12月09日 16:08
 * @description
 */
public class LambdaDemo10 {
    // 使用Lambda判断一个名称，如果名称超过3个字就认为是很长的名称
    public static void main(String[] args) {
        test((name) -> {
            return name.length() > 3;
        }, "迪丽热巴");
    }

    public static void test(Predicate<String> predicate, String name) {
        boolean test = predicate.test(name);
        if (test) {
            System.out.println(name + "的名称很长");
        } else {
            System.out.println(name + "的名称不长");
        }
    }
}

示例：

package org.itjing.lambda;

import java.util.function.Predicate;

/**
 * @author lijing
 * @date 2021年12月09日 16:15
 * @description
 */
public class LambdaDemo11 {
    public static void main(String[] args) {
        // 使用Lambda表达式判断一个字符串即包含W也包含H
        testAnd(s1 -> s1.contains("W"), s2 -> s2.contains("H"), "Hello World");
        // 使用Lambda表达式判断一个字符串包含W或包含H
        testOr(s1 -> s1.contains("W"), s2 -> s2.contains("H"), "Hello World");
        // 使用Lambda表达式判断一个字符串不包含W
        testNegate(s1 -> s1.contains("W"), "Hello world");

    }

    public static void testAnd(Predicate<String> p1, Predicate<String> p2, String str) {
        boolean test = p1.and(p2).test(str);
        if (test) {
            System.out.println(str + "既包含W也包含H");
        }
    }

    public static void testOr(Predicate<String> p1, Predicate<String> p2, String str) {
        boolean test = p1.or(p2).test(str);
        if (test) {
            System.out.println(str + "包含W或包含H");
        }
    }

    public static void testNegate(Predicate<String> p1, String str) {
        boolean test = p1.negate().test(str);
        if (test) {
            System.out.println(str + "不包含W");
        }
    }
}

方法引用

介绍方法引用

示例：使用 Lambda 表达式求一个数组的和

package org.itjing.lambda;

import java.util.function.Consumer;

/**
 * @author lijing
 * @date 2021年12月09日 16:19
 * @description
 */
public class LambdaDemo12 {
    /**
     * 获取一个数组的和
     *
     * @param arr
     */
    public static void getSum(int[] arr) {
        int sum = 0;
        for (int i : arr) {
            sum += i;
        }
        System.out.println("sum = " + sum);
    }

    public static void main(String[] args) {
        int[] arrs = {10, 19, -10, 0};

        // 使用方法引用：让这个指定的方法去重写接口的抽象方法，到时候调用接口的抽象方法就是调用传递过去的这个方法
        printSum(LambdaDemo12::getSum, arrs);

        Consumer<int[]> consumer = LambdaDemo12::getSum;
        consumer.accept(arrs);

    }

    // 有参无返回值，定义为消费型接口
    public static void printSum(Consumer<int[]> consumer, int[] arr) {
        consumer.accept(arr);
    }
}

注意其中的双冒号::写法，这被称为”方法引用”，是一种新的语法。

方法引用的前提：

方法引用所引用的方法的参数列表必须要和函数式接口中抽象方法的参数列表相同（完全一致）。

方法引用所引用的方法的的返回值类型必须要和函数式接口中抽象方法的返回值类型相同（完全一致）。

方法引用的格式

• 符号表示：::。

• 符号说明：双冒号为方法引用运算符，而它所在的表达式被称为方法引用。

• 应用场景：如果 Lambda 所要实现的方案，已经有了其他方法存在相同方法，那么就可以使用方法引用。

常用的引用方式

方法引用在 JDK8 中使用方式非常灵活，有以下几种形式。

• 实例名::成员方法名。
• 类名::静态方法名。
• 类名::方法名。
• 类名::new。
• 数据类型[]::new。

实例名::成员方法名

如果一个类中已经存在了一个成员方法，则可以通过实例名引用成员方法。

package org.itjing.lambda;

import java.util.Date;
import java.util.function.Supplier;

/**
 * @author lijing
 * @date 2021年12月09日 16:26
 * @description 实例名::成员方法名
 */
public class LambdaDemo13 {
    public static void main(String[] args) {
        // 使用Lambda表达式获取当前秒数
        Date date = new Date();
        Supplier<Long> supplier = () -> date.getTime();
        System.out.println(supplier.get());
        // 使用方法引用简化上述代码
        supplier = date::getTime;
        System.out.println(supplier.get());
    }
}

类名::静态方法名

由于在 java.lang.System 类中已经存在了许多静态方法，比如 currentTimeMillis()方法，所以当我们需要通过 Lambda 来调用这些静态方法的时候，可以使用类名::静态方法名。

package org.itjing.lambda;

import java.util.function.Supplier;

/**
 * @author lijing
 * @date 2021年12月09日 16:30
 * @description 类名::静态方法名
 */
public class LambdaDemo14 {
    public static void main(String[] args) {
        // 使用Lambda表达式获取当前的毫秒值
        Supplier<Long> supplier = () -> System.currentTimeMillis();
        System.out.println("supplier = " + supplier.get());
        // 使用方法引用简化上面的代码
        supplier = System::currentTimeMillis;
        System.out.println("supplier = " + supplier.get());
    }
}

类名::方法名

Java 面向对象中，类名只能调用静态方法，类名引用实例方法是有前提的。

实际上是拿入参数作为调用方法的参数。

package org.itjing.lambda;

import java.util.function.Function;

/**
 * @author lijing
 * @date 2021年12月09日 16:31
 * @description 类名::方法名
 */
public class LambdaDemo15 {
    public static void main(String[] args) {
        // 使用Lambda表达式将字符串转换为Long类型
        Function<String, Long> function = (s) -> Long.parseLong(s);

        Long apply = function.apply("5");
        System.out.println("apply = " + apply);

        // 使用Lambda简化上面的代码
        function = Long::parseLong;
        apply = function.apply("5");
        System.out.println("apply = " + apply);
    }
}

类名::new

由于构造器的名称和类名完全一样，所以构造器引用使用类名::new的格式表示。

package org.itjing.lambda;

import java.util.function.BiFunction;
import java.util.function.Supplier;

/**
 * @author lijing
 * @date 2021年12月09日 16:39
 * @description 类名::new
 */
public class LambdaDemo16 {
    public static void main(String[] args) {
        // 使用Lambda表达式获取Person类对象
        Supplier<Person> supplier = () -> new Person();

        Person person = supplier.get();
        System.out.println("person = " + person);

        supplier = Person::new;
        person = supplier.get();
        System.out.println("person = " + person);

        // BiFunction 接收两个参数，返回一个结果
        BiFunction<String, Integer, Person> function = (name, age) -> new Person(name, age);
        person = function.apply("李四", 20);
        System.out.println("person = " + person);

        function = Person::new;
        person = function.apply("张三", 25);
        System.out.println("person = " + person);
    }
}

class Person {

    private String name;
    private Integer age;

    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

数据类型[]::new

数组也是 Object 的子类，所以具有同样的构造器。

package org.itjing.lambda;

import java.util.function.Function;

/**
 * @author lijing
 * @date 2021年12月09日 16:46
 * @description 数据类型[]::new
 */
public class LambdaDemo17 {
    public static void main(String[] args) {
        // 使用Lambda表达式创建指定长度的String数组
        Function<Integer, String[]> function = (length) -> new String[length];
        String[] str = function.apply(2);
        System.out.println("str.length = " + str.length);

        // 使用方法引用简化上面的代码
        // String[]::new 是指 size -> new String[size]。
        function = String[]::new;
        str = function.apply(5);
        System.out.println("str.length = " + str.length);
    }
}

总结

方法引用是对 Lambda 表达式符合特定情况下的一种缩写，它使得我们的 Lambda 表达式更加的精简，也可以理解为 Lambda 表达式的缩写形式，不过要注意的是方法引用只能引用已经存在的方法。

Stream API

集合处理数据的弊端

当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合的遍历。

我们来体验集合操作数据的弊端，需求如下：

一个 ArrayList 集合中存储有以下数据：张无忌、周芷若、赵敏、张强、张三丰
需求：

① 拿到所有姓张的

② 拿到名字长度为 3 个字的

③ 打印这些数据

代码如下：

package org.itjing.stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author lijing
 * @date 2021年12月09日 16:55
 * @description
 */
public class StreamIntroDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");

        // 拿到所有姓张的
        List<String> zhangList = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("张")) {
                zhangList.add(s);
            }
        }

        // 拿到名字长度=3的
        List<String> threeList = new ArrayList<>();
        for (String s : zhangList) {
            if (s.length() == 3) {
                threeList.add(s);
            }
        }

        // 对结果进行打印
        for (String name : threeList) {
            System.out.println(name);
        }
    }
}

循环遍历的弊端：

上面的代码中包含三个循环，每一个作用不同：

• 首先筛选所有姓张的人；
• 然后筛选名字中有三个字的人；
• 最后对结果进行打印输出。

每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环，这样太麻烦了。

Stream 的优雅的写法：

package org.itjing.stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author lijing
 * @date 2021年12月09日 16:59
 * @description
 */
public class StreamDemo01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");
        list.stream()
                .filter(name -> name.startsWith("张"))
                .filter((name) -> name.length() == 3)
                .forEach(System.out::println);
    }
}

Stream 流式思想概述

Stream 流式思想类似于工厂车间的”生产流水线”，Stream 流不是一种数据结构，不保存数据，而是对数据进行加工处理。

Stream 可以看作是流水线上的一个工序。

在流水线上，通过多个工序让一个原材料加工成一个商品。

Stream API 能让我们快速完成许多重复的操作，如筛选，切片、映射、查找、去除重复、统计、匹配和归约。

获取 Stream 流的方式

① java.util.Collection 接口中加入了 default 方法 stream()用来获取流，所以其所有的实现类均可获取 Stream 流。

public interface Collection<E> extends Iterable<E> {
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
    // 略
}

示例：

List<Integer> list = Arrays.asList(1, 2, 3);
list.stream().forEach(System.out::println);

② Stream 接口的静态方法 of 可以获取数组对应的 Stream 流。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
	 /**
     * Returns a sequential {@code Stream} containing a single element.
     *
     * @param t the single element
     * @param <T> the type of stream elements
     * @return a singleton sequential stream
     */
    public static<T> Stream<T> of(T t) {
        return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
    }

    /**
     * Returns a sequential ordered stream whose elements are the specified values.
     *
     * @param <T> the type of stream elements
     * @param values the elements of the new stream
     * @return the new stream
     */
    @SafeVarargs
    @SuppressWarnings("varargs") // Creating a stream from an array is safe
    public static<T> Stream<T> of(T... values) {
        return Arrays.stream(values);
    }
    // 略
}

示例：

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
stream.forEach(System.out::println);

③ java.util.Arrays 的 stream()方法获取数组对应的 Stream 流。

public class Arrays {
    public static <T> Stream<T> stream(T[] array) {
        return stream(array, 0, array.length);
    }

    /**
     * Returns a sequential {@link Stream} with the specified range of the
     * specified array as its source.
     *
     * @param <T> the type of the array elements
     * @param array the array, assumed to be unmodified during use
     * @param startInclusive the first index to cover, inclusive
     * @param endExclusive index immediately past the last index to cover
     * @return a {@code Stream} for the array range
     * @throws ArrayIndexOutOfBoundsException if {@code startInclusive} is
     *         negative, {@code endExclusive} is less than
     *         {@code startInclusive}, or {@code endExclusive} is greater than
     *         the array size
     * @since 1.8
     */
    public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive) {
        return StreamSupport.stream(spliterator(array, startInclusive, endExclusive), false);
    }

    /**
     * Returns a sequential {@link IntStream} with the specified array as its
     * source.
     *
     * @param array the array, assumed to be unmodified during use
     * @return an {@code IntStream} for the array
     * @since 1.8
     */
    public static IntStream stream(int[] array) {
        return stream(array, 0, array.length);
    }

    /**
     * Returns a sequential {@link IntStream} with the specified range of the
     * specified array as its source.
     *
     * @param array the array, assumed to be unmodified during use
     * @param startInclusive the first index to cover, inclusive
     * @param endExclusive index immediately past the last index to cover
     * @return an {@code IntStream} for the array range
     * @throws ArrayIndexOutOfBoundsException if {@code startInclusive} is
     *         negative, {@code endExclusive} is less than
     *         {@code startInclusive}, or {@code endExclusive} is greater than
     *         the array size
     * @since 1.8
     */
    public static IntStream stream(int[] array, int startInclusive, int endExclusive) {
        return StreamSupport.intStream(spliterator(array, startInclusive, endExclusive), false);
    }

    /**
     * Returns a sequential {@link LongStream} with the specified array as its
     * source.
     *
     * @param array the array, assumed to be unmodified during use
     * @return a {@code LongStream} for the array
     * @since 1.8
     */
    public static LongStream stream(long[] array) {
        return stream(array, 0, array.length);
    }

    /**
     * Returns a sequential {@link LongStream} with the specified range of the
     * specified array as its source.
     *
     * @param array the array, assumed to be unmodified during use
     * @param startInclusive the first index to cover, inclusive
     * @param endExclusive index immediately past the last index to cover
     * @return a {@code LongStream} for the array range
     * @throws ArrayIndexOutOfBoundsException if {@code startInclusive} is
     *         negative, {@code endExclusive} is less than
     *         {@code startInclusive}, or {@code endExclusive} is greater than
     *         the array size
     * @since 1.8
     */
    public static LongStream stream(long[] array, int startInclusive, int endExclusive) {
        return StreamSupport.longStream(spliterator(array, startInclusive, endExclusive), false);
    }

    /**
     * Returns a sequential {@link DoubleStream} with the specified array as its
     * source.
     *
     * @param array the array, assumed to be unmodified during use
     * @return a {@code DoubleStream} for the array
     * @since 1.8
     */
    public static DoubleStream stream(double[] array) {
        return stream(array, 0, array.length);
    }

    /**
     * Returns a sequential {@link DoubleStream} with the specified range of the
     * specified array as its source.
     *
     * @param array the array, assumed to be unmodified during use
     * @param startInclusive the first index to cover, inclusive
     * @param endExclusive index immediately past the last index to cover
     * @return a {@code DoubleStream} for the array range
     * @throws ArrayIndexOutOfBoundsException if {@code startInclusive} is
     *         negative, {@code endExclusive} is less than
     *         {@code startInclusive}, or {@code endExclusive} is greater than
     *         the array size
     * @since 1.8
     */
    public static DoubleStream stream(double[] array, int startInclusive, int endExclusive) {
        return StreamSupport.doubleStream(spliterator(array, startInclusive, endExclusive), false);
    }
	// 略
}

示例：

Stream<Integer> stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5});
stream.forEach(System.out::println);

Stream 常用方法

Stream 流模型的操作非常丰富，这里介绍一些常用的 API。

方法名	方法作用	返回值类型	方法种类
count	统计个数	long	终结
forEach	逐一处理	void	终结
filter	过滤	Stream	函数拼接
limit	取前几个	Stream	函数拼接
skip	跳过前几个	Stream	函数拼接
map	映射	Stream	函数拼接
concat	组合	Stream	函数拼接

• 终结方法：返回值类型不是 Stream 类型的方法，不再支持链式调用。

• 非终结方法：返回值类型是 Stream 类型的方式，支持链式调用。

Stream 注意事项

• Stream 只能操作一次
• Stream 方法返回的是新的流。
• Stream 不调用终结方法，中间的操作不会执行。

Stream 流的 forEach 方法

Stream中的forEach方法用来遍历流中的数据，该方法接收一个 Consumer 接口函数，会将每一个流元素交给该函数进行处理

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    void forEach(Consumer<? super T> action);
    // 略
}

Map中的forEach方法用来遍历 Map 中的每个 Map.Entry 类型的元素，该方法接受一个 BiConsumer 接口函数，会将 Map.Entry 类型元素的 key 和 value 交给该函数进行处理。

public interface Map<K,V> {
    default void forEach(BiConsumer<? super K, ? super V> action) {
        Objects.requireNonNull(action);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
            action.accept(k, v);
        }
    }
    // 略
}

示例：

List<String> list = new ArrayList<>();
Collections.addAll(list, "张三", "李四", "王五");
list.stream().forEach(System.out::println);

Map<String,Object> map = new HashMap<>();
map.put("aa","aaa");
map.put("bb","bbb");

map.forEach((k,v)->{
    System.out.println("k = " + k);
    System.out.println("v = " + v);
});

Stream 流的 count 方法

Stream 流提供 count 方法来统计其中的元素个数：

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    long count();
    // 略
}

示例：

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
long count = stream.count();
System.out.println("count = " + count);

Stream 流的 filter 方法

Stream 流中的 filter 方法用于过滤数据，返回符合条件的数据。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    Stream<T> filter(Predicate<? super T> predicate);
    // 略
}

示例：

Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六", "贾七", "沈八");
stream.filter(s -> s.contains("张")).forEach(System.out::println);

Stream 流中的 limit 方法

Stream 流中的 limit 方法可以对流进行截取，只取前 n 个。

参数是一个 long 类型，如果集合当前长度大于参数则进行截取，否则不进行任何操作。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    Stream<T> limit(long maxSize);
    // 略
}

示例：

Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六", "贾七", "沈八");
stream.limit(3).forEach(System.out::println);

Stream 流中的 skip 方法

如果希望跳过前 n 个元素，可以使用 skip 方法获取一个截取之后的新流：

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    Stream<T> skip(long n);
    // 略
}

如果流当前的长度大于 n，则跳过前 n 个；否则将会得到一个长度为 0 的空流。

示例：

Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六", "贾七", "沈八");
stream.skip(3).forEach(System.out::println);

Stream 流中的 map 方法

如果需要将流中的元素映射到另一个流中，可以使用 map 方法。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);
    // 略
}

该接口需要一个 Function 函数式接口参数，可以将当前流中的 T 类型转换为另一种 R 类型的流。

使用场景：

• 转换流中的数据格式。
• 提取流的对象属性

示例：

Stream<String> stream = Stream.of("1", "2", "3", "4", "5", "6");
stream.map(Integer::parseInt).forEach(System.out::println);

Stream 流中的 flatMap 方法

Stream 流中的 flatMap 方法是一个维度升降的方法。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
    // 略
}

比如说：给定单词列表 [“Hello”,“World”] ，要返回列表 [“H”,“e”,“l”, “o”,“W”,“r”,“d”] 。

如果我们使用如下方式：

package org.itjing.stream;

import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author lijing
 * @date 2021年12月09日 17:32
 * @description
 */
public class StreamDemo02 {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("Hello", "World");
        stream.map(s -> s.split(""))
//              .flatMap(Arrays::stream)
                .distinct()
                .collect(Collectors.toList())
                .forEach(t -> {
                    for (String s : t) {
                        System.out.print(s + " ");
                    }
                });
    }
}

结果：

转变类型为：Stream<String> -> Stream<String[]>-> Stream<String[]>-> List<String[]>，当前维度从一维变成二维，map本身不能降维度，执行如下：

可以通过 idea 调试查看具体过程：

引入 flatMap 方法

package org.itjing.stream;

import java.util.Arrays;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author lijing
 * @date 2021年12月09日 17:32
 * @description
 */
public class StreamDemo02 {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("Hello", "World");
        stream.map(s -> s.split(""))
                .flatMap(Arrays::stream)
                .distinct()
                .collect(Collectors.toList())
                .forEach(s -> {
                    System.out.print(s + " ");
                });
    }
}

这里是从二维降为一维，逻辑如下：

从 IDEA 编译器的提醒中，也可以看出降维了：

flatMap 升维

给定两个数字列表，如何返回所有的数对呢？

例如，给定列表[1, 2, 3]和列表[3, 4]，应该返回[(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]。

package org.itjing.stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamInt {
    public static void main(String[] args) {
        List<Integer> numbers1 = Arrays.asList(1, 2, 3);
        List<Integer> numbers2 = Arrays.asList(3, 4);
        // flatMap升维度
        List<int[]> pairs = numbers1.stream()
                .flatMap(x -> numbers2.stream().map(y -> new int[]{x, y}))
                .collect(Collectors.toList());
        for (int[] pair : pairs) {
            System.out.println(Arrays.toString(pair));
        }
    }
}

测试结果：

[1, 3]
[1, 4]
[2, 3]
[2, 4]
[3, 3]
[3, 4]

这里是从一维升为二维，逻辑如下：

总结：flatMap将map结果归类，从而达到升降维目的。

Stream 流中的 sorted 方法

如果需要将数据排序，可以使用 sorted 方法。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    Stream<T> sorted();
    Stream<T> sorted(Comparator<? super T> comparator);
    // 略
}

示例：

List<Integer> list = new ArrayList<>();
Collections.addAll(list, 1, -1, 10, 0, 100, 55);
// 自然排序
list.stream().sorted().forEach(System.out::println);
// 逆序
list.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println);

Stream 流中的 distinct 方法

如果需要去除重复数据，可以使用 distinct 方法。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
   Stream<T> distinct();
    //略
}

示例：

List<Integer> list = new ArrayList<>();
Collections.addAll(list, 1, -1, 10, 0, 10, 55);
list.stream().distinct().forEach(System.out::println);

Stream 流中的 match 方法

如果需要判断数据是否匹配指定的条件，可以使用 match 相关方法。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
   // 只要有一个数据满足条件即返回true
   boolean anyMatch(Predicate<? super T> predicate);
   // 必须全部都满足才会返回true
   boolean allMatch(Predicate<? super T> predicate);
   // 全都不满足才会返回true
   boolean noneMatch(Predicate<? super T> predicate);
   // 略
}

示例：

List<Integer> list = new ArrayList<>();
Collections.addAll(list, 1, -1, 10, 0, 10, 55);

boolean b = list.stream().allMatch((e) -> e > 5);
if (b) {
    System.out.println("元素都 > 5");
}

b = list.stream().anyMatch((e) -> e > 5);
if (b) {
    System.out.println("有元素 > 5");
}

b = list.stream().noneMatch(e -> e > 5);
if (b) {
    System.out.println("都不 > 5");
}

Stream 流中的 find 方法

如果需要找到某些数据，可以使用 find 相关方法。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
   // 获取Stream流中的第一个元素
   Optional<T> findFirst();
   // findAny()操作，返回的元素是不确定的，对于同一个列表多次调用findAny()有可能会返回不同的值。
   // 使用findAny()是为了更高效的性能。
   // 如果是数据较少，串行地情况下，一般会返回第一个结果，如果是并行的情况，那就不能确保是第一个。
   Optional<T> findAny();
    // 略
}

示例：

List<String> lst1 = Arrays.asList("Jhonny", "David", "Jack", "Duke", "Jill","Dany","Julia","Jenish","Divya");
List<String> lst2 = Arrays.asList("Jhonny", "David", "Jack", "Duke", "Jill","Dany","Julia","Jenish","Divya");

Optional<String> findFirst = lst1.parallelStream().filter(s -> s.startsWith("D")).findFirst();
Optional<String> fidnAny = lst2.parallelStream().filter(s -> s.startsWith("J")).findAny();

System.out.println(findFirst.get()); // 总是打印出David
System.out.println(fidnAny.get()); // 会随机地打印出Jack/Jill/Julia

Stream 流中的 max 和 min 方法

如果需要获取最大值和最小值，可以使用 max 和 min 方法。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
   // 获取Stream流中的最大值
   Optional<T> max(Comparator<? super T> comparator);
   // 获取Stream流中的最小值
   Optional<T> min(Comparator<? super T> comparator);
    // 略
}

示例：

List<Integer> list = new ArrayList<>();
Collections.addAll(list, 1, -1, 10, 0, 10, 55);

Optional<Integer> max = list.stream().max(Integer::compareTo);
System.out.println("max = " + max.get());

Optional<Integer> min = list.stream().min(Integer::compareTo);
System.out.println("min = " + min.get());

Stream 流中的 reduce 方法

public interface Stream<T> extends BaseStream<T, Stream<T>> {
   // 提供一个跟Stream中数据同类型的初始值identity，
   // 通过累加器accumulator迭代计算Stream中的数据，
   // 得到一个跟Stream中数据相同类型的最终结果
   T reduce(T identity, BinaryOperator<T> accumulator);
   // 对Stream中的数据通过累加器accumulator迭代计算，最终得到一个Optional对象
   Optional<T> reduce(BinaryOperator<T> accumulator);


   <U> U reduce(U identity,
                 BiFunction<U, ? super T, U> accumulator,
                 BinaryOperator<U> combiner);
   // 略
}

方式一：

T reduce(T identity, BinaryOperator<T> accumulator);

提供一个跟 Stream 中数据同类型的初始值 identity，通过累加器 accumulator 迭代计算 Stream 中的数据，得到一个跟 Stream 中数据相同类型的最终结果

示例：

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
// 第一个参数是初始值
// 第二个参数：对数据进行处理累加的方式
Integer result = stream.reduce(15, Integer::sum);
System.out.println("result = " + result); // result = 30

方式二：

Optional<T> reduce(BinaryOperator<T> accumulator);

函数式接口BinaryOperator，继承于BiFunction，Bifunction中有一个apply方法，接收两个参数，返回一个结果，并且这些类型都是相同的

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T, T, T> {

}

@FunctionalInterface
public interface BiFunction<T, U, R> {
    R apply(T t, U u); // 接收两个参数 t 和 u, 返回 R
}

也就是说，reduce(BinaryOperator<T> accumulator)方法需要一个函数式接口参数，该函数式接口需要两个参数，返回一个结果(reduce 中返回的结果会作为下次累加器计算的第一个参数)，也就是累加器。

示例：

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
Optional<Integer> resultOptional = stream.reduce(Integer::sum);
System.out.println("result = " + resultOptional.get()); // result = 15

方式三：

<U> U reduce(U identity,
             BiFunction<U, ? super T, U> accumulator,
             BinaryOperator<U> combiner);

第一个参数：返回实例 u，传递你要返回的 U 类型对象的初始化实例 u；

第二个参数：累加器 accumulator，可以使用 lambda 表达式，声明你在 u 上累加你的数据来源 t 的逻辑，例如(u,t)->u.sum(t)，此时 lambda 表达式的行参列表是返回实例 u 和遍历的集合元素 t，函数体是在 u 上累加 t；

第三个参数：参数组合器 combiner，接受 lambda 表达式。

---

首先看一下BiFunction的三个泛型类型分别是U、 ? super T、U。

参考BiFunction函数式接口 apply 方法定义可以知道，累加器通过类型为 U 和 ? super T 的两个输入值计算得到一个 U 类型的结果返回。

也就是说这种 reduce 方法，提供一个不同于Stream中数据类型的初始值，通过累加器规则迭代计算 Stream 中的数据，最终得到一个同初始值同类型的结果。

---

再看一下 BinaryOperator 的泛型是 U，函数式接口BinaryOperator，继承于BiFunction，Bifunction中有一个apply方法，接收两个参数，返回一个结果，并且这些类型都是相同的。

即参数类型都是U，返回结果类型也是U。

示例：

ArrayList<Integer> accResult_ = Stream.of(1, 2, 3, 4)
    // 第一个参数，初始值为ArrayList
    .reduce(new ArrayList<Integer>(),
            // 第二个参数，实现了BiFunction函数式接口中apply方法，并且打印BiFunction
            new BiFunction<ArrayList<Integer>, Integer, ArrayList<Integer>>() {
                @Override
                public ArrayList<Integer> apply(ArrayList<Integer> acc, Integer item) {
                    acc.add(item);
                    System.out.println("item: " + item);
                    System.out.println("acc: " + acc);
                    System.out.println("BiFunction");
                    return acc;
                }
                // 第三个参数---参数的数据类型必须为返回数据类型，改参数主要用于合并多个线程的result值
                // （Stream是支持并发操作的，为了避免竞争，对于reduce线程都会有独立的result）
            }, new BinaryOperator<ArrayList<Integer>>() {
                @Override
                public ArrayList<Integer> apply(ArrayList<Integer> acc, ArrayList<Integer> item) {
                    System.out.println("BinaryOperator");
                    acc.addAll(item);
                    System.out.println("item: " + item);
                    System.out.println("acc: " + acc);
                    System.out.println("--------");
                    return acc;
                }
            });
System.out.println("accResult_: " + accResult_);

System.out.println("------------------lambda优化代码-----------------");

ArrayList<Integer> newList = new ArrayList<>();

ArrayList<Integer> accResult_s = Stream.of(1, 2, 3, 4)
    .reduce(newList,
            (acc, item) -> {
                acc.add(item);
                System.out.println("item: " + item);
                System.out.println("acc: " + acc);
                System.out.println("BiFunction");
                return acc;
            }, (acc, item) -> null);
System.out.println("accResult_s: " + accResult_s);

示例代码中，第一个参数是ArrayList,在第二个函数参数中打印了“BiFunction”，而在第三个参数接口中打印了函数接口中打印了”BinaryOperator“。

看下面的打印结果，只打印了“BiFunction”，而没有打印”BinaryOperator“，也就是说第三个函数参数并没有执行。分析参数时我们知道了该变形可以返回任意类型的数据。

这是因为 reduce 的第三个参数是在使用 parallelStream 的 reduce 操作时，合并各个流结果的，本例中使用的是 stream，所以第三个参数是不起作用的。

输出结果：

item: 1
acc: [1]
BiFunction
item: 2
acc: [1, 2]
BiFunction
item: 3
acc: [1, 2, 3]
BiFunction
item: 4
acc: [1, 2, 3, 4]
BiFunction
accResult_: [1, 2, 3, 4]
------------------lambda优化代码-----------------
item: 1
acc: [1]
BiFunction
item: 2
acc: [1, 2]
BiFunction
item: 3
acc: [1, 2, 3]
BiFunction
item: 4
acc: [1, 2, 3, 4]
BiFunction
accResult_s: [1, 2, 3, 4]

对于第三个函数参数，为什么没有执行，而且其参数必须为返回的数据类型？

这是因为Stream是支持并发操作的，为了避免竞争，对于reduce线程都会有独立的result，combiner的作用在于合并每个线程的result得到最终结果。这也说明了了第三个函数参数的数据类型必须为返回数据类型了。

另外需要注意：因为第三个参数用来处理并发操作，如何处理数据的重复性，应多做考虑，否则会出现重复数据！

Stream 流中的 mapToInt 方法

如果需要将Stream<Integer>中的 Integer 类型转成 int 类型，可以使用 mapToInt 方法。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
   IntStream mapToInt(ToIntFunction<? super T> mapper);
   // 略
}

示例：

// Integer占用的内存比int多，在Stream流操作中会自动装箱和拆箱
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
// 操作
stream.filter(n -> n > 3).forEach(System.out::println);

// mapToInt将Stream流中的Integer变为int
// IntStream：内部操作的是int类型的数据，节省内存，减少自动装箱和拆箱
IntStream intStream = Stream.of(1, 2, 3, 4, 5).mapToInt(Integer::intValue);
intStream.filter(n -> n > 3).forEach(System.out::println);

Stream 流中的 concat 方法

如果有两个流，希望合并成一个流，那么就可以使用 Stream 接口中的静态方法 concat。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
   // 将两个流合并成一个流
   public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
        Objects.requireNonNull(a);
        Objects.requireNonNull(b);

        @SuppressWarnings("unchecked")
        Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
                (Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
        Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
        return stream.onClose(Streams.composedClose(a, b));
    }
    // 略
}

示例：

Stream<Integer> stream1 = Stream.of(1, 2, 3);
Stream<Integer> stream2 = Stream.of(4, 5, 6);
// 两个流合并之后，不能操作之前的流
Stream<Integer> concat = Stream.concat(stream1, stream2);
concat.forEach(System.out::println);

收集 Stream 结果

Stream 流中的结果保存到集合中

• Stream 流提供 collect 方法，其参数需要一个java.util.stream.Collector<T, A, R> 接口对象来指定收集到那种集合中。
• java.util.stream.Collectors 类提供一些方法，可以作为 Collector 接口的实例。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
   // Stream流中的结果保存到集合中
   <R, A> R collect(Collector<? super T, A, R> collector);
   // 略
}

示例：

Stream<Integer> stream1 = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
// 将Stream流中的结果保存到List集合中
List<Integer> list = stream1.collect(Collectors.toList());
list.forEach(System.out::println);

// 将Stream流中的结果保存到Set集合中
Stream<Integer> stream2 = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
Set<Integer> set = stream2.collect(Collectors.toSet());
set.forEach(System.out::println);

// 将Stream流中的结果保存到ArrayList集合中
Stream<Integer> stream3 = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
ArrayList<Integer> arrayList = stream3.collect(Collectors.toCollection(ArrayList::new));
arrayList.forEach(System.out::println);

// 将Stream流中的结果保存到HashSet集合中
Stream<Integer> stream4 = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
HashSet<Integer> hashSet = stream4.collect(Collectors.toCollection(HashSet::new));
hashSet.forEach(System.out::println);

package org.itjing.stream;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author lijing
 * @date 2021年12月09日 17:32
 * @description
 */
public class TestToMap {
    public static void main(String[] args) {
        // 阿里巴巴手册：【强制】在使用java.util.stream.Collectors类的toMap()方法转为Map集合时
        // 一定要使用含有参数类型为BinaryOperator,参数名为mergeFunction的方法
        // 否则当出现相同key值时会抛出 IllegalStateException：Duplicate key 异常。
        List<Pair> pairList = new ArrayList<>(3);
        pairList.add(new Pair("version", 12.10));
        pairList.add(new Pair("version", 12.19));
        pairList.add(new Pair("version", 6.28));

        // 注：常见实体类的get方法中，我们看到的是无参，有返回值
        // 但是在 Lamada 的使用上看，神奇的出现了实际上应该是传入了一个Pair对象，返回值为String.
        Function<Pair, String> function = Pair::getKey;

        // 一定要使用含有参数类型为BinaryOperator,参数名为mergeFunction的方法
        // 第三个参数就是为了在 key 出现重复时做出的解决措施
        // 这里 (v1, v2) -> v2 指，v1,v2 冲突了，使用 v2
        Map<String, Double> map = pairList.stream()
                .collect(Collectors.toMap(Pair::getKey, Pair::getValue, (v1, v2) -> v2));

        map.forEach((k, v) -> {
            System.out.println(k + "-->" + v);
        });
    }
}

class Pair {
    private String key;
    private Double value;

    public Pair() {
    }


    public Pair(String key, Double value) {
        this.key = key;
        this.value = value;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public Double getValue() {
        return value;
    }

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

Stream 流中的结果保存到数组中

Stream 流提供 toArray 方法，以便将 Stream 流中的结果保存到数组中。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
   // Stream流中的结果保存到数组中
   Object[] toArray();
   <A> A[] toArray(IntFunction<A[]> generator);
   // 略
}

示例：

// Stream流中的数据转换成Object数组
Stream<Integer> stream1 = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
Object[] array = stream1.toArray();
System.out.println("Stream流转换为Object数组：" + Arrays.toString(array));

// Stream流中的数据转换成String数组
Stream<String> stream2 = Stream.of("1", "2", "3", "4", "5", "6", "7", "8", "9", "0");
String[] strings = stream2.toArray(String[]::new);
System.out.println("Stream流转换为String数组 = " + Arrays.asList(strings));

对流中数据进行聚合计算

当我们使用 Stream 流处理数据的时候，可以像数据库的聚合函数一样对某个字段进行操作。

比如获取最大值、获取最小值、求和、平均值、统计数量。

示例：

// 注意：Stream流一旦调用终止方法，就不可以再操作。

// 获取Stream流中数据的总数
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
long count = stream.count();
System.out.println("count = " + count);
// 获取Stream流中的最大值
stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
Optional<Integer> max = stream.max(Integer::compareTo);
System.out.println("max = " + max.get());
// 获取Stream流中的最小值
stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
Optional<Integer> min = stream.min(Integer::compareTo);
System.out.println("min = " + min.get());

System.out.println("-----------------------------");
stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
Optional<Integer> maxOptional = stream.collect(Collectors.maxBy(Integer::compareTo));
System.out.println("max = " + maxOptional.get());

stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
Optional<Integer> minOptional = stream.collect(Collectors.minBy(Integer::compareTo));
System.out.println("min = " + minOptional.get());

stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
count = stream.collect(Collectors.counting());
System.out.println("count = " + count);

stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
Double avg = stream.collect(Collectors.averagingInt(Integer::intValue));
System.out.println("avg = " + avg);

stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
Integer sum = stream.collect(Collectors.summingInt(Integer::intValue));
System.out.println("sum = " + sum);

对流中的数据进行分组

当我们使用 Stream 流处理数据后，可以根据某个属性进行数据分组。

示例：

package org.itjing.stream;

public class Person {
    private String name;
    private Integer age;
    private Integer score;
    private String sex;

    public Person() {
    }

    public Person(String name, Integer age, Integer score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public Person(String name, Integer age, Integer score, String sex) {
        this.name = name;
        this.age = age;
        this.score = score;
        this.sex = sex;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getScore() {
        return score;
    }

    public void setScore(Integer score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                ", sex='" + sex + '\'' +
                '}';
    }
}

Stream<Person> stream = Stream.of(
    new Person("鞠婧祎", 18, 100),
    new Person("赵丽颖", 18, 95),
    new Person("杨颖", 19, 86),
    new Person("迪丽热巴", 19, 99),
    new Person("柳岩", 20, 77));

// 根据年龄分组
Map<Integer, List<Person>> map = stream.collect(Collectors.groupingBy(Person::getAge));
map.forEach((k, v) -> {
    System.out.println("年龄 = " + k);
    List<Person> personList = v;
    System.out.println("person = " + personList);
});

对流中的数据进行多级分组

还可以对流中的数据进行多级分组。

示例：

Stream<Person> stream = Stream.of(
    new Person("鞠婧祎", 18, 100, "女"),
    new Person("赵丽颖", 18, 95, "女"),
    new Person("杨颖", 19, 86, "女"),
    new Person("迪丽热巴", 19, 99, "女"),
    new Person("柳岩", 20, 77, "女"),
    new Person("胡歌", 20, 100, "男"));

// 先根据性别分组，性别相同再按照年龄分组
Map<String, Map<Integer, List<Person>>> map = stream.collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getAge)));
map.forEach((sex, v1) -> {
    System.out.println("sex = " + sex);
    Map<Integer, List<Person>> m = v1;
    m.forEach((age, v2) -> {
        System.out.print(age + "---->");
        System.out.println("personList = " + v2);
    });
});

结果：

sex = 女
18---->personList = [Person{name='鞠婧祎', age=18, score=100, sex='女'}, Person{name='赵丽颖', age=18, score=95, sex='女'}]
19---->personList = [Person{name='杨颖', age=19, score=86, sex='女'}, Person{name='迪丽热巴', age=19, score=99, sex='女'}]
20---->personList = [Person{name='柳岩', age=20, score=77, sex='女'}]
sex = 男
20---->personList = [Person{name='胡歌', age=20, score=100, sex='男'}]

对流中的数据进行分区

Collectors 的 partitioningBy 方法会根据值是否为 true，把流中的数据分为两个部分，一个是 true 的部分，一个是 false 的部分。

示例：

Stream<Person> stream = Stream.of(
    new Person("鞠婧祎", 18, 100),
    new Person("赵丽颖", 18, 95),
    new Person("杨颖", 19, 86),
    new Person("迪丽热巴", 19, 99),
    new Person("柳岩", 20, 77));

// 根据年龄分组
/*Map<Integer, List<Person>> map = stream.collect(Collectors.groupingBy(Person::getAge));
        map.forEach((k, v) -> {
            System.out.println("年龄 = " + k);
            List<Person> personList = v;
            System.out.println("person = " + personList);
        });*/


/* Stream<Person> stream = Stream.of(
                new Person("鞠婧祎", 18, 100, "女"),
                new Person("赵丽颖", 18, 95, "女"),
                new Person("杨颖", 19, 86, "女"),
                new Person("迪丽热巴", 19, 99, "女"),
                new Person("柳岩", 20, 77, "女"),
                new Person("胡歌", 20, 100, "男"));

        // 先根据性别分组，性别相同再按照年龄分组
        Map<String, Map<Integer, List<Person>>> map = stream.collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getAge)));
        map.forEach((sex, v1) -> {
            System.out.println("sex = " + sex);
            Map<Integer, List<Person>> m = v1;
            m.forEach((age, v2) -> {
                System.out.print(age + "---->");
                System.out.println("personList = " + v2);
            });
        });*/

Map<Boolean, List<Person>> map = stream.collect(Collectors.partitioningBy(p -> p.getScore() > 90));
map.forEach((k,v)->{
    System.out.println("k = " + k);
    System.out.println("v = " + v);
});

对流中的数据进行拼接

Collectors 的 joining 方法会根据指定的连接符，将所有元素连接成一个字符串。

示例：

Stream<Person> stream = Stream.of(
    new Person("鞠婧祎", 18, 100),
    new Person("赵丽颖", 18, 95),
    new Person("杨颖", 19, 86),
    new Person("迪丽热巴", 19, 99),
    new Person("柳岩", 20, 77));

// 根据年龄分组
/*Map<Integer, List<Person>> map = stream.collect(Collectors.groupingBy(Person::getAge));
        map.forEach((k, v) -> {
            System.out.println("年龄 = " + k);
            List<Person> personList = v;
            System.out.println("person = " + personList);
        });*/


/* Stream<Person> stream = Stream.of(
                new Person("鞠婧祎", 18, 100, "女"),
                new Person("赵丽颖", 18, 95, "女"),
                new Person("杨颖", 19, 86, "女"),
                new Person("迪丽热巴", 19, 99, "女"),
                new Person("柳岩", 20, 77, "女"),
                new Person("胡歌", 20, 100, "男"));

        // 先根据性别分组，性别相同再按照年龄分组
        Map<String, Map<Integer, List<Person>>> map = stream.collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getAge)));
        map.forEach((sex, v1) -> {
            System.out.println("sex = " + sex);
            Map<Integer, List<Person>> m = v1;
            m.forEach((age, v2) -> {
                System.out.print(age + "---->");
                System.out.println("personList = " + v2);
            });
        });*/

/*Map<Boolean, List<Person>> map = stream.collect(Collectors.partitioningBy(p -> p.getScore() > 90));
        map.forEach((k,v)->{
            System.out.println("k = " + k);
            System.out.println("v = " + v);
        });*/

String str = stream.map(Person::getName).collect(Collectors.joining("><", "(#^.^#)", "^_^"));
System.out.println("str = " + str);

结果：

str = (#^.^#)鞠婧祎><赵丽颖><杨颖><迪丽热巴><柳岩^_^

并行的 Stream 流

了解串行的 Stream 流

目前使用的 Stream 流是串行的，就是在一个线程上执行。

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
long count = stream.filter(s -> {
    System.out.println(Thread.currentThread().getName() + "---" + s);
    return true;
}).count();
System.out.println("count = " + count);

获取并行的 Stream 流的两种方式

直接获取并行的 Stream 流。

List<String> list = new ArrayList<>();
// 直接获取并行的Stream流
Stream<String> parallelStream = list.parallelStream();

将串行流转成并行流。

List<String> list = new ArrayList<>();
// 串行流转成并行流
Stream<String> parallel = list.stream().parallel();

Optional 类的使用

以前对 null 的处理

String username = null;
if(null != username){
    System.out.println("username = " + username);
}

Optional 类的介绍

Optional 是一个没有子类的工具类，Optional 是一个可以为 null 的容器对象。

它的作用就是为了解决避免 NULL 检查，防止 NullPointerException。

Optional 类的创建方式：

// 创建一个Optional实例
public static <T> Optional<T> of(T value);

// 创建一个空的Optional实例
public static<T> Optional<T> empty();

// 如果value不为null，则创建Optional实例，否则创建空的Optional实例
public static <T> Optional<T> ofNullable(T value);

Optional 类的常用方法：

// 判断是否包含值，如果包含值返回true，否则返回false
public boolean isPresent();
// 如果有值，则去做什么
public void ifPresent(Consumer<? super T> consumer);

// 如果Optional有值则将其抛出NoSuchElementException异常
public T get();

// 如果存在包含值，返回包含值，否则返回参数other
public T orElse(T other) ;

// 如果存在包含值，返回包含值，否则返回other获取的值
public T orElseGet(Supplier<? extends T> other);

// 如果存在包含值，对其处理，并返回处理后的Optional，否则返回Optional.empty()
// 如果mapper为null，则引发 NullPointerException 。
public<U> Optional<U> map(Function<? super T, ? extends U> mapper);

public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper);

// 不同点：区别在于调用两个方法需要的入参（即拥有唯一方法的匿名内部类：也叫函数式接口）的返回值不同
// map方法会自动将入参中的函数式接口返回值包装成Optional对象，
// 而flatMap方法则要求入参中的函数式接口返回值本身就是Optional对象。
// 入参的不同也就导致了使用场景的不同，如果函数式接口返回值本身就是Optional对象，那么就可以直接使用flatMap方法；
// 否则就应该使用map方法，省去了使用Optional包装的麻烦。

// 传一个断言函数，以此过滤Optional实例
// 此方法返回过滤后的Optional实例。
// 如果此Optional实例中没有值，则此方法返回一个空的Optional实例。
// 如果传的predicate为null，则引发 NullPointerException 。
public Optional<T> filter(Predicate<? super T> predicate)；

Optional 类的基本使用

package org.itjing.optional;

import org.junit.jupiter.api.Test;

import java.util.Optional;

/**
 * @author lijing
 * @date 2021年12月10日 11:57
 * @description
 */
public class OptionalDemo {

    /**
     * 创建Optional实例
     * Optional.of(T value)：不能传null，否则报错
     */
    @Test
    public void testCreateOptional1() {
        Optional<String> optional = Optional.of("凤姐");
        System.out.println("optional.get() = " + optional.get());
    }

    /**
     * 创建Optional实例
     * Optional.empty() 创建一个空的Optional
     */
    @Test
    public void testCreateOptional2() {
        Optional<Object> empty = Optional.empty();
        System.out.println("empty = " + empty);
    }

    /**
     * 创建Optional实例
     * Optional.ofNullable(T value)：
     * 如果value是null，则返回Optional.empty()；
     * 如果value有值，则返回Optional.of(T value)
     */
    @Test
    public void testCreateOptional3() {
        Optional<Object> optional = Optional.ofNullable(null);
        System.out.println("optional = " + optional);
        optional = Optional.ofNullable("你好啊");
        System.out.println("optional = " + optional);
    }

    /**
     * 判断Optional类中是否有值
     */
    @Test
    public void testIsPresent() {
        Optional<Object> empty = Optional.empty();
        if (empty.isPresent()) {
            System.out.println("Optional类中有值");
        } else {
            System.out.println("Optional类中没有值");
        }
    }

    /**
     * 获取Optional类中的值
     */
    @Test
    public void testOptional() {
        Optional<String> optional = Optional.ofNullable(null);
        if (optional.isPresent()) {
            // get()方法，可以用来获取Optional类中的值，如果有值就返回具体值，否则就报错。
            // 一般get()方法配合isPresent()方法使用
            String str = optional.get();
            System.out.println("str = " + str);
        }
    }
}

Optional 类的高级使用

package org.itjing.optional;

import org.itjing.stream.Person;
import org.junit.jupiter.api.Test;

import java.util.Optional;

/**
 * @author lijing
 * @date 2021年12月10日 14:13
 * @description
 */
public class OptionalDemo2 {


    @Test
    public void testOrElse() {
        Optional<Object> optional = Optional.empty();

        // orElse：如果Optional中有值，就返回Optional中的值。否则返回orElse方法中参数指定的值
        Object obj = optional.orElse("如花");
        System.out.println("obj = " + obj);
    }

    @Test
    public void testIfPresent() {
        Optional<String> optional = Optional.of("凤姐");
        // ifPresent：如果有值，就调用参数
        optional.ifPresent((s) -> {
            System.out.println("有值：" + s);
        });
        // ifPresentOrElse在JDK9以后才有
        // ifPresentOrElse第一个参数表示如果有值，做什么
        // ifPresentOrElse第二个参数表示如果没有值，做什么
        optional.ifPresentOrElse(s -> {
            System.out.println("s = " + s);
        }, () -> {
            System.out.println("没有值");
        });
    }

    /**
     * 对比 Optional 和 传统方式
     */
    @Test
    public void testOptional() {
        // 将Person中的用户名转成大写返回
        Person person = null;
        person = new Person("hello world", 18, 99);

        String name = getTraditionUpperName(person);
        System.out.println("name = " + name);

        name = getOptionalUpperName(person);
        System.out.println("name = " + name);

    }

    /**
     * 使用 Optional
     * @param person
     * @return
     */
    public String getOptionalUpperName(Person person) {
        return Optional.ofNullable(person)
                .map(Person::getName)
                .map(String::toUpperCase)
                .orElse(null);
    }

    /**
     * 使用 传统方式
     *
     * @param person
     * @return
     */
    public String getTraditionUpperName(Person person) {
        if (null != person) {
            String name = person.getName();
            if (null != name) {
                return name.toUpperCase();
            }
        }
        return null;
    }

}

JDK8 新的时间和日期 API

旧版日期时间 API 存在的问题

• 设计很差，在 java.util 和 java.sql 的包中都有日期类，java.util.Date 同时包含日期和时间，而 java.sql.Date 仅包含日期。此外用于格式化和解析的类在 java.text 包中定义。
• 非线程安全：java.util.Date 是非线程安全的，所有的日期类都是可变的，这是 Java 日期类最大的问题之一。
• 时区处理麻烦：日期类并不提供国际化，没有时区支持，因此引入了 java.util.Calendar 和 java.util.TimeZone 类，但它们同样存在上述所有问题。

新日期时间 API 介绍

• JDK8 中增加了一套全新的日期时间 API，这套 API 设计合理，是线程安全的。

• 新的日期和时间 API 位于 java.time 包中，下面是一些关键类。

  • LocalDate：表示日期，包含年、月、日，格式为 2021-12-12。
  • LocalTIme：表示时间，包含时、分、秒，格式为 14:28:40.426000700。
  • LocalDateTime：表示日期时间，包含年、月、日、时、分、秒，格式为 2020-09-08T14:29:37.546506。
  • DateTimeFormatter：日期时间格式化类。
  • Instant：时间戳，表示一个特定的时间瞬间。
  • Duration：用于计算 2 个时间（LocalTime，Instant 等）的距离。
  • Period：用于计算 2 个日期（LocalDate）的距离。
  • ZoneDateTime：包含时区的时间。

• Java 中使用的历法是 ISO 8601 日历系统，它是世界民用历法，也就是我们所说的公历。平年有 365 天，闰年有 366 天。此外 Java8 还提供了 4 条其他历法，分别是：

  • ThaiBuddhistDate：泰国佛教历法。
  • MinguoDate：中华民国历法。
  • JapaneseDate：日本历法。
  • HijrahDate：伊斯兰历法。

JDK8 的日期和时间类

LocalDate、LocalTime、LocalDateTime 类的实例是不可变的对象，分别表示 ISO 8601 日历系统的日期、时间、日期和时间。

它们提供了简单的日期或时间，并不包含当前的时间信息，也不包含和时区相关的信息。

示例：

package org.itjing.time;

import org.junit.jupiter.api.Test;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

/**
 * @author lijing
 * @date 2021年12月10日 14:52
 * @description
 */
public class DateTimeDemo {
    @Test
    public void testLocalDate() {
        // LocalDate：表示日期，有年、月、日
        LocalDate now = LocalDate.now();
        System.out.println("now = " + now);

        LocalDate date = LocalDate.of(2021, 12, 12);
        System.out.println("date = " + date);

        int year = now.getYear();
        System.out.println("year = " + year);
        int month = now.getMonth().getValue();
        System.out.println("month = " + month);
        month = now.getMonthValue();
        System.out.println("month = " + month);
        int day = now.getDayOfMonth();
        System.out.println("day = " + day);
    }

    @Test
    public void testLocalTime() {
        // LocalTime：表示时间，有时、分、秒
        LocalTime now = LocalTime.now();
        System.out.println("now = " + now);

        LocalTime time = LocalTime.of(14, 53, 44);
        System.out.println("time = " + time);

        int hour = now.getHour();
        System.out.println("hour = " + hour);
        int minute = now.getMinute();
        System.out.println("minute = " + minute);
        int second = now.getSecond();
        System.out.println("second = " + second);
        int nano = now.getNano();
        System.out.println("nano = " + nano);
    }

    @Test
    public void testLocalDateTime() {
        // LocalDateTime：表示日期时间，有年、月、日、时、分、秒
        LocalDateTime now = LocalDateTime.now();
        System.out.println("now = " + now);

        LocalDateTime dateTime = LocalDateTime.of(2021, 12, 12, 14, 54, 50);
        System.out.println("dateTime = " + dateTime);

        int year = now.getYear();
        System.out.println("year = " + year);
        int month = now.getMonthValue();
        System.out.println("month = " + month);
        month = now.getMonth().getValue();
        System.out.println("month = " + month);
        int day = now.getDayOfMonth();
        System.out.println("day = " + day);
        int hour = now.getHour();
        System.out.println("hour = " + hour);
        int minute = now.getMinute();
        System.out.println("minute = " + minute);
        int second = now.getSecond();
        System.out.println("second = " + second);
        int nano = now.getNano();
        System.out.println("nano = " + nano);
    }

    /**
     * 修改时间
     */
    @Test
    public void testLocalDateTime2() {
        LocalDateTime now = LocalDateTime.now();

        LocalDateTime localDateTime = now.withYear(2021).withMinute(5);
        System.out.println("now = " + now);
        System.out.println("localDateTime = " + localDateTime);

        LocalDateTime localDateTime1 = now.plusYears(1);
        System.out.println("localDateTime1 = " + localDateTime1);
    }


    /**
     * 比较时间
     */
    @Test
    public void testLocalDateTime3() {
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime localDateTime = LocalDateTime.now().plusYears(1);
        boolean before = now.isBefore(localDateTime);
        System.out.println("before = " + before);

    }
}

JDK8 的时间格式化和解析

通过java.time.format.DateTimeFormatter类可以进行日期时间解析和格式化。

示例：

package org.itjing.time;

import org.junit.jupiter.api.Test;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * @author lijing
 * @date 2021年12月10日 14:56
 * @description
 */
public class DateTimeFormatterDemo {
    @Test
    public void test() {
        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime now = LocalDateTime.now();

        // 格式化 调用LocalDateTime
        String format = now.format(df);
        System.out.println("format = " + format);

        // 解析 调用LocalDateTime
        LocalDateTime parse = LocalDateTime.parse(format, df);
        System.out.println("parse = " + parse);

        // 格式化
        format = df.format(now);
        System.out.println("format = " + format);

        // 解析
        parse = df.parse(format, LocalDateTime::from);
        System.out.println("parse = " + parse);
    }
}

JDK8 的 Instant 类

Instant 时间戳/时间线，内部保存了从 1970 年 1 月 1 日 00:00:00 以来的秒和纳秒。

示例：

@Test
public void testInstant() {
    // Instant 内部保存了秒和纳秒，一般不是给用户使用的，而是方便我们程序做一些统计
    Instant now = Instant.now();
    System.out.println("now = " + now);

    Instant instant = now.plusSeconds(20);
    System.out.println("instant = " + instant);

    long epochSecond = now.getEpochSecond();
    System.out.println("epochSecond = " + epochSecond);
    int nano = now.getNano();
    System.out.println("nano = " + nano);
}

JDK8 的计算日期时间差类

Duration：用于计算 2 个时间（LocalTime，Instant 等）的距离。

Period：用于计算 2 个日期（LocalDate）的距离。

示例：

@Test
public void testDurationAndPeriod() {
    Duration duration = Duration.between(LocalTime.now(), LocalTime.now().plusSeconds(60));

    System.out.println("相差天 = " + duration.toDays());
    System.out.println("相差小时 = " + duration.toHours());
    System.out.println("相差分钟 = " + duration.toMinutes());
    System.out.println("相差毫秒 = " + duration.toNanos());
    System.out.println("相差秒 = " + duration.getSeconds());

    Period period = Period.between(LocalDate.now(), LocalDate.now().plusDays(2).plusMonths(2));
    System.out.println("相差年 = " + period.getYears());
    System.out.println("相差月 = " + period.getMonths());
    System.out.println("相差日 = " + period.getDays());
}

JDK8 的时间校正器

有时我们可能需要获取例如：将日期调整到下一个月的第一天等操作。可以通过时间校正器来进行。

TemporalAdjuster：时间校正器。

TemporalAdjusters：该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现。

示例：

@Test
public void testTemporalAdjusters() {
    LocalDateTime now = LocalDateTime.now();
    // 将日期和时间调整到"下一个月的第一天"
    LocalDateTime localDateTime = now.with(TemporalAdjusters.firstDayOfNextMonth());
    System.out.println("localDateTime = " + localDateTime);
}

JDK8 设置日期时间的时区

JDK8 中加入了对时区的支持，LocalDate、LocalTime、LocalDateTIme 是不带时区的，带时区的日期时间类分别是 ZonedDate、ZonedTime、ZonedDateTime。

其中每个时区都对应的 ID，ID 的格式是“区域/城市”，比如：Asia/Shanghai 等。

ZoneId：该类中包含了所有的时区信息。

示例：

@Test
public void testZoneId() {
    // 获取所有的时区信息
    ZoneId.getAvailableZoneIds().forEach(System.out::println);
    // 获取当前默认的时区
    String id = ZoneId.systemDefault().getId();
    System.out.println("默认的时区id = " + id);
    // 不带时区，获取计算机的当前时间
    LocalDateTime now = LocalDateTime.now();
    System.out.println("不带时区的当前时间 = " + now);
    // 操作带时区的类
    ZonedDateTime bz = ZonedDateTime.now(Clock.systemUTC());
    System.out.println("世界标准时间 = " + bz);
    ZonedDateTime time = ZonedDateTime.now(ZoneId.systemDefault());
    System.out.println("带时区的当前时间 = " + time);
    // 修改时区
    ZonedDateTime dateTime = ZonedDateTime.now(ZoneId.of("America/Los_Angeles"));
    // withZoneSameInstant既改时区，也改时间
    ZonedDateTime zonedDateTime = dateTime.withZoneSameInstant(ZoneId.systemDefault());
    // withZoneSameLocal只改时区
    ZonedDateTime zonedDateTime1 = dateTime.withZoneSameLocal(ZoneId.systemDefault());
    System.out.println("修改时区和时间 = " + zonedDateTime);
    System.out.println("只改时区 = " + zonedDateTime1);
}

待续!!!!

本文作者： LiJing
发布时间： 2021-12-09
最后更新： 2024-06-24
本文标题： JDK8新特性
本文链接： https://blog-yilia.xiaojingge.com/posts/bcab918b.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 许可协议进行许可。转载请注明出处！

赏

谢谢你请我吃糖果

支付宝

微信