java8新特性——Stream流

目录

Stream流的常用方法汇总：

常用方式

1.count方法：

2.filter方法：

4.limit方法:

3.concat方法

5、sorted方法（排序）

6、收集Stream流—把流转回想要转回的类型

7、parallel()

8、reduce(计算相加)

---

Stream流的常用方法汇总：

• 终结方法：返回值类型不再是Stream接口本身类型的方法，例如：forEach方法和count方法
• 非终结方法/延迟方法：返回值类型仍然是Stream接口自身类型的方法，除了终结方法都是延迟方法。例如：filter,limit,skip,map,conat

方法名称	方法作用	方法种类	是否支持链式调用
count	统计个数	终结方法	否
forEach	逐一处理	终结方法	否
filter	过滤	函数拼接	是
limit	取用前几个	函数拼接	是
skip	跳过前几个	函数拼接	是
map	映射	函数拼接	是
concat	组合	函数拼接	是
sorted	排序	函数拼接	是
skip( long n)	丢弃流的第一个 n元素	函数拼接	是
reduce	函数计算	函数拼接	是

常用方式

1.count方法：

long count (); 统计流中的元素，返回long类型数据

   
			List<String> list = new ArrayList<>();
			list.add("张老三");
			list.add("张小三");
			list.add("李四");
			list.add("赵五");
			list.add("张六");
			list.add("王八");
			long count = list.stream().count();
	    System.out.println("集合中的元素个数是：" + count);

    输出结果：
        集合中的元素个数是：6

2.filter方法：

Stream<T> filter(Predicate<? super ?> predicate); 过滤出满足条件的元素

参数Predicate：函数式接口，抽象方法：boolean test （T t)Predicate接口：是一个判断接口

// 获取stream流
        Stream<String> stream = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");
        // 需求：过去出姓张的元素
        stream.filter(name->name.startsWith("张")).forEach(name->{
            System.out.println("流中的元素" + name);
        });

4.limit方法:

Stream<T> limit(long maxSize); 取用前几个元素

注意： 参数是一个long 类型，如果流的长度大于参数，则进行截取；否则不进行操作

// 获取流的长度
        Stream<String> stream1 = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");
        // 需求：保留前三个元素
        stream1.limit(3).forEach((String name)->{
            System.out.println("流中的前三个元素是：" + name);
        });
 
        输出结果：
            流中的前三个元素是：张老三
            流中的前三个元素是：张小三
            流中的前三个元素是：李四

3.concat方法

public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)--> 合并两个流

把list集合转为Map分组<String,List> ,key(属性)，value(list同属性值对象)

Map<String, List<Employee>> map = emps.stream().collect(Collectors.*groupingBy*(Employee::getCity));

Stream<String> stream1 = Stream.of("11","22","33","44","55");
        Stream<String> stream2 = Stream.of("张颜宇", "张三", "李四", "赵五", "刘六", "王七");
 
        // 需求：合并两个流
        Stream<String> stream = Stream.concat(stream1,stream2);
        stream.forEach((String name)->{
            System.out.print(name);
        });
 
        输出结果：
            1122334455张颜宇张三李四赵五刘六王七

4.分组

Collectors.groupingBy(分组条件，流对象)

流对象可进行二次操作

Map<String, List<Student>> collect1 = studentStream.collect(Collectors.groupingBy(s -> {
            if (s.getScore() >= 60) {
                return "及格";
            } else {
                return "不及格";
            }
        }));

//多级分组
Map<Integer, Map<String, List<Student>>> collect1 = studentStream.collect(Collectors.groupingBy(Student::getScore, Collectors.groupingBy(item -> {
            if (item.getAge() > 60) {
                return "及格";

            } else {
                return "不及格";
            }
        })));

5、sorted方法（排序）

List<Vo>list=list.stream()
    .sorted(Comparator.comparing(Vo::getName))
    .collect(Collectors.toList());

使用vo对象的Name字段进行排序，最后在返回集合

6、收集Stream流—把流转回想要转回的类型

List<String> collect = Stream.concat(stream2, stream).collect(Collectors.toList());

List<String> b = list2.stream()

        .filter(add -> add.startsWith("张")).collect(Collectors.toList());

Stream流中提供了一个方法，可以把流中的数据收集到单例集合中

<R, A> R collect(Collector<? super T, A, R> collector); 把流中的数据手机到单列集合中 返回值类型是R。R指定为什么类型，就是手机到什么类型的集合 参数Collector<? super T, A, R>中的R类型，决定把流中的元素收集到哪个集合中 参数Collector如何得到 ？，可以使用 java.util.stream.Collectors工具类中的静态方法： - public static <T> Collector<T, ?, List<T>> toList()：转换为List集合 - public static <T> Collector<T, ?, Set<T>> toSet() ：转换为Set集合

List<String> list2 = new ArrayList<>();
        list2.add("张老三");
        list2.add("张小三");
        list2.add("李四");
        list2.add("赵五");
        list2.add("张六");
        list2.add("王八");
 
        // 需求：过滤出姓张的并且长度为3的元素
        Stream<String> stream = list2.stream().filter((String name) -> {
            return name.startsWith("张");
        }).filter((String name) -> {
            return name.length() == 3;
        });
 
        // stream 收集到单列集合中
        List<String> list = stream.collect(Collectors.toList());
        System.out.println(list);
 
        // stream 手机到单列集合中
        Set<String> set = stream.collect(Collectors.toSet());
        System.out.println(set);

7、parallel()

多线程并行计算

public static void main(String[] args) {
        Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9)
                .parallel()
                .reduce((a, b) -> {
                    System.out.println(String.format("%s: %d + %d = %d",
                            Thread.currentThread().getName(), a, b, a + b));
                    return a + b;
                }).ifPresent(System.out::println);
    }

8、reduce(函数计算)

reduce可以通过BigDecimal实现把数值进行计算。

        以add为例，可以把结果进行累计汇总。

    public static void main(String[] args) {
        User user1 = new User(new BigDecimal(100));
        User user2 = new User(new BigDecimal(200));

        List<User> list = Arrays.asList(user1, user2);
        BigDecimal bigDecimal = list.stream().map(User::getVal).reduce(BigDecimal::add).get();
        System.out.println(bigDecimal);
    }
    static class User{
        private BigDecimal val;

        public User(BigDecimal val) {
            this.val = val;
        }

        public void setVal(BigDecimal val) {
            this.val = val;
        }

        public BigDecimal getVal() {
            return val;
        }
    }