Lamaba表达式二

Java 8引入了全新的Stream API。这里的Stream和I/O流不同，它更像具有Iterable的集合类，但行为和集合类又有所不同。

一、Stream流

java抽象出了一个Stream流的概念,源码知道Stream抽象出了一个接口，封装了一些常用的流式计算的方法：

public interface Stream<T> extends BaseStream<T, Stream<T>> {

    Stream<T> filter(Predicate<? super T> predicate);

    <R> Stream<R> map(Function<? super T, ? extends R> mapper);

    IntStream mapToInt(ToIntFunction<? super T> mapper);

    LongStream mapToLong(ToLongFunction<? super T> mapper);

    DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);

    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

    IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);

    LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);

    DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);

    Stream<T> distinct();

    Stream<T> sorted();

    Stream<T> sorted(Comparator<? super T> comparator);

    Stream<T> peek(Consumer<? super T> action);


    Stream<T> limit(long maxSize);

    Stream<T> skip(long n);


    void forEach(Consumer<? super T> action);

    void forEachOrdered(Consumer<? super T> action);

    Object[] toArray();

    <A> A[] toArray(IntFunction<A[]> generator);

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


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

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

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

    Optional<T> min(Comparator<? super T> comparator);


    Optional<T> max(Comparator<? super T> comparator);

    long count();


    boolean anyMatch(Predicate<? super T> predicate);


    boolean allMatch(Predicate<? super T> predicate);


    boolean noneMatch(Predicate<? super T> predicate);

    Optional<T> findFirst();


    Optional<T> findAny();

    // Static factories


    public static<T> Builder<T> builder() {
        return new Streams.StreamBuilderImpl<>();
    }


    public static<T> Stream<T> empty() {
        return StreamSupport.stream(Spliterators.<T>emptySpliterator(), false);
    }


    public static<T> Stream<T> of(T t) {
        return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
    }

    @SafeVarargs
    @SuppressWarnings("varargs") // Creating a stream from an array is safe
    public static<T> Stream<T> of(T... values) {
        return Arrays.stream(values);
    }


    public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) {
        Objects.requireNonNull(f);
        final Iterator<T> iterator = new Iterator<T>() {
            @SuppressWarnings("unchecked")
            T t = (T) Streams.NONE;

            @Override
            public boolean hasNext() {
                return true;
            }

            @Override
            public T next() {
                return t = (t == Streams.NONE) ? seed : f.apply(t);
            }
        };
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
                iterator,
                Spliterator.ORDERED | Spliterator.IMMUTABLE), false);
    }


    public static<T> Stream<T> generate(Supplier<T> s) {
        Objects.requireNonNull(s);
        return StreamSupport.stream(
                new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);
    }

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


    public interface Builder<T> extends Consumer<T> {


        @Override
        void accept(T t);


        default Builder<T> add(T t) {
            accept(t);
            return this;
        }


        Stream<T> build();

    }
}

创建一个Stream流的方式有很多，最常见的就是跟集合类结合在一起,jdk8在集合基类Collection中提供了一个stream()方法可以快速将Collection集合变成Stream流，该方法返回一个Stream对象，不会创建新的集合类。

default Stream<E> stream() {
    return StreamSupport.stream(spliterator(), false);
}

可以看到这个方法的访问修饰符是default，也就是说所有集合都默认的都集成实现了这个方法。
一个简单的例子：

List<Integer> list = Lists.newArrayList();
for (int i = 0; i < 100000; i++) {
    list.add(i);
}
list.stream().filter(i-> i>4999).count();

二、实现机制

Stream流就像一个工厂流水线，调用stream()方法可以将集合转化为stream流，然后流水线上可以调用filter方法进行加工，将次品进行过滤，最后调用collect方法从流水线重新组装成集合。

三、常用方法

1.filter方法
遍历数据并检查其中的元素时，可尝试使用 Stream 中提供的新方法 filter。

allArtists.stream().filter(artist -> artist.isFrom("London"));

这行代码并未做什么实际性的工作， filter 只刻画出了 Stream ，但没有产生新的集合。像filter 这样只描述 Stream ，最终不产生新集合的方法叫作惰性求值方法；而像 count 这样最终会从 Stream 产生值的方法叫作及早求值方法。

由于使用了惰性求值，没有输出艺术家的名字

allArtists.stream().filter(artist -> {
System.out.println(artist.getName());
return artist.isFrom("London");
});

如果将同样的输出语句加入一个拥有终止操作的流，就会输出艺术家的名字：

long count = allArtists.stream()
.filter(artist -> {
System.out.println(artist.getName());
return artist.isFrom("London");
})
.count();

2.of()方法
Stream 的 of 方法使用一组初始值生成新的 Stream 。

List<String> strList = Stream.of("a","b","c").collect(Collectors.toList());

3. collect()方法
collect(toList()) 方法由 Stream 里的值生成一个列表，是一个及早求值操作。

List<String> strList = Stream.of("a","b","c").collect(Collectors.toList());

strList.stream().collect(Collectors.joining(","))

4.map方法
如果有一个函数可以将一种类型的值转换成另外一种类型， map 操作就可以
使用该函数，将一个流中的值转换成一个新的流。

List<String> collected = Stream.of("a", "b", "hello")
.map(string -> string.toUpperCase()) ?
.collect(toList());

5.max和min方法
Stream 上常用的操作之一是求最大值和最小值。 Stream API 中的 max 和 min 操作足以解决这一问题。

List<Track> tracks = asList(new Track("Bakai", 524),
new Track("Violets for Your Furs", 378),
new Track("Time Was", 451));
Track shortestTrack = tracks.stream()
.min(Comparator.comparing(track -> track.getLength()))
.get();
assertEquals(tracks.get(1), shortestTrack);