Java8的新特性

1.* 新特性简介

• 速度更快
• 代码更少（增加了新的语法Lambda表达式）
• 强大的Stream API
• 便于并行
• 最大化减少空指针异常Optional

其中最核心的是Lambda表达式和Stream API。

1.* Lambda表达式

1.*.& 为啥使用Lambda表达式？

下面用一个具体的案例抛砖引玉，说明为什么要用Lambda表达式：

查看代码

Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

从匿名内部类到Lambda表达式的转换：

//匿名内部类
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World");
    }
}
//转换成Lambda表达式
Runnable r1 = () -> System.out.println("Hello World");

使用匿名内部类做为参数传递到Lambda表达式的转换：

//原来使用匿名内部类作为参数传递
TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {
    @Override
    public int compare(String o1，String o2) {
        return Integer.compare(o1.1ength(), o2.length());
    }
});
//转换成Lambda表达式
TreeSet<String> ts = new TreeSet<>(
    (o1, o2) -> Integer.compare(o1.length(), 02.lenth())
);

1.*.& Lambda表达式语法

Lambda表达式在Java语言中引入了一个新的语法元素和操作符。这个操作符为“->”，该操作符被称为Lambda操作符或剪头操作符。它将Lambda分为两个部分：

• 左侧：指定了Lambda表达式需要的所有参数
• 右侧：指定了Lambda体，即Lambda表达式要执行的功能

语法格式一：无参数，无返回值，Lambda表达式只需要一条语句

Runnable r1 = () -> System.out.println("Hello Lambda!");

语法格式二：Lambda需要一个参数

Consumer<String> fun = (args) -> System.out.println(args);

语法格式三：Lambda只需要一个参数时，参数的小括号可以省略

Consumer<String> fun = args -> System.out.println(args);

语法格式四：Lambda需要两个参数，并且有返回值

BinaryOperator<Long> bo = (x, y) -> {
    System.out.println("实现函数接口方法");
    return x + y;
};

语法格式五：当Lambda体只有一条语句时，return与大括号可以省略

BinaryOperator<Long> bo = (x, y) -> x + y;

语法格式六：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”，下面参数的Long可以省略

BinaryOperator<Long> bo = (Long x, Long y) -> {
    System.out.println("实现函数接口方法");
    return x + y;
};

查看代码

1.*.& 类型推断

上述Lambda表达式中的参数类型都是由编译器推断得出的。Lambda表达式中无需指定类型，程序依然可以编译，这是因为javac根据程序的上下文，在后台推断出了参数的类型。Lambda表达式的类型依赖于上下文环境，是由编译器推断出来的，这就是所谓的“类型推断”。

1.*.& 练习

查看代码

1.* 函数式接口

1.*.& 什么是函数式接口？

• 只包含一个抽象方法的接口，称为函数式接口。
• 你可以通过Lambda表达式来创建该接口的对象（若Lambda表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。
• 我们可以在任意函数式接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口，同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。

1.*.& 自定义函数式接口

@FunctionalInterface
public interface MyNumber {
    public double getValue();
}

函数式接口中使用泛型：

@FunctionalInterface
public interface MyFunc<T> {
    public T getValue(T t);
}

1.*.& 作为参数传递Lambda表达式

public String toUpperString(MyFunc<String> mf, String str) {
    return mf.getValue(str);
}

作为参数传递Lambda表达式：

String newStr = toUpperString((str) -> str.toUpperCase(), "abcde");
System.out.println(newStr);

作为参数传递Lambda表达式：为了将Lambda表达式作为参数传递，接收Lambda表达式的参数类型必须是与该Lambda表达式兼容的函数式接口的类型。

1.*.& Java内置函数式接口

Java内置四大核心函数式接口：

查看代码

其他接口：

1.* 方法引用与构造器引用

1.*.& 方法引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致）！

方法引用：使用操作符“::”将方法名和对象或类的名字分隔开来。如下三种主要使用情况：

• 对象::实例方法
• 类::静态方法
• 类::实例方法

例如：

(x) -> System.out.println(x);
//等同于：
System.out::println;

例如：

BinaryOperator<Double> bo = (x, y) -> Math.pow(x, y);
//等同于
BinaryOperator<Double> bo = Math:pow

例如：

compare((x, y) -> x.equals(y), "abcdef", "abcdef");
//等同于
compare(String::equals, "abcdef", "abcdef");

注意：当需要引用方法的第一个参数是调用对象，并且第二个参数是需要引用方法的第二个参数(或无参数)时：ClassName::methodName。

1.*.& 构造器引用

格式：ClassName::new

