Java8 新特性概览

Java 8是自Java 5(2004年)发布以来Java语言最大的一次版本升级,Java 8带来了很多的新特性,比如编译器,类库,开发工具和JVM(Java虚拟机).但是最大的也是最难和最灵活的就是函数式接口和Lambda表达式

函数编程的最直接的表现，莫过于将函数作为数据自由传递，结合泛型推导能力，使代码表达能力获得飞一般的提升.

接口的默认方法

Java 8允许我们给接口添加一个非抽象的方法实现,只需要使用 default关键字即可,这个特征又叫做扩展方法
代码如下:

interface Formula {
    double calculate(int a);

    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

Formula接口在拥有calculate方法之外同时还定义了sqrt方法,实现了Formula接口的子类只需要实现一个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

Lambda表达式(也叫做闭包)

是Java 8中最大的也是期待已久的变化.它允许我们将一个函数当作方法的参数(传递函数),或者说把代码当作数据,这是每个函数式编程者熟悉的概念.很多基于 JVM平台的语言一开始就支持Lambda表达式,但是Java程序员没有选择,只能使用匿名内部类来替代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 传入一个List对象以及一个Comparator(比较器)来按指定顺序排列.通常做法都是创建一个匿名的比较器对象然后将其传递给sort方法.

在Java 8 中你就没必要使用这种传统的匿名对象的方式了,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关键字,但是你还可以写得更短点:
代码如下:

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

Java编译器可以自动推导出参数类型,所以你可以不用再写一次类型.接下来我们看看lambda表达式还能作出什么更方便的东西来

Lambda表达式与匿名类的区别

使用匿名类与 Lambda 表达式的一大区别在于关键词的使用。对于匿名类，关键词 this 解 读为匿名类，而对于Lambda表达式，关键词this解 读为写就 Lambda 的外部类。

Lambda 表达式与匿名类的另一不同在于两者的编译方法。Java编译器编译Lambda表达式并将他们转化为类里面的私有函数，它使用 Java7 中新加的invokedynamic指 令动态绑定该方法.

---

Lambda表达式与闭包(Closure)的区别

“Lambda 表达式”
(lambda expression)是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包（注意和数学传统意义上的不同）。
目前主流语言都支持Lambda：Java,C#,C++,Python,JavaScript等。

"闭包（closure）"是指可以包含自由（未绑定到特定对象）变量的代码块；这些变量不是在这个代码块内或者任何全局上下文中定义的，而是在定义代码块的环境中定义（局部变量）。
“闭包” 一词来源于以下两者的结合：要执行的代码块（由于自由变量被包含在代码块中，这些自由变量以及它们引用的对象没有被释放）和为自由变量提供绑定的计算环境（作用域）。
在PHP、Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby、Python、Go、Lua、objective c、swift 以及Java（Java8及以上）等语言中都能找到对闭包不同程度的支持。

---

函数式接口

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

方法引用

要注意这里的方法引用实际上是Lambda表达式的更简洁写法，原因就是在这些情况下，编译器能够智能的推断出参数体中的值究竟是方法的传入参数还是调用者。

方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。方法引用提供了一种引用而不执行方法的方式，它需要由兼容的函数式接口构成的目标类型上下文。

当Lambda表达式中只是执行一个方法调用时，不用Lambda表达式，直接通过方法引用的形式可读性更高一些。方法引用是一种更简洁易懂的Lambda表达式。

注意方法引用是一个Lambda表达式，其中方法引用的操作符是双冒号"::"

有以下四种形式的方法引用：

类型	语法	对应的Lambda表达式
静态方法引用	类名::staticMethodName	(args) -> 类名.staticMethodName(args)
实例方法引用	实例名::instanceMethodName	(args) -> 实例名.instanceMethodName(args)
对象方法引用	类名::instanceMethodName	(实例名,args) -> 实例名.instanceMethodName(args)
构建方法引用	类名::new	(args) -> new 类名(args)

• 引用静态方法
  ClassName::staticMethodName
  例子: String::valueOf，对应的Lambda：(s) -> String.valueOf(s)
  比较容易理解，和静态方法调用相比，只是把.换为::
  
• 引用特定对象的实例方法
  ObjectName::instanceMethodName
  例子: x::toString，对应的Lambda：() -> this.toString()
  与引用静态方法相比，都换为实例的而已
  
• 引用特定类型的任意对象的实例方法
  ClassName::instanceMethodName
  例子: String::toString，对应的Lambda：(s) -> s.toString() //(实例名,args) -> 实例名.methodName(args)

