Java8 Stream

Stream

Stream是元素的集合，將集合數據以流的形式表現出來，以便對其進行操作，各種操作不改變數據源，不存儲值，一旦遍歷就會失效，需要重新創建。
一，Stream流的創建：需要API 24
1.創建串行流

Stream stream = mList.stream();
stream1.sequential();

2.創建並行流

Stream stream1 = mList.parallelStream();
stream.parallel();

3.靜態of方法創建

Stream integerStream = Stream.of(1, 2, 3, 5);
Stream stringStream = Stream.of("taobao");

4.Arrays創建

Arrays.stream(T[] arrays);

5.BufferedReader創建

mBufferedReader.lines();

6.Random創建隨機int流

random.ints();
random.ints(long streamSize);

二，流操作符

	@SuppressWarnings("unchecked")
    @TargetApi(24)
    private void init(){
        Stream stream = mList.stream();
        //是否全部滿足給定條件
        stream.allMatch(Predicate);
        //任意一個滿足給定條件
        stream.anyMatch(Predicate);
        //把stream管道中的結果集裝進一個List集合
        stream.collect(new Collector() {
            @Override
            public Supplier supplier() {
                //給出值T
                return null;
            }
            @Override
            public BiConsumer accumulator() {
                //對T進行變換得到R
                return null;
            }
            @Override
            public BinaryOperator combiner() {
                //將對各R聯合得result
                return null;
            }
            @Override
            public Function finisher() {
                //再對result進行操作
                return null;
            }
            @Override
            public Set<Characteristics> characteristics() {
                //內部枚舉類型，存儲本對象是否併發、是否無序、finisher是否出入參類型一致等信息
                return null;
            }
        });

        stream.collect(Collectors.toCollection(new Supplier() {
            @Override
            public Object get() {
                return null;
            }
        }));
        //返回List<Object>
        stream.collect(Collectors.toList());
        //返回Set<Object>
        stream.collect(Collectors.toSet());
        //去重
        stream.distinct();
        //對每個數據進行消費
        stream.forEach(Consumer);
        stream.forEachOrdered(Consumer);
        //過濾掉不滿足條件的數據
        stream.filter(Predicate);
        //對數據並行的進行函數變換,返回對應數據類型數據流
        stream.flatMap(Function);
        stream.flatMapToDouble(Function);
        stream.flatMapToInt(Function);
        stream.flatMapToLong(Function);
        //流轉換爲Iterator
        stream.iterator();
        //是否是並行流
        stream.isParallel();
        //截取流爲limit長度
        stream.limit(long limit);
        //對數據進行變換操作
        stream.map(Function);
        //轉換爲Double類型數據
        stream.mapToDouble(new ToDoubleFunction() {
            @Override
            public double applyAsDouble(Object o) {
                return 0;
            }
        });
        stream.mapToInt(ToIntFunction);
        stream.mapToLong(ToLongFunction);
        //比較前後兩項數據，返回最大者
        stream.max(new Comparator() {
            @Override
            public int compare(Object o, Object t1) {
                return 0;
            }
        });
        stream.min(Comparator);
        //是否不滿足給定條件
        stream.noneMatch(Predicate);
        //串行流轉換爲並行流
        stream.parallel();
        //生成一個包含原Stream的所有元素的新Stream，新Stream每個元素被消費的時候都會執行給定的消費函數；
        stream.peek(Consumer);
        //
        stream.reduce(new BinaryOperator() {
            @Override
            public Object apply(Object o, Object o2) {
                return null;
            }
        });
        //並行流轉爲串行流
        stream.sequential();
        //丟棄錢skip項數據
        stream.skip(long skip);
        //排序
        stream.sorted();
        //比較前後兩項數據
        stream.sorted(new Comparator() {
            @Override
            public int compare(Object o, Object t1) {
                return 0;
            }
        });
        //返回BaseStream
        stream.unordered();
    }

三，Stream接口
1.Function<T，R> 函數式接口
其定義的方法：

		/** 對數據var1進行函數變換，得到R */
        R apply(T var1);

        /** 第一時間執行裏面的函數before，優先於applay */
        Function<V, R> compose(Function<V,T> before) {}

        /** 對apply的結果進一步操作 */
        Function<T, V> andThen(Function<R,V> after) {}

        /** 返回傳入參數 */
        Function<T, T> identity() {}

2.Predicate 條件接口
其定義的方法：

 		//對數據var1進行測試，是否滿足給定條件
        boolean test(T var1);
        //且，同時得滿足的條件返回true
        Predicate<T> and(Predicate<T> other) {}
        //非，不滿足給定條件
        Predicate<T> negate() {}
        //或，或者滿足給定條件，返回true
        Predicate<T> or(Predicate<? super T> other) {}
        //是否和target相等
        Predicate<T> isEqual(Object target) {}

3.Consumer 消費數據接口

public interface Consumer<T> {
	//接受到數據var
    void accept(T var1);
}

4.Supplier

@FunctionalInterface
public interface Supplier<T> {
	//在get中返回數據
    T get();
}

Supplier supplier = new Supplier() {
            @Override
            public Object get() {
                return Arrays.asList(1,2,3);
            }
        };
List<Integer> mlist = (List<Integer>)supplier.get();