欢迎阅读 Java 8新特性介绍. 该篇问斩将一一介绍所有关于Java8的新特性 。基于短小简单的代码示例，你将会了解到怎么使用接口默认方法、lambda表达式、方法引用和可宠用注解。文章末尾，你会了解最新的API变化，比如stream流、函数式接口、map extensions和新的Date API。
目录
接口默认方法
Java 8中我们可以通过 "default "关键字向接口中添加非抽象方法。这一特性也被称为虚拟扩展方法.
示例:
interface Formula {
double calculate(int a);
default double sqrt(int a) {
return Math.sqrt(a);
}
}
除了抽象方法calculate，接口 Formula还定义了默认方法 sqrt。实现类只需要实现抽象方法calculate。缺省方法sqrt可以在开箱即用。
Formula formula = new Formula() {
@Override
public double calculate(int a) {
return sqrt(a * 100);
}
};
formula.calculate(100); // 100.0
formula.sqrt(16); // 4.0
formula是匿名的对象实现类的实例。一个简单的计算 "sqrt(a*100) "需要6行代码，代码相当啰嗦。正如我们将在下一节中看到的，在Java 8中，有一种更好的方式来实现单方法对象。
Lambda表达式
让我们从一个简单的例子开始，看看如何在以前的Java版本中对字符串集合进行排序。
List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
Collections.sort(names, new Comparator<String>() {
@Override
public int compare(String a, String b) {
return b.compareTo(a);
}
});
静态方法Collections.sort接受一个列表和一个比较器，以便对给定列表中的元素进行排序。你经常要做的是需要创建了一个匿名比较器，并将它们传给排序方法。
Java 8不再必须创建匿名对象，而是可以使用更简洁的语法，lambda表达式。
Collections.sort(names, (String a, String b) -> {
return b.compareTo(a);
});
如你所见，代码更短，更容易阅读。它还可以变得更短：
Collections.sort(names, (String a, String b) -> b.compareTo(a));
对于一行方法体，你可以不适用括号{}和return关键字。这并不是最终的写法，它还可以写成如下格式：
names.sort((a, b) -> b.compareTo(a));
List现在有一个sort方法。同时Java编译器也知道参数类型，所以你也可以不写参数类型。
接下来，让我们深入了解一下lambda表达式更多的用法。
函数式接口
lambda表达式如何融入Java的类型系统？每个lambda由一个接口确定类型。一个所谓的函数式接口必须包含切仅包含一个抽象方法。该类型的每个lambda表达式都将与这个抽象方法相匹配。由于缺省方法不是抽象的，你可以自由地在你的函数接口中添加缺省方法。
我们可以使用任意的接口作为lambda表达式，只要该接口只包含一个抽象方法。为了确保你的接口符合要求，你可以添加@FunctionalInterface注解。一旦你试图在接口中添加第二个抽象方法声明，编译器就会抛出一个编译错误。
示例：
@FunctionalInterface
interface Converter<F, T> {
T convert(F from);
}
Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted); // 123
请注意，如果不写@FunctionalInterface注解，该代码也是正确的。
方法和构造方法引用
上述示例代码可以通过利用静态方法引用进一步简化。
Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted); // 123
Java 8中能够通过::关键字来传递方法或构造函数的引用。上面的例子展示了如何引用一个静态方法。不仅如此，我们也可以通过::关键字来传递实例方法或构造函数的引用。
class Something {
String startsWith(String s) {
return String.valueOf(s.charAt(0));
}
}
Something something = new Something();
Converter<String, String> converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted); // "J"
让我们看一个使用::关键字引用构造函数的例子。首先我们定义一个具有不同构造函数的类。
class Person {
String firstName;
String lastName;
Person() {}
Person(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
}
接下来我们指定一个用于创建Person实例的工厂接口。
interface PersonFactory<P extends Person> {
P create(String firstName, String lastName);
}
实际上在Java8中我们可以不手动实现工厂类，而是通过构造函数引用来实现。
PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");
我们通过Person::new创建一个Person构造函数的引用。Java编译器通过匹配PersonFactory.create的自动选择正确的构造函数。
Lambda作用域
在lambda表达式中访问上层变量与匿名对象非常相似。你可以从本地外部作用域访问final变量，也可以访问实例字段和静态变量。
访问局部变量
我们可以在lambda表达式中访问外部范围访问final的局部变量。
final int num = 1;
Converter<Integer, String> stringConverter =
(from) -> String.valueOf(from + num);
stringConverter.convert(2); // 3
但与匿名对象不同的是，变量num可以不声明为final，代码也是有效的。
int num = 1;
Converter<Integer, String> stringConverter =
(from) -> String.valueOf(from + num);
stringConverter.convert(2); // 3
然而num必须是隐式final的，变量的值在有效作用域内不能再被修改，这样代码才能被编译。以下代码不能编译通过。
int num = 1;
Converter<Integer, String> stringConverter =
(from) -> String.valueOf(from + num);
num = 3;
访问实例变量和静态变量
与局部变量不同，我们可以从lambda表达式内对实例变量和静态变量进行读写访问。
class Lambda4 {
static int outerStaticNum;
int outerNum;
void testScopes() {
Converter<Integer, String> stringConverter1 = (from) -> {
outerNum = 23;
return String.valueOf(from);
};
Converter<Integer, String> stringConverter2 = (from) -> {
outerStaticNum = 72;
return String.valueOf(from);
};
}
}
访问默认接口方法
还记得第一节的示例吗？接口Formula定义了一个默认的方法sqrt，可以从每个实例（包括匿名对象）中访问。但是，在lambda表达式确不可以访问。
缺省方法不能在lambda表达式中访问。以下代码无法编译。
Formula formula = (a) -> sqrt(a * 100);
内建函数式接口
JDK 1.8 API包含许多内置函数式接口。其中一些接口是在旧版本的Java中是就已存在的，如 "Comparator "或 "Runnable"。这些现有的接口通过@FunctionalInterface注解进行扩展，以实现Lambda支持。
Java 8 API也有很多新的功能接口，让你用起来更轻松。其中一些新的接口在Google Guava库中已经存在了了。即使你知道这个库，你也应该密切关注这些接口是如何通过一些有用的方法扩展的。
Predicate
Predicate(谓词)是只有一个参数且返回布尔值的函数。该接口包含各种默认的方法，用于将谓词组合成复杂的逻辑项（与、或、非）。
Predicate<String> predicate = (s) -> s.length() > 0;
predicate.test("foo"); // true
predicate.negate().test("foo"); // false
Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;
Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();
Function
Function接受一个参数并返回一个结果。缺省方法可以用于链式编程（compose，andThen）。
Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
backToString.apply("123"); // "123"
Supplier
Supplier产生一个给定通用类型的结果。与Function不同，Supplier不接受参数。
Supplier<Person> personSupplier = Person::new;
personSupplier.get(); // new Person
Consumer
Consumer是要对单个输入参数进行消费(操作)。
Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));
Comparator
Comparator在Java8之前就很常用。Java 8为该接口增加了多种默认方法。
Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");
comparator.compare(p1, p2); // > 0
comparator.reversed().compare(p1, p2); // < 0
Optionals
Optionals不是功能接口，而是为防止空指针异常而设计。对于下一节来说，这是一个很重要的概念，所以我们来快速了解一下Optionals是如何工作的。
Optional是一个简单的容器，它可以是null或非null的值。想象一下，一个方法可能返回一个非空的结果，但有时返回null。在Java 8中，你可以不返回 "null"，而是返回一个 Optional。
Optional<String> optional = Optional.of("bam");
optional.isPresent(); // true
optional.get(); // "bam"
optional.orElse("fallback"); // "bam"
optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b"
Streams 流
java.util.Stream表示一个元素序列，在这个序列上可以执行一个或多个操作。流操作可以是中间操作，也可以是终端操作。终端操作返回某种类型的结果，而中间操作则返回流本身，因此你可以连续调用多个方法。流是在一个源上创建的，比如像列表或集合一样的java.util.Collection（不支持Map）。流操作既可以顺序执行，也可以并行执行。
我们先来看看顺序流是如何工作的。首先我们创建一个String列表的源。
List<String> stringCollection = new ArrayList<>();
stringCollection.add("ddd2");
stringCollection.add("aaa2");
stringCollection.add("bbb1");
stringCollection.add("aaa1");
stringCollection.add("bbb3");
stringCollection.add("ccc");
stringCollection.add("bbb2");
stringCollection.add("ddd1");
Java 8中的集合得到了扩展，你可以通过调用Collection.stream()或Collection.parallelStream()简单地创建流。下面的章节将解释最常见的流操作。
filter
Filter接受一个Predicate来过滤流中的所有元素，这个是一个中间操作，它返回一个流，使我们能够对结果调用另一个流操作(forEach)。ForEach接受一个Consumer，然后，对过滤后的流中的每个元素执行操作。forEach是一个终端操作。它的返回值是void，所以我们不能再调用另一个流操作。
stringCollection
.stream()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
// "aaa2", "aaa1"
sorted
Sorted是一个中间操作，它返回流的排序视图。除非你传递一个自定义的 "Comparator"，否则元素是按自然顺序排序的。
stringCollection
.stream()
.sorted()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
// "aaa1", "aaa2"
注意，sorted只是创建了一个流的排序视图，而没有对支持的集合的排序进行操作。stringCollection的排序是不会被影响的。
System.out.println(stringCollection);
// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1
map
中间操作map通过给定的函数将每个元素转换为另一个对象。下面的例子将每个字符串转换为大写，但你也可以使用map将每个对象转换为另一种类型。结果流的类型取决于你传递给map的函数。
stringCollection
.stream()
.map(String::toUpperCase)
.sorted((a, b) -> b.compareTo(a))
.forEach(System.out::println);
// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"
match
可以通过Predicate配合各类match操作验证流数据。各类match操作都是终端操作，结果返回布尔值。
boolean anyStartsWithA =
stringCollection
.stream()
.anyMatch((s) -> s.startsWith("a"));
System.out.println(anyStartsWithA); // true
boolean allStartsWithA =
stringCollection
.stream()
.allMatch((s) -> s.startsWith("a"));
System.out.println(allStartsWithA); // false
boolean noneStartsWithZ =
stringCollection
.stream()
.noneMatch((s) -> s.startsWith("z"));
System.out.println(noneStartsWithZ); // true
count
count是一个终端操作，以 long的形式返回流中元素的数量。
long startsWithB =
stringCollection
.stream()
.filter((s) -> s.startsWith("b"))
.count();
System.out.println(startsWithB); // 3
reduce
这个终端操作用给定的函数对流的元素进行转化缩减。返回结果是一个有结果值的Optional。
Optional<String> reduced =
stringCollection
.stream()
.sorted()
.reduce((s1, s2) -> s1 + "#" + s2);
reduced.ifPresent(System.out::println);
// "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2"
并行流
如上所述，流可以是串行流，也可以是并行流。对串行流的操作是在单线程上进行的，而对并行流的操作则是在多线程上并发进行的。
下面的例子展示了通过使用并行流来提高性能是多么容易。
首先我们创建一个比较大的，并且不重复的元素列表。
int max = 1000000;
List<String> values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
UUID uuid = UUID.randomUUID();
values.add(uuid.toString());
}
现在我们测试一下对这个集合的流进行排序所需的时间。
串行排序
long t0 = System.nanoTime();
long count = values.stream().sorted().count();
System.out.println(count);
long t1 = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("sequential sort took: %d ms", millis));
// sequential sort took: 899 ms
并行排序
long t0 = System.nanoTime();
long count = values.parallelStream().sorted().count();
System.out.println(count);
long t1 = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("parallel sort took: %d ms", millis));
// parallel sort took: 472 ms
正如你所看到的，两个代码片段几乎完全相同，但并行排序的速度大约快了50%。你要做的仅仅是把stream()改成parallelStream()。
Maps
如前所述，Map不直接支持流。Map接口本身没有stream()方法，但是你可以通过map.keySet().stream()、map.values().stream()和map.entrySet().stream()对Map的键、值或条目创建专门的流。
此外，Map还有很多有用的方法来完成常见的任务。
Map<Integer, String> map = new HashMap<>();
for (int i = 0; i < 10; i++) {
map.putIfAbsent(i, "val" + i);
}
map.forEach((id, val) -> System.out.println(val));
上面的代码应该是不言自明的：putIfAbsent防止我们编写额外的if null检查；forEach接受一个消费者，通过该消费者对map的每个值进行操作。
下面这个例子展示了Map的计算方法。map.computeIfPresent就是 只有当value存在时候，才会运行function，map.computeIfAbsent 就是 只有当value不存在存在时候，才会运行function。
map.computeIfPresent(3, (num, val) -> val + num);
map.get(3); // val33
map.computeIfPresent(9, (num, val) -> null);
map.containsKey(9); // false
map.computeIfAbsent(23, num -> "val" + num);
map.containsKey(23); // true
map.computeIfAbsent(3, num -> "bam");
map.get(3); // val33
接下来，我们学习如何通过指定的Key删除对应的Entry，只有当给定值也能对应时，才会删除。
map.remove(3, "val33");
map.get(3); // val33
map.remove(3, "val3");
map.get(3); // null
另外一个有用的方法：
map.getOrDefault(42, "not found"); // not found
Merging entries of a map is quite easy:
快速合并Map的value也是相当容易的
map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
map.get(9); // val9
map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
map.get(9); // val9concat
合并后把键/值放到Map中，如果没有Key的Entry存在，可以调用合并函数来改变现有的值。
Date API
Java 8在java.time包下包含了一个全新的日期和时间API。新的Date API可以和Joda-Time库相媲美。下面的例子涵盖了这个新API最重要的部分。
Clock
时钟提供对当前日期和时间的访问。时钟知道一个时区，可以代替System.currentTimeMillis()来检索自Unix EPOCH以来以毫秒为单位的当前时间。这种时间线上的瞬时点也用Instant类来表示。Instants可以用来创建传统的java.util.Date对象。
Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();
Instant instant = clock.instant();
Date legacyDate = Date.from(instant); // legacy java.util.Date
Timezones
时区用ZoneId表示。它们可以很容易地通过静态工厂方法被访问。时区定义了偏移量，这些偏移量对于在时区之间的切换非常重要。
System.out.println(ZoneId.getAvailableZoneIds());
// prints all available timezone ids
ZoneId zone1 = ZoneId.of("Europe/Berlin");
ZoneId zone2 = ZoneId.of("Brazil/East");
System.out.println(zone1.getRules());
System.out.println(zone2.getRules());
// ZoneRules[currentStandardOffset=+01:00]
// ZoneRules[currentStandardOffset=-03:00]
LocalTime
LocalTime代表一个没有时区的时间，例如：10pm或17:30:15。下面的例子为上面定义的时区创建了两个本地时间。然后我们比较两个时间，并计算两个时间之间的小时和分钟的差异。
LocalTime now1 = LocalTime.now(zone1);
LocalTime now2 = LocalTime.now(zone2);
System.out.println(now1.isBefore(now2)); // false
long hoursBetween = ChronoUnit.HOURS.between(now1, now2);
long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);
System.out.println(hoursBetween); // -3
System.out.println(minutesBetween); // -239
LocalTime带有各种工厂方法来简化新实例的创建，包括时间字符串的解析。
LocalTime late = LocalTime.of(23, 59, 59);
System.out.println(late); // 23:59:59
DateTimeFormatter germanFormatter =
DateTimeFormatter
.ofLocalizedTime(FormatStyle.SHORT)
.withLocale(Locale.GERMAN);
LocalTime leetTime = LocalTime.parse("13:37", germanFormatter);
System.out.println(leetTime); // 13:37
LocalDate
LocalDate代表一个独特的日期，例如2014-03-11。它是不可变的，工作原理完全类似于LocalTime。该示例演示了如何通过添加或减去日、月或年来计算新的日期。请记住，每个操作都会返回一个新的实例。
LocalDate today = LocalDate.now();
LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
LocalDate yesterday = tomorrow.minusDays(2);
LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();
System.out.println(dayOfWeek); // FRIDAY
从字符串中解析一个LocalDate就像解析一个LocalTime一样简单。
DateTimeFormatter germanFormatter =
DateTimeFormatter
.ofLocalizedDate(FormatStyle.MEDIUM)
.withLocale(Locale.GERMAN);
LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);
System.out.println(xmas); // 2014-12-24
LocalDateTime
LocalDateTime表示一个日期-时间。它将上述中的日期和时间结合成一个实例。LocalDateTime是不可变的，工作原理与LocalTime和LocalDate类似。我们可以通过一些方法从一个LocalDateTime中获取某些字段。
LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);
DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
System.out.println(dayOfWeek); // WEDNESDAY
Month month = sylvester.getMonth();
System.out.println(month); // DECEMBER
long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
System.out.println(minuteOfDay); // 1439
通过附加的时区信息，可以将其转换为即时日期。即时日期可以很容易地转换为java.util.Date类型的传统日期。
Instant instant = sylvester
.atZone(ZoneId.systemDefault())
.toInstant();
Date legacyDate = Date.from(instant);
System.out.println(legacyDate); // Wed Dec 31 23:59:59 CET 2014
日期-时间的格式化工作就像日期或时间的格式化一样。我们可以通过自定义模式来创建格式，用于解析字符串或者将日期-时间转为字符串。
DateTimeFormatter formatter =
DateTimeFormatter
.ofPattern("MMM dd, yyyy - HH:mm");
LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter);
String string = formatter.format(parsed);
System.out.println(string); // Nov 03, 2014 - 07:13
与 java.text.NumberFormat不同，新的 DateTimeFormatter是不可变的，并且线程安全。
注解
Java 8中的注解是可以重复的。让我们直接进入一个例子来弄清楚这个问题。
首先，我们定义了一个包装器注解，它持有一个实际注解的数组。
@interface Hints {
Hint[] value();
}
@Repeatable(Hints.class)
@interface Hint {
String value();
}
Java 8允许我们通过声明注解@Repeatable来使用同一类型的多个注解。
变式1：使用容器注解（旧式）
@Hints({@Hint("hint1"), @Hint("hint2")})
class Person {}
变式2：使用可重复的注解(新派)
@Hint("hint1")
@Hint("hint2")
class Person {}
使用变式2，java编译器隐式地设置了@Hints注解。这对通过反射读取注解信息很重要。
Hint hint = Person.class.getAnnotation(Hint.class);
System.out.println(hint); // null
Hints hints1 = Person.class.getAnnotation(Hints.class);
System.out.println(hints1.value().length); // 2
Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);
System.out.println(hints2.length); // 2
尽管我们从未在Person类上声明@Hints注解，但它仍然可以通过getAnnotation(Hints.class)来读取。然而，更方便的方法是getAnnotationsByType，它允许直接访问所有的@Hint注解。
此外，Java 8中注解的用法也扩展了两个新的Target。
@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@interface MyAnnotation {}
