原文地址，译文地址，作者: Benjamin Winterberg，译者：Autumn，校对：李任

2014年3月16日

“Java is still not dead—and people are starting to figure that out.”

欢迎阅读我对 Java 8 的介绍。本指南将一步步地通过所有的新的语言特性来引导你认识Java 8。在简短的示例代码的帮助下，你将会学习到如何使用默认的接口方法、lambda表达式、方法引用以及可重复的注解。在文章的最后，你将会熟悉最新的API变化，例如：streams、函数式接口、map 扩展以及新的 Date API。

没有过多的文本 — 仅仅是一些具有注释的代码片段。一起享受吧！

接口的默认方法

Java 8 使我们能够使用default 关键字给接口增加非抽象的方法实现。这个特性也被叫做扩展方法（Extension Methods）。如下例所示：

   
      1 
       interface Formula {  
     
      2 
           double calculate(int a);  
     
      3 
           default double sqrt(int a) {  
     
      4 
               return Math.sqrt(a);  
     
      5 
           }  
     
      6 
      }

除了抽象方法calculate ，接口 Formula 同样定义了默认的方法 sqrt。具体类只需要实现抽象方法calculate。默认的方法sqrt可以在其未实现时“开箱即用”。

   
      1 
       Formula formula = new Formula() {  
     
      2 
           @Override  
     
      3 
           public double calculate(int a) {  
     
      4 
               return sqrt(a * 100);  
     
      5 
           }  
     
      6 
      }; 
     
      7 
       formula.calculate(100);     // 100.0  
     
      8 
       formula.sqrt(16);           // 4.0

formula 被创建的像一个匿名对象。代码看起来很啰嗦：对一个简单的sqrt(a * 100)计算需6行。正如我们在下一节将要看到的，对只有单方法的类的实现，在 Java 8中有个更佳的方式。

Lambda表达式

我们先来讲一个简单的例子：在 Java 之前的版本中是如何排序一个字符串list的：

   
      1 
       List names = Arrays.asList("peter", "anna", "mike", "xenia");  
     
      2 
        
      3 
       Collections.sort(names, new Comparator() {  
     
      4 
           @Override  
     
      5 
           public int compare(String a, String b) {  
     
      6 
               return b.compareTo(a);  
     
      7 
           }  
     
      8 
      });

静态方法Collections.sort 接受一个list和比较方法来对给定的list元素排序。你总是会发现你需要创建匿名的比较方法并且传递给排序方法。

不同于整天创建匿名对象，Java 8有一个简短的多的语法：lambda表达式：

 
      1 
      Collections.sort(names, (String a, String b) -> { 
     
      2 
           return b.compareTo(a);  
     
      3 
      });

正如你所见，代码更短也更易于阅读，而且它还可以更短：

   
      1 
      Collections.sort(names, (String a, String b) -> b.compareTo(a));

对于一行的方法体，你可以省略{} 和return 关键字，而且它还可以更短：

   
      1 
      Collections.sort(names, (a, b) -> b.compareTo(a));

Java 编译器知道参数类型，所以你也可以省略它们。下面让我们一同深入探究下lambda表达式是如何被更广泛地使用的。

函数式接口

lambda表达式是如何符合 Java 类型系统的？每个lambda对应于一个给定的类型，用一个接口来说明。而这个被称为函数式接口（functional interface）的接口必须仅仅包含一个抽象方法声明。每个那个类型的lambda表达式都将会被匹配到这个抽象方法上。因此默认的方法并不是抽象的，你可以给你的函数式接口自由地增加默认的方法。

我们可以使用任意的接口作为lambda表达式，只要这个接口只包含一个抽象方法。为了保证你的接口满足需求，你需要增加@FunctionalInterface 注解。编译器知道这个注解，一旦你试图给这个接口增加第二个抽象方法声明时，它将抛出一个编译器错误。例如：

   
      1 
      @FunctionalInterface 
     
      2 
       interface Converter<F, T> {  
     
      3 
           T convert(F from);  
     
      4 
      } 
     
      5 
      Converter<String, Integer> converter = (from) -> Integer.valueOf(from); 
     
      6 
       Integer converted = converter.convert("123");  
     
      7 
       System.out.println(converted);    // 123

请记住如果@FunctionalInterface 这个注解被遗漏，此代码依然有效。

方法和构造器引用

