Java8 Stream的深入學習

package com.lgx.jdk8.part02;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * Stream的使用介紹
 */
public class Test04Stream {
    public static void main(String[] args) {
        //創建流的幾種方式
        Stream stream1 = Stream.of("hello", "world", "hello world");

        String[] myArray = new String[]{"hello", "world", "hello world"};
        Stream stream2 = Stream.of(myArray);

        Stream stream3 = Arrays.stream(myArray);

        List<String> myList = Arrays.asList("hello", "world", "hello world");
        Stream stream4 = myList.stream();

        System.out.println("------------------------");

        //IntStream的使用
        IntStream.of(new int[]{3,4,5,6,7}).forEach(System.out::print);System.out.println();
        IntStream.range(3,8).forEach(System.out::print);System.out.println();
        IntStream.rangeClosed(3,7).forEach(System.out::print);System.out.println();

        System.out.println("------------------------");

        //每個數乘以2再求和
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);
        //傳統寫法
        /*int sum = 0;
        for(Integer integer: list){
            sum += integer*2;
        }
        System.out.println("sum = [" + sum + "]");*/
        //jdk8寫法
        System.out.println("sum = [" + list.stream().map(i -> i*2).reduce(0, Integer::sum) + "]");

        //流轉換成集合，再遍歷
        Stream<String> streams = Stream.of("hello", "world", "hello world");
        /*String[] strArray = streams.toArray(length -> new String[length]);
        Arrays.asList(strArray).forEach(System.out::println);*/

        //用方法引用來寫
        /*String[] strArray2 = streams.toArray(String[]::new);
        Arrays.asList(strArray2).forEach(System.out::println);*/

        //用collect(),另外方法來寫
        /*List<String> strList = streams.collect(() -> new ArrayList(), (theList, item) -> theList.add(item),
                (theList1, theList2) -> theList1.addAll(theList2));
        strList.forEach(System.out::println);*/

        //用collect(),參數方法引用來寫
        /*List<String> strList2 = streams.collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
        strList2.forEach(System.out::println);*/

        //用collect()配合Collectors.toList()來寫
        /*List<String> strList3 = streams.collect(Collectors.toList());
        strList3.forEach(System.out::println);*/

        //用collect()配合Collectors.toCollection來寫,可以指定類型：如ArrayList,LinkList等
        /*List<String> strList4 = streams.collect(Collectors.toCollection(ArrayList::new));
        strList4.forEach(System.out::println);*/

        //轉換成set
        /*Set<String> set = streams.collect(Collectors.toSet());
        set.forEach(System.out::println);
        System.out.println("set type = [" + set.getClass() + "]");*/

        //轉換成set,指定類型
        /*Set<String> set = streams.collect(Collectors.toCollection(TreeSet::new));
        set.forEach(System.out::println);
        System.out.println("set type = [" + set.getClass() + "]");*/

        //拼接
        /*String str = streams.collect(Collectors.joining());
        System.out.println("拼接str=" + str);*/
        /*String str = streams.collect(Collectors.joining(", "));
        System.out.println("拼接str2=" + str);*/
        /*String str = streams.collect(Collectors.joining(", ", "[", "]"));
        System.out.println("拼接str3=" + str);*/

        //過濾，將每個參數由小寫變成大寫，map函數就是映射，針對每一個元素
        List<String> list2 = Arrays.asList("hello", "world", "hello world");
        list2.stream().map(String::toUpperCase).collect(Collectors.toList()).forEach(System.out::println);

        //過濾，將每個參數變成之前的平方
        List<Integer> list3 = Arrays.asList(2,3,4,5);
        list3.stream().map(item -> item * item).collect(Collectors.toList()).forEach(System.out::println);

        System.out.println("==========================");

        //flatMap操作,扁平化map，會將裏面的集合元素,合併到一個集合
        Stream<List<Integer>> stream5 = Stream.of(Arrays.asList(1,2,3), Arrays.asList(13,14), Arrays.asList(25,26,27));
        stream5.flatMap(theList -> theList.stream()).map(item -> item * item).forEach(System.out::println);

