Java 8 常用Stream操作

Stream 常用API

准备一个简单用户类

/**
     * 用户类
     */
    static class User{
        /**
         * 姓名
         */
        String name;
        /**
         * 年龄
         */
        int age;
        /**
         * 是否是男性
         */
        Boolean isMan;

        public User(String name, int age, Boolean isMan) {
            this.name = name;
            this.age = age;
            this.isMan = isMan;
        }

        public String getName() {
            return name;
        }

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

        public int getAge() {
            return age;
        }

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

        public Boolean getMan() {
            return isMan;
        }

        public void setMan(Boolean man) {
            isMan = man;
        }
    }

获取stream对象

    public static void main(String[] args) {

	    //非集合
        String[] strArr = new String[]
                {
                        "a", "b", "c", "d",
                        "aa", "bb", "cc", "dd",
                        "aaa", "bbb", "ccc", "ddd"
                };
		//数组需要转换为集合
        Stream<String> stringStream = Stream.of(strArr);

		//fastJson JSONArray 实现了list接口可以直接使用stream
        JSONArray jsonArray = new JSONArray(Arrays.asList(strArr));
        Stream<Object> jsonArrStream = jsonArray.stream();

		//集合类型直接直接获取Stream对象
        LinkedList<String> linkedList = new LinkedList();
        Stream<String> linkedListStream = linkedList.stream();

    }

filter 过滤

		 //过滤出符合条件的
        public static void main(String[] args) {

            // 列一 过滤出值包含 ‘b’ 或者包含 ‘a’ 的元素
            List<String> stringList = Arrays.asList(
                    "a", "b", "c", "d",
                    "aa", "bb", "cc", "dd",
                    "aaa", "bbb", "ccc", "ddd"
            );

            List<String> containBOrA = stringList
                    .stream()
                    .filter(str -> str.contains("b") || str.contains("a"))
                    .collect(Collectors.toList());
            System.out.println("containBOrA = " + containBOrA);
            // 输出结果 containB = [a, b, aa, bb, aaa, bbb]

            // 例子二 过滤出年龄大于 >18 的男性用户
            List<User> users = Arrays.asList(
            //      new User(名字, 年龄, 是否是男性),
                    new User("张三", 34, Boolean.TRUE),
                    new User("李红", 14, Boolean.FALSE),
                    new User("小明", 17, Boolean.TRUE),
                    new User("黄忠", 20, Boolean.TRUE),
                    new User("吕布", 28, Boolean.TRUE),
                    new User("貂蝉", 18, Boolean.FALSE)
            );

            List<User> collect = users
                    .stream()
                    .filter(user ->
                        user.getAge() > 18 && user.getMan())
                    .collect(Collectors.toList());

            collect.forEach(user -> System.out.println("user = " + user));
			// 打印结果
			// user = User{name='张三', age=34, isMan=true}
			// user = User{name='黄忠', age=20, isMan=true}
			// user = User{name='吕布', age=28, isMan=true}
        }

map 映射

        // map()方法用于映射每个元素到对应的结果
        public static void main(String[] args) {
            List<User> users = Arrays.asList(
                    //      new User(名字, 年龄, 是否是男性),
                    new User("张三", 34, Boolean.TRUE),
                    new User("李红", 14, Boolean.FALSE),
                    new User("小明", 17, Boolean.TRUE),
                    new User("黄忠", 20, Boolean.TRUE),
                    new User("吕布", 28, Boolean.TRUE),
                    new User("貂蝉", 18, Boolean.FALSE)
            );

            // 例子 获取姓名集合
            List<String> names = users.
                    stream().
                    map(User::getName).//等同于 user-> user.getName()
                    collect(Collectors.toList());

            names.forEach(name-> System.out.println("name = " + name));
            // 打印结果
            // name = 张三
            // name = 李红
            // name = 小明
            // name = 黄忠
            // name = 吕布
            // name = 貂蝉
        }

groupingBy 分组

		// 根据对象的属性对集合中的元素分组并将分组
        public static void main(String[] args) {
            List<User> users = Arrays.asList(
                    //      new User(名字, 年龄, 是否是男性,部门ID),
                    new User("张飞", 34, Boolean.TRUE, 1),
                    new User("关羽", 14, Boolean.FALSE, 1),
                    new User("宋江", 17, Boolean.TRUE, 2),
                    new User("花和尚", 20, Boolean.TRUE, 2),
                    new User("孙悟空", 28, Boolean.TRUE, 3),
                    new User("白骨精", 18, Boolean.FALSE, 3)
            );
            //例子 根据部门分组 分组的属性值作为map中key
            java.util.Map<Integer, List<User>> groupByDeptIdMap = users.
                    stream().
                    collect(Collectors.groupingBy(User::getDept));
            
            //部门ID为1的
            List<User> dept1 = groupByDeptIdMap.get(1);
            //部门ID为2的
            List<User> dept2 = groupByDeptIdMap.get(2);
            //部门ID为3的
            List<User> dept3 = groupByDeptIdMap.get(3);

            System.out.println("部门1 用户dept1 = " + dept1);
            System.out.println("部门2 用户dept2 = " + dept2);
            System.out.println("部门3 用户dept3 = " + dept3);
            // 打印结果
            // 部门1 用户dept1 = [User{name='张飞', age=34, dept=1, isMan=true}, User{name='关羽', age=14, dept=1, isMan=false}]
            // 部门2 用户dept2 = [User{name='宋江', age=17, dept=2, isMan=true}, User{name='花和尚', age=20, dept=2, isMan=true}]
            // 部门3 用户dept3 = [User{name='孙悟空', age=28, dept=3, isMan=true}, User{name='白骨精', age=18, dept=3, isMan=false}]

        }