  String[] stringArray = { "Barbara", "James", "Mary", "John", "Patricia", "Robert", "Michael", "Linda" };
  Arrays.sort(stringArray, String::compareToIgnoreCase);
  //对应的: Arrays.sort(stringArray, (T1, T2) -> T1.compareToIgnoreCase(T2));

有时，我们在 lambda 表达式中调用参数的方法。 在这种情况下，我们可以使用方法引用来调用特定类型的任意对象的实例方法。

太难以理解了。难以理解也要深刻理解!Stream中常用此法

和引用静态方法拥有一样的语法,区别是，Lambda表达式的参数个数需要等于所调用方法的入参个数加一。
为什么要加一？
因为类的成员方法不能通过类名直接调用，只能通过对象来调用，也就是Lambda表达式的第一个参数，是方法的调用者，从第二个开始的参数个数要和需要调用方法的入参个数一致即可

• 引用构造函数
ClassName::new
  例子: String::new，对应的 Lambda：() -> new String()
  构造函数本质上是静态方法，只是方法名字比较特殊。

前一节中的代码还可以通过静态方法引用来表示:
代码如下:

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

接下来看看构造函数是如何使用::关键字来引用的,首先我们定义一个包含多个构造函数的简单类:
代码如下:

class Person {
    String firstName;
    String lastName;

    Person() {}

    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

接下来我们指定一个用来创建Person对象的对象工厂接口:
代码如下:

interface PersonFactory<T> {
	T create(String firstName, String lastName);
}

这里我们使用构造函数引用来将他们关联起来,而不是实现一个完整的工厂:
代码如下:

PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");
System.out.println(person);

我们只需要使用 Person::new 来获取Person类构造函数的引用,Java编译器会自动根据PersonFactory.create方法的签名来选择合适的构造函数.

数组构造方法引用

组成语法格式： TypeName[]::new

例子：
int[]::new是一个含有一个参数的构造器引用，这个参数就是数组的长度。等价于lambda表达式 x -> new int[x]

假想存在一个接收int参数的数组构造方法

IntFunction<int[]> arrayMaker = int[]::new;
int[] array = arrayMaker.apply(10) // 创建数组 int[10]

Lambda 作用域

在lambda表达式中访问外层作用域和老版本的匿名对象中的方式很相似.你可以直接访问标记了final的外层局部变量,或者实例的字段以及静态变量.

访问局部变量

我们可以直接在lambda表达式中访问外层的局部变量:
代码如下:

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

System.out.println(stringConverter.convert(2)); // 3

但是和匿名对象不同的是,这里的变量num可以不用声明为final,该代码同样正确:
代码如下:

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

System.out.println(stringConverter.convert(2)); // 3

不过这里的num必须不可被后面的代码修改(即隐性的具有final的语义),例如下面的就无法编译:
代码如下:

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

System.out.println(stringConverter.convert(2)); // 3
num = 3;

在lambda表达式中试图修改num同样是不允许的.

访问对象字段与静态变量

和本地变量不同的是,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);
		};

		stringConverter1.convert("1");
		stringConverter2.convert("2");

		System.out.println("outerStaticNum:" + outerStaticNum);
		System.out.println("outerNum:" + outerNum);
    }
}

访问接口的默认方法

第一节中的formula例子中,接口Formula定义了一个默认方法sqrt可以直接被formula的实例包括匿名对象访问到,但是在lambda表达式中这个是不行的.
Lambda表达式中是无法访问到默认方法的,以下代码将无法编译:
代码如下:

