Java8详解

Java8详解

1 Java8

Java8简介

Java8 是 Java发布以来改动最大的一个版本
添加了函数式编程、Stream、全新的日期处理类 函数式编程新加了一些概念:Lambda表达式、函数式接口、函数引用、默认方法、Optional类等 Stream中提供了一些流式处理集合的方法，并提供了一些归约、划分等类的方法 日期中添加了ZoneDateTime、DataFormat等线程安全的方法类

1.1 Lambda

Lambda简介

• Lambda 可定义为一种简洁、可传递的匿名函数，它是推动Java 8发布的最重要新特性
• Lambda 本质上是一个函数，虽然它不属于某个特定的类，但具备参数列表、函数主体、返回类型，甚至 能够抛出异常
• Lambda 是匿名的，它没有具体的函数名称
• Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)
• Lambda 可以使代码变的更加简洁

基本语法

• 参数列表 -> 表达式
• 参数列表 -> {表达式集合}
• 需要注意的是 lambda 表达式默认隐含了 return 关键字，在单个表达式中，我们无需在写 return 关键字，也无需写花括号。
• 只有当表达式是一个集合的时候，才需要写花括号及 return关键字

代码示例

// 返回给定字符串的长度（隐含return语句） 
(String str) -> str.length()

// 始终返回233的无参方法（隐含return语句） 
() -> 233

// 返回当前用户是否年龄大于20岁，返回一个boolean值（隐含return语句） 
(User user) -> user.getAge() > 20

// 包含多行表达式，需用花括号括起来，并使用return关键字返回
(int x, int y) -> {
    
    int z = x * y; 
    return x + z; 
}

使用Lambda与传统写法对比

//使用Lambda
Runnable r1 = () -> System.out.println("Hello World 1");
//传统匿名类
Runnable r2 = new Runnable(){
   
   public void run(){
   
			System.out.println("Hello World 2"); 
   }
};
//执行Runnable方法
//使用Lambda
Runnable r1 = () -> System.out.println("Hello World 1");

//传统匿名类
Runnable r2 = new Runnable(){
    
    public void run(){
    
        System.out.println("Hello World 2"); 
    } 
};

//执行Runnable方法
public static void process(Runnable r){
    
    r.run(); 
} 

//打印 "Hello World 1"
process(r1); 
//打印 "Hello World 2"
process(r2); 
//利用直接传递的 Lambda 打印 "Hello World 3"
process(() -> System.out.println("Hello World 3"));	r.run(); 
}
//打印 "Hello World 1"
process(r1);
//打印 "Hello World 2"
process(r2);
//利用直接传递的 Lambda 打印 "Hello World 3" 
process(() -> System.out.println("Hello World 3"));

了解了 lambda 的基本用法，下面我们就可以开始着手Stream API的学习了!

1.2 Lambda 受检异常处理

简介

• Lambda 表达式利用函数式编程提供精简的方式表达行为。
• 然而，JDK函数式接口没有很好地处理异常，使得处理异常代码非常臃肿和麻烦。
• 下面我们来探讨下 Lambda 表达式中处理异常的解决方案

代码示例

首先我们看一段简单的代码，将50与List中每个元素相除并打印出结果

List integers = Arrays.asList(1, 2, 3, 4, 5, 6); 

integers.forEach(i -> System.out.println(50 / i));

这样看是不会有问题的，代码简洁。
但是如果List中包含元素0，那么就会抛出异常：ArithmeticException: / by zero
有经验的小伙伴可能会立马给出解决方案，使用传统的try-catch来处理异常，代码如下：

List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 0);
integers.forEach(i -> {
   
    try {
   
        System.out.println(50 / i);
    } catch (ArithmeticException e) {
   
        System.err.println( "Arithmetic Exception occured : " + e.getMessage());
    }
});

使用try-catch解决了问题，但是失去了lambda表达式的精简，代码变得臃肿，想必并不是完美的解决方案。
对于一些强迫症老哥来说，这种代码是绝对不能存活的，所以我们需要如下的解决方案。

解决方案

我们将会对抛出异常的函数进行包装，使其不抛出受检异常
如果一个 FunctionInterface 的方法会抛出受检异常(比如 Exception )，那么该

FunctionInterface 便可以作为会抛出受检异常的 Lambda 的目标类型。 我们定义如下一个 FunctionInterface :

@FunctionalInterface
interface UncheckedFunction<T, R> {
   
    R apply(T t) throws Exception;
}

那么该 FunctionInterface 便可以作为抛出受检异常的 Lambda 的目标类型，此时 Lambda 中并不需要 捕获异常，因为目标类型的 apply 方法已经将异常抛出了。
我们如何使用 UncheckedFunction 到流式操作的 Lambda 中呢?
首先我们定义一个 Try 类，它的 of 方法提供将 UncheckedFunction 包装为 Function 的功能:

