【JAVA基础】Steam使用教程

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