文章目录
- 一、流简介
- 二、创建流
- 2.1 由值创建流：of
- 2.2 由列表创建流：stream
- 2.3 由 Builder 创建流：build
- 2.4 由文件生成流：lines
- 2.5 由函数生成流
- 2.5.1 迭代（如果不做限制，就是创建无限流）：iterate
- 2.5.2 生成：generate
- 三、常用操作
- 3.1 筛选
- 3.1.1 filter
- 3.1.2 limit
- 3.2 映射
- 3.2.1 map
- 3.3 查找和匹配
- 3.3.1 anyMatch
- 3.3.2 allMatch
- 3.3.3 findAny
- 3.3.4 findFirst
- 3.4 规约
- 3.4.1 reduce
- 3.4.1.1 元素求和
- 3.4.1.2 最大值
- 3.4.1.3 最小值
- 3.5 数值流
- 3.5.1 对象流映射到数值流
- 3.5.1.1 mapToInt
- 3.5.1.2 mapToDouble
- 3.5.1.3 mapToLong
- 3.5.2 数值流转换回对象流
- 3.5.2.1 boxed
- 3.5.3 数值流的应用
一、流简介
- 流式 API 从 Java8 开始引入，支持链式书写。
- 流在管道中流通，在节点被处理。
- Stream是独特的，既不同于io，也不同于List。
- Stream在理论上能容纳无限对象，List不能
- 流不是一种数据结构，流存储的只是一种数据视图。
- 流的计算是惰性计算，真正的计算通常只发生在最后的结果获取时。流式计算存在第一步、中间一步、最后一步的说法，只有当到达最后一步执行函数的时候，整个惰性函数才会执行。
- 流只能消费一次，不能被两次消费
如下的代码，对stream进行了两次遍历，所以会报错
List<String> stringList = Arrays.asList("Java", "Python", "C++", "Matlab");
Stream<String> stream = stringList.stream();
stream.forEach(System.out::println);
stream.forEach(System.out::println);
二、创建流
2.1 由值创建流：of
方法一：使用静态方法 Stream.of() ，通过显式值创建一个流
Stream<String> stream = Stream.of("Java","Python","C++","Matlab");String[] arr = new String[]{"Java","Python","C++","Matlab"};
Stream<String> stream = Stream.of(arr);2.2 由列表创建流：stream
方法二：使用 Collection 的 stream() 方法，创建一个流
List<String> list = Arrays.asList("Java","Python","C++","Matlab");
Stream<String> stream = list.stream();2.3 由 Builder 创建流：build
方法三：使用 builder() 创建一个流
Stream<String> stream = Stream.<String>builder()
.add("Java")
.add("Python")
.add("C++")
.add("Matlab")
.build();2.4 由文件生成流：lines
方法四：使用 Files.lines() 创建一个流
Stream<String> stream = null;
try {
stream = Files.lines(Paths.get("data.txt"), Charset.defaultCharset());
}catch (IOException e){
e.printStackTrace();
}2.5 由函数生成流
2.5.1 迭代（如果不做限制，就是创建无限流）：iterate
Stream<Integer> stream = Stream.iterate(0, n -> n + 2)
.limit(10);
stream.forEach(System.out::println); // 0,2,4,6,8,10,12,14,16,18下面用迭代的方法生成斐波那契数列：
Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1], t[0] + t[1]})
.limit(10)
.forEach(t -> {
System.out.println(t[0] + " " + t[1]);
});输出如下：
0 1
1 1
1 2
2 3
3 5
5 8
8 13
13 21
21 34
34 552.5.2 生成：generate
下面是生成 4 个随机数的代码
// 0.24958123386777675,0.3934127178560789,0.45154850021573034,0.005268717434774417,
Stream.generate(Math::random)
.limit(4)
.forEach(num -> System.out.print(num + ","));三、常用操作
这是下面例子中会用到的学生对象，下面会利用流式编程，对学生列表进行一系列操作
static class Student{
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}下面是获取学生列表的函数，后面都会以这个学生列表进行举例说明
public static List<Student> createStudentList(){
return Arrays.asList(
new Student("WSKH",21),
new Student("WRQ",22),
new Student("SXC",20),
new Student("XCY",36),
new Student("CZG",40),
new Student("LHH",18)
);
}在后面，假设我们已经通过上面的函数获取到了学生列表，并将其命名为 studentList
List<Student> studentList = createStudentList();3.1 筛选
3.1.1 filter
filter()：返回一个包括所有符合谓词的元素的流
应用实例：获取年龄在 25 以下的学生
List<Student> result = studentList.stream().filter(student -> {
return student.age < 25;
}).collect(Collectors.toList());3.1.2 limit
limit(n)：该方法会返回一个不超过给定长度的流
应用实例：获取年龄在25以下的学生，并且要求结果中的学生不超过2位
List<Student> result = studentList.stream().filter(student -> {
return student.age < 25;
}).limit(2).collect(Collectors.toList());3.2 映射
3.2.1 map
map()：对流中每一个元素应用函数
应用案例：获取所有学生的年龄
List<Integer> result = studentList.stream().map(student -> {
return student.age;
}).collect(Collectors.toList());应用案例：获取所有学生的名字
List<String> result = studentList.stream().map(student -> {
return student.name;
}).collect(Collectors.toList());3.3 查找和匹配
3.3.1 anyMatch
anyMatch()：判断流中是否有一个元素能匹配给定的谓词
应用案例：判断是否有小于等于18岁的学生
boolean b = studentList.stream().anyMatch(student -> student.age <= 18);3.3.2 allMatch
allMatch()：判断流中的元素是否都能匹配给定的谓词
应用案例：判断是否所有的学生都大于18岁
boolean b = studentList.stream().allMatch(student -> student.age > 18);3.3.3 findAny
findAny()：返回当前流中的任意元素
应用案例：获取任意一个大于25岁的学生
Optional<Student> any = studentList.stream().filter(student -> {
return student.age > 25;
}).findAny();
System.out.println(any); // Optional[Student{name='XCY', age=36}]3.3.4 findFirst
findFirst()：返回当前流中的第一个元素
应用案例：获取学生列表中第一个大于25岁的学生
Optional<Student> first = studentList.stream().filter(student -> {
return student.age > 25;
}).findFirst();
System.out.println(first); // Optional[Student{name='XCY', age=36}]3.4 规约
3.4.1 reduce
reduce(p1,p2)：操作组合流中的所有元素以产生单个值。
reduce的第一个参数：初始值，相当于给求和或者求最大最小值一个初值
reduce的第二个参数：一个BinaryOperator来将两个元素结合起来产生一个新值
3.4.1.1 元素求和
应用案例：求出学生们的年龄总和
int sum = studentList.stream().map(student -> {
return student.age;
}).reduce(0, (a, b) -> a + b);
System.out.println(sum); // 157也可以简写如下，用 Integer::sum 简化 (a, b) -> a + b
int sum = studentList.stream().map(student -> {
return student.age;
}).reduce(0, Integer::sum);
System.out.println(sum); // 1573.4.1.2 最大值
应用案例：求出学生们的最大年龄
int maxAge = studentList.stream().map(student -> {
return student.age;
}).reduce(0, (a, b) -> a > b ? a : b);
System.out.println(maxAge); // 403.4.1.3 最小值
应用案例：求出学生们的最小年龄
int minAge = studentList.stream().map(student -> {
return student.age;
}).reduce(Integer.MAX_VALUE, (a, b) -> a < b ? a : b);
System.out.println(minAge); // 183.5 数值流
在Java中，因为Java泛型不支持基本类型，所以我们无法使用像Stream这样的形式来保存int，只能采用形如Integer这样的形式。但是频繁装箱、拆箱操作会牺牲编译器的大量性能。
所以为了提高效率，Java标准库提供了三种使用基本类型的Stream，它们的使用和标准的Stream没有太大区别，直接使用：
- IntStream
- LongStream
- DoubleStream
他们也被称为数值流。
3.5.1 对象流映射到数值流
3.5.1.1 mapToInt
mapToInt()：返回一个 IntStream（而不是一个Stream）
IntStream intStream = studentList.stream().mapToInt(student -> student.age);3.5.1.2 mapToDouble
mapToDouble()：返回一个 DoubleStream（而不是一个Stream）
DoubleStream doubleStream = studentList.stream().mapToDouble(student -> student.age);3.5.1.3 mapToLong
mapToLong()：返回一个 LongStream（而不是一个Stream）
LongStream longStream = studentList.stream().mapToLong(student -> student.age);3.5.2 数值流转换回对象流
3.5.2.1 boxed
boxed()：要把原始流转换成一般流（这里每个int都会装箱成一个Integer）
IntStream intStream = studentList.stream().mapToInt(student -> student.age);
Stream<Integer> boxed = intStream.boxed();3.5.3 数值流的应用
应用案例：求出学生们的年龄总和
int sum = studentList.stream().mapToInt(student -> student.age).sum();
System.out.println(sum); // 157应用案例：求出学生们的最大年龄
OptionalInt max = studentList.stream().mapToInt(student -> student.age).max();
System.out.println(max.isPresent() ? max.getAsInt() : "不存在最大值"); // 40应用案例：求出学生们的最小年龄
OptionalInt min = studentList.stream().mapToInt(student -> student.age).min();
System.out.println(min.isPresent() ? min.getAsInt() : "不存在最小值"); // 18应用案例：求出学生们的平均年龄
OptionalDouble average = studentList.stream().mapToInt(student -> student.age).average();
System.out.println(average.isPresent() ? average.getAsDouble() : "不存在平均值"); // 26.166666666666668应用案例：求出大于25岁的学生的数量
long count = studentList.stream().mapToInt(student -> student.age).filter(age -> {
return age > 25;
}).count();
System.out.println(count); // 2
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