public class Try {
   

   public static <T, R> Function<T, R> of(UncheckedFunction<T, R> mapper) {
   
      Objects.requireNonNull(mapper);
      return t -> {
   
         try {
   
            return mapper.apply(t);
         } catch (Exception e) {
   
            throw Exceptions.unchecked(e);
         }
      };
   }

   @FunctionalInterface
   public interface UncheckedFunction<T, R> {
   
      R apply(T t) throws Exception;
   }

}

然后在原先的代码中，我们使用 Try.of方法来对会抛出受检异常的 Lambda 进行包装:

List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 0);
integers.forEach(Try.of(i -> System.out.println(50 / i)));

此时，我们便可以选择是否去捕获异常( RuntimeException )。这种解决方法下，我们一般不关心抛出异 常的情况 。 比如自己写的小例子，抛出了异常程序就该终止;或者你知道这个 Lambda 确实 100% 不会抛出异 常。

1.3 Stream 简介

Stream 关于流

什么是流？

流是Java8引入的全新概念，它用来处理集合中的数据，暂且可以把它理解为一种高级集合。 众所周知，集合操作非常麻烦，若要对集合进行筛选、投影，需要写大量的代码，而流是以声明的形式操作集 合，它就像SQL语句，我们只需告诉流需要对集合进行什么操作，它就会自动进行操作，并将执行结果交给你， 无需我们自己手写代码。

因此，流的集合操作对我们来说是透明的，我们只需向流下达命令，它就会自动把我们想要的结果给我们。由于 操作过程完全由Java处理，因此它可以根据当前硬件环境选择最优的方法处理，我们也无需编写复杂又容易出错 的多线程代码了。

**流的特点 **

1. 只能遍历一次 我们可以把流想象成一条流水线，流水线的源头是我们的数据源(一个集合)，数据源中的元素依次被输送到流 水线上，我们可以在流水线上对元素进行各种操作。 一旦元素走到了流水线的另一头，那么这些元素就被“消费掉了”，我们无法再对这个流进行操作。当然， 我们可以从数据源那里再获得一个新的流重新遍历一遍。
2. 采用内部迭代方式
   若要对集合进行处理，则需我们手写处理代码，这就叫做外部迭代。 而要对流进行处理，我们只需告诉流我们需要什么结果，处理过程由流自行完成，这就称为内部迭代。

**流的操作种类 **

流的操作分为两种，分别为中间操作和终端操作。

1. 中间操作 当数据源中的数据上了流水线后，这个过程对数据进行的所有操作都称为“中间操作”。 中间操作仍然会返回一个流对象，因此多个中间操作可以串连起来形成一个流水线。
2. 终端操作 当所有的中间操作完成后，若要将数据从流水线上拿下来，则需要执行终端操作。 终端操作将返回一个执行结果，这就是你想要的数据。

**流的操作过程 **

使用流一共需要三步:

1. 准备一个数据源

2. 执行中间操作

   中间操作可以有多个，它们可以串连起来形成流水线。

3. 执行终端操作

   执行终端操作后本次流结束，你将获得一个执行结果。

1.4 Stream API 一览

List 转 Stream

// 转stream 
list.stream()
// 并发处理 
list.parallelStream()

filter(过滤)

Stream<T> filter(Predicate<? super T> predicate);

map(元素转换)

<R> Stream<R> map(Function<? super T, ? extends R> mapper);
IntStream mapToInt(ToIntFunction<? super T> mapper);
LongStream mapToLong(ToLongFunction<? super T> mapper);
DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);

flatMap(元素转换)

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);
LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);
DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);

distinct(去除重复，对象需要重写 equals、hashCode)

Stream<T> distinct();

sorted(排序)

Stream<T> sorted();
Stream<T> sorted(Comparator<? super T> comparator);	

peek(生成新的流:流是单向的，例如用于日志打印)

Stream<T> peek(Consumer<? super T> action);

limit(取前面 n 个元素)

Stream<T> limit(long maxSize);

skip(跳过 n 个元素)

Stream<T> skip(long n);

forEach(遍历)

void forEach(Consumer<? super T> action);
void forEachOrdered(Consumer<? super T> action);

toArray(转换成数组)

Object[] toArray();
<A> A[] toArray(IntFunction<A[]> generator);

reduce(结果归并)

T reduce(T identity, BinaryOperator<T> accumulator);
  Optional<T> reduce(BinaryOperator<T> accumulator);
  <U> U reduce(U identity,
              BiFunction<U, ? super T, U> accumulator,
              BinaryOperator<U> combiner);

collect(转换成集合)

<R> R collect(Supplier<R> supplier,
               BiConsumer<R, ? super T> accumulator,
               BiConsumer<R, R> combiner);
  <R, A> R collect(Collector<? super T, A, R> collector);

转list

// 转