通过使用静态方法引用，如上的示例代码可以被进一步的简化：

   
      1 
      Converter<String, Integer> converter = Integer::valueOf; 
     
      2 
       Integer converted = converter.convert("123");  
     
      3 
       System.out.println(converted);   // 123

Java 8使你能够通过::关键字传递对方法或者构造器的引用。如上例子告诉我们如何引用一个静态的方法。但是我们也可以引用对象的方法：

   
      1 
       class Something {  
     
      2 
           String startsWith(String s) {  
     
      3 
               return String.valueOf(s.charAt(0));  
     
      4 
           }  
     
      5 
      } 
     
      6 
       Something something = new Something();  
     
      7 
      Converter<String, String> converter = something::startsWith; 
     
      8 
       String converted = converter.convert("Java");  
     
      9 
       System.out.println(converted);    // "J"

我们一起来看看::关键字是如何为构造器工作的。首先，我们定义一个具有多个不同构造器的示例bean：

   
      01 
       class Person {  
     
      02 
           String firstName;  
     
      03 
           String lastName;  
     
      04 
        
      05 
           Person() {}  
     
      06 
        
      07 
           Person(String firstName, String lastName) {  
     
      08 
               this.firstName = firstName;  
     
      09 
               this.lastName = lastName;  
     
      10 
           }  
     
      11 
      }

其次，我们指定一个Person的工厂接口，它用来创建新的Person：

   
      1 
       interface PersonFactory</pre>  
     
      2 
      { 
     
      3 
        P create(String firstName, String lastName);  
     
      4 
      }

为避免手工实现这个工厂，我们通过构造器引用将所有事情连接起来：

   
      1 
       PersonFactory personFactory = Person::new;  
     
      2 
       Person person = personFactory.create("Peter", "Parker");

我们通过Person::new创建了一个对 Person 构造器的引用。Java编译器通过匹配PersonFactory.create标记自动选择合适的构造器。

Lambda作用域

通过lambda表达式访问作用域变量非常类似于匿名对象。你可以通过局部作用域以及实例域和静态变量来访问final变量。

访问局部变量

我们可以通过lambda表达式的作用域读到final类型的局部变量：

   
      1 
       final int num = 1;  
     
      2 
      Converter<Integer, String> stringConverter = 
     
      3 
               (from) -> String.valueOf(from + num);  
     
      4 
        
      5 
       stringConverter.convert(2);

然而不同于匿名对象，变量num 并不需要必须被声明为 final，如下代码同样有效：

   
      1 
       int num = 1;  
     
      2 
      Converter<Integer, String> stringConverter = 
     
      3 
               (from) -> String.valueOf(from + num);  
     
      4 
        
      5 
       stringConverter.convert(2);

然而，为了代码可以编译， num 必须隐含为final类型，如下代码不会编译通过：

   
      1 
       int num = 1;  
     
      2 
      Converter<Integer, String> stringConverter = 
     
      3 
               (from) -> String.valueOf(from + num);  
     
      4 
       num = 3;

在lambda表达式里对 num 赋值也同样是被禁止的。

访问实例域和静态变量

区别于局部变量，我们在lambda表达式里对实例域和静态变量具有读写权限。这种行为在匿名对象中是众所周知的。

   
      01 
       class Lambda4 {  
     
      02 
           static int outerStaticNum;  
     
      03 
           int outerNum;  
     
      04 
        
      05 
           void testScopes() {  
     
      06 
               Converter<Integer, String> stringConverter1 = (from) -> {  
     
      07 
                   outerNum = 23;  
     
      08 
                   return String.valueOf(from);  
     
      09 
               };  
     
      10 
        
      11 
               Converter<Integer, String> stringConverter2 = (from) -> {  
     
      12 
                   outerStaticNum = 72;  
     
      13 
                   return String.valueOf(from);  
     
      14 
               };  
     
      15 
           }  
     
      16 
      }

访问默认的接口方法

还记得第一节的formula 例子吗？接口Formula 定义了一个默认的方法sqrt ，它可以被每个formula 实例（包含匿名对象）来访问。lambda表达式对此并不奏效。

默认的方法不能在lambda表达式内部被访问到，如下代码不能通过编译：

   
      1 
       Formula formula = (a) -> sqrt( a * 100);

内置功能接口

JDK 1.8 API 包含很多内置的功能接口。其中一些在旧的 Java 版本中就众所周知了，例如Comparator 以及 Runnable。通过@FunctionalInterface标记，这些现有的接口已被扩展为lambda所能支持的。

