java流式编程工具类_Java8的心特性-集合的流式编程

最新推荐文章于 2023-08-14 17:36:17 发布

weixin_39562197

最新推荐文章于 2023-08-14 17:36:17 发布

阅读量152

点赞数

文章标签： java流式编程工具类

本文链接：https://blog.csdn.net/weixin_39562197/article/details/114755304

版权

1、集合流的简介

1.1 集合的流式编程的简介

Stream是JDK1.8之后出现的新特性，也是JDK1.8新特性中最值得学习的两种特性之一。(另一个是Lambda表达式)。

Stream是对集合操作的增强，流不是集合的元素，不是一种数据结构，不负责数据的存储。流更像是一个迭代器，可以单向的遍历一个集合中的每一个元素，并且不可循环(废话，单向还怎么循环)。

1.2 为什么要使用集合的流式编程

有些时候，对集合中的元素进行操作的时候，需要使用到其他操作的结果。在这个过程中，集合的流式编程可以大幅度的简化代码的数量，将数据源中的数据，读取到一个流中，可以对这个流中的数据进行操作(删除、过滤、映射...)，每次的操作结果也是一个流对象，可以对这个流再进行其他的操作。

1.3 使用流式编程的步骤

通常情况下，对集合中的数据使用流式编程，需要经过以下三步：

获取数据源，将数据源中的数据读取到流中。

对流中的数据进行各种各样的处理。

对流中的数据进行整合处理。

在上述三个过程中，过程2，有若干方法，可以对流中的数据进行各种各样的操作，并且返回流对象本身，这样的操作，被称为-中间操作，过程2中，有若干方法，可以对流中的数据进行各种处理，并关闭流，这样的操作，被称为-最终操作。

在中间操作和最终操作中，基本上所有的方法参数都是函数式接口，可以使用lambda表达式来实现，使用集合的流式编程，来简化代码量，是需要对lambda表达式做到熟练掌握。

2、数据源的获取

2.1 数据源的简介

数据源，顾名思义，即是流中的数据的来源，是集合的流式编程的第一步，将数据源中的数据读取到流中，进行处理，注意：将数据读取到流中进行处理的时候，与数据源中的数据没有关系。也就是说，中间操作对流中的数据进行处理、过滤、映射、排序...此时是不会影响数据源中的数据的。

2.2 数据源的获取

这个过程，其实是将一个容器中的数据，读取到一个流中。因此无论什么容器作为数据源，读取到流中的方法返回值一定是一个Stream。

