Java 8 In Action

本贴最后更新于 221 天前,其中的信息可能已经时移世异

函数式编程

函数式编程给我的直观感受:

引言——让方法参数具备行为能力

假设你现在是一个农场主,你采摘了一筐苹果如下:

List<Apple> apples = Arrays.asList(
    new Apple("red", 100),
    new Apple("red", 300),
    new Apple("red", 500),
    new Apple("green", 200),
    new Apple("green", 400),
    new Apple("green", 600),
    new Apple("yellow", 300),
    new Apple("yellow", 400),
    new Apple("yellow", 500)
);

Apple

@Data
@AllArgsConstructor
public class Apple {
    private String color;
    private int weight;
}

现在需要你编写一个方法,挑选出箩筐中颜色为绿色的苹果,于是你轻而易举地写了如下代码:

@Test
public void pickGreenApples() {
    List<Apple> list = new ArrayList<>();
    for (Apple apple : apples) {
        if (Objects.equals(apple.getColor(), "green")) {
            list.add(apple);
        }
    }
    System.out.println(list);
}

[Apple(color=green, weight=200), Apple(color=green, weight=400), Apple(color=green, weight=600)]

如果需要你挑选出红色的呢?你发现可以将按照颜色挑选苹果抽取出来以供复用:

public void pickByColor(List<Apple> apples, String color) {
    for (Apple apple : apples) {
        if (Objects.equals(apple.getColor(), color)) {
            System.out.println(apple);
        }
    }
}

@Test
public void testPickByColor() {
    pickByColor(apples, "red");
}

Apple(color=red, weight=100)
Apple(color=red, weight=300)
Apple(color=red, weight=500)

好了,现在我需要你挑选出重量在 400g 以上,颜色不是绿色的苹果呢?你会发现,根据不同的颜色和重量挑选标准能够组合成若干的挑选策略,那是不是针对每个策略我们都需要编写一个方法呢?这当然不可能,我们也无法事先预知顾客需要什么样的苹果。

现在我们来理一下业务需求,其实也就是我们给顾客一个苹果,由他来判断是否符合他的食用标准,这可以采用策略模式来实现:

  1. 将判断某个苹果是否符合标准这一行为抽象为一个接口:

    public interface AppleJudgementStrategy {
        /**
         * 你给我一个apple,我判断他是否符合挑选出来的标准
         * @param apple the apple in container
         * @return true if apple need be picked
         */
        boolean judge(Apple apple);
    }
    
  2. 挑选苹果的方法根据策略挑选苹果(面向接口编程,灵活性更大)

    public void pickByStrategy(List<Apple> apples,AppleJudgementStrategy strategy) {
        for (Apple apple : apples) {
            if (strategy.judge(apple)) {
                // apple 符合既定的挑选策略
                System.out.println(apple);
            }
        }
    }
    
  3. 业务方法根据实际的业务需求创建具体的挑选策略传给挑选方法

    @Test
    public void testPickByStrategy() {
        // 挑选400g以上且颜色不是绿色的
        pickByStrategy(apples, new AppleJudgementStrategy() {
            @Override
            public boolean judge(Apple apple) {
                return apple.getWeight() >= 400 && !Objects.equals(apple.getColor(), "green");
            }
        });
    }
    
    Apple(color=red, weight=500)
    Apple(color=yellow, weight=400)
    Apple(color=yellow, weight=500)
    

那么以上的代码重构是无需基于 Java 8 的,但其中有一个弊端:策略模式的实现要么需要创建一个新类,要么使用匿名类的方式。在此过程中,new/implements AppleJudgementStrategypublic boolean judge 的大量重复是很冗余的,Java 8 引入的 Lambda 表达式就很好的改善了这一点,如上述代码可简化如下:

@Test
public void testPickByStrategyWithLambda() {
    pickByStrategy(apples, apple -> apple.getWeight() >= 400 && !Objects.equals(apple.getColor(), "green"));
}

Apple(color=red, weight=500)
Apple(color=yellow, weight=400)
Apple(color=yellow, weight=500)