然而 Java 8 API 同样拥有众多新的功能接口来使你的生活更加简单。这些新接口中的一些从Google Guava 库中已经广为人知。即使你对此库很熟悉，你也应该仔细看看那些接口是如何通过一些有用的方法所扩展的。

谓词

谓词是单参数的布尔值函数。该接口包含多个默认的方法使谓词转换成复杂的逻辑表达式（与，或，非）

   
      01 
       Predicate predicate = (s) -> s.length() > 0;  
     
      02 
        
      03 
       predicate.test("foo");              // true  
     
      04 
       predicate.negate().test("foo");     // false  
     
      05 
        
      06 
      Predicate nonNull = Objects::nonNull; 
     
      07 
      Predicate isNull = Objects::isNull; 
     
      08 
        
      09 
      Predicate isEmpty = String::isEmpty; 
     
      10 
      Predicate isNotEmpty = isEmpty.negate();

函数

函数接受单一参数，产出结果。默认的方法可被用来将多个函数链接起来（compose，andThen）。

   
      1 
      Function<String, Integer> toInteger = Integer::valueOf; 
     
      2 
      Function<String, String> backToString = toInteger.andThen(String::valueOf); 
     
      3 
        
      4 
       backToString.apply("123");     // "123"

生产者

生产者产生一个给定的泛型类型的结果。区别于函数，生产者不接受参数。

   
      1 
       Supplier personSupplier = Person::new;  
     
      2 
       personSupplier.get();   // new Person

消费者

消费者代表了将要对一个单一输入参数采取的运算。

   
      1 
       Consumer greeter = (p) -> System.out.println("Hello, " + p.firstName);  
     
      2 
        
      3 
       greeter.accept(new Person("Luke", "Skywalker"));

比较器

比较器在较老的 Java版本中众所周知。Java 8给这个接口增加了多个默认的方法。

   
      1 
      Comparator comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName); 
     
      2 
        
      3 
       Person p1 = new Person("John", "Doe");  
     
      4 
        
      5 
       Person p2 = new Person("Alice", "Wonderland");  
     
      6 
        
      7 
       comparator.compare(p1, p2);             // > 0  
     
      8 
        
      9 
       comparator.reversed().compare(p1, p2);  // < 0

Optionals

Optionals 并不是函数式接口，而是一个避免空指针异常NullPointerException的俏皮工具。这是一个下一节用到的重要的概念，所以让我们快速地看一下它是如何工作的。

Optional 是对空或者非空的一个值的简单的容器。想象一下，一个应该返回非空值结果的方法却有时候什么也没返回。在Java 8 中，你将返回一个Optional 而不是null。

   
      1 
       Optional optional = Optional.of("bam");  
     
      2 
        
      3 
       optional.isPresent();           // true  
     
      4 
        
      5 
       optional.get();                 // "bam"  
     
      6 
        
      7 
       optional.orElse("fallback");    // "bam"  
     
      8 
        
      9 
       optional.ifPresent((s) -> System.out.println(s.charAt(0)));     <i>// "b"</i>

Streams

java.util.Stream 代表元素的一个序列，一个或者多个运算可以在这个序列上运行。Stream运算可以是中间的（intermediate），也可是末端的（terminal）。末端运算返回具有特定类型的结果，中间运算返回 stream 自身，所以聂艺将多个方法调用串联在一行。Streams是在一个源上创建的，例如，一个java.util.Collection 类似的lists或者ses（不支持maps）。Sream运算可以被顺序执行或者并行执行。

让我们一起看看顺序streams是如何工作的。首先，我们创建一个字符串类型的list作为示例源：

   
      01 
       List stringCollection = new ArrayList<>();  
     
      02 
        
      03 
       stringCollection.add("ddd2");  
     
      04 
        
      05 
       stringCollection.add("aaa2");  
     
      06 
        
      07 
       stringCollection.add("bbb1");  
     
      08 
        
      09 
       stringCollection.add("aaa1");  
     
      10 
        
      11 
       stringCollection.add("bbb3");  
     
      12 
        
      13 
       stringCollection.add("ccc");  
     
      14 
        
      15 
       stringCollection.add("bbb2");  
     
      16 
        
      17 
       stringCollection.add("ddd1");

