stream流——开发必备

Stream流

stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。
stream不会改变数据源，通常情况下会产生一个新的集合或一个值。
stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。

1.创建流的几种方式

list.stream();//创建一个顺序流，由主线程按顺序对流执行操作
list.parallelStream;//创建一个并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求
Arrays.stream(array);//利用数组创建流
//Stream的静态方法：of()、iterate()、generate()
Stream.of(1, 2, 3, 4, 5, 6);
Stream.iterate(0, (x) -> x + 3).limit(4);
Stream.generate(Math::random).limit(3);

2.遍历

// 遍历输出符合条件的元素
list.stream().filter(x -> x > 6).forEach(System.out::println);
// 匹配第一个
Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
// 匹配任意（适用于并行流）
Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
// 是否包含符合特定条件的元素
boolean anyMatch = list.stream().anyMatch(x -> x > 6);

3.筛选

//筛选形成新的集合
List<String> fiterList = personList.stream().filter(x -> x.getSalary() > 8000).map(Person::getName).collect(Collectors.toList());

4.聚合

//获取String集合中最长的元素
List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
Optional<String> max = list.stream().max(Comparator.comparing(String::length));
max.get();
//获取Integer集合中的最大值
List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);// 自然排序Optional<Integer> max = list.stream().max(Integer::compareTo);// 自定义排序Optional<Integer> max2 = list.stream().max(new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o1.compareTo(o2);}});
//获取对象某个属性最大值
Optional<Person> max = personList.stream().max(Comparator.comparingInt(Person::getSalary));System.out.println("员工工资最大值：" + max.get().getSalary());
//计算个数
long count = list.stream().filter(x -> x > 6).count();

5.映射

// map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
// flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。String[] strArr = { "abcd", "bcdd", "defde", "fTr" };List<String> strList = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);List<Integer> intListNew = intList.stream().map(x -> x + 3).collect(Collectors.toList());// 将员工的薪资全部增加1000。
1.// 不改变原来员工集合的方式。List<Person> personListNew = personList.stream().map(person -> {Person personNew = new Person(person.getName(), 0, 0, null, null);personNew.setSalary(person.getSalary() + 10000);return personNew;}).collect(Collectors.toList());
2.// 改变原来员工集合的方式。List<Person> personListNew2 = personList.stream().map(person -> {person.setSalary(person.getSalary() + 10000);return person;}).collect(Collectors.toList());
// 将两个字符数组合并成一个新的字符数组。
List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");List<String> listNew = list.stream().flatMap(s -> {// 将每个元素转换成一个streamString[] split = s.split(",");Stream<String> s2 = Arrays.stream(split);return s2;}).collect(Collectors.toList());

6.归约

//归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。
List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);
// 求和方式1
Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
// 求和方式2
Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
// 求和方式3
Integer sum3 = list.stream().reduce(0, Integer::sum);// 求乘积
Optional<Integer> product = list.stream().reduce((x, y) -> x * y);// 求最大值方式1
Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
// 求最大值写法2
Integer max2 = list.stream().reduce(1, Integer::max);
---------------------------------------------------------------
// 求工资之和方式1：
Optional<Integer> sumSalary = personList.stream().map(Person::getSalary).reduce(Integer::sum);
// 求工资之和方式2：
Integer sumSalary2 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(),(sum1, sum2) -> sum1 + sum2);
// 求工资之和方式3：
Integer sumSalary3 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);// 求最高工资方式1：
Integer maxSalary = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),Integer::max);
// 求最高工资方式2：
Integer maxSalary2 = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),(max1, max2) -> max1 > max2 ? max1 : max2);

7.聚合

collect主要依赖java.util.stream.Collectors类内置的静态方法。

1.// 归集  toList、toSet、toMap
List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());Map<?, Person> map = personList.stream().filter(p -> p.getSalary() > 8000).collect(Collectors.toMap(Person::getName, p -> p));-------------------------------------------------------
2.// 统计 count、averaging
/*Collectors提供了一系列用于数据统计的静态方法：
计数：count
平均值：averagingInt、averagingLong、averagingDouble
最值：maxBy、minBy
求和：summingInt、summingLong、summingDouble
统计以上所有：summarizingInt、summarizingLong、summarizingDouble*/// 求总数
Long count = personList.stream().collect(Collectors.counting());
// 求平均工资
Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
// 求最高工资
Optional<Integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
// 求工资之和
Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary));
// 一次性统计所有信息
DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));
/*DoubleSummaryStatistics{count=3, sum=23700.000000,min=7000.000000, average=7900.000000, max=8900.000000}*/-------------------------------------------------------
3.// 分组partitioningBy、groupingBy/*分区：将stream按条件分为两个Map，比如员工按薪资是否高于8000分为两部分。分组：将集合分为多个Map，比如员工按性别分组。有单级分组和多级分组。*/
// 将员工按薪资是否高于8000分组
Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
// 将员工按性别分组
Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));
// 将员工先按性别分组，再按地区分组
Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));-------------------------------------------------------
4.//接合 joining
//joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串
String names = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
List<String> list = Arrays.asList("A", "B", "C");
String string = list.stream().collect(Collectors.joining("-"));-------------------------------------------------------
5.// 归约 reducing
// 每个员工减去起征点后的薪资之和
Integer sum = personList.stream().collect(Collectors.reducing(0, Person::getSalary, (i, j) -> (i + j - 5000)));
// 员工薪资总和 stream的reduce
Optional<Integer> sum2 = personList.stream().map(Person::getSalary).reduce(Integer::sum);