本节通过挑选苹果的例子初步体验了一下 Lambda 表达式的魅力,但其的作用不仅于此,接下来让我们打开函数式编程的大门。

为什么要引入函数式编程

正如上一节说表现的,面对同一业务(挑选苹果)的需求的频繁变更,业务方法仅能接受基本类型、引用类型(对象类型)的参数已经不能满足我们的需求了,我们期望能够通过参数接受某一特定的行为(如判断某个苹果是否应该被挑选出来)以使方法能够“以不变应万变”。

上例中,虽然我们能通过策略模式达到此目的,但如果究其本质,策略接口其实就是对一个函数的封装,而我们业务方法参数接收该对象也仅仅是为了调用该对象实现的接口方法。无论我们是在调用业务方法之前创建一个该接口的实现类然后在调用业务方法传参时 new 该实现类,还是在调用业务方法传参时直接 new 一个匿名类,这些创建类的操作都只是为了遵守“在 Java 中,类是第一公民的事实”(即先有类,后有方法,方法必须封装在类中)。因此,创建类和声明方法的过程显得有些多余,其实业务方法只是想要一个具体的策略而已,如 return apple.getWeight() >= 400(挑选出重量大于 400g 的苹果)。

因此你会看到 Java 8 引入 Lambda 表达式之后,业务调用方可以变更如下:

// 业务方法
public void pickByStrategy(List<Apple> apples,AppleJudgementStrategy strategy) {
    for (Apple apple : apples) {
        if (strategy.judge(apple)) {
            // apple 符合既定的挑选策略
            System.out.println(apple);
        }
    }
}

// 调用业务
@Test
public void testPickByStrategy() {
    // 挑选400g以上的
    pickByStrategy( apples, (apple) -> { return apple.getWeight() >= 400 } );
}

我们使用一个 Lambda 表达式 (apple) -> { return apple.getWeight() >= 400 } 代替了 AppleJudgementStrategy 实例的创建

什么是 Lambda 表达式

Lambda 表达式可以理解为函数表达式,在上例中指的就是 (apple) -> { return apple.getWeight() >= 400 },表示对接口 AppleJudgementStrategy 函数 boolean judge(Apple apple); 的一个实现。其中 (apple) 表示函数接受一个 Apple 类型的对象;{ return apple.getWeight() >= 400 } 则是函数体,表示传入 Apple 对象的重量大于 400 时返回 true

Lambda 表达式和接口是密切相关的,而且能使用 Lambda 表达式代替其实例的接口必须是只声明了一个抽象方法的接口

注意:Java 8 对接口进行了重新定义,为了获得更好的兼容性,接口中的方法可以有方法体,此时该方法需被标记为 default,即该方法有一个默认的实现,子类可以选择性的重写。不像抽象方法,必须被具体子类重写。

此外接口中还可以定义带有方法体的静态方法,可以通过 接口名.方法名 的形式访问,这一点与类静态方法无异。

上述两点打破了 Java 8 之前对接口的定义:接口中的方法必须都是抽象方法(public abstract)。

也就是说在 AppleJudgementStrategy 添加若干 defaultstatic 方法,都是不影响使用 Lambda 表达式来代替其实例的(在 IDE 中,@FunctionalInterface 注解不会报红表示这是一个合法的函数式接口):

@FunctionalInterface
public interface AppleJudgementStrategy {
    /**
     * 你给我一个apple,我判断他是否符合挑选出来的标准
     * @param apple the apple in container
     * @return true if apple need be picked
     */
    boolean judge(Apple apple);

    default void fun1() {
        System.out.println("这是带有默认实现的方法");
    }

    static void fun2() {
        System.out.println("这是定义在接口中的静态方法");
    }
}

有了函数式接口之后我们就可以在需要该接口实例的地方使用 lambda 表达式了。

实战