在Java 8 中Collections 被扩展了，因而你可以简单地通过调用Collection.stream() 或者 Collection.parallelStream()创建 streams 。如下节将解释最普遍的流运算。

Filter

Filter 接受一个谓词来过滤出流中所有的元素。此运算是一个中间运算，它可以使我们在结果上调用其它的stream运算（forEach）。forEach 接受一个可以对每个流过滤出的元素进行操作的消费者。forEach 是一个末端运算，换句话说，我们不能再调用其他的流运算

   
      1 
      stringCollection 
     
      2 
        
      3 
      .stream() 
     
      4 
        
      5 
       .filter((s) -> s.startsWith("a"))  
     
      6 
        
      7 
      .forEach(System.out::println); 
     
      8 
        
      9 
      // "aaa2", "aaa1"

Sorted

Sorted 是一个返回流的排序视图的中间运算。除非你传递一个定制的Comparator ，元素将被以自然顺序进行排序。

   
      01 
      stringCollection 
     
      02 
        
      03 
      .stream() 
     
      04 
        
      05 
      .sorted() 
     
      06 
        
      07 
       .filter((s) -> s.startsWith("a"))  
     
      08 
        
      09 
      .forEach(System.out::println); 
     
      10 
        
      11 
      // "aaa1", "aaa2"

请记住，sorted 真的仅仅对此stream创建一个排序的视图，它并不操纵背后的聚集（collection）。stringCollection 的顺序并未改变：

   
      1 
      System<b>.</b>out<b>.</b>println<b>(</b>stringCollection); 
     
      2 
        
      3 
      // ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bb<i>b2, ddd1</i>

Map

中间运算 map 将每个元素通过给定的函数转变为其它对象。如下示例讲每个string转换为一个大写字母的string。但是你也可以使用map 将每个对象转换为其它了下。转换结果的类型依赖于你传递给map 的类型。

   
      01 
      stringCollection 
     
      02 
        
      03 
      .stream() 
     
      04 
        
      05 
      .map(String::toUpperCase) 
     
      06 
        
      07 
      .sorted((a, b) -> b.compareTo(a)) 
     
      08 
        
      09 
      .forEach(System.out::println); 
     
      10 
        
      11 
      // "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "A<i>AA2", "AAA1"</i>

匹配

多个匹配运算可以被用来检验是否一个特定的谓词与某stream匹配。所有的这些运算都为末端运算，并且返回一个布尔值结果。

   
      01 
       boolean anyStartsWithA =  
     
      02 
        
      03 
      stringCollection 
     
      04 
        
      05 
      .stream() 
     
      06 
        
      07 
       .anyMatch((s) -> s.startsWith("a"));  
     
      08 
        
      09 
       System.out.println(anyStartsWithA);      // true  
     
      10 
        
      11 
       boolean allStartsWithA =  
     
      12 
        
      13 
      stringCollection 
     
      14 
        
      15 
      .stream() 
     
      16 
        
      17 
       .allMatch((s) -> s.startsWith("a"));  
     
      18 
        
      19 
       System.out.println(allStartsWithA);      // false  
     
      20 
        
      21 
       boolean noneStartsWithZ =  
     
      22 
        
      23 
      stringCollection 
     
      24 
        
      25 
      .stream() 
     
      26 
        
      27 
       .noneMatch((s) -> s.startsWith("z"));  
     
      28 
        
      29 
       System.out.println(noneStartsWithZ);      // true

计数

计数是一个末端运算，以long类型返回在stream中的元素的数目。

   
      01 
       long startsWithB =  
     
      02 
        
      03 
      stringCollection 
     
      04 
        
      05 
      .stream() 
     
      06 
        
      07 
       .filter((s) -> s.startsWith("b"))  
     
      08 
        
      09 
      .count(); 
     
      10 
        
      11 
       System.out.println(startsWithB);    // 3

Reduce

这个末端运算使用给定的函数对stream的元素进行一个减缩运算。结果是一个保存有减缩值的Optional 。

   
      01 
      Optional<b><</b>String> reduced = 
     
      02 
        
      03 
      stringCollection 
     
      04 
        
      05 
      .stream() 
     
      06 
        
      07 
      .sorted() 
     
      08 
        
      09 
       .reduce((s1, s2) -> s1 + "#" + s2);  
     
      10 
        
      11 
      reduced.ifPresent(System.out::println); 
     
      12 
        
      13 
      // "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2"

Parallel Streams

