整体介绍

Stream可以配合Lambda表达式来使用，其类型可分为以下四种：

中间操作

有状态操作：当前元素的操作需要等所有元素处理完后进行
无状态操作：当前元素的操作不受前面元素的影响

结束操作

短路操作：不需要处理完所有元素即可结束
非短路操作：必须处理完所有元素才能结束

创建steam

//基于集合创建List<Integer>list=Arrays.asList(5, 2, 3, 1, 4);
Streamstream=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}};
IntStreamintStream=Arrays.stream(data).flatMapToInt(row->Arrays.stream(row));
System.out.println(intStream.sum());
// 1+2+3+4+5+6 out: 21

filter

筛选功能，按照规定从原始Stream中提取符合条件的元素至新Stream中

classStudent{
privateStringname;
privateIntegerage;
privateStringsex;
privateIntegerscore;
publicStudent(Stringname, Integerage, Stringsex, Integerscore){
this.name=name;
this.age=age;
this.score=score;
this.sex=sex;
    }
//省略getters/setters}
List<Student>students=newArrayList<>();
students.add(newStudent("Mike", 10, "male", 88));
students.add(newStudent("Jack", 13,"male", 90));
students.add(newStudent("Lucy", 15,"female", 100));
students.add(newStudent("Jessie", 12,"female", 78));
students.add(newStudent("Allon", 16,"female", 92));
students.add(newStudent("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个元素

//取出前5个元素：c,c,a,b,b

String[] array= { "c", "c", "a", "b", "b", "e", "e", "d", "d"};
List<String>newList=Arrays.stream(array).limit(5).collect(Collectors.toList());

skip

跳过前n个元素

//跳过前5个元素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=newArrayList<>();
students.add(newStudent("Mike", 10, "male", 88));
students.add(newStudent("Jack", 13,"male", 90));
students.add(newStudent("Lucy", 15,"female", 100));
students.add(newStudent("Jessie", 12,"female", 78));
students.add(newStudent("Allon", 16,"female", 92));
students.add(newStudent("Alis", 22,"female", 50));
//正序List<String>nameList=students.stream()
    .sorted(Comparator.comparing(Student::getScore))
    .map(Student::getName)
    .collect(Collectors.toList());
System.out.println("按成绩排序输出学生姓名："+nameList);
//倒序List<String>nameList2=students.stream()
    .sorted(Comparator.comparing(Student::getScore).reversed())
    .map(Student::getName)
    .collect(Collectors.toList());
System.out.println("按成绩排序输出学生姓名："+nameList2);
//按成绩排序输出学生姓名：[Alis, Jessie, Mike, Jack, Allon, Lucy]//按成绩排序输出学生姓名：[Lucy, Allon, Jack, Mike, Jessie, Alis]正序：list=list.stream().sorted().collect(Collectors.toList());
或者list.stream().sorted(Comparator.comparing(Student::getAge)) ;
倒序：list.stream().sorted(Comparator.comparing(Student::getAge)) ;
list.stream().sorted(Comparator.comparing(Student::getAge).reversed());
//含空值的正序（升序）排序(按创建时间排序) nullsFirst：空值放第一位list=list.stream().sorted(Comparator.comparing(l->l.getCreateTime(), Comparator.nullsFirst(Date::compareTo))).collect(Collectors.toList());
//nullsLast：空值放最后list=list.stream().sorted(Comparator.comparing(l->l.getCreateTime(), Comparator.nullsLast(Date::compareTo).reversed())).collect(Collectors.toList());

短路操作

findAny

找出 stream 中任何一个满足过滤条件的元素。

List<Student> students = new ArrayList<>();

students.add(newStudent("Mike", 10, "male", 88));
students.add(newStudent("Jack", 13,"male", 90));
students.add(newStudent("Lucy", 15,"female", 100));
students.add(newStudent("Jessie", 12,"female", 78));
students.add(newStudent("Allon", 16,"female", 92));
students.add(newStudent("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

是否存在任意一个满足给定条件的元素。

booleanresult1=students.stream().anyMatch(x->x.getScore() >90);
System.out.println("是否存在成绩高于 90 分的学生："+result1);
booleanresult2=students.stream().anyMatch(x->x.getScore() <50);
System.out.print("是否存在成绩低于 50 分的学生："+result2);
// out: 是否存在成绩高于 90 分的学生：true//      是否存在成绩低于 50 分的学生：false

allMatch

是否集合中所有元素都满足给定的条件，如果集合是空，则返回 true。

booleanresult1=students.stream().allMatch(x->x.getScore() >90);
System.out.println("是否所有学生的成绩都高于90分："+result1);
booleanresult2=students.stream().allMatch(x->x.getScore() >50);
System.out.print("是否所有学生的成绩都高于50分："+result2);
// out: 是否所有学生的成绩都高于 90 分：false//      是否所有学生的成绩都高于 50 分：true

noneMatch

是否没有元素能匹配给定的条件，如果集合是空，则返回true。booleanresult1=students.stream().noneMatch(x->x.getScore() >90);
System.out.println("是不是没有学生成绩在 90 分以上："+result1);
booleanresult2=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<String>stream=Arrays.asList("ab", "abc", "abcd", "abcde", "abcdef").stream();
String[] newArray1=stream.toArray(str->newString[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=newArrayList<>();
students.add(newStudent("Mike", 10, "male", 88));
students.add(newStudent("Jack", 13,"male", 90));
students.add(newStudent("Lucy", 15,"female", 100));
students.add(newStudent("Jessie", 12,"female", 88));
students.add(newStudent("Allon", 16,"female", 92));
students.add(newStudent("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);
longcount=list.stream().collect(Collectors.counting());
intsum=list.stream().collect(Collectors.summingInt(r->r));
doubleaverage=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=newArrayList<>();
students.add(newStudent("Mike", 10, "male", 88));
students.add(newStudent("Jack", 10,"male", 90));
students.add(newStudent("Lucy", 12,"female", 100));
students.add(newStudent("Jessie", 12,"female", 78));
students.add(newStudent("Allon", 16,"female", 92));
students.add(newStudent("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 中的元素用指定的连接符合并，连接符可以是空。

StringstudentNames=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);
intlistSum=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

Java Stream使用

整体介绍

创建steam

无状态操作

map：

mapToXXX

flatMap

flatMapToXXX

filter

peek

unordered

有状态操作

distinct

limit

skip

sorted

短路操作

findAny

anyMatch

allMatch

noneMatch

findFirst

非短路操作

forEach

forEachOrdered

toArray

reduce

collect

归集成新集合

统计功能

分区和分组

连接

规约

max、min、count

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java Stream使用

整体介绍

创建steam

无状态操作

map：

mapToXXX

flatMap

flatMapToXXX

filter

peek

unordered

有状态操作

distinct

limit

skip

sorted

短路操作

findAny

anyMatch

allMatch

noneMatch

findFirst

非短路操作

forEach

forEachOrdered

toArray

reduce

collect

归集成新集合

统计功能

分区和分组

连接

规约

max、min、count

热门文章

最新文章

相关课程

相关电子书

相关实验场景