Java Stream使用示例
这篇文章借鉴了链接所示的公众号文章推文
整体介绍
Stream可以配合Lambda表达式来使用,其类型可分为以下四种:
- 中间操作
- 有状态操作:当前元素的操作需要等所有元素处理完后进行
- 无状态操作:当前元素的操作不受前面元素的影响
- 结束操作
- 短路操作:不需要处理完所有元素即可结束
- 非短路操作:必须处理完所有元素才能结束
创建Stream
基于集合创建
List<Integer> list = Arrays.asList(5, 2, 3, 1, 4);
Stream stream = list.stream();
基于数组创建
String[] array={"ab", "abc", "abcd", "abcde", "abcdef" };
Stream<String> stream = Arrays.stream(array);
使用Stream静态方法创建
Stream<String> stream = Stream.of("ab", "abc", "abcd", "abcde", "abcdef");
无状态操作
map
接收一个函数作为形参,将这个函数应用到每个元素中,返回一个新的Stream,函数可以是Lambda形式的。
List<Integer> list = Arrays.asList(5, 2, 3, 1, 4);
List<Integer> newList = list.stream().map(x -> x + 3).collect(Collectors.toList());
mapToXXX
包括三个方法:mapToInt、mapToDouble、mapToLong
是将Stream中的元素转为XXX的类型
List<String> list = Arrays.asList("ab", "abc", "abcd", "abcde", "abcdef");
int[] newList = list.stream().mapToInt(r -> r.length()).toArray();
flatMap
flatMap接收函数作为入参,然后把集合中每个元素转换成一个 stream,再把这些 stream 组成一个新的 stream,是拆分单词很好的工具。
List<String> list = Arrays.asList("ab-abc-abcd-abcde-abcdef", "5-2-3-1-4");
List<String> newList = list.stream().flatMap(s -> Arrays.stream(s.split("-"))).collect(Collectors.toList());
flatMapToXXX
包括三个方法:flatMapToInt、flatMapToLong、flatMapToDouble
与map中的不同,这里是返回一个XXXStream类型的Stream,用以支持其他已经定义的操作。
int[][] data = {{1,2},{3,4},{5,6}};
IntStream intStream = Arrays.stream(data).flatMapToInt(row -> Arrays.stream(row));
System.out.println(intStream.sum());
// out: 21
filter
筛选功能,按照规定从原始Stream中提取符合条件的元素至新Stream中
class Student{
private String name;
private Integer age;
private String sex;
private Integer score;
public Student(String name, Integer age, String sex, Integer score){
this.name = name;
this.age = age;
this.score = score;
this.sex = sex;
}
//省略getters/setters
}
List<Student> students = new ArrayList<>();
students.add(new Student("Mike", 10, "male", 88));
students.add(new Student("Jack", 13,"male", 90));
students.add(new Student("Lucy", 15,"female", 100));
students.add(new Student("Jessie", 12,"female", 78));
students.add(new Student("Allon", 16,"female", 92));
students.add(new Student("Alis", 22,"female", 50));
List<String> nameList = students.stream().filter(x -> x.getScore() >= 90).map(Student::getName).collect(Collectors.toList());
System.out.print("考试成绩90分以上的学生姓名:" + nameList);
// out: 考试成绩90分以上的学生姓名:[Jack, Lucy, Allon]
peek
返回由 stream 中元素组成的新 stream,用给定的函数作用在新 stream 的每个元素上。传入的函数是一个 Consume 类型的,没有返回值,因此并不会改变原 stream 中元素的值。peek 主要用是 debug,可以方便地 查看流处理结果是否正确。
Stream.of("one", "two", "three", "four")
.filter(e -> e.length() > 3)
.peek(e -> System.out.println("Filtered value: " + e))
.map(String::toUpperCase)
.peek(e -> System.out.println("Mapped value: " + e))
.collect(Collectors.toList());
unordered
把一个有序的 stream 转成一个无序 stream ,如果原 stream 本身就是无序的,可能会返回原始的 stream。
Arrays.asList("1", "2", "3", "4", "5")
.parallelStream()
.unordered()
.forEach(r -> System.out.print(r + " "));
有状态操作
distinct
去除Stream中重复的元素
String[] array = { "a", "b", "b", "c", "c", "d", "d", "e", "e"};
List<String> newList = Arrays.stream(array).distinct().collect(Collectors.toList());
limit
限制从Stream中获取前n个元素
String[] array = { "c", "c", "a", "b", "b", "e", "e", "d", "d"};
List<String> newList = Arrays.stream(array).limit(5).collect(Collectors.toList());
skip
跳过前n个元素
String[] array = { "a", "b", "c", "d", "e", "f", "g", "h", "i"};
List<String> newList = Arrays.stream(array).skip(5).collect(Collectors.toList());
sorted
对Stream中的元素进行排序
String[] array = { "c", "c", "a", "b", "b", "e", "e", "d", "d"};
List<String> newList = Arrays.stream(array).sorted().collect(Collectors.toList());
List<Student> students = new ArrayList<>();
students.add(new Student("Mike", 10, "male", 88));
students.add(new Student("Jack", 13,"male", 90));
students.add(new Student("Lucy", 15,"female", 100));
students.add(new Student("Jessie", 12,"female", 78));
students.add(new Student("Allon", 16,"female", 92));
students.add(new Student("Alis", 22,"female", 50));
List<String> nameList = students.stream().sorted(Comparator.comparing(Student::getScore)).map(Student::getName).collect(Collectors.toList());
System.out.print("按成绩排序输出学生姓名:" + nameList);
// out: 考试成绩90分以上的学生姓名:[Alis, Jessie, Mike, Jack, Allon, Lucy]
短路操作
findAny
找出 stream 中任何一个满足过滤条件的元素。
List<Student> students = new ArrayList<>();
students.add(new Student("Mike", 10, "male", 88));
students.add(new Student("Jack", 13,"male", 90));
students.add(new Student("Lucy", 15,"female", 100));
students.add(new Student("Jessie", 12,"female", 78));
students.add(new Student("Allon", 16,"female", 92));
students.add(new Student("Alis", 22,"female", 50));
Optional<Student> studentFindAny = students.stream().filter(x -> x.getScore() > 90).findAny();
System.out.print("找出任意一个考试成绩在90分以上的学生姓名:" + studentFindAny.orElseGet(null).getName());
// out: 找出任意一个考试成绩在90分以上的学生姓名:Lucy
anyMatch
是否存在任意一个满足给定条件的元素。
boolean result1 = students.stream().anyMatch(x -> x.getScore() > 90);
System.out.println("是否存在成绩高于 90 分的学生:" + result1);
boolean result2 = students.stream().anyMatch(x -> x.getScore() < 50);
System.out.print("是否存在成绩低于 50 分的学生:" + result2);
// out: 是否存在成绩高于 90 分的学生:true
// 是否存在成绩低于 50 分的学生:false
allMatch
是否集合中所有元素都满足给定的条件,如果集合是空,则返回 true。
boolean result1 = students.stream().allMatch(x -> x.getScore() > 90);
System.out.println("是否所有学生的成绩都高于90分:" + result1);
boolean result2 = students.stream().allMatch(x -> x.getScore() > 50);
System.out.print("是否所有学生的成绩都高于50分:" + result2);
// out: 是否所有学生的成绩都高于 90 分:false
// 是否所有学生的成绩都高于 50 分:true
noneMatch
是否没有元素能匹配给定的条件,如果集合是空,则返回 true。
boolean result1 = students.stream().noneMatch(x -> x.getScore() > 90);
System.out.println("是不是没有学生成绩在 90 分以上:" + result1);
boolean result2 = students.stream().noneMatch(x -> x.getScore() < 50);
System.out.print("是不是没有学生成绩在 50 分以下:" + result2);
// out: 是不是没有学生成绩在 90 分以上:false
// 是不是没有学生成绩在 50 分以下:true
findFirst
找出第一个符合条件的元素。
Optional<Student> studentFindAny = students.stream().filter(x -> x.getScore() > 90).findFirst();
System.out.print("第一个成绩在 90 分以上的学生姓名:" + studentFindAny.orElseGet(null).getName());
// out: 第一个成绩在 90 分以上的学生姓名:Lucy
非短路操作
forEach
遍历Stream中的所有元素
List<Integer> array = Arrays.asList(5, 2, 3, 1, 4);
array.stream().forEach(System.out :: println);
// out: 5 2 3 1 4
forEachOrdered
按照给定集合中元素的顺序输出。主要使用场景是在并行流的情况下,按照给定的顺序输出元素。
List<Integer> array = Arrays.asList(5, 2, 3, 1, 4);
array.parallelStream().forEachOrdered(System.out :: println);
// out: 5 2 3 1 4
toArray
将Stream转换为数组
Stream<String> stream = Arrays.asList("ab", "abc", "abcd", "abcde", "abcdef").stream();
String[] newArray1 = stream.toArray(str -> new String[5]);
String[] newArray2 = stream.toArray(String[]::new);
Object[] newArray3 = stream.toArray();
reduce
规约操作,把一个流的所有元素合并成一个元素,比如求和、求乘积、求最大最小值等。
List<Integer> list = Arrays.asList(5, 2, 3, 1, 4);
Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
Optional<Integer> product = list.stream().reduce((x, y) -> x * y);
Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
System.out.println("数组元素之和:" + sum.get());
System.out.println("数组元素乘积:" + product.get());
System.out.println("数组元素最大值:" + max.get());
// out: 数组元素之和:15
// 数组元素乘积:120
// 数组元素最大值:5
collect
把 stream 中的元素归集到新的集合或者归集成单个元素。
归集成新集合
方法包括 toList、toSet、toMap。
List<Student> students = new ArrayList<>();
students.add(new Student("Mike", 10, "male", 88));
students.add(new Student("Jack", 13,"male", 90));
students.add(new Student("Lucy", 15,"female", 100));
students.add(new Student("Jessie", 12,"female", 88));
students.add(new Student("Allon", 16,"female", 92));
students.add(new Student("Alis", 22,"female", 50));
List<String> list = students.stream().map(r -> r.getName()).collect(Collectors.toList());
Set<Integer> set = students.stream().map(r -> r.getScore()).collect(Collectors.toSet());
Map<String, Integer> map = students.stream().collect(Collectors.toMap(Student::getName, Student::getScore));
System.out.println("全班学生姓名列表:" + list);
System.out.println("全班学生不同分数列表:" + set);
System.out.println("全班学生姓名分数集合:" + map);
统计功能
使用Collectors工具类中的操作来实现统计的功能:count、averagingInt、averagingLong、averagingDouble、maxBy、minBy、summingInt、summingLong、summingDouble、summarizingInt、summarizingLong、summarizingDouble。
List<Integer> list = Arrays.asList(5, 2, 3, 1, 4);
long count = list.stream().collect(Collectors.counting());
int sum = list.stream().collect(Collectors.summingInt(r -> r));
double average = list.stream().collect(Collectors.averagingDouble(r -> r));
Optional<Integer> max = list.stream().collect(Collectors.maxBy(Integer::compare));
Optional<Integer> min = list.stream().collect(Collectors.maxBy((x, y) -> x > y ? y : x));
System.out.println("总数:" + count);
System.out.println("总和:" + sum);
System.out.println("平均值:" + average);
System.out.println("最大值:" + max.get());
System.out.println("最小值:" + min.get());
分区和分组
- partitioningBy:把 stream 分成两个 map
- groupingBy:把 stream 分成多个 map
List<Student> students = new ArrayList<>();
students.add(new Student("Mike", 10, "male", 88));
students.add(new Student("Jack", 10,"male", 90));
students.add(new Student("Lucy", 12,"female", 100));
students.add(new Student("Jessie", 12,"female", 78));
students.add(new Student("Allon", 16,"female", 92));
students.add(new Student("Alis", 16,"female", 50));
Map<Boolean, List<Student>> partitionByScore = students.stream().collect(Collectors.partitioningBy(x -> x.getScore() > 80));
System.out.println("将学生按照考试成绩80分以上分区:");
partitionByScore.forEach((k,v ) -> {
System.out.print(k ? "80分以上:" : "80分以下:");
v.forEach(r -> System.out.print(r.getName() + ","));
System.out.println();
});
System.out.println();
// out:将学生按照考试成绩80分以上分区:
// 80分以下:Jessie,Alis,
// 80分以上:Mike,Jack,Lucy,Allon,
连接
将 stream 中的元素用指定的连接符合并,连接符可以是空。
String studentNames = students.stream().map(r -> r.getName()).collect(Collectors.joining(","));
System.out.println("所有学生姓名列表:" + studentNames);
// out:所有学生姓名列表:Mike,Jack,Lucy,Jessie,Allon,Alis
规约
支持更大的
List<Integer> list = Arrays.asList(5, 2, 3, 1, 4);
int listSum = list.stream().collect(Collectors.reducing(0, x -> x + 1, (sum, b) -> sum + b));
System.out.println("数组中每个元素加 1 后总和:" + listSum);
// out:数组中每个元素加 1 后总和:20
max、min、count
Stream提供的方便统计的方法
List<Integer> list = Arrays.asList(5, 2, 3, 1, 4);
System.out.println("数组元素最大值:"+list.stream().max(Integer::compareTo).get());
System.out.println("数组元素最小值:"+list.stream().min(Integer::compareTo).get());
System.out.println("数组中大于3的元素个数:"+list.stream().filter(x -> x > 3).count());
// out: 数组元素最大值:5
// 数组元素最小值:1
// 数组中大于3的元素个数:2