下面我们通过实战来巩固 lambda 表达式的运用。

  1. 编写函数式接口:

    @FunctionalInterface
    public interface AccumulatorFunction {
    
        /**
         * 该函数聚合两个整数通过运算生成一个结果
         * @param a 整数a
         * @param b 整数b
         * @return  运算结果
         */
        int accumulate(int a, int b);
    }
    
  2. 编写业务方法,参数接受函数式接口实例,让该参数具备行为能力

    /**
         * 通过既定的计算规则对输入值a和b得出输出结果
         * @param a
         * @param b
         * @param accumulatorFunction
         * @return
         */
    public int compute(int a, int b, AccumulatorFunction accumulatorFunction) {
        return accumulatorFunction.accumulate(a,b);
    }
    
  3. 编写业务调用方,通过 lambda 表达式阐述行为

    @Test
    public void testAccumulatorFunction() {
        int res1 = compute(1, 2, (a, b) -> {		//阐述的行为是求和
            return a + b;
        });
        System.out.println("1加2的结果是:" + res1);
        int res2 = compute(1, 2, (a, b) -> {		//阐述的行为是求乘积
            return a * b;
        });
        System.out.println("1乘2的结果是:" + res2);
    }
    
    1加2的结果是3
    1乘2的结果是2
    

Lambda 表达式的编写规则

通过上一节我们知道 lambda 表达式是和函数式接口密切相关的,在需要传入函数式接口实例时我们可以编写 lambda 表达式,编写时我们要特别关注该接口抽象方法定义的参数列表以及返回值。

假设函数式接口声明如下(其中 R,T1,T2,T3 为基本类型或引用类型):

@FunctionalInterface
public interface MyFunction{
    R fun(T1 t1, T2 t2, T3 t3);
}

那么你的 lambda 表达式就应该编写如下:

(t1, t2, t3) -> {	// 参数名自定义,为a,b,c也可以,但是要知道在方法体中访问时a的类型是T1,b的类型是T2
    // do you service with t1,t2,t3
    return instance_of_R;
}

总结如下,严格意义上的 lambda 表达式需包含:

但是为了书写简洁,上述几点有时不是必须的。

入参列表只有一个参数时可以省略小括号

t1 -> {
    // do your service with t1
    return instance_of_R;
}

其他情况下(包括无参时)都必须有小括号

函数体可以用表达式代替

当函数体只有一条语句时,如 return t1+t2+t3(假设 t1,t2,t3,R 都是 int 型),那么方法体可以省略大括号和 return

(t1,t2,t3) -> t1+t2+t3

只要函数体包含了语句(必须以分号结尾),那么函数体就需要加上大括号

function 包 & 方法推导

在 Java 8 中,为我们新增了一个 java.util.function 包,其中定义的就全部都是函数式接口,其中最为主要的接口如下:

该包下的其他所有接口都是基于以上接口在参数接受个数(如 BiConsumer 消费两个参数)、和参数接收类型(如 IntConsumer 仅用于消费 int 型参数)上做了一个具体化。

Consumer In Action

对每个苹果进行“消费”操作:

public void consumerApples(List<Apple> apples, Consumer<Apple> consumer) {
    for (Apple apple : apples) {
        consumer.accept(apple);
    }
}

如“消费”操作就是将传入的苹果打印一下:

@Test
public void testConsumer() {
    consumerApples(apples, apple -> System.out.println(apple));
}

Apple(color=red, weight=100)
Apple(color=red, weight=300)
Apple(color=red, weight=500)
Apple(color=green, weight=200)
Apple(color=green, weight=400)
Apple(color=green, weight=600)
Apple(color=yellow, weight=300)
Apple(color=yellow, weight=400)
Apple(color=yellow, weight=500)

如果你使用的 IDE 是 IDEA,那么它会提示你 System.out.println(apple) 可以 Lambda can be replaced with method inference(即该 lambda 表达式可以使用方法推导),于是我们使用快捷键 alt + Enter 寻求代码优化提示,代表被替换成了 apple -> System.out::println

这里引申出了 lambda 的一个新用法:方法推导。当我们在编写 lambda 时,如果方法体只是一个表达式,并且该表达式调用的方法行为与此处对应的函数接口的行为一致时,可以使用方法推导(类名::方法名对象名::方法名)。