Formula formula = (a) -> sqrt( a * 100);
Built-in Functional Interfaces

---

JDK 8 API包含了很多内建的函数式接口,在老Java中常用到的比如Comparator或者Runnable接口,这些接口都增加了@FunctionalInterface注解以便能用在lambda上.
Java 8 API同样还提供了很多全新的函数式接口来让工作更加方便,有一些接口是来自Google Guava库里的,即便你对这些很熟悉了,还是有必要看看这些是如何扩展到lambda上使用的.

常用函数接口列表

接口	输入参数	返回类型	说明
UnaryOperator	T	T	一元函数，输入输出类型相同
Predicate	T	boolean	断言
Consumer	T	/	消费一个数据，只有输入没有输出
Function<T,R>	T	R	输入 T 返回 R，有输入也有输出
Supplier	/	T	提供一个数据，没有输入只有输出
BiFunction<T,U,R>	(T,U)	R	两个输入参数
BiPredicate<L, R>	(L,R)	boolean	两个输入参数
BiConsumer<T, U>	(T,U)	void	两个输入参数
BinaryOperator	(T,T)	T	二元函数，输入输出类型相同

接下来我们来看看这些函数接口。

Predicate(断言)接口

Predicate 接口只有一个参数,返回boolean类型.该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑(比如:与,或,非):
代码如下:

Predicate predicate = (s) -> ((String) s).length() > 0;

predicate.test("foo"); // true
predicate.negate().test("foo"); // false

Predicate nonNull = Objects::nonNull;
Predicate isNull = Objects::isNull;

String ss="s123";
Predicate<String> isEmpty = ss::startsWith;
Predicate isNotEmpty = isEmpty.negate();

Function 接口

Function 接口有一个参数并且返回一个结果,并附带了一些可以和其他函数组合的默认方法(compose, andThen):
代码如下:

Function<String, Integer> toInteger = Integer::valueOf;
Function backToString = toInteger.andThen(String::valueOf);

backToString.apply("123"); // "123"

Supplier 接口

Supplier 接口返回一个任意范型的值,和Function接口不同的是该接口没有任何参数
代码如下:

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

Consumer 接口

Consumer 接口表示执行在单个参数上的操作.
代码如下:

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

Comparator 接口

Comparator 是老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

Optional 接口

Optional 不是函数是接口,这是个用来防止NullPointerException异常的辅助类型,这是下面将要用到的重要概念,现在先简单的看看这个接口能干什么:

Optional 被定义为一个简单的容器,其值可能是null或者不是null.在Java 8之前一般某个函数应该返回非空对象但是偶尔却可能返回了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"

流式操作(Stream 接口)

Java 8之所以费这么大功夫引入函数式编程,原因如下:

1. 代码简洁 函数式编程写出的代码简洁且意图明确,使用stream接口让你从此告别for循环.
2. 多核友好 Java函数式编程使得编写并行程序从未如此简单,你需要的全部就是调用一下parallel()方法.
3. 无存储 stream不是一种数据结构,它只是某种数据源的一个视图,数据源可以是一个数组,Java容器或I/O channel等.
4. 为函数式编程而生 对stream的任何修改都不会修改背后的数据源,比如对stream执行过滤操作并不会删除被过滤的元素,而是会产生一个不包含被过滤元素的新stream.
5. 惰式执行 stream上的操作并不会立即执行,只有等到用户真正需要结果的时候才会执行.
6. 可消费性 stream只能被"消费"一次,一旦遍历过就会失效,就像容器的迭代器那样,想要再次遍历必须重新生成.

---

Java 8扩展了集合类,可以通过 Collection.stream() 或者 Collection.parallelStream() 来创建一个Stream.下面几节将详细解释常用的Stream操作.
java.util.Stream表示能应用在一组元素上执行的操作序列.
Stream 操作分为中间操作或者最终操作两种,最终操作返回一特定类型的计算结果,而中间操作返回Stream本身,这样你就可以将多个操作依次串起来.
Stream 的创建需要指定一个数据源,比如java.util.Collection的子类,List或者Set, Map不支持.Stream的操作可以串行执行或者并行执行.