正如上述提到的，streams可以是顺序或者并行的。在顺序streams上的操作是在一个单线程中完成的，然而在并行streams上的操作时在多个线程上并发完成的。

如下例子证明了通过使用并发流是如何简单地提高运算性能的。

首先，我们创建一个无重复元素的大的list：

 
      01 
       int max <b>=</b> 1000000;  
     
      02 
        
      03 
       List values = new ArrayList<>(max);  
     
      04 
        
      05 
       for (int i = 0; i < max; i++) {  
     
      06 
        
      07 
      UUID uuid = UUID.randomUUID(); 
     
      08 
        
      09 
      values.add(uuid.toString()); 
     
      10 
        
      11 
      }

现在我们对需要多少时间来完成对其排序进行统计。

顺序排序

   
      01 
       long t0 <b>=</b> System<b>.</b>nanoTime();  
     
      02 
        
      03 
       long count = values.stream().sorted().count();  
     
      04 
        
      05 
      System.out.println(count); 
     
      06 
        
      07 
       long t1 = System.nanoTime();  
     
      08 
        
      09 
       long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);  
     
      10 
        
      11 
       System.out.println(String.format("sequential sort took: %d ms", millis));  
     
      12 
        
      13 
      // sequential sort took: 899 ms

并行排序

   
      01 
       long t0 <b>=</b> System<b>.</b>nanoTime<b>();</b>  
     
      02 
        
      03 
       long count = values.parallelStream().sorted().count();  
     
      04 
        
      05 
      System.out.println(count); 
     
      06 
        
      07 
       long t1 = System.nanoTime();  
     
      08 
        
      09 
       long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);  
     
      10 
        
      11 
       System.out.println(String.format("parallel sort took: %d ms", millis));  
     
      12 
        
      13 
      // parallel sort took: 472 ms

正如你所看到的，两个代码片段几乎相同，但是并行排序快了将近50%。而所有你所需要做的仅仅是将stream() 改为 parallelStream()。

Map

正如已经提到的，maps并不支持streams。然而，maps现在支持多种新的有用的方法来完成普通的任务。

   
      1 
       Map<Integer, String> map = new HashMap<>();  
     
      2 
       for (int i = 0; i < 10; i++) {     map.putIfAbsent(i, "val" + i); } map.forEach((id, val) -> System.out.println(val));

如上的代码应该是意义很明确的：putIfAbsent避免了我们写多余的null检查；forEach 接受一个消费者去对每个map的值做运算。

这个例子显示了如何利用函数在map上进行操作。

   
      1 
       map.computeIfPresent(3, (num, val) -> val + num);  
     
      2 
       map.get(3);             // val33  
     
      3 
       map.computeIfPresent(9, (num, val) -> null);  
     
      4 
       map.containsKey(9);     // false  
     
      5 
       map.computeIfAbsent(23, num -> "val" + num);  
     
      6 
       map.containsKey(23);    // true  
     
      7 
       map.computeIfAbsent(3, num -> "bam");  
     
      8 
       map.get(3);             // val33

接下来，我们学习如何对给定的key删除entry（只有它对应到了一个给定的值时生效）：

   
      1 
       map.remove(3, "val3");  
     
      2 
       map.get(3);             // val33  
     
      3 
       map.remove(3, "val33");  
     
      4 
       map.get(3);             // null

另一个有用的方法：

   
      1 
       map.getOrDefault(42, "not found");

合并map的记录很方便：

   
      1 
       map.merge(9, "val9", (value, newValue) -> value.concat(newValue));  
     
      2 
       map.get(9);             // val9  
     
      3 
        
      4 
       map.merge(9, "concat", (value, newValue) -> value.concat(newValue));  
     
      5 
       map.get(9);             // val9concat

如果没有相应记录，合并会将key/value 对放入map，否则合并函数将会被调用来改变现有的值。

Date API

Java 8在包java.time包含一个全新的日期和时间的API。这个新的Date API堪比Joda-Time库，然而，它们并不完全相同。如下的例子将会覆盖这个新API的大多数重要的部分。

Clock

Clock 提供对现在时间和日期的访问。Clocks 能感知时区，可能被用来替代System.currentTimeMillis() 来获取现在毫秒数。这样一个在时间线上即时的点也被类Instant所表示。Instant可以被用来创建java.util.Date 对象。

   
      1 
      Clock clock = Clock.systemDefaultZone(); 
     
      2 
       long millis = clock.millis();  
     
      3 
        
      4 
      Instant instant = clock.instant(); 
     
      5 
       Date legacyDate = Date.from(instant);   // legacy java.util.Date