因为这里我们需要一个 Consumer,而 println 的定义与 Consumer.accept 的函数行为是一致的(接受一个对象,无返回值):

public void println(Object x) {
    String s = String.valueOf(x);
    synchronized (this) {
        print(s);
        newLine();
    }
}

因此 IDEA 提示我们此处可以使用方法推导 apple -> System.out::println 代替方法调用 apple -> System.out.println(apple)。如此,前者看起来更具可读性:使用 println 行为消费这个 apple

Supplier In Action

Supplier 像是一个工厂方法,你可以通过它来获取对象实例。

如,通过 Supplier 你给我一个苹果,我来打印它的信息

public void printApple(Supplier<Apple> appleSupplier) {
    Apple apple = appleSupplier.get();
    System.out.println(apple);
}

@Test
public void testSupplier() {
    printApple(() -> {
        return new Apple("red", 666);
    });
}

Apple(color=red, weight=666)

如果 Apple 提供无参构造方法,那么这里可以使用构造函数的方法推导(无参构造函数不接收参数,但返回一个对象,和 Supplier.get 的函数类型一致):

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Apple {
    private String color;
    private int weight;
}

@Test
public void testSupplier() {
    //        printApple(() -> {
    //            return new Apple("red", 666);
    //        });
    printApple(Apple::new);
}

Apple(color=null, weight=0)

Predicate In Action

Predicate 则是用来断言对象,即按照某种策略判定入参对象是否符合标准的。

为此我们可以将先前写的挑选苹果的业务方法中的 AppleJudgementStrategy 换成 Predicate,作用是一样的,以后用到策略模式的地方直接使用 Predicate<T> 就行了

//    public void pickByStrategy(List<Apple> apples, AppleJudgementStrategy strategy) {
//        for (Apple apple : apples) {
//            if (strategy.judge(apple)) {
//                // apple 符合既定的挑选策略
//                System.out.println(apple);
//            }
//        }
//    }
public void pickByStrategy(List<Apple> apples, Predicate<Apple> applePredicate) {
    for (Apple apple : apples) {
        if (applePredicate.test(apple)) {
            // apple 符合既定的挑选策略
            System.out.println(apple);
        }
    }
}

@Test
public void testPickByStrategyWithLambda() {
    pickByStrategy(apples, apple -> 
                   apple.getWeight() >= 400 && !Objects.equals(apple.getColor(),"green"));
}

Apple(color=red, weight=500)
Apple(color=yellow, weight=400)
Apple(color=yellow, weight=500)

Function In Action

Function 就不用说了,代表了最普通的函数描述:有输入,有输出。

我们此前编写的 AccumulatorFunction 就属于一个 BiFunction,让我们来使用 BiFucntion 对其进行改造:

//    public int compute(int a, int b, AccumulatorFunction accumulatorFunction) {
//        return accumulatorFunction.accumulate(a,b);
//    }

public int compute(int a, int b, BiFunction<Integer,Integer,Integer> biFunction) {
    return biFunction.apply(a,b);
}

@Test
public void testAccumulatorFunction() {
    int res1 = compute(1, 2, (a, b) -> {
        return a + b;
    });
    System.out.println("1加2的结果是:" + res1);
    int res2 = compute(1, 2, (a, b) -> {
        return a * b;
    });
    System.out.println("1乘2的结果是:" + res2);
}

1加2的结果是3
1乘2的结果是2

Stream——更优雅的集合操作工具类

引言——Stream 初体验

现在有一个菜品类定义如下:

public class Dish {

    public enum Type {MEAT, FISH, OTHER}

    private final String name;			//菜品名称
    private final boolean vegetarian;	//是否是素食
    private final int calories;			//提供的卡路里
    private final Type type;			//菜品类型