所有流计算都有一种共同的结构:它们具有一个流来源 ,0或多个中间操作,以及一个终止操作.

1. 流的来源

方法	描述
Collection.stream()	使用一个集合的元素创建一个流.
Stream.of(T…)	使用传递给工厂方法的参数创建一个流.
Stream.of(T[])	使用一个数组的元素创建一个流.
Stream.empty()	创建一个空流.

---

中间操作负责将一个流转换为另一个流,中间操作包括 filter() (选择与条件匹配的元素), map() (根据函数来转换元素), distinct() (删除重复),limit() (在特定大小处截断流)和 sorted() .
2. 中间流操作

方法	描述
filter(Predicate)	与预期匹配的流的元素
map(Function<T, U>)	将提供的函数应用于流的元素的结果
flatMap(Function<T, Stream>	将提供的流处理函数应用于流元素后获得的流元素
distinct()	已删除了重复的流元素
sorted()	按自然顺序排序的流元素
Sorted(Comparator)	按提供的比较符排序的流元素
limit(long)	截断至所提供长度的流元素
skip(long)	丢弃了前 N 个元素的流元素

中间操作始终是 惰性的 :调用中间操作只会设置流管道的下一个阶段,不会启动任何操作.重建操作可进一步划分为 无状态 和 有状态 操作.无状态操作(比如filter() 或 map() )可独立处理每个元素,而有状态操作(比如 sorted() 或distinct() )可合并以前看到的影响其他元素处理的元素状态.

---

数据集的处理在执行终止操作时开始,比如缩减( sum() 或 max() ),应用 (forEach() ) 或搜索 ( findFirst() ) 操作.终止操作会生成一个结果.执行终止操作时,会终止流管道,如果您想再次遍历同一个数据集,可以设置一个新的流管道.表 3 给出了一些终止流操作.

3. 终止流操作

方法	描述
forEach(Consumer action)	将提供的操作应用于流的每个元素.
toArray()	使用流的元素创建一个数组.
reduce(…)	将流的元素聚合为一个汇总值.
collect(…)	将流的元素聚合到一个汇总结果容器中.
min(Comparator)	通过比较符返回流的最小元素.
max(Comparator)	通过比较符返回流的最大元素.
count()	返回流的大小.
{any,all,none}Match(Predicate)	返回流的任何/所有元素是否与提供的预期相匹配.
findFirst()	返回流的第一个元素(如果有).
findAny()	返回流的任何元素(如果有).

---

首先看看Stream是怎么用,首先创建实例代码的用到的数据List:
代码如下:

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");

Filter 过滤

过滤通过一个predicate接口来过滤并只保留符合条件的元素,该操作属于中间操作,所以我们可以在过滤后的结果来应用其他Stream操作(比如forEach).forEach需要一个函数来对过滤后的元素依次执行.forEach是一个最终操作,所以我们不能在forEach之后来执行其他Stream操作.
代码如下:

stringCollection
    .stream()
    .filter((s) -> s.startsWith("a"))
    .forEach(System.out::println);

// "aaa2", "aaa1"

Sort 排序

排序是一个中间操作,返回的是排序好后的Stream.如果你不指定一个自定义的Comparator则会使用默认排序.
代码如下:

stringCollection
    .stream()
    .sorted()
    .filter((s) -> s.startsWith("a"))
    .forEach(System.out::println);

// "aaa1", "aaa2"

需要注意的是,排序只创建了一个排列好后的Stream,而不会影响原有的数据源,排序之后原数据stringCollection是不会被修改的:
代码如下:

System.out.println(stringCollection);
// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1

Map 映射

中间操作map会将元素根据指定的Function接口来依次将元素转成另外的对象,下面的示例展示了将字符串转换为大写字符串.你也可以通过map来讲对象转换成其他类型,map返回的Stream类型是根据你map传递进去的函数的返回值决定的.
代码如下:

stringCollection
    .stream()
    .map(String::toUpperCase)
    .sorted((a, b) -> b.compareTo(a))
    .forEach(System.out::println);

// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"

flatMap

flatMap()的作用就相当于把原Stream中的所有元素都"摊平"之后组成的Stream,转换前后元素的个数和类型都可能会改变.

Match 匹配

Stream提供了多种匹配操作,允许检测指定的Predicate是否匹配整个Stream.所有的匹配操作都是最终操作,并返回一个boolean类型的值.
代码如下:

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 计数

计数是一个最终操作,返回Stream中元素的个数,返回值类型是long.
代码如下:

long startsWithB =
    stringCollection
        .stream()
        .filter((s) -> s.startsWith("b"))
        .count();

System.out.println(startsWithB); // 3

Reduce 规约

这是一个最终操作,允许通过指定的函数来将stream中的多个元素规约为一个元素,规约后的结果是通过Optional接口表示的:
代码如下:

Optional reduced =
    stringCollection
        .stream()
        .sorted()
        .reduce((s1, s2) -> s1 + "#" + s2);

reduced.ifPresent(System.out::println);
// "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2"

并行Streams

前面提到过Stream有串行和并行两种,串行Stream上的操作是在一个线程中依次完成,而并行Stream则是在多个线程上同时执行.

下面的例子展示了是如何通过并行Stream来提升性能:

首先我们创建一个没有重复元素的大表:
代码如下:

int max = 1000000;
List values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
    UUID uuid = UUID.randomUUID();
    values.add(uuid.toString());
}

