接口的默认方法
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
该公式被实现为匿名对象。代码相当冗长：6行代码用于这样一个简单的计算sqrt(a * 100)...正如我们将在下一节中看到的那样，在Java 8中实现单个方法对象的方法要好得多。
Lambda表达式
让我们从一个简单的示例开始，说明如何在早期版本的Java中排序字符串列表：
List names = Arrays.asList("peter", "anna", "mike", "xenia");
Collections.sort(names, new Comparator() {
@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));
列表现在有一个sort方法。而且，java编译器知道参数类型，所以您也可以跳过它们。让我们深入探讨如何在野外使用lambda表达式。
功能接口
如何将lambda表达式融入Java的类型系统？每个lambda对应于由接口指定的给定类型。a所谓的功能接口必须包含精确一种抽象方法申报。该类型的每个lambda表达式将与此抽象方法匹配。由于默认方法不是抽象的，所以可以自由地将默认方法添加到功能接口中。
只要接口只包含一个抽象方法，就可以使用任意接口作为lambda表达式。为了确保您的界面符合要求，您应该添加@FunctionalInterface注释编译器知道这个注释，并在尝试向接口添加第二个抽象方法声明时抛出一个编译器错误。
例子：
@FunctionalInterface
interface Converter {
T convert(F from);
}
Converter converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted); // 123
请记住，如果@FunctionalInterface注释将被省略。
方法和构造器引用
通过使用静态方法引用，可以进一步简化上述示例代码：
Converter 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 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 create(String firstName, String lastName);
}
我们没有手动实现工厂，而是通过构造函数引用将所有内容粘合在一起：
PersonFactory personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");
我们通过以下方法创建对Person构造函数的引用Person::new...的签名匹配，Java编译器自动选择正确的构造函数。PersonFactory.create.
Lambda Scopes
从lambda表达式访问外部作用域变量与匿名对象非常相似。您可以从本地外部作用域以及实例字段和静态变量访问最终变量。
访问局部变量
我们可以从lambda表达式的外部范围读取最终局部变量：
final int num = 1;
Converter stringConverter =
(from) -> String.valueOf(from + num);
stringConverter.convert(2); // 3
但是与匿名对象不同的是变量num不必被宣布为最终。此代码也是有效的：
int num = 1;
Converter stringConverter =
(from) -> String.valueOf(from + num);
stringConverter.convert(2); // 3
不过num代码编译必须是隐式最终的。下面的代码会不汇编：
int num = 1;
Converter stringConverter =
(from) -> String.valueOf(from + num);
num = 3;
写信给num还禁止使用lambda表达式。
访问字段和静态变量
与局部变量不同，我们可以从lambda表达式中读取和写入实例字段和静态变量。这种行为是众所周知的匿名对象。
class Lambda4 {
static int outerStaticNum;
int outerNum;
void testScopes() {
Converter stringConverter1 = (from) -> {
outerNum = 23;
return String.valueOf(from);
};
Converter stringConverter2 = (from) -> {
outerStaticNum = 72;
return String.valueOf(from);
};
}
}
访问默认接口方法
还记得第一部分的公式示例吗？界面Formula定义默认方法sqrt可以从每个公式实例(包括匿名对象)访问。这不适用于lambda表达式。
默认方法不可能从lambda表达式中访问。以下代码未编译：
Formula formula = (a) -> sqrt(a * 100);
内置函数接口
JDK1.8API包含许多内置的函数接口。其中一些是从Java的旧版本中广为人知的，比如Comparator或Runnable...这些现有接口通过@FunctionalInterface注释
但是Java8API也充满了新的功能接口，以使您的生活更轻松。这些新接口中的一些是众所周知的。谷歌番石榴图书馆。即使您熟悉这个库，也应该密切关注这些接口是如何通过一些有用的方法扩展的。
谓词
谓词是一个参数的布尔值函数.该接口包含各种默认方法，用于将谓词组合为复杂的逻辑术语(和，或，否定)。
Predicate predicate = (s) -> s.length() > 0;
predicate.test("foo"); // true
predicate.negate().test("foo"); // false
Predicate nonNull = Objects::nonNull;
Predicate isNull = Objects::isNull;
Predicate isEmpty = String::isEmpty;
Predicate isNotEmpty = isEmpty.negate();
功能
函数接受一个参数并产生一个结果。默认方法可用于将多个函数链接在一起(组合，然后)。
Function toInteger = Integer::valueOf;
Function backToString = toInteger.andThen(String::valueOf);
backToString.apply("123"); // "123"
供货商
供应商产生给定的通用类型的结果。与功能不同的是，供应商不接受争论。
Supplier personSupplier = Person::new;
personSupplier.get(); // new Person
消费者
使用者表示要对单个输入参数执行的操作。
Consumer greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));
比较器
比较器在早期版本的Java中是众所周知的。Java 8向接口添加了各种默认方法。
Comparator 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
选项
选项不是功能接口，而是用于防止的实用程序。NullPointerException...这是下一节的一个重要概念，所以让我们快速看看选项词是如何工作的。
可选的值是一个简单的容器，它可以是空的，也可以是非空的.设想一种方法，它可能返回一个非空结果，但有时什么也不返回。而不是返回null您返回一个Optional在Java 8中。
Optional optional = Optional.of("bam");
optional.isPresent(); // true
optional.get(); // "bam"
optional.orElse("fallback"); // "bam"
optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b"
溪流
A java.util.Stream表示可以对其执行一个或多个操作的元素序列。流操作是中间型或终端...当终端操作返回某种类型的结果时，中间操作返回流本身，这样就可以在一行中链接多个方法调用。流是在源上创建的，例如java.util.Collection类似于列表或集合(不支持地图)。流操作既可以顺序执行，也可以并行执行。
让我们先看看顺序流是如何工作的。首先，我们以字符串列表的形式创建一个示例源：
List 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接受一个谓词来过滤流的所有元素。这个手术是中间型它使我们能够调用另一个流操作(forEach)在结果上。ForEach接受要对过滤流中的每个元素执行的使用者。ForEach是一个终端操作。它是void，因此我们不能调用另一个流操作。
stringCollection
.stream()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
// "aaa2", "aaa1"
分门别类
排序是中间型操作，该操作返回流的排序视图。元素按自然顺序排序，除非您传递自定义。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.
stringCollection
.stream()
.map(String::toUpperCase)
.sorted((a, b) -> b.compareTo(a))
.forEach(System.out::println);
// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"
匹配
可以使用各种匹配操作来检查某个谓词是否与流匹配。所有这些操作都是终端并返回一个布尔结果。
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
数数
伯爵是终端操作，将流中的元素数作为long.
long startsWithB =
stringCollection
.stream()
.filter((s) -> s.startsWith("b"))
.count();
System.out.println(startsWithB); // 3
减少
这，这个终端操作使用给定的函数对流的元素执行约简。结果是Optional持有减值。
Optional 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 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().
地图
如前所述，映射不直接支持流。没有stream()方法的Map接口本身，但是您可以通过以下方式在映射的键、值或条目上创建专用流：map.keySet().stream(), map.values().stream()和map.entrySet().stream().
此外，地图支持执行常见任务的各种新的和有用的方法。
Map map = new HashMap<>();
for (int i = 0; i < 10; i++) {
map.putIfAbsent(i, "val" + i);
}
map.forEach((id, val) -> System.out.println(val));
以上代码应自我解释：putIfAbsent阻止我们编写额外的如果为空检查；forEach接受使用者对映射的每个值执行操作。
此示例演示如何利用函数计算地图上的代码：
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
接下来，我们将学习如何删除给定键的条目，仅在当前将其映射到给定值的情况下：
map.remove(3, "val3");
map.get(3); // val33
map.remove(3, "val33");
map.get(3); // null
另一个有用的方法是：
map.getOrDefault(42, "not found"); // not found
合并地图条目非常容易：
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
如果不存在键的条目，则合并或者将键/值放到映射中，或者调用合并函数来更改现有的值。
日期API
Java 8在包中包含一个全新的日期和时间API。java.time...新的日期API与尤达-时间图书馆，不管是什么不一样...下面的示例介绍了这个新API最重要的部分。
钟
时钟提供对当前日期和时间的访问。时钟是知道时区的，可以用它来代替。System.currentTimeMillis()检索自Unix时代以来的当前时间(毫秒)。时间线上的这种瞬时点也由类表示。Instant...即时可用于创建遗留文件。java.util.Date物品。
Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();
Instant instant = clock.instant();
Date legacyDate = Date.from(instant); // legacy java.util.Date
时区
时区由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表示没有时区的时间，例如晚上10点或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代表一个不同的日期，例如2014-03-11。它是不变的，它的工作方式与当地时间完全类似。该示例演示了如何通过添加或减去天数、月份或年份来计算新日期。请记住，每个操作都返回一个新实例。
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与解析本地时间一样简单：
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是不可变的，其工作方式类似于本地时间和LocalDate。我们可以利用方法从日期时间检索某些字段：
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是不可变的而且thread-safe
注解
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
虽然我们从未宣布@Hints上的注释Person类，它仍然可以通过getAnnotation(Hints.class)...然而，更方便的方法是getAnnotationsByType允许直接访问所有带注释的@Hint注释。
此外，Java 8中注释的使用扩展到两个新目标：
@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@interface MyAnnotation {}