共计 8802 个字符，预计需要花费 23 分钟才能阅读完成。
Stream api
**Stream api 是 java8 中提供的对集合处理的 api，对数据进行一系列的中间操作，元数据不会发生改变
集合讲的是数据，流 讲的是计算（用于操作数据源，集合，数组）所生成的元素序列。**
Stream API 位于 java.util.stream.* 包下。1 Stream 自己不会存储元素
2 Stream 不会改变源对象。相反，他们会返回一个持有结果的性 Sstream。3 Stream 操作是延迟执行的。这以为这他们会等到需要结果的时候才执行（延迟加载）。
一 创建里 Stream 流的四种方式
### 1 第一种 通过 Collection 得 Stream（）方法（串行流）或者 parallelStream（）方法（并行流）创建 Stream。
List<String> list = Arrays.asList("1","2","3","4","0","222","33");
Stream<String> stream = list.stream();
Stream<String> stream1 = list.parallelStream();### 2 通过 Arrays 中得静态方法 stream（）获取数组流
IntStream stream = Arrays.stream(new int[]{1,2,3});### 3 通过 Stream 类中得 of（）静态方法获取流
Stream<String> stream = Stream.of("a","b","c");### 4 创建无限流 (迭代、生成)
// 迭代（需要传入一个种子，也就是起始值，然后传入一个一元操作）Stream<Integer> stream1 = Stream.iterate(2, (x) -> x * 2);
// 生成 (无限产生对象)
Stream<Double> stream2 = Stream.generate(() -> Math.random());
二 Stream 中间操作
多个中间操作可以连接起来形成一个流水线，除非流水线终止操作，否则中间操作不会执行任何处理。终止操作时一次性全部处理，称为“延迟加载”
1 筛选切片
1 过滤
List<String> list = Arrays.asList("1","2","3","4","0","222","33");
Stream<String> stream = list.stream().filter((x) -> {System.out.println("api 中建操作。");
return x.equals("3");
});
// 终止操作：只有执行终止操作才会执行全部。即：延迟加载
stream.forEach(System.out::println);结果
api 中建操作。api 中建操作。api 中建操作。3
api 中建操作。api 中建操作。api 中建操作。api 中建操作。2 limit() 截断流，使其元素不超过给定数量。
List<String> list = Arrays.asList("1","2","3","4","0","222","33","3","3");
Stream<String> stream = list.stream().filter((x) -> {System.out.println("api 中建操作。");
return x.equals("3");
});
// 取两个，可以配合其他得中间操作，并截断流，取到相应的元素个数，这不会往下执行，可以提高效率
stream.limit(2).forEach(System.out::println);3 skip(n) 跳过元素
skip（n），返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空，与 limit（n）互补。
List<String> list = Arrays.asList("1","2","3","4","0","222","33","3","3");
Stream<String> stream = list.stream().filter((x) -> {System.out.println("api 中建操作。");
return x.equals("3");
});
//skip（n），返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空，与 limit（n）互补。stream.skip(3).limit(1).forEach(System.out::println);4 筛选
distinct 通过流所生成元素的 hashCode（）和 equals（）去除重复元素
List<String> list = Arrays.asList("1","2","3","4","0","222","33","3","3");
Stream<String> stream = list.stream();
stream.distinct().forEach(System.out::println);1
2
3
4
0
222
335 映射
map – 接受 lambda 将元素转换为其他形式或提取信息。
接受一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新元素
flatMap 接受一个函数作为参数，将流中的每个值都转成另一个流，然后把所有流连成一个流。
List<Stu> stuList = Arrays.asList(new Stu("a",1),new Stu("ab",3),new Stu("c",11),new Stu("f",12));
Stream<Stu> stream = stuList.stream();
// 去除 list 中所有的年龄
stream.map(Stu::getAge).forEach(System.out::println);
// 把所有年龄再返回一个集合
List<Integer> collect = stream.map(Stu::getAge).collect(Collectors.toList());
stream.flatMap(stu -> test1.filterCharacter(stu.getName())).forEach(System.out::println);
6 排序
sorted 有两种方法，一种是不传任何参数，叫自然排序，还有一种需要传 Comparator 接口参数，叫做定制排序。
// 自然排序
List<String> collect = list.stream().sorted().collect(Collectors.toList());
List<String> collect2 = list.stream().sorted((o1, o2) -> {if(o1.length()>o2.length()){return 1;}else
if(o1.length()<o2.length()){return -1;}else {return 0;}
}).collect(Collectors.toList());
三 Stream 终止操作
实体类
public class Person {
String name ;
String sex ;
int age;
Status statusEnum;
public Person(String name, String sex, int age, Status statusEnum) {
this.name = name;
this.sex = sex;
this.age = age;
this.statusEnum = statusEnum;
}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public String getSex() {return sex;}
public void setSex(String sex) {this.sex = sex;}
public int getAge() {return age;}
public void setAge(int age) {this.age = age;}
public Status getStatusEnum() {return statusEnum;}
public void setStatusEnum(Status statusEnum) {this.statusEnum = statusEnum;}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
", statusEnum=" + statusEnum +
'}';
}
}
操作
List<Person> persons = Arrays.asList(new Person("张三", "男", 76, Status.FREE),
new Person("李四", "女", 12, Status.BUSY),
new Person("王五", "男", 35, Status.BUSY),
new Person("赵六", "男", 3, Status.FREE),
new Person("钱七", "男", 56, Status.BUSY),
new Person("翠花", "女", 34, Status.VOCATION),
new Person("翠花", "女", 34, Status.FREE),
new Person("翠花", "女", 34, Status.VOCATION)
);1 查找与匹配
##### 1 allMatch —— 检查是否匹配所有元素。
public void test1(){boolean allMatch = persons.stream().allMatch((x) -> {return x.getStatusEnum().equals(Status.FREE);
});
System.out.println(allMatch);
}2 anyMatch —— 检查是否至少匹配一个元素。
public void test2(){boolean allMatch = persons.stream().anyMatch((x) -> {return x.getStatusEnum().equals(Status.FREE);
});
System.out.println(allMatch);
}3 noneMatch —— 检查是否没有匹配所有元素。
检查 所有的是否都是 FREE ----- 结果是 false
public void test3(){boolean allMatch = persons.stream().noneMatch((x) -> {return x.getStatusEnum().equals(Status.FREE);
});
System.out.println(allMatch);
}4 findFirst —— 返回第一个元素。
public void test4(){Optional<Person> first = persons.stream().findFirst();
System.out.println(first.get());
}##### 5 findAny —— 返回当前流中任意元素。
public void test5(){Optional<Person> first = persons.stream().findAny();
//first.orElse(new Person()); 如果没空 可以穿一个新的对象去代替它
System.out.println(first.get());
}##### 6 count —— 返回流中元素总个数。
public void test6(){long first = persons.stream().count();
System.out.println(first);
}##### 7 max —— 返回流中最大值。
public void test7(){Optional<Person> person = persons.stream().max((x,y) -> Integer.compare(x.age, y.age));
System.out.println(person.get());
}##### 8 min —— 返回流中最小值。
public void test8(){Optional<Person> person = persons.stream().min((x,y) -> Integer.compare(x.age, y.age));
System.out.println(person.get());
}2 归约 : 可以将流中元素反复结合在一起，得到一个值
1 reduce（T identitty，BinaryOperator）首先，需要传一个起始值，然后，传入的是一个二元运算。
public void test9(){List<Integer> list = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// identitty 起始值 0 然后与集合中的值进行 相应的运算，再次赋值给 identity 然后 在进行运算。Integer sum = list.stream().reduce(0, (x, y) -> x + y);
System.out.println(sum);
}##### 2 reduce（BinaryOperator）此方法相对于上面方法来说，没有起始值，则有可能结果为空，所以返回的值会被封装到 Optional 中。
map 和 reduce 的连接通常称为 map-reduce 模式，因 Google 用它来进行网络搜索而出名。用 map 来提取 对象中某个属性，然后再用 reduce 进行归约。 public void test10() {Optional<Integer> reduce = persons.stream().map(Person::getAge).reduce(Integer::sum);
System.out.println(reduce.get());
}3 收集：收集 collect（将流转换为其他形式。接收一个 Collector 接口得实现，用于给其他 Stream 中元素做汇总的方法）
Collector 接口中方法得实现决定了如何对流执行收集操作（如收集到 List，Set，Map）。但是 Collectors 实用类提供了很多静态方法，可以方便地创建常见得收集器实例。1 Collectors.toList（）将流转换成 List
public void test11() {List<Person> collect = persons.stream().collect(Collectors.toList());
collect.forEach(System.out::println);
}###### 2 将流转换成 HashSet
public void test12() {
//hashset 会去重复
Set<String> collect = persons.stream().map(Person::getName).collect(Collectors.toSet());
collect.forEach(System.out::println);
}###### 3 将流转换成其他集合
public void test13() {Set<Integer> collect = persons.stream().map(Person::getAge).collect(Collectors.toCollection(LinkedHashSet::new));
collect.forEach(System.out::println);
}##### 4 Collectors.counting() 元素个数
public void test14() {Long collect = persons.stream().map(Person::getAge).collect(Collectors.counting());
System.out.println(collect);
}##### 5 将流转换为其他形式，接受一个 conllectors 接口的实现，用于给 Stream 中元素做汇总的方法
public void test14s() {
// 1 对元素进行汇总方法
DoubleSummaryStatistics collect = persons.stream().collect(Collectors.summarizingDouble(Person::getAge));
IntSummaryStatistics collect2 = persons.stream().collect(Collectors.summarizingInt(Person::getAge));
System.out.println(collect.getMax());
System.out.println(collect.getAverage());
System.out.println(collect.getCount());
System.out.println(collect.getMin());
System.out.println(collect.getSum());###### 2 讲元素转换为其他形式
String collect1 = persons.stream().map(Person::getName).collect(Collectors.joining("，","头","尾"));
String collect3 = persons.stream().map(Person::getName).collect(Collectors.joining());
System.out.println(collect1); // 头张三，李四，王五，赵六，钱七，翠花，翠花，翠花尾
System.out.println(collect3); // 张三李四王五赵六钱七翠花翠花翠花
}
1. Collectors.averagingDouble（）2 Collectors.averagingDouble()
3 Collectors.averagingLong()
平均数，这三个方法都可以求平均数，不同之处在于传入得参数类型不同，返回值都为 Double
public void test15() {Double s = persons.stream().collect(Collectors.averagingDouble(Person::getAge));
System.out.println(s);
}##### 8 Collectors.maxBy（）求最大值
public void test16() {Optional<Person> collect = persons.stream().collect(Collectors.maxBy((o1, o2) -> Integer.compare(o1.age, o2.age)));
System.out.println(collect.get().age);
}##### 9 Collectors.minBy（）求最小值
public void test17() {Optional<Person> collect = persons.stream().collect(Collectors.minBy((o1, o2) -> Integer.compare(o1.age, o2.age)));
System.out.println(collect.get().age);
}10 Collectors.groupingBy（）分组，返回一个 map
按照 Status 分组 public void test18() {Map<Status, List<Person>> collect = persons.stream().collect(Collectors.groupingBy(Person::getStatusEnum));
collect.forEach((status, people) -> {System.out.println("status ===" + status);
people.forEach(System.out::println);
});
}###### 11 多级分组
Collectors.groupingBy（）还可以实现多级分组 public void test19() {Map<Status, Map<String, List<Person>>> collect = persons.stream().collect(Collectors.groupingBy(Person::getStatusEnum,Collectors.groupingBy(Person::getSex)));
Map<Status, Map<String, List<Person>>> collect2 = persons.stream().collect(Collectors.groupingBy(Person::getStatusEnum,Collectors.groupingBy(
e->{if (e.getAge()>10){return "小孩";}else {return "大人";}
}
)));
System.out.println(collect);
System.out.println(collect2);
}##### 12 分区
Collectors.partitioningBy（）分区，参数中传一个函数，返回 true，和 false 分成两个区
public void test20() {年龄大于 39 的分区 不满足再的分区 Map<Boolean, List<Person>> collect = persons.stream().collect(Collectors.groupingBy(e -> e.getAge() > 30));
System.out.println(collect);
}
正文完