    public Dish(String name, boolean vegetarian, int calories, Type type) {
        this.name = name;
        this.vegetarian = vegetarian;
        this.calories = calories;
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public boolean isVegetarian() {
        return vegetarian;
    }

    public int getCalories() {
        return calories;
    }

    public Type getType() {
        return type;
    }

    @Override
    public String toString() {
        return name;
    }
}

给你一份包含若干菜品的菜单:

List<Dish> menu = Arrays.asList(
    new Dish("pork", false, 800, Dish.Type.MEAT),
    new Dish("beef", false, 700, Dish.Type.MEAT),
    new Dish("chicken", false, 400, Dish.Type.MEAT),
    new Dish("french fries", true, 530, Dish.Type.OTHER),
    new Dish("rice", true, 350, Dish.Type.OTHER),
    new Dish("season fruit", true, 120, Dish.Type.OTHER),
    new Dish("pizza", true, 550, Dish.Type.OTHER),
    new Dish("prawns", false, 300, Dish.Type.FISH),
    new Dish("salmon", false, 450, Dish.Type.FISH));

现在要你以卡路里升序的方法打印卡路里在 400 以下的菜品名称清单,在 Java 8 之前,你可能需要这样做:

@Test
public void beforeJava8() {
    // 1. filter which calories is lower than 400 and collect them
    List<Dish> filterMenu = new ArrayList<>();
    for (Dish dish : menu) {
        if (dish.getCalories() < 400) {
            filterMenu.add(dish);
        }
    }
    // 2. sort by calories ascending
    Collections.sort(filterMenu, new Comparator<Dish>() {
        @Override
        public int compare(Dish o1, Dish o2) {
            return o1.getCalories() - o2.getCalories();
        }
    });
    // 3. map Dish to Dish.getName and collect them
    List<String> nameList = new ArrayList<>();
    for (Dish dish : filterMenu) {
        nameList.add(dish.getName());
    }
    // print name list
    System.out.println(nameList);
}

[season fruit, prawns, rice]

在 Java 8 之后,通过 Stream 只需简洁明了的一行代码就能搞定:

@Test
public void userJava8() {
    List<String> nameList = menu.stream()
        // 1. filter which calories is lower than 400
        .filter(dish -> dish.getCalories() < 400)
        // 2. sort by calories ascending
        .sorted(Comparator.comparing(Dish::getCalories))
        // 3. map Dish to Dish.getName
        .map(Dish::getName)
        // 4. collect
        .collect(Collectors.toList());
    System.out.println(nameList);
}

[season fruit, prawns, rice]

Stream 的强大才刚刚开始……

Stream 到底是什么

《Java 8 In Action》给出的解释如下:

定义

特性

上一节菜品的例子中数据处理流可描述如下(其中的 limit 表示取前 n 个元素):

Stream 的并发

Stream 内部集成了 Java 7 提供的 ForkJoin 框架,当我们通过调用它的 parallel 开启并行执行开关时,Stream 会将数据序列的处理通过 ForkJoinPool 进行并行化执行(不仅仅是开启多个线程,底层还会根据你 CPU 核心数量将子任务分配到不同的核心执行):

@Test
public void userJava8() {
    List<String> nameList = menu.stream().parallel()
        .filter(dish -> {
            System.out.println(Thread.currentThread().getName());
            return dish.getCalories() < 400;
        })
        .sorted(Comparator.comparing(Dish::getCalories))
        .map(Dish::getName)
        .collect(Collectors.toList());
    System.out.println(nameList);
}

ForkJoinPool.commonPool-worker-7
ForkJoinPool.commonPool-worker-2
ForkJoinPool.commonPool-worker-6
ForkJoinPool.commonPool-worker-5
ForkJoinPool.commonPool-worker-3
main
ForkJoinPool.commonPool-worker-4
ForkJoinPool.commonPool-worker-1
[season fruit, prawns, rice]

否则在当前线程串行化执行:

@Test
public void userJava8() {
    List<String> nameList = menu.stream()
        .filter(dish -> {
            System.out.println(Thread.currentThread().getName());
            return dish.getCalories() < 400;
        })
        .sorted(Comparator.comparing(Dish::getCalories))
        .map(Dish::getName)
        .collect(Collectors.toList());
    System.out.println(nameList);
}

main
main
main
main
main
main
main
main
main
[season fruit, prawns, rice]

Stream 实例化

上文曾提到,Stream 是无法凭空而来的,需要一个数据提供源,而我们最常见的就是数组和集合了。

作为一个接口,我们是无法通过 new Stream 获取其实例的,获取其实例的常用方法有以下几种

Collection#stream

通过 Collection 接口中的 stream() 方法,从一个集合实例中创建一个 Stream,对同一个集合对象调用多次 stream() 会产生不同的 Stream 实例。

开篇挑选苹果的例子中,apples.stream 就是调用了此方法

Arrays.stream(T[] arr)

Stream.of()

range/rangeClosed & generate

使用 IntStream/LongStream/DoubleStream 中的方法

IntStream 中的 range/rangeClosed (int, int) 可以创建一个包含指定开区间/闭区间中所有元素的 StreamLongStream 也一样,但 DoubleStream 因为区间中的浮点数有无数个因此没有此方法

IntStream.rangeClosed(0, 4).forEach(i -> {
    new Thread(() -> {
        System.out.println("I am a thread, my name is " + Thread.currentThread().getName());
    }, "t-" + i).start();
});

I am a thread, my name is t-0
I am a thread, my name is t-1
I am a thread, my name is t-2
I am a thread, my name is t-3
I am a thread, my name is t-4

generate(Supplier s),三者都有此方法,通过一个生产策略来创建一个无穷大的 Stream,如果在此 Stream 上进行操作那么每处理完一个元素都会通过调用 s.get 获取下一个要处理的元素。

final int a = 0;
IntStream.generate(() -> a).forEach(System.out::println);

你会发现上述程序会一直打印 0

通过 generate 创建的 stream,如果在之上进行 operation,那么该 processing 会一直进行下去只有遇到异常时才会停止

IntStream.generate(i::getAndIncrement).forEach(e -> {
    System.out.println(e);
    if (e == 5) {
        throw new RuntimeException();
    }
});

0
1
2
3
4
5

java.lang.RuntimeException

Stream Operation 详解

Stream 的数据操纵方法分为 terminalnon-terminalnon-terminal 操作之后可以继续链式调用其他 operation,形成一个流式管道,而 terminal 操作则会终止数据流的移动。Stream 中方法返回 Stream(实际返回的是当前 Stream 实例本身)的都是 non-terminal option

filter——过滤

调用 Streamfilter 并传入一个 Predicate 可以对元素序列进行过滤,丢弃不符合条件(是否符合条件根据你传入的 Predicate 进行判断)的元素

// print the even number between 1 and 10
IntStream.rangeClosed(1, 10).filter(i -> i % 2 == 0).forEach(System.out::println);

2
4
6
8
10

distinct——去重

@Test
public void testDistinct() {
    Stream.of("a", "b", "a", "d", "g", "b").distinct().forEach(System.out::println);
}

a
b
d
g

distinct 会根据 equals 方法对“相等”的对象进行去重。

skip——去除前 n 个元素

相当于 SQLlimit <offset,rows> 语句中的 offset

public void testSkip() {
    IntStream.rangeClosed(1,10).skip(6).forEach(System.out::println);
}

7
8
9
10

limit——取前 n 个元素,丢弃剩余的元素

相当于 SQLlimit <offset,rows> 语句中的 rows

// 丢弃前6个之后Stream只剩下7~10了,再截取前2个,Stream就只有7和8了
IntStream.rangeClosed(1, 10).skip(6).limit(2).forEach(System.out::println);

7
8

map——映射

map 方法接收一个 Function(接收一个对象,返回一个对象),返回什么对象、需不需要借助传入的对象信息就是映射的逻辑,根据你的所需你可以将 Stream 中的所有元素统一换一个类型。

// 从一份菜单(菜品集合)中提取菜品名称清单
List<String> nameList = menu.stream().map(dish -> dish.getName()).collect(Collectors.toList());
System.out.println(menu);

[pork, beef, chicken, french fries, rice, season fruit, pizza, prawns, salmon]

flatMap——扁平化

flatMap 可以将你的元素进一步细粒度化,如从某个文件读取文件内容后根据换行符分割创建一个以“行”为元素的 Stream,如果你想进一步将“行”按照“空格”分割得到以“字词”为元素的 Stream,那么你就可以使用 flatMap

你需要传入一个 Function<T,Stream>:传入一个元素,返回一个包含由该元素分割形成若干细粒度元素的 Stream

Stream.of("hello", "world").
    flatMap(str -> Stream.of(str.split(""))).
    forEach(System.out::println);

h
e
l
l
o
w
o
r
l
d

sorted & Comparator.comparing

sort 需要你传入一个定义了排序规则的 Comparator,它相当于一个 BiPredicate

// 将菜品按照卡路里升序排序
menu.stream().
    sorted((dish1,dish2)->dish1.getCalories()-dish2.getCalories())
    .map(Dish::getCalories)
    .forEach(System.out::println);

120
300
350
400
450
530
550
700
800

你会发现 IDEA 提示你 (dish1,dish2)->dish1.getCalories()-dish2.getCalories() 可以简化为 Comparator.comparingInt(Dish::getCalories),使用 comparing 你可以直接传入排序字段如 getColaries,它会自动帮我们封装成一个升序的 BiPredicate,如果你需要降序则再链式调用 reversed 即可:

menu.stream().
    sorted(Comparator.comparingInt(Dish::getCalories).reversed())
    .map(Dish::getCalories)
    .forEach(System.out::println);

800
700
550
530
450
400
350
300
120

count——返回当前 Stream 中的元素个数

match——判断 Stream 中是否有符合条件的元素

这是一个 terminal option,当 Stream 调用 match 之后会返回一个布尔值,match 会根据你传入的 Predicate 返回 true or false,表示当前 Stream 中的所有元素是否存在至少一个匹配(anyMatch)、是否全部匹配(allMatch)、是否全都不匹配(noneMatch)。

这几仅以 anyMatch 的使用示例:

// 菜单中是否有卡路里小于100的菜品
boolean res = menu.stream().anyMatch(dish -> dish.getCalories() < 100);
System.out.println(res);

false

find

这也是一个 terminal operation。通常用于在对 Stream 进行一系列处理之后剩下的元素中取出一个进行消费。

reduce——聚合计算

reduce 是对当前 Stream 中的元素进行求和、求乘积、求最大/小值等需要遍历所有元素得出一个结果的聚合操作。它有如下重载方法:

collect——收集元素到集合、分组、统计等

collect 需要传入一个 CollectorCollectors 为我们封装了很多 Collector 的默认实现。

例如

Stream In Action

下面通过一个业务员 Trader 和交易 Transaction 的例子来巩固 Stream 的运用。

两个类定义如下:

public class Trader{
    private final String name;
    private final String city;
    public Trader(String n, String c){
        this.name = n;
        this.city = c;
    }
    public String getName(){
        return this.name;
    }
    public String getCity(){
        return this.city;
    }
    public String toString(){
        return "Trader:"+this.name + " in " + this.city;
    }
}

public class Transaction{

