Java Stream 的技巧

Posted 2021-09-04 n6nzcewp

Stream
使用这个方法创建一个 Stream 对象。

new ArrayList<>().stream()
Filter
过滤器，里面传递一个函数，这个函数的返回结果如果为 true 则保留这个元素，否则的话丢弃这个元素。

    stringCollection
            .stream()
            .filter((s) -> s.startsWith("a"))
            .forEach(System.out::println);

Foreach
遍历，消费。

    stringCollection
            .stream()
            .filter((s) -> s.startsWith("a"))
            .forEach(System.out::println);

Map
这个功能也是遍历，但是他是有返回值的，而上面的 Foreach 是没有返回值的，仅仅是单纯的消费。而且 Foreach 不能够链式调用，因为没有返回值，但是 Map 没问题。

    stringCollection
            .stream()
            .map(String::toUpperCase)
            .sorted(Comparator.reverseOrder())
            .forEach(System.out::println);

Sorted
这个方法是用来排序的，里面传递的函数就是一个比较器，也可以不传递参数，使用默认的就好。

    stringCollection
            .stream()
            .sorted(( x, y)-> y.length()-x.length())
            .filter((s) -> s.startsWith("a"))
            .forEach(System.out::println);

Match
根据在给定的 stream 对象中是否含有指定内容返回 true 或者 false 。

具体的有：

allMatch
anyMatch
noneMatch

    boolean anyStartsWithA = stringCollection
            .stream()
            .anyMatch((s) -> s.startsWith("a"));

    boolean allStartsWithA = stringCollection
            .stream()
            .allMatch((s) -> s.startsWith("a"));

    boolean noneStartsWithZ = stringCollection
            .stream()
            .noneMatch((s) -> s.startsWith("z"));

count
计算集合中的元素的个数。

long startsWithB = stringCollection

    .stream()
    .filter((s) -> s.startsWith("b"))
    .count();

reduce
这个函数就是类似于斐波那契数列，每次传递的参数是上一次的结果和从集合中取出的新元素。第一次默认取出了第一个元素和第二个元素。

简单的例子就是，第一次取出 0,1 第二次取出 第一次reduce的结果作为第一个参数，取出 2 作为第二个参数，以此类推。

Optional<String> reduced =

    stringCollection
            .stream()
            .sorted()
            .reduce((s1, s2) -> s1 + "#" + s2);

parallelStream
并行的 steam 流，可以进行并行处理，这样会效率更高。在使用stream.foreach时这个遍历没有线程安全问题，但是使用parallelStream就会有线程安全问题，所有在parallelStream里面使用的外部变量，比如集合一定要使用线程安全集合，不然就会引发多线程安全问题。如果说需要保证安全性需要使用 reduce 和 collect，不过这个用起来超级麻烦！！！

long count = values.parallelStream().sorted().count();
IntStream.range(a,b)
可以直接生成 从 a 到 b 的整数这里还是遵循编程语言的大多数约定，那就是含头不含尾。

IntStream.range(0, 10)

.forEach(System.out::println);

输出的结果是

0
1
2
3
4
5
6
7
8
9
new Random().ints()
获取一系列的随机值，这个接口出来的数据是连续不断的，所以需要用limit来限制一下。

new Random().ints().limit(10).forEach(System.out::println);
Supplier
Supplier<String> stringSupplier=String::new;
stringSupplier.get();
该接口就一个抽象方法get方法,不用传入任何参数,直接返回一个泛型T的实例.就如同无参构造一样

Consumer

1. accept方法
   ​ 该函数式接口的唯一的抽象方法,接收一个参数,没有返回值.
2. andThen方法
   ​ 在执行完调用者方法后再执行传入参数的方法.

public class ConsumerTest {
public static void main(String[] args) {
Consumer<Integer> consumer = (x) -> {
int num = x * 2;
System.out.println(num);

    };

Consumer<Integer> consumer1 = (x) -> {
int num = x * 3;
System.out.println(num);

    };

consumer.andThen(consumer1).accept(10);

}

先执行了 consumer.accept(10) 然后执行了 consumer1.accept(10)

ifPresent
针对一个optional 如果有值的话就执行否则不执行。

IntStream

.builder()
.add(1)
.add(3)
.add(5)
.add(7)
.add(11)
.build()
.average()
.ifPresent(System.out::println);

average 执行结果就是一个 optional

Collect
他有两种调用方式

<R> R collect(Supplier<R> supplier,
BiConsumer<R, ? super T> accumulator,
BiConsumer<R, R> combiner);

<R, A> R collect(Collector<? super T, A, R> collector);
下面主要介绍一下这两种方式的使用方法：

1. 函数
   第一种调用方式的接口如下

   <R> R collect(Supplier<R> supplier,
   BiConsumer<R, ? super T> accumulator,
   BiConsumer<R, R> combiner);
   supplier 这个参数就是提供一个容器，可以看到最后 collect 操作的结果是一个 R 类型变量，而 supplier 接口最后需要返回的也是一个 R 类型的变量，所以说这里返回的是收集元素的容器。
   accumulator 参数，看到这个函数的定义是传入一个 R 容器，后面则是 T 类型的元素，需要将这个 T 放到 R 容器中，即这一步是用来将元素添加到容器中的操作。
   conbiner 这个参数是两个容器，即当出现多个容器的时候容器如何进行聚合。
   一个简单的例子：

String concat = stringStream.collect(StringBuilder::new, StringBuilder::append,StringBuilder::append).toString();
//等价于上面,这样看起来应该更加清晰
String concat = stringStream.collect(() -> new StringBuilder(),(l, x) -> l.append(x), (r1, r2) -> r1.append(r2)).toString();

2. Collector 接口
   第二种方案是更高级的用法采用了 Collector 接口：

   <R, A> R collect(Collector<? super T, A, R> collector);
   可以看到他返回的还是一个 R 类型的变量，也就是容器。

Collector接口是使得collect操作强大的终极武器,对于绝大部分操作可以分解为旗下主要步骤,提供初始容器->加入元素到容器->并发下多容器聚合->对聚合后结果进行操作

static class CollectorImpl<T, A, R> implements Collector<T, A, R> {
private final Supplier supplier;
private final BiConsumer<A, T> accumulator;
private final BinaryOperator combiner;
private final Function<A, R> finisher;
private final Set<Characteristics> characteristics;

CollectorImpl(Supplier supplier,
BiConsumer<A, T> accumulator,
BinaryOperator combiner,
Function<A,R> finisher,
Set<Characteristics> characteristics) {
this.supplier = supplier;
this.accumulator = accumulator;
this.combiner = combiner;
this.finisher = finisher;
this.characteristics = characteristics;

    }

CollectorImpl(Supplier supplier,
BiConsumer<A, T> accumulator,
BinaryOperator combiner,
Set<Characteristics> characteristics) {
this(supplier, accumulator, combiner, castingIdentity(), characteristics);

    }

    @Override

public BiConsumer<A, T> accumulator() {
return accumulator;

    }

    @Override

public Supplier supplier() {
return supplier;

    }

    @Override

public BinaryOperator combiner() {
return combiner;

    }

    @Override

public Function<A, R> finisher() {
return finisher;

    }

    @Override

public Set<Characteristics> characteristics() {
return characteristics;

    }
}

可以看到我们可以直接 new CollectorImpl 然后将这些函数传入，另外还有一种简单的方式就是 使用 Collector.of()依然可以直接传入函数。和 new CollectorImpl 是等价的。