java8 stream流API笔记

 即将踏入职场，务必提高自己的代码质量，于是乎再温习了一遍stream流的API调用。

// 对象实体类
public class User {
    private String name;
    private long id;
    private int age;

    public String getName() {
        return name;
    }

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

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public User(String name, long id, int age) {
        this.name = name;
        this.id = id;
        this.age = age;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id == user.id &&
                age == user.age &&
                Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, id, age);
    }
}

 API代码笔记：

public class StreamAPI1 {
    /**
     * 三步骤
     * 1、创建stream
     * 2、中间操作
     * 3、终止操作
     */

    //一、获取流的方式
    @Test
    public void test1() {
        //1、通过Collection系列集合提供的stream（）或parallelStream()
        List<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();

        //2、通过Arrays中的静态方法stream（）获取数组流
        User[] users = new User[10];
        Stream<User> stream1 = Arrays.stream(users);

        //3、通过Stream的of静态方法
        Stream<String> stream2 = Stream.of("yuec", "1998");

        //4、创建无限流
        Stream.iterate(0, x -> x + 2).forEach(System.out::println);
        Stream.generate(() -> Math.random()).limit(5).forEach(System.out::println);

    }

    //二、中间操作
    List<User> users = Arrays.asList(
            new User("A1", 1111, 16),
            new User("A2", 2222, 17),
            new User("A3", 3333, 18),
            new User("A4", 44444, 19),
            new User("A4", 44444, 19),
            new User("A4", 44444, 19)
    );

    @Test
    public void test2() {
        //------------------------------筛选与切片--------------------------------------
        //1、filter---结束lambda，从流中排除某些元素
        users.stream().filter(u -> u.getAge() < 18).forEach(System.out::println);
        System.out.println();
        /**
         * User{name='A1', id=1111, age=16}
         * User{name='A2', id=2222, age=17}
         */

        //2、limit---截断流，使其元素不超过给定数量
        users.stream().limit(2).forEach(System.out::println);
        System.out.println();
        /**
         * User{name='A1', id=1111, age=16}
         * User{name='A2', id=2222, age=17}
         */

        //3、skip---跳过元素，返回一个人掉了前n个元素的流。如六种元素不足n个，则放回一个空流。与limit（n）互补
        users.stream().skip(2).forEach(System.out::println);
        System.out.println();
        /**
         *User{name='A3', id=3333, age=18}
         * User{name='A4', id=44444, age=19}
         * User{name='A4', id=44444, age=19}
         * User{name='A4', id=44444, age=19}
         */

        //4、distinct---筛选，通过流所生成元素的hashCode（）和equals()去除重复元素###需要重写hashCode和equals
        users.stream().distinct().forEach(System.out::println);
        System.out.println();
        /**
         * User{name='A1', id=1111, age=16}
         * User{name='A2', id=2222, age=17}
         * User{name='A3', id=3333, age=18}
         * User{name='A4', id=44444, age=19}
         */

        //------------------------------筛选与切片--------------------------------------

        //------------------------------映射map--------------------------------------
        //1、map---接收lambda，将元素转换接收成其他形式或提取信息。接收一个函数作为参数，该行数会被应用到每个元素上，并将其映射成一个心的元素
        List<String> list = Arrays.asList("aaa", "bbb", "ccc");
        list.stream().map((x) -> x.toUpperCase()).forEach(System.out::println);
        System.out.println();
        /**
         * AAA
         * BBB
         * CCC
         */
        users.stream().distinct().map(User::getName).forEach(System.out::println);
        System.out.println();
        /**
         * A1
         * A2
         * A3
         * A4
         */

        //2、flatMap---接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
        list.stream().flatMap(StreamAPI1::filterCharacter).forEach(System.out::println);
        /**
         * a
         * a
         * a
         * b
         * b
         * b
         * c
         * c
         * c
         */
        //------------------------------映射map--------------------------------------

        //------------------------------排序--------------------------------------
        users.stream().sorted((o1, o2) -> -(o1.getAge() - o2.getAge())).forEach(System.out::println);
        /**
         * User{name='A4', id=44444, age=19}
         * User{name='A4', id=44444, age=19}
         * User{name='A4', id=44444, age=19}
         * User{name='A3', id=3333, age=18}
         * User{name='A2', id=2222, age=17}
         * User{name='A1', id=1111, age=16}
         */
        //------------------------------排序--------------------------------------


    }

    //此方法传入字符串放回stream流，用于上面flatMap()的API
    public static Stream<Character> filterCharacter(String str) {
        List<Character> list = new ArrayList<>();
        for (Character ch : str.toCharArray()) {
            list.add(ch);
        }
        return list.stream();
    }


    //3、终止操作
    @Test
    public void test3() {
        //allMatch---检查是否匹配所有的元素，返回值boolean类型
        boolean flag = users.stream().allMatch(u -> u.getAge() > 14);
        System.out.println(flag);//true

        //anyMatch---检查是否至少匹配一个的元素，返回值boolean类型
        boolean flag2 = users.stream().anyMatch(u -> u.getAge() > 18);
        System.out.println(flag2);//true

        //noneMatch---检查是否没有匹配所有的元素(即，存在有匹配的元素)，返回值boolean类型
        boolean flag3 = users.stream().anyMatch(u -> u.getAge() > 18);
        System.out.println(flag3);//true

        //findFirst---返回第一个元素，返回值User类型
        Optional<User> first = users.stream().sorted((o1, o2) -> o2.getAge() - o1.getAge()).findFirst();
        System.out.println(first.get());//User{name='A4', id=44444, age=19}

        //count---返回当前流的个数
        long count = users.stream().count();
        System.out.println(count);//6

        //max---返回流中最大值
        Optional<User> max = users.stream().max((o1, o2) -> Integer.compare(o1.getAge(), o2.getAge()));
        System.out.println(max.get());//User{name='A4', id=44444, age=19}

        //max---返回流中最大值
        Optional<User> min = users.stream().min((o1, o2) -> Integer.compare(o1.getAge(), o2.getAge()));
        System.out.println(min.get());//User{name='A1', id=1111, age=16}

        //reduce---规约，参数一起始值，参数二lambda
        //第一次x是初始值，y是list第一个值，往后每次取list下一个值作为y计算后赋值给x
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer sum = list.stream().reduce(0, (x, y) -> x + y);
        System.out.println(sum);//55
        Integer ageSum = users.stream().map(User::getAge).reduce(0, (x, y) -> x + y);
        System.out.println(ageSum);//108

        //collect---收集，将流转换为其他形式。接受一个Collector接口的实现，用于给Stream中元素做汇总的方法
        List<String> collect = users.stream().map(User::getName).collect(Collectors.toList());
        System.out.println(collect);//[A1, A2, A3, A4, A4, A4]

        Double collect1 = users.stream().collect(Collectors.averagingInt(User::getAge));
        System.out.println(collect1);//18.0

        Integer sumAge = users.stream().collect(Collectors.summingInt(User::getAge));
        System.out.println(sumAge);//108

        Optional<User> collect2 = users.stream().collect(Collectors.maxBy((o1, o2) -> Integer.compare(o1.getAge(), o2.getAge())));
        System.out.println(collect2.get());//User{name='A4', id=44444, age=19}

    }


}