Timezones

Timezones由一个ZoneId代表。他们可以被静态工厂方法很容易地访问。 Timezones 定义偏移量，这对于instants 和本地日期、时间之间的转换非常重要。

   
      01 
      System.out.println(ZoneId.getAvailableZoneIds()); 
     
      02 
      // prints all available timezone ids 
     
      03 
        
      04 
       ZoneId zone1 = ZoneId.of("Europe/Berlin");  
     
      05 
       ZoneId zone2 = ZoneId.of("Brazil/East");  
     
      06 
      System.out.println(zone1.getRules()); 
     
      07 
      System.out.println(zone2.getRules()); 
     
      08 
        
      09 
      // ZoneRules[currentStandardOffset=+01:00] 
     
      10 
      // ZoneRules[currentStandardOffset=-03:00]

LocalTime

LocalTime 代表一个不带时区的时间，例如：10pm 或者 17:30:15。如下示例为如上定义的时区创建两个本地时间。那么，我们就可以比较两个时间，并且计算出两个时间间的时间差（小时或者分钟为单位）。

   
      01 
      LocalTime now1 = LocalTime.now(zone1); 
     
      02 
      LocalTime now2 = LocalTime.now(zone2); 
     
      03 
        
      04 
       System.out.println(now1.isBefore(now2));  // false  
     
      05 
        
      06 
       long hoursBetween = ChronoUnit.HOURS.between(now1, now2);  
     
      07 
       long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);  
     
      08 
        
      09 
       System.out.println(hoursBetween);       // -3  
     
      10 
       System.out.println(minutesBetween);     // -239

伴随着LocalTime ，这里存在多种工厂方法来简化新实例的创建，也包含对时间字符串的解析。

   
      01 
       LocalTime late = LocalTime.of(23, 59, 59);  
     
      02 
       System.out.println(late);       // 23:59:59  
     
      03 
        
      04 
      DateTimeFormatter germanFormatter = 
     
      05 
           DateTimeFormatter  
     
      06 
               .ofLocalizedTime(FormatStyle.SHORT)  
     
      07 
               .withLocale(Locale.GERMAN);  
     
      08 
        
      09 
       LocalTime leetTime = LocalTime.parse("13:37", germanFormatter);  
     
      10 
       System.out.println(leetTime);   // 13:37

LocalDate

LocalDate 代表一个明确的日期，例如2014-03-11。它是不可变的，并且非常类似LocalTime。这个示例将证明如何通过增加或者减少日期、月份、年来计算出一个新的日期。记住每次操作将返回一个新的实例。

   
      1 
      LocalDate today = LocalDate.now(); 
     
      2 
       LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);  
     
      3 
       LocalDate yesterday = tomorrow.minusDays(2);  
     
      4 
        
      5 
       LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);  
     
      6 
      DayOfWeek dayOfWeek = independenceDay.getDayOfWeek(); 
     
      7 
       System.out.println(dayOfWeek);    // FRIDAY

从字符串中解析LocalDate就像解析 LocalTime一样简单：

   
      01 
      DateTimeFormatter germanFormatter = 
     
      02 
        
      03 
      DateTimeFormatter 
     
      04 
        
      05 
      .ofLocalizedDate(FormatStyle.MEDIUM) 
     
      06 
        
      07 
      .withLocale(Locale.GERMAN); 
     
      08 
        
      09 
       LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);  
     
      10 
        
      11 
       System.out.println(xmas);   // 2014-12-24

LocalDateTime

LocalDateTime 代表日期-时间。它将如上所示的日期和时间合并为一个实例。LocalDateTime 是不可变的，它类似LocalTime和 LocalDate。我们可以使用方法获取日期-时间中特定的域：

   
      1 
       LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);  
     
      2 
      DayOfWeek dayOfWeek = sylvester.getDayOfWeek(); 
     
      3 
       System.out.println(dayOfWeek);      // WEDNESDAY  
     
      4 
      Month month = sylvester.getMonth(); 
     
      5 
       System.out.println(month);          // DECEMBER  
     
      6 
       long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);  
     
      7 
       System.out.println(minuteOfDay);    // 1439