与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，与构造器参数列表要与接口中抽象方法的参数列表一致！

例如：

Function<Integer, MyClass> fun = (n) -> new MyClass(n);
//等同于
Function<Integer, MyClass> fun = MyClass::new

1.*.& 数组引用

格式：type[]::new

例如：

Function<Integer, Integer[]> fun = (n) -> new Integer[n];
//等同于
Function<Integer, Integer[]> fun = Integer[]::new

查看代码

1.* Stream API

1.*.& 了解Stream

Java8中有两大最为重要的改变。第一个是Lambda表达式；另外一个则是Stream API(java.util.stream.*)。Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。简而言之，Stream API提供了一种高效且易于使用的处理数据的方式。

1.*.& 什么是Stream

流（Stream）到底是什么呢？它本质上是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

“集合讲的是数据，流讲的是计算！”

注意：

1. Stream自己不会存储元素。
2. Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream。
3. Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

1.*.& Stream的操作三个步骤

• 创建Stream：一个数据源（如：集合、数组），获取一个流
• 中间操作：一个中间操作链，对数据源的数据进行处理
• 终止操作(终端操作)：一个终止操作，执行中间操作链，并产生结果

1.*.&.% 创建Stream

创建Stream：

Java8中的Collection接口被扩展，提供了两个获取流的方法：

• default Stream<E> stream()：返回一个顺序流
• default Stream<E> parallelStream()：返回一个并行流

由数组创建流：

Java中的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)

由值创建流：

可以使用静态方法Stream.of()，通过显示值创建一个流。它可以接收任意数量的参数：

public static<T> Stream<T> of(T... values)：返回一个流

由函数创建流，创建无限流：

可以使用静态方法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)

查看代码

1.*.&.% Stream的中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

筛选与切片：

• filter(Predicate p)：接受Lambda，从流中排除某些元素
• distinct()：筛选，通过流所生成元素的hashCode()和equals()去除重复元素
• limit(long maxSize)：截断流，使其元素不超过给定数量
• skip(long n)：跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流，与limit(n)互补

查看代码

映射：

• map(Function f)：接收一个函数作为参数，该函数会被应用到每个函数上，并将其映射成一个新的元素
• mapToDouble(ToDoubleFuntion f)：接收一个函数作为参数，该函数会被应用到每个函数上，产生一个新的DoubleStream
• mapToInt(ToIntFunction f)：接收一个函数作为参数，该函数会被应用到每个函数上，产生一个新的IntStream
• mapToLong(ToLongFunction f)：接收一个函数作为参数，该函数会被应用到每个函数上，产生一个新的LongStream
• flatMap(Function f)：接收一个函数作为参数，将流中的每一个值都换成另外一个流，然后把所有的流连接成一个流

查看代码

排序：

• sorted()：产生一个新流，其中按自然顺序排序
• sorted(Comparator comp)：产生一个新流，其中按比较器顺序排序

查看代码

1.*.&.% Stream的终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是void。

查找与匹配：

• allMath(Predicate p)：检查是否匹配所有元素
• anyMatch(Predicate p)：检查是否匹配至少一个元素
• noneMatch(Predicate p)：检查是否没有匹配所有元素
• findFirst()：返回第一个元素
• findAny()：返回当前流中的任意元素
• count()：返回流中元素总数
• max(Comparator c)：返回流中最大值
• min(Comparator c)：返回流中最小值
• foreach(Comparator c)：内部迭代（使用Collection接口需要用户去做迭代，称为外部迭代。相反，Stream API使用内部迭代---它帮你把迭代做了）

查看代码

规约：

• reduce(T iden, BinaryOperator b)：可以将流中元素反复结合起来，得到一个值。返回T
• reduce(BinaryOperator b)：可以将流中元素反复结合起来，得到一个值。返回Option<T>

备注：map和reduce的连接通常称为map-reduce模式，因Google用它来进行网络搜索而出名。

收集：

• collect(Collector c)：将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法。

Collector接口中方法的实现决定了如何对流执行收集操作(如收集到List、Set、Map)。但是Collectors实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下：