        /**
         * generate方法使用
         * findFirst之所以返回一個Optional,是因爲避免NPE(空指針異常)，因爲可能一個都沒找到
         */
        Stream<String> stream6 = Stream.generate(UUID.randomUUID()::toString);
        stream6.findFirst().ifPresent(System.out::println);

        //iterate方法使用
        Stream.iterate(1, item -> item + 2).limit(10).forEach(System.out::println);

        //找出上面那個流中大於2的元素，然後將每個元素乘以3，然後忽略掉前4個元素，然後再取出流中的前5個元素，最後求出流中元素的總和
        //mapToInt是map的一個具化，省去類型轉換，skip標示忽略掉前幾個元素，limit是取幾個元素
        Stream<Integer> stream7 = Stream.iterate(1, item -> item + 2).limit(10);
        /*int sum = stream7.filter(item -> item > 2).mapToInt(item -> item * 3).skip(4).limit(5).sum();
        System.out.println("sum=" + sum);*/

        //如果是求最大值
        /*OptionalInt max = stream7.filter(item -> item > 2).mapToInt(item -> item * 3).skip(4).limit(5).max();
        max.ifPresent(System.out::print);*/

        //如果我們又想求總和，或者最大值，最小值，平均值，個數之類的應該怎麼寫呢
        //summaryStatistics是總結統計的，是一個終止操作
        IntSummaryStatistics intSummaryStatistics = stream7.filter(item -> item > 2).mapToInt(item -> item * 3).skip(4).limit(5).summaryStatistics();
        System.out.println("sum = [" + intSummaryStatistics.getSum() + "]");
        System.out.println("max = [" + intSummaryStatistics.getMax() + "]");
        System.out.println("min = [" + intSummaryStatistics.getMin() + "]");
        System.out.println("ave = [" + intSummaryStatistics.getAverage() + "]");
        System.out.println("count = [" + intSummaryStatistics.getCount() + "]");

//Stream的使用陷阱

Stream<Integer> stream8 = Stream.iterate(1, item -> item + 2).limit(10);
        /*System.out.println("stream8 = " + stream8);
        System.out.println("stream8 = " + stream8.filter(item -> item > 2));
        System.out.println("stream8 = " + stream8.distinct());//distinct去重的作用*/
        //執行2個操作，會報錯，流一旦被關閉了就不能再去操作了，或者被操作了一次之後，在另外一個地方又重新去操作，

        //規避辦法如下，當然最好寫成鏈的形式
        System.out.println("stream8 = " + stream8);
        Stream<Integer> stream8_2 = stream8.filter(item -> item > 2);
        System.out.println("stream8_2 = " + stream8_2);
        Stream<Integer> stream8_3 = stream8_2.distinct();
        System.out.println("stream8_3 = " + stream8_3);

        List<String> list4 = Arrays.asList("hello", "world", "hello world");
        //正常打印
        //list4.stream().map(item -> item.substring(0, 1) + item.substring(2)).forEach(System.out::println);
        //啥都不打印，因爲沒有及早求值或者沒有終止操作
        /*list4.stream().map(item ->{
            String result = item.substring(0, 1) + item.substring(2);
            System.out.println("test-------");
            return result;
        });*/
        //依次打印一個test，再輸出一個元素
        /*list4.stream().map(item ->{
            String result = item.substring(0, 1) + item.substring(2);
            System.out.println("test-------");
            return result;
        }).forEach(System.out::println);*/

        //關於執行順序
        //IntStream.iterate(0, i -> (i+1)%2).limit(10).distinct().forEach(System.out::println);//limit已經定義了個數，再去重，就不會無限循環
        //IntStream.iterate(0, i -> (i+1)%2).distinct().limit(10).forEach(System.out::println);//無限循環，因爲distinct會一直等待前面的數字

}}