sorted 排序

// 对流进行排序
        public static void main(String[] args) {
            List<User> users = Arrays.asList(
                    //      new User(名字, 年龄, 是否是男性,部门ID),
                    new User("张飞", 34, Boolean.TRUE, 1),
                    new User("关羽", 14, Boolean.FALSE, 1),
                    new User("宋江", 17, Boolean.TRUE, 2),
                    new User("花和尚", 20, Boolean.TRUE, 2),
                    new User("孙悟空", 28, Boolean.TRUE, 3),
                    new User("白骨精", 18, Boolean.FALSE, 3)
            );

            // 例子 根据年龄降序
            List<User> sortedList = users.
                    stream().
                    // 升序 去掉.reversed()
                    sorted(Comparator.comparing(User::getAge).reversed())
                    .collect(Collectors.toList());
            sortedList.forEach(user -> System.out.println("user = " + user));
            // 输出结果
            // user = User{name='张飞', age=34, dept=1, isMan=true}
            // user = User{name='孙悟空', age=28, dept=3, isMan=true}
            // user = User{name='花和尚', age=20, dept=2, isMan=true}
            // user = User{name='白骨精', age=18, dept=3, isMan=false}
            // user = User{name='宋江', age=17, dept=2, isMan=true}
            // user = User{name='关羽', age=14, dept=1, isMan=false}
        }

limit 方法用于获取指定数量的流

       // 获取指定数量流
        public static void main(String[] args) {
            List<User> users = Arrays.asList(
                    //      new User(名字, 年龄, 是否是男性,部门ID),
                    new User("张飞", 34, Boolean.TRUE, 1),
                    new User("关羽", 14, Boolean.FALSE, 1),
                    new User("宋江", 17, Boolean.TRUE, 2),
                    new User("花和尚", 20, Boolean.TRUE, 2),
                    new User("孙悟空", 28, Boolean.TRUE, 3),
                    new User("白骨精", 18, Boolean.FALSE, 3)
            );

            // 例子 获取3个元素
            List<User> limit = users
                    .stream()
                    .limit(3)
                    .collect(Collectors.toList());
            limit.forEach(item-> System.out.println("item = " + item));
            // 输出结果
            // item = User{name='张飞', age=34, dept=1, isMan=true}
            // item = User{name='关羽', age=14, dept=1, isMan=false}
            // item = User{name='宋江', age=17, dept=2, isMan=true}
        }

统计&统计结果收集器

		// 统计api
        public static void main(String[] args) {
            List<User> users = Arrays.asList(
                    //      new User(名字, 年龄, 是否是男性,部门ID),
                    new User("张飞", 34, Boolean.TRUE, 1),
                    new User("关羽", 14, Boolean.FALSE, 1),
                    new User("宋江", 17, Boolean.TRUE, 2),
                    new User("花和尚", 20, Boolean.TRUE, 2),
                    new User("孙悟空", 28, Boolean.TRUE, 3),
                    new User("白骨精", 18, Boolean.FALSE, 3)
            );

            // 例子 统计成年用户数量
            long count = users.
                    stream()
                    .filter(user -> user.getAge() >= 18)
                    .count();
            System.out.println("成年用户 count = " + count);
            // 输出结果 成年用户 count = 3


            // 获取统计结果的收集器
            DoubleSummaryStatistics doubleSummaryStatistics = users.
                    stream().mapToDouble(User::getAge).summaryStatistics();
            LongSummaryStatistics longSummaryStatistics = users.
                    stream().mapToLong(User::getAge).summaryStatistics();

            IntSummaryStatistics intSummaryStatistics = users.
                    stream().
                    mapToInt(User::getAge).summaryStatistics();
            long count1 = intSummaryStatistics.getCount();// 总数
            int min = intSummaryStatistics.getMin();//最小
            int max = intSummaryStatistics.getMax();//最大
            long sum = intSummaryStatistics.getSum();// 总和
            double average = intSummaryStatistics.getAverage();//平均值
            // 将值加入结果中
            intSummaryStatistics.accept(13);


        }

并行流 parallelStream

			 List<User> users = Arrays.asList(
			            //      new User(名字, 年龄, 是否是男性),
			            new User("张三", 34, Boolean.TRUE),
			            new User("李红", 14, Boolean.FALSE),
			            new User("小明", 17, Boolean.TRUE),
			            new User("黄忠", 20, Boolean.TRUE),
			            new User("吕布", 28, Boolean.TRUE),
			            new User("貂蝉", 18, Boolean.FALSE)
			        );

	 		// 获取并行流，数据量大时可以采用并行将会多线程执行
			Stream<User> parallelStream = users.parallelStream();
			

完