- Stream 关注的是对数据的运算，与CPU打交道
- 集合关注的数据的存储，与内存打交道
3、Stream 执行流程1.Stream 不会自己存储元素
2.Stream 不会改变源对象。相反，其会返回一个持有结果的新Stream
3.Stream 操作是延迟执行的，这意味着他们会等到需要结果的时候才执行
- Stream 的实例化
- 一系列的中间操作（过滤、映射。。。）
- 终止操作
4、Stream 创建 方式一： 通过集合说明：
一个中间操作链，对数据源的数据进行处理
一旦执行 终止操作，就会执行中间操作链，并产生结果，之后不会再被使用。
// 创建Stream方式一：通过集合
@Test
public void test1() {
List> employees = new EmpData().getEmployees();
// default Stream stream() ： 返回一个顺序流 (保持原数据的顺序)
Stream> stream = employees.stream();
// default Stream parallelStream()：返回一个并行流 （数据的顺序不能保证）
Stream> parallelStream = employees.parallelStream();
}
方式二：通过数组
// 创建 Stream方式二：通过数组
@Test
public void test2() {
int[] arr = {1, 2, 3, 4, 5};
// 调用Arrays类的Static Stream stream(T[] array) :返回一个流
IntStream stream = Arrays.stream(arr);
}
方式三：通过Stream 的of（）
// 创建 Stream方式三：通过 Stream的of()
@Test
public void test3() {
Stream stream = Stream.of(1, 2, 3);
}
方式四：创建无限流
// 创建 Stream 方式四：创建无限流
@Test
public void test4() {
// static Stream iterate(T seed,UnaryOperator f)
// 参数
//seed - 初始元素
//f - 要应用于前一个元素以生成新元素的函数
// 遍历前10个偶数
Stream.iterate(0,t -> t + 2).limit(10).forEach(System.out::println);
// 生成10个随机数
// static Stream generate(Supplier s)
Stream.generate(Math::random).limit(10).forEach(System.out::println);
}
5、Stream的中间操作
1、筛选与切片
public void test1(){
List> employees = EmpData.getEmployees();
// filter(Predicate predicate) --- 接收Lambda，从流中排除某些元素
Stream> stream = employees.stream();
// 查询年龄为16的员工信息
stream.filter(e -> e.get("age").equals("16")).forEach(System.out::println);
// limit(long maxSize) : 截断流，使其元素不超过给定数量
employees.stream().limit(2).forEach(System.out::println);
// skip(long n)：跳过几个元素，返回由该流的n元素组成的流。 如果此流包含少于n元素，那么将返回一个空流。
employees.stream().skip(1).forEach(System.out::println);
// distinct() ： 去重
System.out.println();
Map map = new HashMap<>();
map.put("name", "张三");
map.put("age", "12");
employees.add(map);
employees.stream().distinct().forEach(System.out::println);
}
2、映射
// 映射
@Test
public void test2() {
// map(Function f) : 接收一个函数作为参数，将元素转换为其它形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素
// 将所有字母转为大写
List list = Arrays.asList("aa", "bb", "cc");
list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
// 获取员工姓名长度大于3的员工的姓名
List> employees = EmpData.getEmployees();
Stream nameStream = employees.stream().map(e -> String.valueOf(e.get("name")));
nameStream.filter(name -> name.length() > 3).forEach(System.out::println);
// flatMap(Function f) : 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流，和 addAll()类似
// 当需要遍历每一个具体元素的时候，就用这个
}
3、排序
// 排序
@Test
public void test3() {
// sorted() ：自然排序
List list = Arrays.asList(11, 33, 22, 9, 55);
list.stream().sorted().forEach(System.out::println);
// sorted(Comparator c) : 定制排序
List> employees = EmpData.getEmployees();
employees.stream().sorted((e1,e2) -> {
int agevalue = Integer.compare(Integer.valueOf(String.valueOf(e1.get("age"))), Integer.valueOf(String.valueOf(e2.get("age"))));
if (agevalue != 0) {
return agevalue;
} else {
// 默认从小到大，如果需要从大到小，前面加 负号 - 。（ -return Integer.compare(Integer.valueOf(String.valueOf(e1.get("index"))), Integer.valueOf(String.valueOf(e2.get("index"))));）
return Integer.compare(Integer.valueOf(String.valueOf(e1.get("index"))), Integer.valueOf(String.valueOf(e2.get("index"))));
}
}).forEach(System.out::println);
}
6、Stream 的终止操作—（匹配与查找）
@Test
public void test1() {
List> employees = EmpData.getEmployees();
// allMatch(Predicate predicate)：检查所有元素是否符合要求
// 是否所有员工的年龄都大于17岁
boolean allMatch = employees.stream().allMatch(e -> Integer.valueOf(String.valueOf(e.get("age"))) > 17);
System.out.println(allMatch);
// anyMatch(Predicate predicate) : 检查是否至少有一个元素符合要求
// 是否至少有一个员工的年龄大于17岁
boolean anyMatch = employees.stream().anyMatch(e -> Integer.valueOf(String.valueOf(e.get("age"))) > 17);
System.out.println(anyMatch);
// noneMatch(Predicate predicate) : 检查是否没有符合要求的元素
// 检查是否没有姓张的员工
boolean noneMatch = employees.stream().noneMatch(e -> String.valueOf("name").startsWith("张"));
System.out.println(noneMatch);
// findFirst： 返回第一个元素
Optional> first = employees.stream().findFirst();
System.out.println(first);
// findAny()：返回当前流中的任意一个元素
Optional> any = employees.parallelStream().findAny();
System.out.println(any);
// count：返回流中元素的个数
// 查询年龄大于16的员工数量
long count = employees.stream().filter(e -> Integer.valueOf(String.valueOf(e.get("age"))) > 16).count();
System.out.println(count);
// max(Comparator comparator) ：返回流中最大值
// 查询员工最大的年龄为多少
Stream ageStream = employees.stream().map(e -> Integer.valueOf(String.valueOf(e.get("age"))));
Optional max = ageStream.max(Integer::compareTo);
System.out.println(max);
// min(Comparator comparator) ： 返回流中最小值
// 返回最低工资的员工信息
Optional> emp = employees.stream().min((e1, e2) -> Integer.compare(Integer.valueOf(String.valueOf(e1.get("age"))), Integer.valueOf(String.valueOf(e2.get("age")))));
System.out.println(emp);
// forEach(Consumer c) : 内部迭代
employees.stream().forEach(System.out::println);
}
7、Stream 的终止操作—（规约）
// 规约
@Test
public void test2() {
// reduce(T identity, BinaryOperator accumulator)：可以将流中元素反复结合起来，得到一个值
// 参数1 为 ：初始值
// 求 1 ~ 10 的和
List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Integer sum = list.stream().reduce(0, Integer::sum);
System.out.println(sum);
// reduce(BinaryOperator accumulator) ： 可以将流中元素反复结合起来，得到一个值
// 计算所有员工的年龄总和
List> employees = EmpData.getEmployees();
Stream ageStream = employees.stream().map(e -> Integer.valueOf(String.valueOf(e.get("age"))));
System.out.println(ageStream.reduce(Integer::sum));
}
8、Stream 的终止操作—（收集）
Collectors的方法
// 收集
@Test
public void test3() {
// Collect(Collector c) ： 将流转换为其它形式 。
// 查找年龄大于15的员工，结果返回一个List或者Set
List> employees = EmpData.getEmployees();
List> empList = employees.stream().filter(e -> Integer.valueOf(String.valueOf(e.get("age"))) > 15).collect(Collectors.toList());
empList.stream().forEach(System.out::println);
}
9、Optional类
