jdk1.8已经发布好几年了，最新的已经发布到jdk12了，但是目前开发种还是jdk1.8用到的较多，最近在工作种用到了Stream，在这做个笔记整理学习。
什么是Stream
Stream是java8的新特性，位于包java.util.stream,但是和java的iostream完全不同，是对集合功能的增强，可以进行大批量的数据操作，分为并行和串行操作，结合java8 lambda表达式使用
使用步骤
获取一个数据源（source）→ 数据转换→执行操作获取想要的结果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。
有多种方式生成 Stream Source：
从 Collection 和数组
Collection.stream() //串行流
Collection.parallelStream() // 并行流
Arrays.stream(T array) or Stream.of()
从 BufferedReader
java.io.BufferedReader.lines()
静态工厂
java.util.stream.IntStream.range()
java.nio.file.Files.walk()
自己构建
java.util.Spliterator
其它
Random.ints()
BitSet.stream()
Pattern.splitAsStream(java.lang.CharSequence)
JarFile.stream()
常用操作
filter
过滤器，使用该方法过滤stream中的数据
List<Person> list = new ArrayList<>();
list.add(new Person("jack", 20));
list.add(new Person("mike", 25));
list.add(new Person("tom", 30));
/**
* stream filter
* x -> x.getAge() == 20 过滤条件保留年龄为20的用户
* 输出结果 [Person(name=jack, age=20)]
*/
list = list.stream().filter(x -> x.getAge() == 20).collect(Collectors.toList());
System.out.println(list);
distinct
去除重复数据，注意stream中的对象需要重写equal和hashcode方法
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person implements Comparable<Person> {
private String name;
private int age;
@Override
public int compareTo(Person o) {
return age-o.getAge();
}
}
list = new ArrayList<>();
list.add(new Person("jack", 20));
list.add(new Person("mike", 25));
list.add(new Person("jack", 20));
list.add(new Person("tom", 30));
System.out.println(list);
List<Person> list1 = list.stream().distinct().collect(Collectors.toList());
System.out.println(list1);
输出结果
此时new Person(“jack”, 20) 只保留了一条数据，去除了相同的数据
[Person(name=jack, age=20), Person(name=mike, age=25), Person(name=jack, age=20), Person(name=tom, age=30)]
[Person(name=jack, age=20), Person(name=mike, age=25), Person(name=tom, age=30)]
sorted
用于对stream中的数据排序，有三种方式
1.stream中对象实现java.lang.Comparable 接口，
2.也可以写内部类实现接口调用java.util.Comparator
3. 调用java.util.Comparator的抽象方法
// 1. 对象实现java.lang.Comparable 接口
List<Person> list2 = list.stream().sorted().collect(Collectors.toList());
System.out.println(list2);
//2 内部类实现接口调用java.util.Comparator
List<Person> list3 = list.stream().sorted((p1, p2) -> p1.getAge() - p2.getAge()).collect(Collectors.toList());
System.out.println(list3);
//3 调用java.util.Comparator的方法
list.stream().sorted(Comparator.comparingInt(Person::getAge));
limit
返回前n个数据
List<Person> list4 = list.stream()
.limit(2)
.collect(Collectors.toList());
System.out.println(list4);
System.out.println("----------------");
skip
去除前n个数据
List<Person> list5 = list.stream()
.skip(2)
.collect(Collectors.toList());
System.out.println(list5);
System.out.println("----------------");
map
map(T -> R) 将流中的每一个元素 T 映射为 R（类似类型转换）
这个是将listz person中name转换成单独的list
可以从数据库中查询出数据，然后再将某一列单独提取出来
// 将person中name字段单独提取出来，作为list
List<String> nameList = list.stream().map(Person::getName).collect(Collectors.toList());
System.out.println(nameList);
// 将name字段分别+aa
List<String> collect = nameList.stream().map(x -> x + "aa").collect(Collectors.toList());
System.out.println(collect);
System.out.println("----------------");
//将字符串分隔成字符数组，在合并为一个list
List<String> listS = new ArrayList<>();
listS.add("aaa bbb ccc");
listS.add("ddd eee fff");
listS.add("ggg hhh iii");
//collect1
List<String[]> collect1 = listS.stream().map(s -> s.split(" ")).collect(Collectors.toList());
collect1.forEach(strings -> Arrays.asList(strings).forEach(System.out::println));
System.out.println(collect1);
输出结果
----------------
[jack, mike, jack, tom]
[jackaa, mikeaa, jackaa, tomaa]
aaa
bbb
ccc
ddd
eee
fff
ggg
hhh
iii
collect1 的大小=3
flatMap(T -> Stream)
将流中的每一个元素 T 映射为一个流，再把每一个流连接成为一个流
List<String> listS = new ArrayList<>();
listS.add("aaa bbb ccc");
listS.add("ddd eee fff");
listS.add("ggg hhh iii");
List<String[]> collect1 = listS.stream().map(s -> s.split(" ")).collect(Collectors.toList());
collect1.forEach(strings -> Arrays.asList(strings).forEach(System.out::println));
System.out.println("collect1 的大小="+collect1.size());
/**
* ，我们的目的是把 List 中每个字符串元素以" "分割开，变成一个新的 List<String>。
* 首先 map 方法分割每个字符串元素，但此时流的类型为 Stream<String[ ]>，
* 因为 split 方法返回的是 String[ ] 类型；所以我们需要使用 flatMap 方法，先使用Arrays::stream将每个 String[ ] 元素变成一个 Stream<String> 流，
* 然后 flatMap 会将每一个流连接成为一个流，最终返回我们需要的 Stream<String>
*/
List<String> list6 = listS.stream().map(s -> s.split(" ")).flatMap(Arrays::stream).collect(Collectors.toList());
System.out.println(list6);
// 输出结果 [aaa, bbb, ccc, ddd, eee, fff, ggg, hhh, iii]
anyMatch
anyMatch(T -> boolean)
流中是否有一个元素匹配给定的 T -> boolean 条件
//匹配年龄为20的
boolean b = list.stream().anyMatch(person -> person.getAge() == 20);
System.out.println(b);
allMatch
流中是否所有元素都匹配给定的 T -> boolean 条件
boolean b1 = list.stream().allMatch(person -> person.getAge() == 20);
System.out.println(b1);
noneMatch(T -> boolean)
流中是否没有元素匹配给定的 T -> boolean 条件
boolean b2 = list.stream().noneMatch(person -> person.getAge() == 20);
System.out.println(b2);
findAny findFirst
findAny()：找到其中一个元素 （使用 stream() 时找到的是第一个元素；使用 parallelStream() 并行时找到的是其中一个元素）
findFirst()：找到第一个元素
值得注意的是，这两个方法返回的是一个 Optional 对象
Optional<Person> any = list.stream().findAny();
Person person = any.get();
System.out.println(person.getAge());
Optional<Person> first = list.stream().findFirst();
Person person1 = first.get();
System.out.println(person1.getAge());
reduce
reduce((T, T) -> T) 和 reduce(T, (T, T) -> T)
用于组合流中的元素，如求和，求积，求最大值等
list.stream().map(Person::getAge).reduce(0,Integer::sum);
list.stream().map(Person::getAge).reduce(Integer::sum);
list.stream().map(Person::getAge).reduce(0,(a,b3)-> a+b3); // （a,b） 是在整个{}范围内生效，假设说定义一个private String a, 则会和（a.b ）有冲突
count
返回流中元素个数，结果为 long 类型
List aa = null;
long count = list.stream().count();
System.out.println(count);
System.out.println("----------------");
unordered()
返回一个等效的无序流，
当然如果流本身就是无序的话，那可能就会直接返回其本身
扫一扫
355
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
