Java8 Stream API学习笔记，只看一文成为Lambda表达式、Stream API编写熟手，直接拷贝过去运行即可

package cn.cuit.testa0;


import static java.util.stream.Collectors.averagingDouble;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Random;
import java.util.Set;
import java.util.Spliterator;
import java.util.Stack;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.IntPredicate;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import org.junit.Before;
import org.junit.Test;

import com.google.common.collect.ContiguousSet;
import com.google.common.collect.DiscreteDomain;
import com.google.common.collect.Range;


/**
 * 参考文章： 搜索java Stream API查看更多文章
 * https://www.cnblogs.com/CarpenterLee/p/6545321.html
 * https://www.cnblogs.com/CarpenterLee/p/6550212.html
 * https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/index.html
 * 
 * 
 * 当把一个数据结构包装成 Stream 后，就要开始对里面的元素进行各类操作了。常见的操作可以归类如下。
 * 
 * Intermediate中间操作： map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、
 * limit、 skip、 parallel、 sequential、 unordered
 * 
 * Terminal终结操作： forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、
 * count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator
 * 
 * Short-circuiting短路操作： anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、
 * limit
 * 
 * java8 四大核心函数式接口Function、Consumer、Supplier、Predicate
 * https://blog.csdn.net/smithallenyu/article/details/80653897
 * 
 * Function
 * 
 * T：入参类型，R：出参类型
 * 
 * 调用方法：R apply(T t);
 * 
 * 定义函数示例：Function func = p -> p * 10; // 输出入参的10倍
 * 
 * 调用函数示例：func.apply(10); // 结果100
 * 
 * Consumer
 * 
 * T：入参类型；没有出参
 * 
 * 调用方法：void accept(T t);
 * 
 * 定义函数示例：Consumer consumer= p -> System.out.println(p); //
 * 因为没有出参，常用于打印、发送短信等消费动作
 * 
 * 调用函数示例：consumer.accept("18800008888");
 * 
 * Supplier
 * 
 * T：出参类型；没有入参
 * 
 * 调用方法：T get();
 * 
 * 定义函数示例：Supplier supplier= () -> 100; //
 * 常用于业务“有条件运行”时，符合条件再调用获取结果的应用场景；运行结果须提前定义，但不运行。
 * 
 * 调用函数示例：supplier.get();
 * 
 * Predicate
 * 
 * T：入参类型；出参类型是Boolean, 所以Boolean表达式就用这个函数式接口
 * 
 * 调用方法：boolean test(T t);
 * 
 * 定义函数示例：Predicate predicate = p -> p % 2 == 0; // 判断是否、是不是偶数
 * 
 * 调用函数示例：predicate.test(100); // 运行结果true
 * 
 * Collector接受三个泛型参数，对可变减少操作的数据类型作相应限制：
 * 
 * T：输入元素类型 A：缩减操作的可变累积类型（通常隐藏为实现细节） R：可变减少操作的结果类型
 * 
 * UnaryOperator UnaryOperator 接收T对象，返回T对象，是Function的特例化，本质上也是Function型的函数式接口
 * 
 * BinaryOperator BinaryOperator 接收两个T对象，返回T对象
 * 
 * 原则：遇到操作或者生产集合类型及数组容器，都可以想到可以使用Stream操作，并非要刻意去使用，简 单易懂的代码才是好代码
 */
public class Java8StreanAPI
{

    // @Test
    // public void testTakeWhileAndDropWhile() {
    /**
     * 从Stream中依次获取满足条件的元素，直到不满足条件为止结束获取
     * 
     * 举例：Stream中的元素 12, 4, 3, 6, 8, 9
     * 
     * 条件是 x -> x % 2 == 0 ，即判断是否为偶数，即当遇到元素不为偶数时终止获取
     * 
     * 那么得到的结果输出就是，12, 4 因为下一个元素为3不为偶数，即结束获取，丢弃后面的其他元素
     */
    // IntStream.of(12,4,3,6,8,9).takeWhile(x->x%2==0).forEach(System.out::print);

    /**
     * 从Stream中依次删除满足条件的元素，直到不满足条件为止结束删除
     * 
     * 举例：Stream中的元素 12, 4, 3, 6, 8, 9
     * 
     * 条件是 x -> x % 2 == 0 ，即判断是否为偶数，即当遇到元素不为偶数时终止删除
     * 
     * 那么得到的结果输出就是，3, 6, 8, 9 因为下一个元素为3不为偶数，即结束删除，返回3及以后剩下的所有元素
     */
    // IntStream.of(12,4,3,6,8,9).dropWhile(x->x%2==0).forEach(System.out::print);
    // }

    // public void testIO(String source, String target) {
    // Java7后自动关闭流，把需要关闭的资源声明再try的小括号里,Java10后的类型推断var
    // try (var in = new FileInputStream(source); var out = new
    // FileOutputStream(target)) {
    // Java9后，文件复制
    // in.transferTo(out);
    // } catch (Exception e) {
    // e.printStackTrace();
    // }
    // }

