在学习Java8新特性中Stream API和Optional类的时候，发现学习的时候不系统，用的时候总是忘记怎么去使用。所以总结一些实例，便于理解其使用。
Stream API
Stream简介
Stream 是Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用SQL 执行的数据库查询。也可以使用Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。
什么是Stream？
Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，流讲的是计算！”
注意事项
- Stream 自己不会存储元素。
- Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
- Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
Stream的使用
Stream操作的三个步骤
- 创建Stream
一个数据源（如：集合、数组），获取一个流 - 中间操作
一个中间操作链，对数据源的数据进行处理 - 终止操作(终端操作)
一个终止操作，执行中间操作链，并产生结果
图解Stream的操作步骤
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qb9v9dBL-1592729583891)(F:\知识库\Java\Java8新特性\Java8新特性.assets\image-20200620202143071.png)]
创建Stream
1.通过集合创建Stream
Java8 中的Collection 接口被扩展，提供了两个获取流的方法：
default Stream<E> stream(): 返回一个顺序流default Stream<E> parallelStream(): 返回一个并行流
2.通过数组创建Stream
Java8 中的Arrays 的静态方法stream() 可以获取数组流：
static <T> Stream<T> stream(T[] array): 返回一个流
重载形式，能够处理对应基本类型的数组：
public static IntStream stream(int[] array)public static LongStream stream(long[] array)public static DoubleStream stream(double[] array)
3.通过Stream的静态方法of()创建Stream
可以调用Stream类静态方法of(), 通过显示值创建一个流。它可以接收任意数量的参数。
public static<T> Stream<T> of(T... values): 返回一个流
4.创建无限流
可以使用静态方法Stream.iterate() 和Stream.generate(),创建无限流。
- 迭代
public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) - 生成
public static<T> Stream<T> generate(Supplier<T> s)
示例
@Test
public void test1 () {
//1. Collection 提供了两个方法 stream() 与 parallelStream()
List<String> list = new ArrayList<>();
//获取一个顺序流
Stream<String> stream = list.stream();
//获取一个并行流
Stream<String> parallelStream = list.parallelStream();
//2. 通过 Arrays 中的 stream() 获取一个数组流
Integer[] nums = new Integer[10];
Stream<Integer> stream1 = Arrays.stream(nums);
//3. 通过 Stream 类中静态方法 of()
Stream<Integer> stream2 = Stream.of(1,2,3,4,5,6);
//4. 创建无限流
//迭代
Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2).limit(10);
stream3.forEach(System.out::println);
//生成
Stream<Double> stream4 = Stream.generate(Math::random).limit(2);
stream4.forEach(System.out::println);
}
Stream的中间操作
多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！
而在终止操作时一次性全部处理，称为“惰性求值”。
新建一个学生类，方便测试。
public class Student {
private String name;
private int age;
private Gender gender;
public Student () {
}
public Student ( String name, int age, Gender gender ) {
this.name = name;
this.age = age;
this.gender = gender;
}
public String getName () {
return name;
}
public void setName ( String name ) {
this.name = name;
}
public int getAge () {
return age;
}
public void setAge ( int age ) {
this.age = age;
}
public Gender getGender () {
return gender;
}
public void setGender ( Gender gender ) {
this.gender = gender;
}
@Override
public boolean equals ( Object o ) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name) &&
gender == student.gender;
}
@Override
public int hashCode () {
return Objects.hash(name, age, gender);
}
@Override
public String toString () {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", gender=" + gender +
'}';
}
/** 性别枚举 */
public enum Gender{
/** 男 */
MAN,
/** 女 */
WOMAN;
}
}
创建一个集合方便测试
List<Student> studentList = Arrays.asList(
new Student("李四", 59, Student.Gender.MAN),
new Student("张三", 18, Student.Gender.MAN),
new Student("王五", 28, Student.Gender.MAN),
new Student("赵小苗", 8, Student.Gender.WOMAN),
new Student("赵小苗", 8, Student.Gender.WOMAN),
new Student("李芳", 8, Student.Gender.WOMAN)
);
1.筛选与切片
| 方法 | 描述 |
|---|---|
| filter(Predicate p) | 接收Lambda ，从流中排除某些元素。 |
| distinct() | 筛选，通过流所生成元素的hashCode() 和equals() 去除重复元素 |
| limit(long maxSize) | 截断流，使其元素不超过给定数量。 |
| skip(long n) | 跳过元素，返回一个扔掉了前n 个元素的流。若流中元素不足n 个，则返回一个空流。与limit(n) 互补 |
使用示例
@Test
public void test2 () {
System.out.println("---测试filter，过滤信息---");
Stream<Student> studentStream = studentList.stream()
.filter(s -> s.getAge() > 20);
studentStream.forEach(System.out::println);
System.out.println("---测试limit,取前1个元素---");
studentList.stream()
.filter((e) -> e.getAge() >= 20)
.limit(1)
.forEach(System.out::println);
System.out.println("---测试skip，跳过1个元素---");
studentList.stream()
.filter((e) -> e.getAge() >= 20)
.skip(1)
.forEach(System.out::println);
System.out.println("---测试distinct，去重---");
studentList.stream()
.distinct()
.forEach(System.out::println);
}
结果：
---测试filter，过滤信息---
Student{name='李四', age=59, gender=MAN}
Student{name='王五', age=28, gender=MAN}
---测试limit,取前1个元素---
Student{name='李四', age=59, gender=MAN}
---测试skip，跳过1个元素---
Student{name='王五', age=28, gender=MAN}
---测试distinct，去重---
Student{name='李四', age=59, gender=MAN}
Student{name='张三', age=18, gender=MAN}
Student{name='王五', age=28, gender=MAN}
Student{name='赵小苗', age=8, gender=WOMAN}
2.映射
| 方法 | 描述 |
|---|---|
| map(Function f) | 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的素。 |
| mapToDouble(ToDoubleFunction f) | 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新DoubleStream。 |
| mapToInt(ToIntFunction f) | 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream。 |
| mapToLong(ToLongFunction f) | 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream。 |
| flatMap(Function f) | 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流 |
使用示例
public class StreamTest {
@Test
public void test3 () {
Stream<String> stringStream = studentList.stream()
.map(Student::getName);
stringStream.forEach(System.out::println);
//map与flatMap的区别 与list的add、addAll方法区别类似
List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
Stream<String> stream = strList.stream()
.map(String::toUpperCase);
stream.forEach(System.out::println);
Stream<Stream<Character>> stream2 = strList.stream()
.map(StreamTest::filterCharacter);
stream2.forEach((sm) -> {
sm.forEach(System.out::println);
});
System.out.println("---------------------------------------------");
Stream<Character> stream3 = strList.stream()
.flatMap(StreamTest::filterCharacter);
stream3.forEach(System.out::println);
}
private static Stream<Character> filterCharacter(String str){
List<Character> list = new ArrayList<>();
for (Character ch : str.toCharArray()) {
list.add(ch);
}
return list.stream();
}
}
3.排序
| 方法 | 描述 |
|---|---|
| sorted() | 产生一个新流，其中按自然顺序排序 |
| sorted(Comparatorcomp) | 产生一个新流，其中按比较器顺序排序 |
使用示例
@Test
public void test4 () {
System.out.println("---自然排序---");
studentList.stream()
.map(Student::getName)
.sorted()
.forEach(System.out::println);
System.out.println("---定制排序---");
studentList.stream()
.sorted((x,y)->{
if(x.getAge() == y.getAge()){
return x.getName().compareTo(y.getName());
}else{
return Integer.compare(x.getAge(), y.getAge());
}
})
.forEach(System.out::println);
}
结果：
---自然排序---
张三
李四
李芳
王五
赵小苗
赵小苗
---定制排序---
Student{name='李芳', age=8, gender=WOMAN}
Student{name='赵小苗', age=8, gender=WOMAN}
Student{name='赵小苗', age=8, gender=WOMAN}
Student{name='张三', age=18, gender=MAN}
Student{name='王五', age=28, gender=MAN}
Student{name='李四', age=59, gender=MAN}
终止操作
流进行了终止操作后，不能再次使用
1.查找与匹配
| 方法 | 描述 |
|---|---|
| allMatch(Predicate p) | 检查是否匹配所有元素 |
| anyMatch(Predicate p) | 检查是否至少匹配一个元素 |
| noneMatch(Predicatep) | 检查是否没有匹配所有元素 |
| findFirst() | 返回第一个元素 |
| findAny() | 返回当前流中的任意元素 |
| count() | 返回流中元素总数 |
| max(Comparatorc) | 返回流中最大值 |
| min(Comparatorc) | 返回流中最小值 |
| forEach(Consumerc) | 内部迭代 |
注：forEach(Consumerc)，内部迭代(使用Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)。
示例
@Test
public void test5 () {
boolean b1 = studentList.stream()
.allMatch(e -> e.getGender().equals(Student.Gender.WOMAN));
System.out.println("是否有女学生：" + b1);
Optional<Student> first = studentList.stream()
.sorted(( x, y ) -> {
return x.getAge() - y.getAge();
})
.findFirst();
System.out.println("得到年龄最小的学生：\n" + first.get());
long count = studentList.stream()
.filter(e->e.getGender().equals(Student.Gender.WOMAN))
.count();
System.out.println("女生数量：" + count);
}
结果：
是否有女学生：false
得到年龄最小的学生：
Student{name='赵小苗', age=8, gender=WOMAN}
女生数量：3
2.规约
| 方法 | 描述 |
|---|---|
| reduce(T iden, BinaryOperator b) | 可以将流中元素反复结合起来，得到一个值。返回T |
| reduce(BinaryOperator b) | 可以将流中元素反复结合起来，得到一个值。返回Optional |
注：map 和reduce 的连接通常称为map-reduce 模式，因Google 用它来进行网络搜索而出名。
@Test
public void test6 () {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Integer sum = list.stream()
.reduce(0, ( x, y ) -> x + y);
System.out.println(sum);
System.out.println("----------------------------------------");
Optional<Integer> op = studentList.stream()
.map(Student::getAge)
.reduce(Integer::sum);
System.out.println("所有学生年龄之和" + op.get());
}
结果：
55
----------------------------------------
所有学生年龄之和129
3.收集
| 方法 | 描述 |
|---|---|
| collect(Collector c) | 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法 |
Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到List、Set、Map)。但是Collectors 类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：
| 序号 | 方法 | 返回类型 | 描述 |
|---|---|---|---|
| 1 | toList | List | 把流中元素收集到List |
| 2 | toSet | Set | 把流中元素收集到Set |
| 3 | toCollection | Collection | 把流中元素收集到创建的集合 |
| 4 | counting | Long | 计算流中元素的个数 |
| 5 | summingInt | Integer | 对流中元素的整数属性求和 |
| 6 | averagingInt | Double | 计算流中元素Integer属性的平均值 |
| 7 | summarizingInt | IntSummaryStatistics | 收集流中Integer属性的统计值。如：平均值 |
| 8 | joining | String | 连接流中每个字符串 |
| 9 | maxBy | Optional | 根据比较器选择最大值 |
| 10 | minBy | Optional | 根据比较器选择最小值 |
| 11 | reducing | 归约产生的类型 | 从一个作为累加器的初始值开始，利用BinaryOperator与 流中元素逐个结合，从而归约成单个值 |
| 12 | collectingAndThen | 转换函数返回的类型 | 包裹另一个收集器，对其结果转换函数 |
| 13 | groupingBy | Map<K,List> | 根据某属性值对流分组，属性为K，结果为V |
| 14 | partitioningBy | Map<Boolean,List> | 根据true或false进行分区 |
使用示例：
@Test
public void test7 () {
//测试收集collect
List<String> list = studentList.stream()
.map(Student::getName)
.collect(Collectors.toList());
System.out.println("学生姓名转集合：" + list);
Set<String> set = studentList.stream()
.map(Student::getName)
.collect(Collectors.toSet());
System.out.println("学生姓名转Set，去重：" + set);
//求最小的学生年龄
Optional<Integer> minAge = studentList.stream()
.map(Student::getAge)
.collect(Collectors.minBy(Integer::compare));
System.out.println("求最小的学生年龄：" + minAge.get());
System.out.println("---根据性别分组---");
Map<Student.Gender, List<Student>> map = studentList.stream()
.collect(Collectors.groupingBy(Student::getGender));
System.out.println(map);
System.out.println("---根据年龄和性别多级分组---");
Map<Student.Gender, Map<String, List<Student>>> map2=studentList.stream()
.collect(Collectors.groupingBy(Student::getGender,Collectors.groupingBy(e->{
if(e.getAge() >= 60) {
return "老年";
} else if(e.getAge() >= 35) {
return "中年";
} else {
return "成年";
}
})));
System.out.println(map2);
System.out.println("---根据年龄分区---");
Map<Boolean, List<Student>> map3 = studentList.stream()
.collect(Collectors.partitioningBy((e) -> e.getAge() >= 30));
System.out.println(map3);
System.out.println("连接流的字符串");
String str = studentList.stream()
.map(Student::getName)
.collect(Collectors.joining("," , "----", "----"));
System.out.println(str);
System.out.println("规约收集，求所有学生年龄的和");
Optional<Integer> sum = studentList.stream()
.map(Student::getAge)
.collect(Collectors.reducing(Integer::sum));
System.out.println(sum.get());
}
结果：
学生姓名转集合：[李四, 张三, 王五, 赵小苗, 赵小苗, 李芳]
学生姓名转Set，去重：[李四, 张三, 赵小苗, 王五, 李芳]
求最小的学生年龄：8
---根据性别分组---
{WOMAN=[Student{name='赵小苗', age=8, gender=WOMAN}, Student{name='赵小苗', age=8, gender=WOMAN}, Student{name='李芳', age=8, gender=WOMAN}], MAN=[Student{name='李四', age=59, gender=MAN}, Student{name='张三', age=18, gender=MAN}, Student{name='王五', age=28, gender=MAN}]}
---根据年龄和性别多级分组---
{WOMAN={成年=[Student{name='赵小苗', age=8, gender=WOMAN}, Student{name='赵小苗', age=8, gender=WOMAN}, Student{name='李芳', age=8, gender=WOMAN}]}, MAN={成年=[Student{name='张三', age=18, gender=MAN}, Student{name='王五', age=28, gender=MAN}], 中年=[Student{name='李四', age=59, gender=MAN}]}}
---根据年龄分区---
{false=[Student{name='张三', age=18, gender=MAN}, Student{name='王五', age=28, gender=MAN}, Student{name='赵小苗', age=8, gender=WOMAN}, Student{name='赵小苗', age=8, gender=WOMAN}, Student{name='李芳', age=8, gender=WOMAN}], true=[Student{name='李四', age=59, gender=MAN}]}
连接流的字符串
----李四,张三,王五,赵小苗,赵小苗,李芳----
规约收集，求所有学生年龄的和
129
并行流与串行流
并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。
Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过parallel()与sequential()在并行流与顺序流之间进行切换。
了解Fork/Join 框架
Fork/Join 框架：就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行join 汇总.
图解
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CyG1g9O9-1592729583902)(F:\知识库\Java\Java8新特性\Java8新特性.assets\image-20200620212853966.png)]
Fork/Join 框架与传统线程池的区别
采用“工作窃取”模式（work-stealing）：
当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。
相对于一般的线程池实现,fork/join框架的优势体现在对其中包含的任务处理方式上。
在一般的线程池中,如果一个线程正在执行的任务由于某些原因无法继续运行,那么该线程会处于等待状态.
而在fork/join框架实现中,如果某个子问题由于等待另外一个子问题的完成而无法继续运行。那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行。
这种方式减少了线程的等待时间,提高了性能。
Optional类
Optional类的由来？解决空指针问题
到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。
以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。
受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。
Optional类简介
Optional 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用null 表示一个值不存在，现在Optional 可以更好的表达这个概念。并且可以避免空指针异常。
Optional类的Javadoc描述如下：
这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
Optional类的使用
创建Optional类对象
Optional.of(T t): 创建一个Optional 实例，t必须非空Optional.empty(): 创建一个空的Optional 实例Optional.ofNullable(T t)：若 t 不为 null,创建 Optional 实例,否则创建空实例（t可以为null）
判断Optional容器中是否包含对象
boolean isPresent(): 判断是否包含对象void ifPresent(Consumer<? super T> consumer)：如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它。
获取Optional容器的对象
T get(): 如果调用对象包含值，返回该值，否则抛异常T orElse(T other)：如果有值则将其返回，否则返回指定的other对象。T orElseGet(Supplier<? extends T> other)：如果有值则将其返回，否则返回由Supplier接口实现提供的对象。T orElseThrow(Supplier<? extends X> exceptionSupplier)：如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。
其他
map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
flatMap(Function mapper):与 map 类似，要求返回值必须是Optional
示例
@Test
public void test1 () {
//测试创建Optional
Optional<Student> op = Optional.of(new Student( "张三", 18, Student.Gender.MAN));
Optional<String> s = op.map(Student::getName);
String name = s.get();
System.out.println(name);
Optional<Student> op1 = Optional.ofNullable(null);
if (op1.isPresent()){
System.out.println(op1.get());
}else{
System.out.println("此对象为空");
}
System.out.println(op1.orElse(new Student( "默认", 18, Student.Gender.MAN)));
}
结果：
张三
此对象为空
Student{name='默认', age=18, gender=MAN}