Java Stream流對象的使用案例

1. Stream流對象介紹 

java.util.stream.Stream<T>;是JDK8新加入的最常用的流接口

常用的獲取流的方式
（1）所有的Collection集合都可以通過stream默認方法獲取流；
     default Stream<E> stream();
 (2)Stream接口的靜態方法of可以獲取數組對應的流
     static <T> Stream<T> of(T... value);
     參數是一個可變參數，那麼我們就可以傳遞一個數組。
Stream流的屬於管道流，只能被使用一次，第一個Stream流調用完畢以後數據就會流向下一個Stream上，此時第一個Stream流已經關閉，不能在使用第一個Stream流調用方法

Stream流的常用方法：延遲方法返回是一個流，仍然可以調用流的方法，
 (1)filter();延遲方法，用於過濾流中的元素，返回的還是一個流。
     源碼：Stream<T> filter(Predicate<? super T> predicate);
 (2)forEach();延遲方法，用於循環輸出流中的元素
     源碼：void forEach(Consumer<? super T> action);
 (3)count();用於統計Stream流中元素的個數，返回值是一個long類型的數據
 (4)limit();延遲方法，對流中的元素進行截取，返回的還是一個流，所以可以繼續調用其他Stream流的方法
     源碼：Stream<T> limit(long maxSize);
 (5)skip();延遲方法，希望跳過前n個元素，獲取n元素之後元素形成一個新流。
     源碼：Stream<T> skip(long n);
 (6)concat();延遲方法，把兩個流組合在一起，形成一個新的流
     源碼：
     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));
    }

2.案例

    public static void main(String[] args) {
        Stream<String> stream = Stream.of("1", "2", "3", "4", "5");

        //map方法案例
        /*stream.map(str-> Integer.valueOf(str))//map方法中傳入的是Function函數式接口，實現數據類型轉換，該接口中的抽象方法是apply方法，用於數據類型轉換
                .forEach(s-> System.out.println(s));結果：1 2 3 4 5 */

        //count方法案例
        /*long count = stream.count();
        System.out.println(count);//結果：5*/

        //limit方法案例
        /*Stream<String> stream2 = stream.limit(3);
        stream2.forEach(s-> System.out.println(s));//結果：1 2 3*/

        //skip方法案例
       /* Stream<String> stream3 = stream.skip(3);
        stream3.forEach(s-> System.out.println(s));//結果：4 5*/

       //concat方法案例
        /*Stream<String> stream4 = Stream.of("a", "b", "v", "b");
        Stream<String> stream5 = Stream.concat(stream, stream4);
        stream5.forEach(s-> System.out.println(s));//1 2 3 4 5 a b v b*/
    }

3. 對list集合的優化

（1）原代碼:

//獲取list集合中，元素包含a,且長度爲3的元素，並打印
public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("AAA");
        list.add("ABB");
        list.add("Bcc");
        list.add("CsA");

        List<String> listA = new ArrayList<>();
        for (String s : list) {
            if(s.contains("A")){
                listA.add(s);
            }
        }

        List<String> listB = new ArrayList<>();
        for (String s : listA) {
            if(s.length()==3){
                listB.add(s);
            }

        }

        for (String s : listB) {
            System.out.println(s);

        }
    }

（2）優化代碼：

   //使用stream流對集合遍歷進行優化
   public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("AAA");
        list.add("ABB");
        list.add("Bcc");
        list.add("CsA");

        list.stream().filter(s -> s.contains("A"))//該方法中傳入的是一個Predicate函數式接口，實現過濾，接口中的抽象方法爲test方法，用於判斷
                     .filter(s->s.length()==3)
                     .forEach(s->System.out.println(s));//該方法中傳入的是一個Consumer函數式接口，實現循環，該接口中的抽象方法是accept方法，用於消費
    }