# java8-learning **Repository Path**: baoqizhang/java8-learning ## Basic Information - **Project Name**: java8-learning - **Description**: java8新特性学习 - **Primary Language**: Unknown - **License**: Not specified - **Default Branch**: master - **Homepage**: None - **GVP Project**: No ## Statistics - **Stars**: 0 - **Forks**: 0 - **Created**: 2020-06-01 - **Last Updated**: 2020-12-19 ## Categories & Tags **Categories**: Uncategorized **Tags**: None ## README # Java8特性 [TOC] ## 1. Lambda 表达式 ### 与传统匿名内部类写法的对比无返回值 ```java // 传统写法 new Thread(new Runnable() { @Override public void run() { System.out.println("worker thread is running"); } }).start(); // lambda表达式的写法 new Thread(() -> System.out.println("worker thread is running")).start(); ``` 有返回值 ```java // 传统写法 ExecutorService executorService = Executors.newSingleThreadExecutor(); executorService.submit(new Callable() { @Override public String call() throws Exception { return "result"; } }); // lambda表达式的写法 ExecutorService executorService = Executors.newSingleThreadExecutor(); // 行内写法需要省略return Future future1 = executorService.submit(() -> "result"); // 多行写法return不能省略 Future future2 = executorService.submit(() -> { return "result"; }); ``` ### lambda表达式的使用方式 - 使用时声明 ```java // 单行写法，省略语句最后分号 new Thread(() -> System.out.println("单行写法")).start(); // 多行写法 new Thread(() -> { System.out.println("多行写法"); System.out.println("多行写法"); }).start(); // 赋值给一个变量/常量的写法 Runnable runnable = () -> System.out.println("赋值给一个变量/常量的写法"); new Thread(runnable).start(); ``` - 引用已有方法 ```java Stream.of("111", "-222", "333") .map(Integer::new) // 引用构造方法 .map(Math::abs) // 引用静态方法 .forEach(System.out::println); // 引用实例方法 // 等价于下面的写法 Stream.of("111", "-222", "333") .map(str -> new Integer(str)) .map(intVal -> Math.abs(intVal)) .forEach(val -> System.out.println(val)); ``` > 当lambda表达式的方法体仅仅是一个方法，并且lambda所有参数和这个方法的所有参数一样的时候可以使用"::"将方法转的引用化为lambda表达式 **Lambda表达式实质上是一个只有一个方法的接口的实例，而这个接口有个名字叫函数式接口（Functional Interface）** ## 2. 函数式接口（Functional Interface) 函数式接口是只有一个方法的接口，可以用注解@FunctionalInterface标记在接口上，例如 ```java @FunctionalInterface public interface Calculator { /** * 计算 * @param val1 运算数1 * @param val2 运算数2 * @return 计算结果 */ T calculate(T val1, T val2); } ``` > 注：@FunctionalInterface注解并不是必须的，但是可以帮助编译器检查你的接口是否只拥有一个方法，如果有多个方法，编译器会报错。凡是只有一个函数的接口，都可以使用lambda表达式来定义其实现，比如针对上面的Calculator接口，可以按照下面的方式使用： ```java // 声明换一个方法的参数包含Calculator @Data @AllArgsConstructor public class CalculatorData { private Integer val1; private Integer val2; private Integer calculate(Calculator calculator) { return calculator.calculate(this.val1, this.val2); } } // 调用端写法 CalculatorData context = new CalculatorData(3, 4); // 内联写法：加法 assert context.calculate((a, b) -> a + b) == 7; // 变量引用的写法：减法 Calculator minus = (a, b) -> a - b; assert context.calculate(minus) == -1; // 方法引用的写法：较大值 assert context.calculate(Integer::max) == 4; ``` 从上面代码可以看出，使用函数式接口可以简化策略模式的写法，也让策略的定义更加灵活。 ### Java内置的函数式接口 jdk1.8已经为我们提供了很多常用的函数式接口供我们使用，所有的接口定义，可以查看jdk源码的`java.util.function`包，这里介绍几种常见的函数式接口 #### 1. Function 一个入参，有返回值，常用于类型转换的场景。 ```java List stringList = Stream.of(1, 2, 3) // 这里的map方法参数就是一个Function .map(String::valueOf) .collect(Collectors.toList()); ``` Stream的map方法的参数就是一个Function，用于将stream中的元素转换成另一个元素 ##### Function的组合组合可以将多个Function的计算联合成一个Function，在下面的例子中，组合了三个Function操作： 1. 将一个Integer x 2 2. 将x2后的数字转换成字符串 3. 在转换后的字符串前面拼上“value is ” 最后组合成一个Integer输入，String输出的Function。 ```java Function doubleVal = i -> i * 2; Function func = doubleVal .andThen(String::valueOf) .andThen(str -> "value is " + str); // 在stream转换中 Stream.of(1, 2, 3, 4) .map(func) .forEach(System.out::println); // 直接使用 String result = func.apply(5); assert "value is 10".equals(result); ``` #### 2. Consumer 一个参数，无返回值，常用于回调函数中消费某个值。 ```java Stream.of(1, 2, 3) // 这里的forEach方法参数就是一个Consumer .forEach(System.out::println); ``` ##### Consumer的组合 ```java final StringBuilder sb = new StringBuilder(); // 控制台消费后StringBuilder再消费一次 Consumer consumer = ((Consumer) System.out::println) .andThen(sb::append); Stream.of(1, 2, 3, 4) .map(String::valueOf) .forEach(consumer); assert "1234".equals(sb.toString()); ``` #### 3. Predicate 一个入参，返回值为boolean类型，常用于某种条件判定。 ```java Stream.of(1, 2, 3) // filter的参数就是一个Predicate，用于过滤Stream中的元素，返回true是保留元素 .filter(i -> i > 2) .forEach(System.out::println); // 这里只会打印出3 ``` Predicate的组合 ```java User user = new User().setName("Clark"); // user != null 和 user.getName() != null 用and组合 Predicate userPredicate = ((Predicate) u -> u != null) .and(u -> u.getName() != null); User theUser = Optional.ofNullable(user) .filter(userPredicate) .orElseThrow(() -> new IllegalArgumentException("用户和用户名不能为空")); assert "Clark".equals(theUser.getName()); ``` #### 4. Supplier 没有参数，只要返回值，常用于延迟初始化某个值。 ```java String value = null; // 只有当value为空的，需要抛出异常的时候，才会在内部调用Supplier.get()初始化这段message Objects.requireNonNull(value, () -> "value can't be null"); ``` 延迟初始化对与创建哪些不需要立即创建的一些大对象或频繁创建，但很少真正使用的对象很有用，例如打印日志，通常情况下我们会先判断当前的日志级别是否是debug级别，如果是，才打印debug日志，可以避免无谓的日志信息String对象的创建： ```java // 通常打印debug日志的方式 if (log.isDebugEnabled()) { log.debug("some debug messages"); } ``` 我们通常会在项目中发现很多上述重复的代码，现在有了lambda和Supplier接口，我们可以对日志类加一层代理： ```java public void debug(Supplier messageSupplier) { if (log.isDebugEnabled()) { log.debug(messageSupplier.get()); } } ``` 在调用时，只需要 ```java debug(() -> "some debug messages"); ``` 上面的lambda表达式并不会真正初始化方法中的字符串，而是延迟到debug方法内部，if为空，真正用到的时候才会初始化这个字符串。这样大大简化了客户端使用的方式。 #### 5. 其他基于上述4中基本函数式接口的扩展接口 - Bi或者Binary开头的代表两个参数的版本，比如BiFunction是两个参数版本的Function，BiConsumer是两个参数版本的Consumer - UnaryOperator是入参和返回值类型一样的Function，BinaryOperator是两个入参和返回值类型一样的BiFunction，例如上面的Calculator其实就是一个BinaryOperator。 - 其他Int，Long，Double开头的函数式接口都是针对int long double这些非包装类型的封装，使用这些函数式接口可以更节省资源，因为一个int只占4个字节，而一个Integer对象要占16个字节。 ## 3. Stream API Stream API是java8中最常用的处理集合的API，充分运用的lambda表达式的优势，让程序员站在更高的抽象层面对集合进行操作 ### 3.1 Stream的创建方式 Stream的创建常用的方式有以下几种 ```java // 1.Stream的静态方法 Stream.of(), 转换数组为Stream Stream stream1 = Stream.of(1, 2, 3); // 2.使用Arrays.stream()方法，转换数组为Stream Stream stream2 = Arrays.stream(new Integer[]{1, 2, 3}); // 3.Collection.toStream()，转换Collection为Stream Stream stream3 = Arrays.asList(1, 2, 3).stream(); // 4.生成一个空的Stream Stream emptyStream = Stream.empty(); // 5.通过Stream.builder()创建包含指定元素的流 Stream buildStream = Stream.builder() .add(1).add(2).add(3) .build(); // 6.创建一个无限长度的流，这里生成一个无线长度的随机数流 final Random random = new Random(); Stream randomStream = Stream.generate(() -> random.nextInt(10)); // 通过limit截取指定长度后打印 randomStream.limit(10).forEach(System.out::print); // 7.使用迭代器创建一个无限的流 Stream iterStream = Stream.iterate(1, prev -> prev * 2); // 16 iterStream.limit(5).forEach(System.out::println); ``` ### 3.2 Stream的处理API #### Stream.map() 转换一个类型的列表转换成另一个类型的列表 ```java List list = Arrays.asList(1, 2, 3); List newList = list.stream() .map(i -> i * i) .map(String::valueOf) .collect(Collectors.toList()); // ["1", "4", "9"] System.out.println(newList); ``` #### Stream.filter() 过滤 filter的表达式，判断结果为true的元素保留下来 ```java List list = Arrays.asList(1, 2, 3); List newList = list.stream() .filter(i -> i > 1) .collect(Collectors.toList()); // [2, 3] System.out.println(newList); ``` #### Stream.flatMap() 展开子集合展开集合中每个元素的子集合到一个的集合中 ![](https://cdn.cnbj1.fds.api.mi-img.com/book/images/ecc9d917f0bd4f3a4c55e0bd7f060736?thumb=1&w=384&h=384) ```java // 假设现在有一组用户列表，每个用户有多个爱好 User user1 = new User() .setId(1) .setName("张三") .setHobbies(Arrays.asList("看书", "听音乐")); User user2 = new User() .setId(2) .setName("李四") .setHobbies(Arrays.asList("看电影", "乒乓球")); User user3 = new User() .setId(3) .setName("王五") .setHobbies(Arrays.asList("爬山", "履行")); List users = Arrays.asList(user1, user2, user3); // 要获取所有用户的所有的爱好，只需要这样 List hobbies = users.stream() .flatMap(user -> user.getHobbies().stream()) .collect(Collectors.toList()); // [看书, 听音乐, 看电影, 乒乓球, 爬山, 履行] System.out.println(hobbies); ``` #### Stream.forEach() 循环消费 ```java // Stream可以调用forEach方法 Stream.of(1, 2, 3, 4) .forEach(System.out::println); // List也可以直接调用forEach方法，不用先转成Stream Arrays.asList(1, 2, 3, 4) .forEach(System.out::println); ``` #### Stream.anyMatch()、allMatch()、noneMatch() 检查是否存在元素 ```java List list = Arrays.asList(1, 2, 3); boolean anyGreaterThanOne = list.stream().anyMatch(i -> i > 1); assert anyGreaterThanOne == true; boolean allGreaterThanOne = list.stream().allMatch(i -> i > 1); assert allGreaterThanOne == false; boolean noneGreaterThanOne = list.stream().noneMatch(i -> i > 1); assert noneGreaterThanOne == false; ``` #### Stream.distinct() 去重 ```java List list = Arrays.asList(1, 1, 2, 3, 3); List distinctList = list.stream() .distinct() .collect(Collectors.toList()); // [1, 2, 3] System.out.println(distinctList); ``` #### Stream.count() 计数 ```java List list = Arrays.asList(1, 2, 3); long count = list.stream() .filter(i -> i > 2) .count(); // 1 System.out.println(count); ``` #### Stream.skip()、limit() 分页 ```java Stream.iterate(1, prev -> prev + 1) // 1开始，自增1的无限序列 .skip(6) // 跳过前6个 .limit(3) // 取3个元素 .forEach(System.out::print); // 打印出789 ``` #### Stream.sorted() 排序 ```java List list = Stream.of("abcd", "a", "abc", "ab") .sorted(Comparator.comparingInt(String::length).reversed()) // 按字符串长度排序，逆序 .collect(Collectors.toList()); // [abcd, abc, ab, a] System.out.println(list); ``` #### Stream.reduce() 聚合 ```java // 求和的例子 List list = Arrays.asList(1, 2, 3, 4); // 初始值为0，累加所有元素 Integer sum1 = list.stream().reduce(0, (x, y) -> x + y); // 10 System.out.println(sum1); // 无初始值，计算结果为Optional，需要处理为空的情况后才能使用，因为结果stream中可能没有元素 Integer sum2 = list.stream() .reduce(Integer::sum) .orElse(0); // 10 System.out.println(sum2); // 聚合时目标类型和Stream中元素类型不同时，使用此重载方法 BigDecimal sum3 = list.stream() .reduce( BigDecimal.ZERO, //初始值 (prev, i) -> prev.add(BigDecimal.valueOf(i)), // 转换成目标类型后累加 BigDecimal::add // 多线程的parallelStream中，对每个线程的累加结果进行汇总的方法 ); // 10 System.out.println(sum3); ``` #### Stream.peek() 预览 ```java String result = Stream.of(1, 2, 3, 4) .map(i -> i * i) // 在流处理过程中提前窥视一下当前数据的样子 // 这里会分别打印出 1, 4, 9, 16 .peek(System.out::println) .map(i -> i * 2) .map(String::valueOf) .collect(Collectors.joining(",")); assert "2,8,18,32".equals(result); ``` ### 3.3 Stream的收集器 Stream的收集器是将Stream转换成具体的集合工具，Stream本身并不 Java 8的Stream本身在得到数据前并不会立即执行计算，而是将一系列操作按照顺序组合起来，形成一条方法链，只有在最后进行聚合、消费和收集的时候才会对Stream中的元素执行实际操作。这些惰性执行的方法判断起来也很容易，只需要打开Stream的源码，那些返回值是Stream的方法，就是惰性方法。 #### 简单集合收集器 ```java // 收集到ArrayList中 List list = Stream.of(1, 2, 3) .collect(Collectors.toList()); // 收集到HashSet中 Set set = Stream.of(1, 2, 3) .collect(Collectors.toSet()); // 收集到HashMap中 Map map = Stream.of( new User().setId(1).setName("Tom"), new User().setId(2).setName("Jeff"), new User().setId(3).setName("Jack") ) .collect( Collectors.toMap( User::getId, // 获取key的Function Function.identity()// 获取value的Function ) ); // 自定义收集器 // 第一种方式，用于Collection接口的子类，可以定义具体的实现类 LinkedList linkedList = Stream.of(1, 2, 3) .collect(Collectors.toCollection(LinkedList::new)); // 第二种方式，用于任何集合，是最灵活的方式 HashSet set = Stream.of(1, 2, 3) .collect( HashSet::new, // 定义一个用来收集结果的容器 HashSet::add, // 定义每个元素通过什么方法收集到容器中 HashSet::addAll // 定义并发情况下如何合并多个容器的结果 ); ``` #### 分块和分组收集 ##### 分块分块根据判断条件，分为判断结果为true和判断条件为false的两块集合 ![](https://cdn.cnbj1.fds.api.mi-img.com/book/images/3d2097bb2ae0857ea7e79e77bf6bbc52?thumb=1&w=384&h=384) ```java // 将奇数和偶数收集到map的两个List value中 Map> oddEvenMap = Stream.of(1, 2, 3, 4, 5) .collect(Collectors.partitioningBy(i -> i % 2 == 0)); System.out.println("偶数：" + oddEvenMap.get(Boolean.TRUE)); System.out.println("奇数：" + oddEvenMap.get(Boolean.FALSE)); ``` ##### 分组分组是根据元素的某个属性，把集合分布到map的多个value集合中 ![](https://cdn.cnbj1.fds.api.mi-img.com/book/images/b0ac0758b5700d8b6c2e61d9d84b5413?thumb=1&w=384&h=384) ```java // 简单分组：默认分组的map value使用的是Collectors.toList()收集器 // 按用户的职位分组 Map> jobUserMap = Stream.of( new User().setJob("DEV").setName("Tom"), new User().setJob("QA").setName("Jeff"), new User().setJob("DEV").setName("Jack") ) .collect(Collectors.groupingBy(User::getJob)); System.out.println(jobUserMap); // 自定义分组收集器 Map> jobUserMap2 = Stream.of( new User().setJob("DEV").setName("Tom"), new User().setJob("QA").setName("Jeff"), new User().setJob("DEV").setName("Jack") ) .collect(Collectors.groupingBy(User::getJob, Collectors.toSet())); System.out.println(jobUserMap2); // 可以通过自定义收集器进行更多的聚合计算 Map jobScoreMap = Stream.of( new User().setJob("DEV").setName("Tom").setScore(100), new User().setJob("QA").setName("Jeff").setScore(200), new User().setJob("DEV").setName("Jack").setScore(300) ) .collect(Collectors.groupingBy( User::getJob, // 按职位分组 Collectors.summingInt(User::getScore) // 收集每个组用户的积分总和 )); System.out.println(jobScoreMap); ``` > 和goupingBy一样，partitionBy同样也支持自定义收集器 #### 聚合收集器 jdk内置了很多聚合收集器，包括： - Collectors.summingInt() 求和 - Collectors.averagingInt() 求平均值 - Collectors.maxBy() 求最大值 - Collectors.minBy() 求最小值 - Collectors.counting() 计数 - Collectors.joining() 字符串连接 - Collectors.reducing() 自定义聚合其中reducing最为灵活，可以实现其他聚合收集器的功能。 ```java // summing 求和 Integer sumResult = Stream.of(1, 2, 3, 4) .collect(Collectors.summingInt(Integer::valueOf)); assert sumResult == 10; // averaging 求平均值 Double avgResult = Stream.of(1, 2, 3, 4) .collect(Collectors.averagingInt(Integer::valueOf)); assert avgResult == 2.5D; // maxBy，minBy 求最大最小值 Optional maxResult = Stream.of(1, 2, 3, 4) .collect(Collectors.maxBy(Comparator.comparingInt(Integer::valueOf))); assert maxResult.get() == 4; // counting 计数 Long countResult = Stream.of(4, 3, 2, 1) .collect(Collectors.counting()); assert countResult == 4; // joining 字符串连接 String joinResult = Stream.of("a", "b", "c", "d") .collect(Collectors.joining("|")); assert "a|b|c|d".equals(joinResult); // reduce 自定义方式求和 Integer reduceResult = Stream.of(1, 2, 3, 4) // 两个参数分别为初始结果值和累加函数 // 初始结果0，每次遍历时当前元素和结果如何进行性累加 .collect(Collectors.reducing(0, Integer::sum)); assert reduceResult == 10; ``` ### 3.4 基本数据流对于一些基本类型如int, double, long，在使用Stream是不得不包装成Integer，Double，Long，因为Stream本身使用了泛型。为了解决装箱拆箱带来的性能损耗，jdk为我们专门提供了一些处理这类数据的流，并且还提供了一些额外的统计方法。这些基础数据流分别是`IntStream`，`LongStream`和`DoubleStream`。这里只以`IntStream`来举例，其他两个和他差不读，看源码的方法声明就可以类推了。 #### 基础数据流的创建 ```java // 范围创建（左闭右开），1-10不包含10 IntStream.range(1, 10); // 范围创建（双闭区间），1-10包含10 IntStream.rangeClosed(1, 10); // 从数组创建，包含1, 2, 3的流 IntStream.of(1, 2, 3); // 使用生成器创建，从1开始，每次递增2的无限int流 IntStream.iterate(1, i -> i + 2); // 从其他类型转换来，使用mapToInt int charCount = Stream.of("a", "ab", "abc", "abcd") .mapToInt(String::length) .sum(); assert 10 == charCount; ``` #### 对象流，基础数据流之间的转换 ```java //流之间的转换 Stream longStream = Stream.of("1", "2", "3", "4") // 包装类型流转换成IntStream .mapToInt(Integer::valueOf) // IntStream转换成LongStream .asLongStream() // 转换成包装类型流 .boxed(); ``` #### 一些增强的统计方法 ```java // 求和 assert 10 == IntStream.of(1, 2, 3, 4).sum(); // 最大值 assert 4 == IntStream.of(1, 2, 3, 4).max().orElse(0); // 最小值 assert 1 == IntStream.of(1, 2, 3, 4).min().orElse(0); // 平均值 assert 2.5 == IntStream.of(1, 2, 3, 4).average().orElse(0); // 个数 assert 4L == IntStream.of(1, 2, 3, 4).count(); // 所有常规统计值一次性计算 IntSummaryStatistics intSummaryStatistics = IntStream.of(1, 2, 3, 4) .summaryStatistics(); assert 1 == intSummaryStatistics.getMin(); assert 4 == intSummaryStatistics.getMax(); assert 2.5 == intSummaryStatistics.getAverage(); assert 4L == intSummaryStatistics.getCount(); ``` ### 3.5 Stream并行流上面的所有StreamAPI都是串行执行的，一个元素处理完了才会处理下一个元素，同时JDK也为我们提供了一种并行流，即Stream的多线程版。这个多线程版的Stream会利用ForkJoinPool.commonPool()的线程池来处理任务。 #### 基本用法 ```java List list = Stream.of(1, 2, 3, 4) .parallel() .map(String::valueOf) .collect(Collectors.toList()); ``` #### 使用自定义线程池需要注意的是，由于ForkJoinPool.commonPool是整个JVM共享的固定大小的线程池，线程池的大小为***CPU核心数-1***。如果遇到同一时间大量请求到服务器，且都是IO密集型的操作，会造成线程池中的线程全部被阻塞在IO过程中，而其他并行流只能等待线程池释放空闲线程。可以根据业务情况使用线程数更大一点的，有队列和可扩容的线程池： ```java private static final ExecutorService CUSTOM_THREAD_POOL = new ThreadPoolExecutor( 20, 30, 1, TimeUnit.MINUTES, new LinkedBlockingDeque<>(100), new ThreadPoolExecutor.DiscardPolicy() ); ... final Stream stream = Stream.of(1, 2, 3, 4); Future result = CUSTOM_THREAD_POOL.submit(() -> { return stream.map(String::valueOf).collect(Collectors.joining()); }); System.out.println(result.get()); ``` #### 其他注意事项 ##### 线程安全问题由于并行流是多线程版的流，因此在使用并行流中修改共享变量时，需要特别注意线程安全问题。 ##### 内存泄漏问题由于并行流使用了线程池技术，如果在线程任务中使用了ThreadLocal，需要注意在线程任务执行完之后及时remove掉ThreadLocal的值，避免内存泄漏。关于ThreadLocal在线程池中的内存泄漏问题，可以参考[这篇文章](https://www.jianshu.com/p/a1cd61fa22da) ##### 性能问题并不是所有的操作使用并行流都能带来性能上的收益。stream的管道操作本身是否耗时，越耗时，并行流带来的收益越大，如果是CPU密集型操作，使用普通流也许更好，因为单线程能减少线程上下文切换以及合并各线程的流带来的额外开销。 ### 3.6 关于流的其他建议和问题 #### 长Lambda表达式使用方法引用代替流中使用的Lambda表达式尽量不要太多行，如果超过3行，最好提到一个方法中来引用：如下面这种代码： ```java // 不好的风格 Stream.of(1, 2, 3, 4) .map(i -> { int doubleVal = i * 2; String str = "The double value is: " + doubleVal; byte[] encodedData = Base64.getEncoder().encode(str.getBytes()); return new String(encodedData, UTF_8); }) .forEach(System.out::println); ``` 可以替换成下面这样： ```java // 推荐的风格 Stream.of(1, 2, 3, 4) .map(Other::convertAndEncode) .forEach(System.out::println); public static String convertAndEncode(final Integer intVal) { int doubleVal = intVal * 2; String str = "The double value is: " + doubleVal; byte[] encodedData = Base64.getEncoder().encode(str.getBytes()); return new String(encodedData, UTF_8); } ``` #### List转换前的空检查 ```java List list = null; // 下面的代码做了空检查，因此不会抛空指针异常 // 前两行是模板，可以封装到工具类中 Optional.ofNullable(list) .orElseGet(Collections::emptyList) .stream() .map(String::valueOf) .forEach(System.out::println); ``` #### lambda抛出异常的问题 Lambda表达式实际上是一个实现了某个接口的匿名内部类，如果内部发生了checked异常，无法通过在外部函数声明throws来捕获，比如下面这个例子，就会报编译错误，提示IOException没有被捕获： ```java public void exceptionThrow() throws IOException { Arrays.asList(1, 2, 3) .forEach(i -> { throw new IOException("message"); }); } ``` 很遗憾的是JDK并没有直接给我们提供一个向外抛出异常的解决方案，我们只能在lambda表达式内catch异常并处理，如果确实需要向外抛出异常，有3种解决方法： 1. 放弃使用Lambda表达式 2. 在Lambda表达式内部catch checked异常后，另外抛出一个运行时异常。 3. 使用适配模式，在Lambda外面再包装一层，并使用一种hack的手法绕过异常检查： ```java // 声明一个能抛异常的Consumer函数式接口 // 这个接口对应于会抛出unchecked异常的Lambda表达式 @FunctionalInterface private interface ConsumerWithException { void accept(T t) throws E; } // 将抛异常的Consumer包装成普通的Consumer返回，该方法本身会抛出异常E private Consumer rethrowConsumer(ConsumerWithException consumer) throws E { return t -> { try { consumer.accept(t); } catch (Exception exception) { throwAsUnchecked(exception); } }; } // 将异常作为一个异常泛型抛出，该方法由于用到泛型，编译器无法确定是否是checked异常，因此可以绕过编译器的异常检查 @SuppressWarnings ("unchecked") private static void throwAsUnchecked(Exception exception) throws E { throw (E)exception; } // 改进后的带异常的lambda表达式 public void exceptionThrow() throws IOException { Arrays.asList(1, 2, 3) .forEach(rethrowConsumer(t -> { throw new IOException("message"); }) ); } ``` 上面这种方式已经有人专门封装成一个工具类，可以参考[StackOverflow](https://stackoverflow.com/questions/27644361/how-can-i-throw-checked-exceptions-from-inside-java-8-streams)上查看该解决方案的完整代码 ## 4. Optional Optional是一个用来包装其他对象的类，顾名思义，被包装的对象是可能为空的对象。Optional提供了一些特殊的API来判断被包装对象是否为空，要获取被包装的对象值，我们可以通过一些结合了Lambda表达式和流式编程风格的API更优雅的处理空对象。 ### 创建Optional包装对象 ```java // of的参数如果为空会抛出空指针异常 Optional num1 = Optional.of(123); // 创建一个空对象 Optional