8.排序

// sorted()：自然排序，流中元素需实现Comparable接口
// sorted(Comparator com)：Comparator排序器自定义排序// 按工资升序排序（自然排序）List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName).collect(Collectors.toList());// 按工资倒序排序List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed()).map(Person::getName).collect(Collectors.toList());// 先按工资再按年龄升序排序List<String> newList3 = personList.stream().sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName).collect(Collectors.toList());// 先按工资再按年龄自定义排序（降序）List<String> newList4 = personList.stream().sorted((p1, p2) -> {if (p1.getSalary() == p2.getSalary()) {return p2.getAge() - p1.getAge();} else {return p2.getSalary() - p1.getSalary();}}).map(Person::getName).collect(Collectors.toList());

9.提取、组合

String[] arr1 = { "a", "b", "c", "d" };
String[] arr2 = { "d", "e", "f", "g" };
Stream<String> stream1 = Stream.of(arr1);
Stream<String> stream2 = Stream.of(arr2);
// concat:合并两个流 distinct：去重
List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
// limit：限制从流中获得前n个数据
List<Integer> collect = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
// skip：跳过前n个数据
List<Integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());

10.Optional类

      Java8Tester java8Tester = new Java8Tester();Integer value1 = null;Integer value2 = new Integer(10);// Optional.ofNullable - 允许传递为 null 参数Optional<Integer> a = Optional.ofNullable(value1);// Optional.of - 如果传递的参数是 null，抛出异常 NullPointerExceptionOptional<Integer> b = Optional.of(value2);System.out.println(java8Tester.sum(a,b));}public Integer sum(Optional<Integer> a, Optional<Integer> b){// Optional.isPresent - 判断值是否存在System.out.println("第一个参数值存在: " + a.isPresent());System.out.println("第二个参数值存在: " + b.isPresent());// Optional.orElse - 如果值存在，返回它，否则返回默认值Integer value1 = a.orElse(new Integer(0));//Optional.get - 获取值，值需要存在Integer value2 = b.get();return value1 + value2;

stream流——开发必备相关推荐

程序员开发必备英语基础–狂神版
程序员开发必备英语基础–狂神版一.开发常用英语词汇排序 A array数组 accessible 可存取的 area面积 audio 音频 addition 加法 action 行动 arithme ...
CUDA 7 Stream流简化并发性
CUDA 7 Stream流简化并发性异构计算是指高效地使用系统中的所有处理器,包括 CPU 和 GPU .为此,应用程序必须在多个处理器上并发执行函数. CUDA 应用程序通过在 streams ...
stream distinct去重_再来看看Java的新特性——Stream流
半年前开始试着使用Java的新特性,给我印象最深的就是Stream流和Optional.其中Stream提高了看法效率,让代码看起来十分清爽. 为什么要使用流? 摘要中已经说明了,为了提高开发效率.流 ...
【Java10】lambda表达式（函数式编程），Stream流，File类，字节/字符流，乱码，缓冲/转换/序列化/打印流，Properties
文章目录 1.lambda表达式标准语法:()->{} 2.lambda表达式简略语法:可推导即可省略 3.lambda表达式原理:lambda效率比匿名内部类高 4.两个函数式接口:Consu ...
Flutter StreamController 异步通信、Stream 流异步通信
题记 -- 执剑天涯,从你的点滴积累开始,所及之处,必精益求精. Flutter是谷歌推出的最新的移动开发框架. [x1]微信公众号的每日提醒随时随记每日积累随心而过 [x2]各种系列的视频教程 ...
嵌入式基础（1）---硬件知识，搞嵌入式开发必备
嵌入式基础硬件知识,搞嵌入式开发必备做嵌入式系统开发,经常要接触硬件.做嵌入式开发对数字电路和模拟电路要有一定的了解. 这样才能深入的研究下去.下面我们简单的介绍嵌入式开发中的一些硬件相关的概念. ...
Lambda表达式和Stream流式编程
写在前面 IDEA都默认是jdk11了,我这还写着jdk8的新特性呢,惭愧惭愧.其实在学校的时候,基本没咋用过Lambda表达式和Stream流式编程,但是在实习的时候,发现公司的代码好多这样写的,没 ...
stream 定长循环_Java8之Stream流代替For循环操作
Stream流代替For循环进行输出可以使代码更简洁. 需求:根据姓名获取员工信息 1.建立实体类:Emp 2.测试类: (1.) 原始For写法: (2.) Stream流: 输出结果为: 补充知识 ...
Stream流和Optional
Lambda表达式和函数式接口 https://blog.csdn.net/qq_45888932/article/details/122451124 目录一.什么是Stream流注意事项二.快 ...

stream流——开发必备

Stream流

1.创建流的几种方式

2.遍历

3.筛选

4.聚合

5.映射

6.归约

7.聚合

8.排序

9.提取、组合

stream流——开发必备相关推荐

最新文章

热门文章