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
         */
    }
}

创建Stream：

/**
 * @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);
        //limit 与 skip 配合分页
        List<Integer> list1 = Stream.iterate(1,x -> x+1).limit(50).sorted((a,b) -> b-a).skip(0).limit(10).collect(Collectors.toList());
        System.out.println(list1);//[50, 49, 48, 47, 46, 45, 44, 43, 42, 41]
        List<Integer> list3 = Stream.iterate(1,x -> x+1).limit(50).sorted((a,b) -> b-a).skip(10).limit(10).collect(Collectors.toList());
        System.out.println(list3);//[40, 39, 38, 37, 36, 35, 34, 33, 32, 31] 通过skip个数实现分页

        //转换
        String s = "11,22,33,44,55";//先通过逗号分割转换成int数组，再相加
        String[] split = s.split(",");
        Integer sum1 = Stream.of(split).map(x -> Integer.valueOf(x)).mapToInt(x->x).sum();//转换成int数组
        System.out.println(sum1);//
        Integer sumStream = Stream.of(s.split(",")).mapToInt(x->Integer.valueOf(x)).sum();//转换成int数组
        System.out.println(sumStream);//165
        //改写成方法的引用
        Integer sum2 = Stream.of(s.split(",")).mapToInt(Integer::valueOf).sum();
        System.out.println(sum2);//165

        //将字符串转成User对象
        String userString = "admin,nginx,apache,jetty";
        //User{name='admin'}
        //User{name='nginx'}
        //User{name='apache'}
        //User{name='jetty'}
        Stream.of(userString.split(",")).map(x -> new User(x)).forEach(System.out::println);//有构造方法
        Stream.of(userString.split(",")).map(x->Person.build(x)).forEach(System.out::println);
        Stream.of(userString.split(",")).map(Person::build).forEach(System.out::println);//静态方法引用
        //peek ：中间操作时，在内部遍历的时候会调用consume去消费(在内部转换的时候去调用内部方法)
        //求和例子
        //会依从输出
        //11
        //22
        //33
        //44
        //
        Integer sum4 = Stream.of("11,22,33,44,55".split(",")).peek(System.out::println).mapToInt(Integer::valueOf).sum();
    }
}

class User{
    private String name;
    public User(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Person{
    private String name;
    public static Person build(String name){
        Person p = new Person();
        p.setName(name);
        return p;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}