    /**
     * 改进的 Stream API
     * 
     * 在 Java 9 中它会变得更好。Stream 接口中添加了 4 个新的方法：dropWhile, takeWhile, ofNullable。还有个
     * iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代
     * 
     * Optional 和 Stream 之间的结合也得到了改进。现在可以通过 Optional 的新方法 stram将一个 Optional
     * 对象转换为一个(可能是空的) Stream 对象,在组合复杂的 Stream 管道时，将 Optional 转换为 Stream 非常有用。
     */
    @Test
    public void test03()
    {
        // 向控制台打印 1 到 99
        // IntStream.iterate(1, i -> i < 100, i -> i + 1).forEach(System.out::println);
        // Optional转换为Stream
        // Stream s = Optional.of(1).stream();
        // s.forEach(System.out::println);
    }

    public static List transactions = new ArrayList<>();

    public static Transaction transaction = null;
    static
    {
        for (int i = 0; i < 10; i++ )
        {
            if (new Random().nextBoolean())
            {
                transaction = new Transaction(i, "JAVA8", "JDK8-Stream");
                transactions.add(transaction);
            }
            else
            {
                transaction = new Transaction(i, "JAVA7", "JDK7-Non-Stream");
                transactions.add(transaction);
            }
        }
    }

    /**
     * 在 Java 7 中，如果要发现 type 为 grocery 的所有Transaction，然后返回以Transaction降序排序好的交易 ID
     * 集合，我们需要这样写：
     */
    @SuppressWarnings({"unchecked", "rawtypes"})
    @Test
    public void testInJ7()
    {
        List groceryTransactions = new ArrayList<>();
        for (Transaction t : transactions)
        {
            if (t.getType() == Transaction.GROCERY)
            {
                groceryTransactions.add(t);
            }
        }

        Collections.sort(groceryTransactions, new Comparator()
        {
            public int compare(Object t1, Object t2)
            {
                return ((Transaction)t2).getValue().compareTo(((Transaction)t1).getValue());
            }
        });

        List transactionsIds = new ArrayList<>();
        for (Transaction t : groceryTransactions)
        {
            transactionsIds.add(t.getId());
        }

        transactionsIds.forEach(System.out::print);

    }

    /**
     * 对比上面的Java 7代码，在 Java 8 中，使用Stream API首先不说其他的，代码量就少了一般，而且看起来也更加优雅,默认升序
     */
    @Test
    public void testInJ8()
    {
        List transactionsIds = transactions.parallelStream().filter(t -> t.getType() == Transaction.GROCERY).sorted(
            Comparator.comparing(Transaction::getValue).reversed()).map(Transaction::getId).collect(Collectors.toList());

        transactionsIds.forEach(System.out::print);

        transactions.stream().filter(e -> e != null).filter(e -> e.getId() == 1).findAny().get();
        transactions.stream().filter(Objects::nonNull).filter(Java8StreanAPI.idIs1()).findAny().get();
        transactions.stream().filter(Objects::nonNull).filter(Java8StreanAPI::idIs101).findAny().get();
    }

    public static Predicate idIs1()
    {
        return e -> e.getId() == 1;
    }

    public static boolean idIs101(Transaction e)
    {
        return e.getId() == 1;
    }

    /* 构造流的方式很多，下面是的几种常见方法 */
    @SuppressWarnings({"unused", "rawtypes"})
    @Test
    public void testCreateStream()
    {
        // 1. Individual values
        Stream stream = Stream.of("a", "b", "c");

        // 2. Arrays
        String[] strArray = new String[] {"a", "b", "c"};
        stream = Stream.of(strArray);

        stream = Arrays.stream(strArray);

        // 3. Collections
        List list = Arrays.asList(strArray);
        stream = list.stream();

        // 需要注意的是，对于基本数值型，目前有三种对应的包装类型 Stream：
        // IntStream、LongStream、DoubleStream
        // 数值流的构造
        IntStream.of(new int[] {1, 2, 3}).forEach(System.out::println);
        IntStream.range(1, 3).forEach(System.out::println);
        IntStream.rangeClosed(1, 3).forEach(System.out::println);

        // 流转换为其它数据结构
        // 一个 Stream 只可以使用一次，下面的代码为了简洁而重复使用了数次
        // 1. Array
        String[] strArray1 = (String[])stream.toArray(String[]::new);

        // 2. Collection
        List list1 = (List)stream.collect(Collectors.toList());
        List list2 = (List)stream.collect(Collectors.toCollection(ArrayList::new));
        Set set1 = (Set)stream.collect(Collectors.toSet());
        Stack stack1 = (Stack)stream.collect(Collectors.toCollection(Stack::new));

        // 3. String
        String str = stream.collect(Collectors.joining()).toString();
    }

    @SuppressWarnings("unused")
    @Test
    public void testMapWithFlatMap()
    {
        List nums = Arrays.asList(1, 2, 3, 4);
        List squareNums = nums.stream().map(n -> n * n).collect(Collectors.toList());

        squareNums.forEach(System.out::print);

        // 一对多,flatMap 把 input Stream 中的层级结构扁平化【就是把多个集合整合成一个集合】，就是将最底层元素抽出来放到一起，最终
        // output 的新 Stream
        // 里面已经没有 List 了，都是直接的数字。
        /**
         * Stream -> flatMap -> Stream 

         * Stream> -> flatMap -> Stream 

         * Stream> -> flatMap -> Stream 

         * Stream> -> flatMap -> Stream