然后我们计算一下排序这个Stream要耗时多久,
串行排序:
代码如下:

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));
// 串行耗时: 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));

// 并行排序耗时: 472 ms

上面两个代码几乎是一样的,但是并行版的快了50%之多,唯一需要做的改动就是将stream()改为parallelStream().

---

Map增强

前面提到过,Map类型不支持stream,不过Map提供了一些新的有用的方法来处理一些日常任务.
代码如下:

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则接收一个BiConsumer接口来对map里的每一个键值对进行操作.

下面的例子展示了map上的其他有用的函数:
代码如下:

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里删除一个键值全都匹配的项:
代码如下:

map.remove(3, "val3");
map.get(3); // val33

map.remove(3, "val33");
map.get(3); // null

另外一个有用的方法:
代码如下:

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

对Map的元素做合并也变得很容易了:
代码如下:

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

Merge做的事情是如果键名不存在则插入,否则则对原键对应的值做合并操作并重新插入到map中.

Date API

Java 8 在包java.time下包含了一组全新的时间日期API.新的日期API和开源的Joda-Time库差不多,但又不完全一样,下面的例子展示了这组新API里最重要的一些部分:

Clock 时钟

Clock类提供了访问当前日期和时间的方法,Clock是时区敏感的,可以用来取代 System.currentTimeMillis() 来获取当前的微秒数.某一个特定的时间点也可以使用Instant类来表示,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

Timezones 时区

在新API中时区使用ZoneId来表示.时区可以很方便的使用静态方法of来获取到. 时区定义了到UTS时间的时间差,在Instant时间点对象到本地日期对象之间转换的时候是极其重要的.
代码如下:

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 定义了一个没有时区信息的时间,例如 晚上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 本地日期

LocalDate 表示了一个确切的日期,比如 2014-03-11.该对象值是不可变的,用起来和LocalTime基本一致.下面的例子展示了如何给Date对象加减天/月/年.另外要注意的是这些对象是不可变的,操作返回的总是一个新实例.
代码如下:

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

只要附加上时区信息,就可以将其转换为一个时间点Instant对象,Instant时间点对象可以很容易的转换为老式的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

格式化LocalDateTime和格式化时间和日期一样的,除了使用预定义好的格式外,我们也可以自己定义格式:
代码如下:

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是不可变的,所以它是线程安全的.