• Collectors.toList()：返回List<T>类型，用于把流中元素收集到List
• Collectors.toSet()：返回Set<T>类型，用于把流中元素收集到Set
• Collectors.toCollection()：返回Collection<T>类型，用于把流中元素收集到创建的集合
• Collectors.counting()：返回Long类型，用于计算流中元素的个数
• Collectors.summingInt()：返回Integer类型，用于对流中元素的整数属性求和
• Collectors.averagingInt()：返回Double类型，计算流中元素Integer属性的平均值
• Collectors.summarizingInt()：返回IntSummaryStatistics类型，用于收集流中Integer属性的统计值，如：平均值
• Collectors.joining()：返回String类型，连接流中每个字符串
• Collectors.maxBy()：返回Optional<T>类型，根据比较器选择最大值
• Collectors.minBy()：返回Optional<T>类型，根据比较器选择最小值
• Collectors.reducing()：返回规约产生的类型，从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而规约成单个值
• Collectors.collectingAndThen()：返回转换函数返回的类型，包裹另一个收集器，对其结果转换函数
• Collectors.groupingBy()：返回Map<K, List<T>>类型，根据某属性值对流分组，属性为K，结果为V
• Collectors.partitioningBy()：返回Map<Boolean, List<T>>类型，根据true或false进行分区

查看代码

1.*.&.% stream练习

查看代码

1.*.& 并行流与串行流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。

Java 8中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API可以声明性地通过parallel()与sequential()在并行流与顺序流之间进行切换。

1.*.& 了解Fork和Join框架

1.*.&.% Fork和Join的简介

Fork/Join框架：就是在必要的情况下，将一个大任务，进行拆分（fork）成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行join汇总。

1.*.&.% Fork/Join框架与传统线程池的区别

采用“工作窃取”模式（work-stealing）：

当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。

相对于一般的线程池实现，Fork/Join框架的优势体现在对其中包含的任务的处理方式上。在一般的线程池中，如果一个线程正在执行的任务由于某些原因无法继续运行，那么该线程会处于等待状态。而在Fork/Join框架实现中，如果某个子问题由于等待另外一个子问题的完成而无法继续运行。那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行。这种方式减少了线程的等待时间，提高了性能。

查看代码

1.* Optional类

Optional<T>类（java.util.Optional）是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在Optional可以更好的表达这个概念。并且可以避免空指针异常。

常用的方法：

• Optional.of(T t)：创建一个Optional实例
• Optional.empty()：创建一个空的Optional实例
• Optional.ofNullable(T t)：若t不为null，创建Optional实例，否则创建空实例
• isPresent()：判断是否包含值
• orElse(T t)：如果调用对象包含值，返回该值，否则返回t
• orElseGet(Supplier s)：如果调用对象包含值，返回该值，否则返回s获取的值
• map(Function f)：如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty()
• flatMap(Function mapper)：与map类似，要求返回值必须是Optional

查看代码

1.* 接口中的默认方法与静态方法

1.*.& 接口中的默认方法

Java8中允许接口中包含具有具体实现的方法，该方法称为“默认方法”，默认方法使用default关键字修饰。

例如：

查看代码

接口默认方法的“类优先”原则

若一个接口中定义了一个默认方法，而另外一个父类或接口中又定义了一个同名的方法时：

• 选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略。
• 接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法（不管方法是否是默认方法），那么必须覆盖该方法来解决冲突。

查看代码

上图演示了接口冲突的情况。

1.* 新时间日期API

1.*.& 使用LocalDate、LocalTime、LocalDateTime

LocalDate、LocalTime、LocalDateTime类的实例是不可变的对象，分别表示使用ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的日期或时间，并不包含当前的时间信息。也不包含与时区相关的信息。

ISO-8601日历系统是国际标准化组织制定的现代公民的日期和时间的表示法。

对应的具体方法见：

Java8的API地址

1.*.& Instant时间戳

用于“时间戳”的运算。它是以Unix元年（传统的设定为UTC时区1970年1月1日午夜时分）开始所经历的描述进行运算。

1.*.& Duration和Period

• Duration：用于计算两个“时间”间隔
• Period：用于计算两个“日期”间隔

1.*.& 日期的操纵

• TemporalAdjuster：时间校正器。有时我们可能需要获取例如：将日期调整到“下个周日”等操作。
• TemporalAdjusters：该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现。

1.*.& 解析和格式化

java.time.format.DateTimeFormatter类，该类提供了三种格式化方法：

• 预定义的标准格式
• 语言环境相关的格式
• 自定义的格式

1.*.& 时区的处理

Java8中加入了对时区的支持，带时区的时间为分别为：ZonedDate、ZonedTime、ZonedDateTime。

其中每个时区都对应着 ID，地区ID都为 “{区域}/{城市}”的格式，例如：Asia/Shanghai等。

ZoneId类中包含了所有的时区信息：

• getAvailableZoneIds()：可以获取所有时区时区信息
• of(id)：用指定的时区信息获取 ZoneId对象

查看代码

1.* 其他新特性

1.*.& 重复注解和类型注解

Java8对注解处理提供了两点改进：可重复的注解及可用于类型的注解。

查看代码