packagestream;importjava.util.ArrayList;importjava.util.Arrays;importjava.util.stream.IntStream;importjava.util.stream.Stream;public classDataSourceDemo {//数据源的获取

public static voidmain(String[] args) {//1、集合的流失编程

ArrayList list = new ArrayList<>();//2、Collection流的获取

Stream stream =list.stream();

Stream stream2 =list.parallelStream();//3、Array流的获取(这个没有并行流)

int[] array = {1,2,3,4,5};

IntStream stream3=Arrays.stream(array);

}

关于stream()和parallelStream

他们都是Collection集合获取数据源的方法，不同点在于stream()方法获取的数据源是串行的，parallelStream()获取的数据源是并行的。parallelStream()内部集成了多个线程对流中的数据进行操作，效率更高。

3、最终操作

3.1 最终操作的简介

将流中的数据整合到一起，可以存入一个集合，也可以直接对流中的数据进行遍历、数据统计...通过最终操作，需要掌握如何从流中提取出来玩吗想要的信息。

注意事项：最终操作，之所以叫最终操作，是因为，在最终操作执行结束后，会关闭这个流，流中的所有数据都会被销毁，如果使用一个已经关闭了的流，会出现异常。

3.2 collect

将流中的数据收集到一起，对这些数据进行处理。最常见的处理，就是讲流中的数据存入一个集合。collect方法的参数，是一个Collector接口，而且这个接口并不是一个函数式接口。实现这个接口，可以自定义收集规则，但是，绝大部分情况下，不需要自定义。我们可以使用Collectors工具类提供的方法。

直接使用Collectors工具类提供的方法即可。

packagestream;importjava.util.ArrayList;importjava.util.Collections;importjava.util.List;importjava.util.Map;importjava.util.Set;importjava.util.stream.Collectors;public classFinalOperationDemo {//最终操作

public static voidmain(String[] args) {

ArrayList list = new ArrayList<>();

Collections.addAll(list,10,20,30,40,50,60,70,80,90,5,15,25,35,45,55,65,75,86,95,100);//1、collect//1.1 转成list

List result1 =list.stream().collect(Collectors.toList());

System.out.println(result1);//1.2 转成set

Set result2 =list.stream().collect(Collectors.toSet());

System.out.println(result2);//1.3 转成map，需要提供两个函数式接口的实现，分别实现键和值的生成规则。如果ele/10会报错，因为key重复了。

Map result3 = list.stream().collect(Collectors.toMap(ele -> ele + 10, ele ->ele));

System.out.println(result3);//1.4 转成Collection，这个用的少，而且还要传参数(转换规则)，因为你都转成list和set了，还转Collection干什么

}

3.3 reduce

将流中的数据按照一定的规则聚合起来。

//2、reduce//将流中的元素，逐一带入到这个方法中，进行运算//最终的运算结果，得到的其实是一个Optional类型，需要使用get()获取到里面的数据。

Integer result4 = list.stream().reduce((e1, e2) -> e1 +e2).get();

System.out.println(result4);

3.4 count

统计流中的元素数量

//3、count

long result5 =list.stream().count();

System.out.println(result5);

3.5 forEach

迭代、遍历流中的数据。

//4、forEach

list.stream().forEach(System.out::println);

3.6 max & min

获取流中的最大的元素、最小的元素(结果也是Optional类型，需要用get方法获取值)

//5、max & min//获取最大值

Integer result6 =list.stream().max(Integer::compareTo).get();

System.out.println("max is : " +result6);//获取最小值

Integer result7 =list.stream().min(Integer::compareTo).get();

System.out.println("min is : " + result7);

3.7 Matching

allMatch：只有当流中所有的元素，都匹配指定的会泽，才会返回true；

anyMatch：只要流中任意的数据，满足指定的规则，就会返回true；

noneMatch：只有当流中的所有的元素，都不满足指定的规则，才会返回true。

//6、Matching//判断流中是否所有的元素都大于 50

boolean result8 = list.stream().allMatch(ele -> ele > 50);

System.out.println(result8);//判断流中是否有大于 50 的数据

boolean result9 = list.stream().anyMatch(ele -> ele > 50);

System.out.println(result9);//判断流中是否没有奇数

boolean result10 = list.stream().noneMatch(ele -> ele % 2 != 0);

System.out.println(result10);

3.8 find

当我们第一眼看到这个”find“单词的时候，想到的就是按照一定规则获取一定的元素。其实不是这样。关于通过一定规则获取到(过滤掉一些得到其他)一定的元素是“中间操作”中的方法，后面会学到。

findFirst：从流中获取一个元素(一般情况下，是获取的开头的元素)

findAny：从流中获取一个元素(一般情况下，是获取的开头的元素)

这两个方法，绝大部分情况下，是完全相同的，但是在多线程的环境下，findAny和findFirst返回的结果可能不一样。

//8、find

Optional result11 =list.stream().findFirst();

System.out.println(result11);

Optional result12 =list.stream().findAny();

System.out.println(result12);

Optional result13 =list.parallelStream().findFirst();

System.out.println(result13);

Optional result14 =list.parallelStream().findAny();

System.out.println(result14);

//运行结果，find的运行结果是Optional，如果想得到具体值，可以用get()方法

Optional[10]

Optional[35]

//这里可以看到在多线程(并行流下)结果是不确定的，有可能意义，有可能不一样。

3.9 最终操作的注意事项

最终操作，会关闭流。如果一个流被关闭了，再去使用这个流，就会出现异常。

//9、最终操作错误示范

Stream stream =list.stream();long count =stream.count();

stream.forEach(System.out::println);

// 异常信息

// Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed

全部代码

packagestream;importjava.util.ArrayList;importjava.util.Collections;importjava.util.List;importjava.util.Map;importjava.util.Optional;importjava.util.Set;importjava.util.stream.Collectors;importjava.util.stream.Stream;public classFinalOperationDemo {//最终操作

public static voidmain(String[] args) {

ArrayList list = new ArrayList<>();

Collections.addAll(list,10,20,30,40,50,60,70,80,90,5,15,25,35,45,55,65,75,86,95,100);//1、collect//1.1 转成list

List result1 =list.stream().collect(Collectors.toList());

System.out.println(result1);//1.2 转成set

Set result2 =list.stream().collect(Collectors.toSet());

System.out.println(result2);//1.3 转成map，需要提供两个函数式接口的实现，分别实现键和值的生成规则。如果ele/10会报错，因为key重复了。

Map result3 = list.stream().collect(Collectors.toMap(ele -> ele + 10, ele ->ele));

System.out.println(result3);//1.4 转成Collection，这个用的少，而且还要传参数(转换规则)，因为你都转成list和set了，还转Collection干什么//2、reduce//将流中的元素，逐一带入到这个方法中，进行运算//最终的运算结果，得到的其实是一个Optional类型，需要使用get()获取到里面的数据。

Integer result4 = list.stream().reduce((e1, e2) -> e1 +e2).get();

System.out.println(result4);//3、count

long result5 =list.stream().count();

System.out.println(result5);//4、forEach

list.stream().forEach(System.out::println);//5、max & min//获取最大值

Integer result6 =list.stream().max(Integer::compareTo).get();

System.out.println("max is : " +result6);//获取最小值

Integer result7 =list.stream().min(Integer::compareTo).get();

System.out.println("min is : " +result7);//6、Matching//判断流中是否所有的元素都大于 50

boolean result8 = list.stream().allMatch(ele -> ele > 50);

System.out.println(result8);//判断流中是否有大于 50 的数据

boolean result9 = list.stream().anyMatch(ele -> ele > 50);

System.out.println(result9);//判断流中是否没有奇数

boolean result10 = list.stream().noneMatch(ele -> ele % 2 != 0);

System.out.println(result10);//8、find

Optional result11 =list.stream().findFirst();

System.out.println(result11);

Optional result12 =list.stream().findAny();

System.out.println(result12);

Optional result13 =list.parallelStream().findFirst();

System.out.println(result13);

Optional result14 =list.parallelStream().findAny();

System.out.println(result14);//9、最终操作错误示范

Stream stream =list.stream();long count =stream.count();

stream.forEach(System.out::println);

}

4、中间操作

4.1 中间操作的简介

将数据从数据源中读取到流中，中间操作，就是对流中的数据进行各种各样的操作、处理，中间操作可以连续操作，每一个操作的返回值都是一个Stream对象，可以继续进行其他的操作，直到最终操作。

4.2 filter

条件过滤，仅保留流中满足指定条件的数据，其他不满足的数据都会被删除。这么一想，参数肯定是Predicate。

//2、条件过滤

list.stream().filter(ele -> ele.length() > 5).forEach(System.out::println);

4.3 distinct

去重集合中重复的元素，这个方法没有参数，去重的规则与HashSet相同。

那HashSet的去重规则是什么？？如果HashCode不一样，则不同；如果一样，则比较equals方法，如果不一样，则不同，即是不同元素；如果一样，则相同，是重复元素，去重。

因此如果这个流中的数据是自定义的类型等，则需要实现这两个方法，方能进行去重操作。

//3、去重

list.stream().distinct().forEach(System.out::println);

4.4 sorted

将流中的数据进行排序(这里排序有两种：一种是有参数[Comparator]，指定排序规则；一种是无参，按照流中元素类实现的Comparable接口中的comparato方法。)

//4、排序(一个是有参[Comparator接口]，一个数无参)//按照流中的元素对应的类，实现的Comparable接口中的方法实现排序

list.stream().sorted().forEach(System.out::println);//对流中的数据，按照指定的规则进行排序

list.stream().sorted((e1,e2) -> e1.length() - e2.length()).forEach(System.out::println);

4.5 limit & skip

limit：限制，截取流中指定数量的元素

skip：跳过，跳过流中的指定数量的元素

通常配合使用

//5、跳过或截断(通常配合使用)//跳过开头指定的元素

list.stream().skip(3).forEach(System.out::println);//截断指定数量的元素

list.stream().limit(3).forEach(System.out::println);//配合使用，截取部

list.stream().skip(5).limit(2).forEach(System.out::println);

4.6 map & flatMap

看到这个map，大家不要以为是要将流中的数据变成一个键值对的Map，那是最终操作collection(Colletors.toMap(key映射关系，value映射关系))方法的内容。

map：对流中的数据进行映射，用新的数据替换旧的数据(而且新的数据可以和原有数据不是一个类型，甚至可以一个元素变成一列数组)。

//6、map & faltMap

list.stream().map(ele -> ele + ".txt").forEach(System.out::println);

map最主要的作用就是用来做元素的替换(换成另一个元素，或者一组元素)，其实map是一个元素的映射。

flatMap也是元素的映射，flatMap是扁平化映射。

packagestream;importjava.util.Arrays;public classFlapMap {public static voidmain(String[] args) {

String[] strs= {"hello","world"};/** 映射之前，流中有两个元素，是两个字符串

* 映射完成后，流中依然是两个元素，是两个char[]

* 最后forEach遍历的，其实是两个char[]

**/

//Arrays.stream(strs).map(ele -> ele.toCharArray()).forEach(ele -> System.out.println(Arrays.toString(ele)));

Arrays.stream(strs).map(String::toCharArray).forEach(ele ->System.out.println(Arrays.toString(ele)));/** flatMap：扁平化映射，将流中的容器中的元素直接取出，直接存放在流中。

**/Arrays.stream(strs).map(ele-> ele.split("")).flatMap(Arrays::stream).forEach(System.out::println);

}

4.7 mapToInt

将流中的数据替换成int类型，此时得到IntStream结果。

packagestream;importjava.util.ArrayList;importjava.util.Collections;public classMapDemo {public static voidmain(String[] args) {//1、准备一个集合，作为数据源

ArrayList list = new ArrayList();

Collections.addAll(list,new Person("xiaoming",12),new Person("laowang",13),new Person("xiaobai",11));//2、如果现在没有流式编程，让你返回所有学生的最大年龄，最小年龄，平均年龄。//如果可以用流

Integer sum = list.stream().map(Person::getAge).reduce((e1, e2) -> e1 +e2).get();

System.out.println(sum);//如果是平均，你还要用count配合计算//现在这些我们都不用//2、mapToInt:将流中的数据，映射成int类型的数据，此时，这个方法的返回值不再是Stream，而是IntStream//其实对于上面的注释，映射为int类型没什么厉害的，map就可以，但是呢？但是呢？这里的厉害之处是返回结果已经不再是Stream//结果是IntStream，而IntStream里面有很多管局数的操作，比如最大，最小，平均，求和等等。

double avg =list.stream().mapToInt(Person::getAge).average().getAsDouble();

System.out.println(avg);

}

}classPerson{

String name;intage;public Person(String name, intage) {this.name =name;this.age =age;

}public intgetAge() {returnage;

}

6、综合案例

需求：一个集合中存储了若干个Student对象，要求查询出以下结果：

1、所有及格的学生信息

2、所有及格的学生姓名

3、所有学生的平均信息

4、班级的前3名(按照成绩)

5、班级的3-10名(按照成绩)

6、所有不及格的学生平均成绩

7、将及格的学生，按照成绩降序输出所有信息

8、班级学生总分。

暂时略。。。