Stream流

Stream流

Java8 API添加了一个新的抽象称为流 Streram 可以让你以一种声明的方式处理数据。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

Stream（流）是一个来自数据源的元素队列并支持聚合 操作。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9SJGjNM3-1600866251861)(file:///C:\Users\coin\AppData\Local\Temp\ksohtml17364\wps22.jpg)]元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s4SirbUP-1600866251866)(C:\Users\coin\AppData\Local\Temp\ksohtml17364\wps2.jpg)]数据源 流的来源。 可以是集合，数组等

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pirR827x-1600866251867)(file:///C:\Users\coin\AppData\Local\Temp\ksohtml17364\wps24.jpg)]聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。

Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作(bulk data operation)。

1. Stream的操作三个步骤

1、创建Stream

一个数据源（如：集合、数组），获取一个流

2、中间操作

一个中间操作链，对数据源的数据进行处理

3、终止操作

一个终止操作，执行中间操作链，并产生结果

1.1. 创建Stream

/**
* StreamAPI三个操作步骤：
* 1、创建Stream
* 2、中间操作
* 3、终止操作
*/
public class TestStreamAPI1 {
	// 创建Stream
	public void test1() {
		// 1、可以通过Conllection系列集合提供的顺序流stream()或并行流parallelStream()
		List<String> list = new ArrayList<>();
		Stream<String> stream1 =
list.stream();
		stream1 = list.parallelStream();
        
		// 2、通过Arrays中的静态方法stream()获取数据流
		Integer ints[] = new Integer[10];
		Stream<Integer> stream2 =Arrays.stream(ints);
        
		// 3、通过Stream类中的静态方法of()
		Stream<String> stream3 =Stream.of("aa", "bb", "cc");
		String str[] = new String[10];
		Stream<String> stream4 =Stream.of(str)
	}
}

1.2. Stream的中间操作

​ 多个中间操作可以连接起来形成一个流水线,除非流水线上触发终止操作,否则中间操作不会执行任何的处理,而在终止操作时一次性全部处理,称为”惰性求值”。

1.2.1. 筛选和切片

filter

List<Employee> emps = Arrays.asList(
	new Employee("张三", 18, 3333.33),
	new Employee("李四", 38, 4444.44),
	new Employee("王五", 50, 5555.55),
	new Employee("赵六", 16, 6666.66),
	new Employee("田七", 28, 7777.77)
);
// filter-接收Lambda，从流中排除某些元素
public void test1() {
	Stream<Employee> stream = emps.stream()
		.filter((e) -> {
			System.out.println("StreamAPI的中间操作");
			return e.getAge() > 35;
});
// 终止操作：一次性执行全部内容，即“惰性求值”
stream.forEach(System.out::println);
}

limit

// limit-截断流，使其元素不超过给定数量
public void test2() {
emps.stream()
.filter((e) -> e.getSalary() > 5000)
.limit(2)
.forEach(System.out::println);
}

skip

// skip-跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流。
public void test3() {
	emps.stream()
	.filter((e) -> e.getSalary() > 5000)
	.skip(2)
	.forEach(System.out::println);
}

distinct

// distinct-筛选，通过流所生产元素的hashCode()和equals()去除重复元素
public void test4() {
	emps.stream()
	.filter((e) -> e.getSalary() > 5000)
	.distinct()
	.forEach(System.out::println);
}

1.2.2. 排序

sorted(Comparable)-自然排序

// sorted(Comparable)-自然排序
public void test1() {
	List<String> list = Arrays.asList("cc","aa", "bb", "ee", "dd");
	list.stream()
		.sorted()
		.forEach(System.out::println);
}

sorted(Comparator)-定制排序

// sorted(Comparator)-定制排序
// 需求：按年龄排序，年龄一样按姓名排序
public void test2() {
	emps.stream()
	.sorted((e1, e2) -> {
		if(e1.getAge().equals(e2.getAge())) {
			return
		e1.getName().compareTo(e1.getName());
		}else {
			return
		e1.getAge().compareTo(e2.getAge());
	}
	}).forEach(System.out::println);
}

1.3. 终止操作

1.3.1. 查找与匹配

public void test1() {
// allMatch-检查是否匹配所有元素
boolean b1 = emps.stream()
.allMatch((e) ->
e.getStatus().equals(Status.BUSY));
System.out.println(b1);
// anyMatch-检查是否至少匹配一个元素
    boolean b2 = emps.stream()
.anyMatch((e) ->
e.getStatus().equals(Status.BUSY));
System.out.println(b2);
// noneMatch-检查是否没有匹配所有元素
boolean b3 = emps.stream()
.noneMatch((e) ->
e.getStatus().equals(Status.OTHER));
System.out.println(b3);
// findFirst-返回第一个元素
// 需求：按工资排序，获取第一个员工信息
Optional<Employee> op1 = emps.stream()
.sorted((e1, e2) ->
Double.compare(e1.getSalary(),
e2.getSalary()))
.findFirst();
System.out.println(op1.get());
// findAny-返回当前流中的任意元素
// 需求：找一个空闲状态的员工，添加到开发团队中
Optional<Employee> op2 =
emps.parallelStream()// 并行流-多条线程进行，谁先
找到就是谁
.filter((e) ->
e.getStatus().equals(Status.FERR))
.findAny();
System.out.println(op2.get());
1.4. 收集（了解）
收集-将流转换为其他形式，接收一个Collertor接口的实
现，用于给Stream中元素做汇总的方法
// count-返回流中元素的总个数
Long count = emps.stream().count();
System.out.println(count);
// max-返回流中最大值
// 需求：获取工资最高的员工信息
Optional<Employee> op3 = emps.stream()
.max((e1, e2) ->
Double.compare(e1.getSalary(),
e2.getSalary()));
System.out.println(op3.get());
// min-返回流中最小值
// 需求：获取公司中工资最少员工的工资
Optional<Double> op4 = emps.stream()
.map(Employee::getSalary)
.min(Double::compare);
System.out.println(op4.get());
}

1.4. 收集

收集-将流转换为其他形式，接收一个Collertor接口的实现，用于给Stream中元素做汇总的方法.

// 需求：获取当前公司所有员工的姓名添加到集合中
// List-把流中所有元素收集到List中
List<String> list = emps.stream()
.map(Employee::getName)
.collect(Collectors.toList());
list.forEach(System.out::println);
// Set-把流中所有元素收集到Set中，删除重复项
Set<String> set = emps.stream()
.map(Employee::getName)
.collect(Collectors.toSet());
set.forEach(System.out::println);
// Map-把流中所有元素收集到Map中，当出现相同的key时会
抛异常
Map<String, Integer> map = emps.stream()
.collect(Collectors.toMap(Employee::getName,
Employee::getAge));
System.out.println(map);
// 员工总数
Long count = emps.stream()
.collect(Collectors.counting());
System.out.println(count);
注意：
1、Stream自己不会存储元素·
2、Stream不会改变源对象。相反，会返回一个持有结果
的新Stream。
// 工资平均数
Double avg = emps.stream()
.collect(Collectors.averagingDouble(Employee::
getSalary));
System.out.println(avg);
// 工资总和
Double sum = emps.stream()
.collect(Collectors.summingDouble(Employee::ge
tSalary));
System.out.println(sum);
// 工资最大值的员工
Optional<Employee> op = emps.stream()
.collect(Collectors.maxBy((e1, e2) ->
Double.compare(e1.getSalary(),
e2.getSalary())));
System.out.println(op.get());

注意：
1、Stream自己不会存储元素·
2、Stream不会改变源对象。相反，会返回一个持有结果
的新Stream。

​ 3、Stream操作是延迟执行的，这意味着他们会等到需要
m);
// 工资最大值的员工
Optional op = emps.stream()
.collect(Collectors.maxBy((e1, e2) ->
Double.compare(e1.getSalary(),
e2.getSalary())));
System.out.println(op.get());

**注意：**
	1、Stream自己不会存储元素·
	2、Stream不会改变源对象。相反，会返回一个持有结果
	的新Stream。

​	3、Stream操作是延迟执行的，这意味着他们会等到需要
结果的时候才执行。