JAVA8 Stream API的使用

/**
 * @auther hhh
 * @date 2018/12/31 12:48
 * @description Stream流：用来处理数组、集合的API
 *      1、不是数据结构，没有内部存储（只是用来操作与处理）
 *      2、不支持索引访问
 *      3、延迟计算
 *      4、支持并行
 *      5、很容易生成数组或者集合
 *      5、支持过滤、查找、转换、汇总、聚合等操作
 *
 *      Stream分为    源source、中间操作、终止操作
 *      流的源可以是数组、集合、生成器方法，一个I/O通道等等
 *      一个流可以有零个或者多个中间操作，每一个中间操作都会放回一个新的流，供下个操作使用，一个流只会有一个终止操作
 *      Stream只有遇到终止操作，他的源才会执行遍历操作
 */
public class StreamTest {
    public static void main(String[] args) {
        /**
         * 中间操作API：
         *      过滤：filter
         *      去重：distinct
         *      排序：sorted
         *      截取：limit、skip
         *      转换：map/flatMap
         *      其他：peek
         */
        /**
         * 终止操作：
         *      循环：forEach
         *      计算：min/max/count/average
         *      匹配：anyMatch/allMatch/noneMatch/findFirst/findAny
         *      汇聚：reduce
         *      收集器：toArray/collect
         */
    }
}

/**
 * @auther hhh
 * @date 2018/12/31 13:08
 * @description Stream流的创建
 */
public class CreatedStreamTest {
    /**
     * 创建Stream：
     * 通过数组
     * 通过集合
     * 通过Stream.generate创建
     * 通过Stream.iterate方法创建
     * 其他API创建
     */
    //通过数组（一般都是使用集合和流进行创建是最多的）
    static void stringGen() {
        String[] arr = {"a", "b", "c", "12"};
        Stream<String> stringStream = Stream.of(arr);
    }
    //通过集合
    static void listGen() {
        List<String> lists = Arrays.asList("a", "b", "c", "12");
        Stream<String> stringStream = lists.stream();
    }
    //通过Stream.generate创建(使用 Supplier提供一个输出)
    //iterate与generate是无止境流，会一直调用函数式接口进行输出，可以进行截取
    static void generateGen() {
        Stream<Integer> stream = Stream.generate(() -> 1);
    }
    //通过Stream.iterate方法创建（通过UnaryOperator<T>提供输入输出,三个类型必须为一致）
    static void iterateGen() {
        Stream.iterate(1,(x) -> x+1).limit(10).forEach(x -> System.out.println(x));
        Stream.iterate("1",(x) -> x.toString()).limit(10).forEach(x -> System.out.println(x));;
    }
    //其他API创建
    static void otherGen() throws Exception{
        String s = "abcdefg";
        IntStream intStream = s.chars();//返回一个int类型的Stream
        //终止操作
        intStream.forEach(x -> System.out.println(x));
//        intStream.forEach(System.out::println);
        Files.lines(Paths.get("D:\\MyCode\\vaildating\\src\\main\\java\\com\\example\\vaildating\\VaildatingApplication.java")).forEach(x -> System.out.println(x));
    }
    public static void main(String[] args) throws Exception{
        iterateGen();
        otherGen();
    }
}

/**
 * @auther hhh
 * @date 2018/12/31 13:44
 * @description 中间操作API
 */
public class MiddleOperaStream {
    /**
     * 中间操作API：
     * 过滤：filter
     * 去重：distinct
     * 排序：sorted
     * 截取：limit、skip
     * 转换：map/flatMap
     * 其他：peek
     */
    public static void main(String[] args) throws Exception {
        List<Integer> list = Arrays.asList(2, 6, 1, 3, 7, 4, 8, 9);
        //创建流
        list.stream().filter(x -> x % 2 == 0).forEach(System.out::println);
        //中间操作与终止操作，终止操作只能有一个
        int sum = list.stream().filter(x -> x % 2 == 0).mapToInt(x -> x).sum();
        System.out.println(sum);
        //在进行最大值与最小值输出的时候，需要传入一个比较器
        int max = list.stream().max((a, b) -> a - b).get();
        int min = list.stream().min((a, b) -> a - b).get();
        System.out.println(max + "   " + min);
        //匹配终止操作
        //输出所有集合中的偶素，默认从小大大排序
        Optional<Integer> any = list.stream().filter(x -> x % 2 == 0).sorted().findFirst();
        //从大到小排序,传入一个比较器
        Optional<Integer> sorted = list.stream().filter(x -> x % 2 == 0).sorted((a,b)->b-a).findFirst();
        //传入升序比较器 Comparator.naturalOrder()
        Optional<Integer> sorted1 = list.stream().filter(x -> x % 2 == 0).sorted(Comparator.naturalOrder()).findFirst();
        //传入降序比较器 Comparator.reverseOrder()
        Optional<Integer> sorted2 = list.stream().filter(x -> x % 2 == 0).sorted(Comparator.reverseOrder()).findFirst();
        System.out.println(any.get() + "====" + sorted.get()+"==="+sorted1.get()+"==="+sorted2.get());//2====8===2===8
        Optional<Integer> first = list.stream().filter(x -> x % 2 == 0).findFirst();
        List<Integer> l= list.stream().sorted(Comparator.naturalOrder()).collect(Collectors.toList());
        List<Integer> ll = list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
        System.out.println(l+"==="+ll);//[1, 2, 3, 4, 6, 7, 8, 9]===[9, 8, 7, 6, 4, 3, 2, 1]
        //字符串根据长度进行排序
        List<String> stringList = Arrays.asList("abc","bc","a","cdef");
        List<String> stringList1 = stringList.stream().sorted().collect(Collectors.toList());
        List<String> stringList2 = stringList.stream().sorted((a,b)-> b.length()-a.length()).collect(Collectors.toList());
        System.out.println(stringList1+"==="+stringList2);//[a, abc, bc, cdef]===[cdef, abc, bc, a]
        //去重
        List<Integer> integerList = Arrays.asList(1,2,3,4,5,1,2,3);
        Set<Integer> integers = integerList.stream().collect(Collectors.toSet());//[1, 2, 3, 4, 5]
        System.out.println(integers);
    }
}