关于java:Java-Stream-的技巧

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

accept 办法
该函数式接口的惟一的形象办法, 接管一个参数, 没有返回值.
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);
上面次要介绍一下这两种形式的应用办法：

函数
第一种调用形式的接口如下

<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();

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 是等价的。

关于java:Java-Stream-的技巧

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）