知道额外的时区信息，它就可以转换为一个instant，instant可以很容易地转换为java.util.Date 类型的日期。

   
      1 
      Instant instant = sylvester 
     
      2 
        
      3 
      .atZone(ZoneId.systemDefault()) 
     
      4 
        
      5 
      .toInstant(); 
     
      6 
        
      7 
      Date legacyDate = Date.from(instant); 
     
      8 
        
      9 
       System.out.println(legacyDate);     // Wed Dec 31 23:59:59 CET 2014

形式化日期-时间的工作就像形式化日期或者时间一样。我们可以从客户化的模式来创建格式（formatter），而不是使用预先定义的格式。

   
      01 
      DateTimeFormatter formatter = 
     
      02 
        
      03 
      DateTimeFormatter 
     
      04 
        
      05 
       .ofPattern("MMM dd, yyyy - HH:mm");  
     
      06 
        
      07 
       LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter);  
     
      08 
        
      09 
      String string = formatter.format(parsed); 
     
      10 
        
      11 
       System.out.println(string);     // Nov 03, 2014 - 07:13

区别于 java.text.NumberFormat ，新的DateTimeFormatter 时而不可变的且是线程安全的。

模式语法的细节可以点击这里。

Annotations/

在Java8 中Annotations是可重复的。让我们通过一个具体的例子来理解它。

首先，我们定义一个包装器注解，它拥有一组真正的注解：

 
      01 
       @interface Hints {  
     
      02 
        
      03 
      Hint[] value(); 
     
      04 
        
      05 
      } 
     
      06 
        
      07 
       @Repeatable(Hints.class)  
     
      08 
        
      09 
       @interface Hint {  
     
      10 
        
      11 
      String value(); 
     
      12 
        
      13 
      }

Java 8 中，通过声明注解@Repeatable使我能够使用多个具有相同类型的注解。

变体 1: 使用容器注解（守旧派）

   
      1 
       @Hints({@Hint("hint1"), @Hint("hint2")})  
     
      2 
       class Person {}

变体 2: 使用可重复的注解（新派）

   
      1 
       @Hint("hint1")  
     
      2 
       @Hint("hint2")  
     
      3 
       class Person {}

使用变体2，Java编译器可以隐式地设置 @Hints注解。这对于通过反射来阅读注解信息是很重要的。

   
      1 
       Hint hint = Person.class.getAnnotation(Hint.class);  
     
      2 
       System.out.println(hint);                   // null  
     
      3 
        
      4 
       Hints hints1 = Person.class.getAnnotation(Hints.class);  
     
      5 
       System.out.println(hints1.value().length);  // 2  
     
      6 
        
      7 
       Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);  
     
      8 
      System.out.println(hints2.length);

尽管我们从不在Person类上声明@Hints 注解，它依然通过getAnnotation(Hints.class)可读。然而，更多便捷的方法是 getAnnotationsByType，它将具有对所有带注释的@Hint 注解直接访问的能力。

此外，在Java8中对注解的使用被扩大到两个新的targets：

   
      1 
       @Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})  
     
      2 
       @interface MyAnnotation {}

就是这样

我对Java 8 编程的指南就到这里。肯定还有更多的东西值得探究。由你决定去探索在Java 8 编程中所有其它伟大的改进，例如，Arrays.parallelSort、StampedLock以及 CompletableFuture 等等。

Java 8 指南

接口的默认方法

Lambda表达式

函数式接口

方法和构造器引用

Lambda作用域

访问局部变量

访问实例域和静态变量

访问默认的接口方法

内置功能接口

谓词

函数

生产者

消费者

比较器

Optionals

Streams

Filter

Sorted

Map

匹配

计数

Reduce

Parallel Streams

顺序排序

并行排序

Map

Date API

Clock

Timezones

LocalTime

LocalDate

LocalDateTime

Annotations/

就是这样

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java 8 指南

接口的默认方法

Lambda表达式

函数式接口

方法和构造器引用

Lambda作用域

访问局部变量

访问实例域和静态变量

访问默认的接口方法

内置功能接口

谓词

函数

生产者

消费者

比较器

Optionals

Streams

Filter

Sorted

Map

匹配

计数

Reduce

Parallel Streams

顺序排序

并行排序

Map

Date API

Clock

Timezones

LocalTime

LocalDate

LocalDateTime

Annotations/

就是这样

热门文章

最新文章

相关课程

相关电子书

相关实验场景