    private final Trader trader;
    private final int year;
    private final int value;
    public Transaction(Trader trader, int year, int value){
        this.trader = trader;
        this.year = year;
        this.value = value;
    }
    public Trader getTrader(){
        return this.trader;
    }
    public int getYear(){
        return this.year;
    }
    public int getValue(){
        return this.value;
    }
    @Override
    public String toString(){
        return "{" + this.trader + ", " +
                "year: "+this.year+", " +
                "value:" + this.value +"}";
    }
}

需求如下:

/**
* 1. Find all transactions in the year 2011 and sort them by value (small to high).
* 2. What are all the unique cities where the traders work?
* 3. Find all traders from Cambridge and sort them by name.
* 4. Return a string of all traders’ names sorted alphabetically.
* 5. Are any traders based in Milan?
* 6. Print all transactions’ values from the traders living in Cambridge.
* 7. What’s the highest value of all the transactions?
* 8. Find the transaction with the smallest value.
*/

代码示例:

//1. Find all transactions in the year 2011 and sort them by value (small to high).
List<Transaction> transactions1 = transactions.stream()
    .filter(transaction -> transaction.getYear() == 2011)
    .sorted(Comparator.comparing(Transaction::getValue))
    .collect(Collectors.toList());
System.out.println(transactions1);

//2. What are all the unique cities where the traders work?
String value = transactions.stream()
    .map(transaction -> transaction.getTrader().getCity())
    .distinct()
    .reduce("", (c1, c2) -> c1 + " " + c2);
System.out.println(value);

//3. Find all traders from Cambridge and sort them by name.
transactions.stream()
    .filter(transaction -> "Cambridge".equals(transaction.getTrader().getCity()))
    .map(Transaction::getTrader)
    .sorted(Comparator.comparing(Trader::getName))
    .forEach(System.out::println);

//4. Return a string of all traders’ names sorted alphabetically.
transactions.stream()
    .map(transaction -> transaction.getTrader().getName())
    .distinct()
    .sorted()
    .forEach(System.out::println);

//5. Are any traders based in Milan?
boolean res = transactions.stream()
    .anyMatch(transaction -> "Milan".equals(transaction.getTrader().getCity()));
System.out.println(res);

//6. Print all transactions’ values from the traders living in Cambridge.
transactions.stream()
    .filter(transaction -> "Cambridge".equals(transaction.getTrader().getCity()))
    .map(Transaction::getValue)
    .forEach(System.out::println);

//7. What’s the highest value of all the transactions?
Optional<Integer> integerOptional = transactions.stream()
    .map(Transaction::getValue)
    .reduce(Integer::max);
System.out.println(integerOptional.get());

//8. Find the transaction with the smallest value.
integerOptional = transactions.stream()
    .map(Transaction::getValue)
    .reduce(Integer::min);
System.out.println(integerOptional.get());

Optional——规避空指针异常

其实上节介绍 reduce 的使用时,就有 Optional 的身影,如果你没有给出 identity,那么 reduce 会给你返回一个 Optional,如此 Optional 的身份(拿到这个类的实例,你会立马条件反射:要在访问对象之前判断一下 Optional 包装的对象是否为 null)会提醒你进行非空判断,不至于你拿着 reduce 返回的 null 去使用从而导致空指针异常。

这种将非空判断交给 API 的机制,能够让我们不必每次拿到对象的时候都要为其是否为空而提心吊胆,又或十分敏感地每拿到一个对象都进行一下 if (obj != null)

有了 Optional 以后,避免空指针的两个点转变如下:

说白了,之前需要我们人为的记住非空判断,但引入 Optional 后,非空判断流程交给 API 了,卸去了我们对非空判断的关注点,规范了流程开发。

Optional 的创建、使用、非空判断

相关源码如下:

private static final Optional<?> EMPTY = new Optional<>();
private final T value;

private Optional() {
    this.value = null;
}

private Optional(T value) {
    this.value = Objects.requireNonNull(value);
}

public static <T> Optional<T> of(T value) {
    return new Optional<>(value);
}
public static <T> Optional<T> ofNullable(T value) {
    return value == null ? empty() : of(value);
}

public T get() {
    if (value == null) {
        throw new NoSuchElementException("No value present");
    }
    return value;
}
public T orElse(T other) {
    return value != null ? value : other;
}
public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get();
    }
}

public boolean isPresent() {
    return value != null;
}

public void ifPresent(Consumer<? super T> consumer) {
    if (value != null)
        consumer.accept(value);
}

你会发现其实他的源码很简单,就是将我们要使用的对象包了一层

此外,Optional 中还提供了 filtermap 两个从 Stream 中借鉴的方法,作用类似,可自行查看源码。

其实我还想说 CompletableFutrueLocalDate/LocalTime/LocalDateTime...

参考资料

  • Java

    Java 是一种可以撰写跨平台应用软件的面向对象的程序设计语言,是由 Sun Microsystems 公司于 1995 年 5 月推出的。Java 技术具有卓越的通用性、高效性、平台移植性和安全性。

    2624 引用 • 8021 回帖 • 775 关注
1 回帖
请输入回帖内容...
  • Tidhy

    赞一个,挺详细的