Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合进行操作，就类似与使用SQL执行的数据库操作。也可以使用Stream API来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。
是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列
集合讲的是数据，流讲的是计算
PS：
下面的图可以比较直观的反映这一过程：
Java8中的Collection接口被扩展，提供了两个获取流的方法：
- default Stream
stream()：返回一个顺序流 - default Stream
parallelStream()：返回一个并行流
示例代码：
List<Integer> list = new ArrayList<>();
Stream<Integer> stream1 = list.stream();
Stream<Integer> stream2 = list.parallelStream();Java8的Arrays的静态方法stream()可以获取数据流
- static
Stream stream(T[] arrays)：返回一个流
示例代码：
Integer[] integers = new Integer[10];
Stream<Integer> stream = Arrays.stream(integers);通过Stream类中的静态方法of()，通过显示值创建一个流，可以接收任意数量的参数
- public static
Stream of(T ... values)：返回一个流
示例代码：
Stream<Integer> stream = Stream.of(1, 2, 3);使用静态方法Stream.iterate()和Stream.generate()，创建无限流
- 迭代：public static
Stream iterate(final T seed, final UnaryOperator f) - 生成：public static
Stream generate(Supplier s)
示例代码：
// 迭代
Stream stream1 = Stream.iterate(0, (x) -> x + 2);
// 生成
Stream stream2 = Stream.generate(() -> Math.random());多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称之为“惰性求值”。
- filter：结合搜lambda，从流中排除元素
- limit：截断流，使其元素不超过给定数量
- skip(n)：跳过元素，返回一个删除了前n个元素的流；若流中元素不足n个，则返回一个空流；与limit(n)互补
- distinct：筛选，通过流所生成的元素的hashCode()和equals()去除重复元素
示例代码：
public class TestStreamApi {
private static List<Demo> demoList = Arrays.asList(
new Demo(1, "哈哈哈"),
new Demo(2, "嘿嘿嘿嘿"),
new Demo(3, "呵呵呵"),
new Demo(4, "恩恩恩恩"),
new Demo(5, "哼哼哼"),
new Demo(6, "啧啧啧"),
new Demo(5, "哼哼哼"),
new Demo(8, "哼")
);
public static void main(String[] args) {
// 中间操作不会执行任何操作
Stream<Demo> demoStream = demoList.stream()
.filter((x) -> x.getRemark().length() == 3)
.limit(4)
.skip(1)
.distinct();
// 终止操作一次性执行全部内容
// 内部迭代：迭代操作由Stream API完成
demoStream.forEach(System.out::println);
}
}运行结果：
3-呵呵呵
5-哼哼哼
6-啧啧啧
注意：distinct筛选通过流所生成的元素的hashCode()和equals()去除重复元素，所以需要重写Demo的hashCode()和equals()方法。
- map：接收Lambda，将元素转换成其它形式或提取信息；接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
- flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连接成一个流
示例代码：
public class TestStreamApi {
private static List<Demo> demoList = Arrays.asList(
new Demo(1, "哈哈哈"),
new Demo(2, "嘿嘿嘿嘿")
);
public static void main(String[] args) {
demoList.stream()
.map(Demo::getRemark)
.flatMap(TestStreamApi :: filterCharacter)
.forEach(System.out::println);
}
public static Stream<Character> filterCharacter(String str) {
List<Character> list = new ArrayList<>();
for (Character c : str.toCharArray()) {
list.add(c);
}
return list.stream();
}
}运行结果：
哈
哈
哈
嘿
嘿
嘿
嘿
- sorted()：自然排序
- sorted(Comparator c)：定制排序
示例代码：
public class TestStreamApi {
private static List<Demo> demoList = Arrays.asList(
new Demo(5, "哈哈哈"),
new Demo(2, "嘿嘿嘿嘿"),
new Demo(3, "呵呵呵"),
new Demo(2, "哼哼哼"),
new Demo(5, "啧啧啧")
);
public static void main(String[] args) {
List<String> list = Arrays.asList("aaa", "bbb", "ccc");
list.stream()
.sorted()
.forEach(System.out::println);
System.out.println("----------");
demoList.stream()
.sorted((x, y) -> {
if (x.getNum().equals(y.getNum())) {
return x.getRemark().compareTo(y.getRemark());
} else {
return x.getNum().compareTo(y.getNum());
}
})
.forEach(System.out::println);
}
}运行结果：
aaa
bbb
ccc
----------
2-哼哼哼
2-嘿嘿嘿嘿
3-呵呵呵
5-哈哈哈
5-啧啧啧
- allMatch：检查是否匹配所有元素
- anyMatch：检查是否匹配所有元素
- noneMatch：检查是否没有匹配所有元素
- findFirst：返回第一个元素
- findAny：返回当前流中的任意元素
- count：返回流中元素的总个数
- max：返回流中的最大值
- min：返回流中的最小值
示例代码：
public class TestStreamApi2 {
private static List<Demo> demoList = Arrays.asList(
new Demo("张三", 18, 6666.66, Demo.Status.BUSY),
new Demo("李四", 38, 3333.33, Demo.Status.FREE),
new Demo("王五", 28, 5555.55, Demo.Status.FREE),
new Demo("赵六", 48, 7777.77, Demo.Status.BUSY),
new Demo("王二麻子", 58, 8888.88, Demo.Status.VOCATION)
);
public static void main(String[] args) {
// 是不是所有的对象都处于BUSY状态
System.out.println(demoList.stream()
.allMatch((d) -> d.getStatus().equals(Demo.Status.BUSY)));
// 是否有对象处于BUSY状态
System.out.println(demoList.stream()
.anyMatch((d) -> d.getStatus().equals(Demo.Status.BUSY)));
// 是否没有对象处于BUSY状态
System.out.println(demoList.stream()
.noneMatch((d) -> d.getStatus().equals(Demo.Status.BUSY)));
// 获取工资最高的
Optional<Demo> optionalDemo1 = demoList.stream()
.sorted((x, y) -> -Double.compare(x.getSalary(), y.getSalary()))
.findFirst();
System.out.println(optionalDemo1.get());
// 获取随机一个空闲的
Optional<Demo> optionalDemo2 = demoList.stream()
.filter((e) -> e.getStatus().equals(Demo.Status.FREE))
.findAny();
System.out.println(optionalDemo2.get());
// 总数
System.out.println(demoList.stream().count());
// 工资最高的
Optional<Demo> optionalDemo3 = demoList.stream()
.max((x, y) -> Double.compare(x.getSalary(), y.getSalary()));
System.out.println(optionalDemo3.get());
// 最小的工资
Optional<Double> optionalDemo4 = demoList.stream()
.map(Demo::getSalary)
.max(Double::compare);
System.out.println(optionalDemo4.get());
}
}
class Demo{
// 姓名
String name;
// 年龄
Integer age;
// 工资
Double salary;
// 状态
Status status;
public Demo() {}
public Demo(String name, Integer age, Double salary, Status status) {
this.name = name;
this.age = age;
this.salary = salary;
this.status = status;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Double getSalary() {
return salary;
}
public void setSalary(Double salary) {
this.salary = salary;
}
public Status getStatus() {
return status;
}
public void setStatus(Status status) {
this.status = status;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Demo demo = (Demo) o;
return name.equals(demo.name) &&
age.equals(demo.age) &&
salary.equals(demo.salary) &&
status == demo.status;
}
@Override
public int hashCode() {
return Objects.hash(name, age, salary, status);
}
@Override
public String toString() {
return "Demo{" +
"name='" + name + '\'' +
", age=" + age +
", salary=" + salary +
", status=" + status +
'}';
}
public enum Status{
FREE,
BUSY,
VOCATION
}
}运行结果：
false
true
false
Demo{name=‘王二麻子‘, age=58, salary=8888.88, status=VOCATION}
Demo{name=‘李四‘, age=38, salary=3333.33, status=FREE}
5
Demo{name=‘王二麻子‘, age=58, salary=8888.88, status=VOCATION}
8888.88
- reduce(T identify, BinaryOperator) / reduce(BinaryOperator)：可以将流中元素反复结合起来，得到一个值
示例代码：
public class TestStreamApi3 {
private static List<Demo> demoList = Arrays.asList(
new Demo("张三", 18, 6666.66, Demo.Status.BUSY),
new Demo("李四", 38, 3333.33, Demo.Status.FREE),
new Demo("王五", 28, 5555.55, Demo.Status.FREE),
new Demo("赵六", 48, 7777.77, Demo.Status.BUSY),
new Demo("王二麻子", 58, 8888.88, Demo.Status.VOCATION)
);
public static void main(String[] args) {
Optional<Double> optional = demoList.stream()
.map(Demo::getSalary)
.reduce(Double::sum);
System.out.println(optional.get());
}
}运行结果：
32222.190000000002
- collect：将流转换为其他形式。接收一个Collection接口的实现，用于给Stream中元素做汇总的方法
Collectors接口中方法的实现决定了如何对流执行收集操作（如搜集到List、Set、Map）。
- toList：把流中元素收集到List
- toSet：把流中元素收集到Set
- toCollection：把流中元素收集到创建的集合
- counting：计算流中元素的个数
- summingInt：对流中元素的整数属性求和
- averagingInt：计算流中元素Integer属性的平均值
- summarizingInt：收集流中Integer属性的统计值
- jioning：连接流中的每个字符串
- maxBy：根据比较器选择最大值
- minBy：根据比较器选择最小值
- reducing：从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而规约成单个值
- collectingAndThen：包裹另一个收集器，对其结果转换函数
- groupingBy：根据某个属性值对流分组，属性为K，结果为V
- partitioningBy：根据true、false进行分区
示例代码：
public class TestStreamApi4 {
private static List<Demo> demoList = Arrays.asList(
new Demo("张三", 18, 6666.66, Demo.Status.BUSY),
new Demo("李四", 38, 3333.33, Demo.Status.FREE),
new Demo("王五", 28, 5555.55, Demo.Status.FREE),
new Demo("赵六", 48, 7777.77, Demo.Status.BUSY),
new Demo("王二麻子", 58, 8888.88, Demo.Status.VOCATION)
);
public static void main(String[] args) {
HashSet<String> set = demoList.stream()
.map(Demo::getName)
.collect(Collectors.toCollection(HashSet::new));
set.forEach(System.out::println);
// 总数
System.out.println(demoList.stream()
.collect(Collectors.counting()));
// 工资平均值
System.out.println(demoList.stream()
.collect(Collectors.averagingDouble(Demo::getSalary)));
}
}运行结果：
李四
张三
王二麻子
王五
赵六
5
6444.438
原文：https://www.cnblogs.com/fx-blog/p/11745205.html