Java8简明教程

虽然 Java8 已经发布了很长的时间,但是大多数 Java 程序员还是没有跨过 Java8 这个坎, Benjamin 在2014年写下的这篇 Java8 的入门教程我觉得非常不错,或许可以帮助你跨过 Java8 这个坎。


这份教程会指导你一步一步学习 Java8 的新特性。按照先后顺序,这篇文章中包括以下的内容:接口的 default 方法,lambda 表达式,方法引用,可复用注解,还有一些 Api 的更新,streams,功能性接口,map 的扩展和新的 Date Api。

本文没有大段的文字,只有带注释的代码,希望你能喜欢!

接口的 default 方法

Java8 允许在接口中实现具体的方法,只需要在方法前加上 default 关键字就行。这一特性也称之为扩展方法。这里是第一个例子:

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

在上面的例子中,Formual 接口定义了一个 default 方法 sqrt,接口的实现类只要需要实现 calculate 方法,sqrt 方法开箱即用。

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

formula.calculate(100); // 100.0
formula.sqrt(16); // 4.0

上面的代码匿名实现了 Formual 接口。代码相当的冗长,用了 6 行代码才实现了 sqrt(a * 100) 的功能。在下一节中我们可以通过 Java8 的特性来优雅的完成这个类。

Lambda 表达式

先让我们看一下之前版本的 Java 中如何实现对一个字符串 List 进行排序的功能:

1
2
3
4
5
6
7
8
9

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

静态方法 Collection.sort 接收一个字符串 List 和一个字符串的比较器用于比较传入的字符串 List。通常的做法就是实现一个匿名的比较器然后传入到 sort 方法中。

相比于使用匿名方法的冗长实现,Java8 可以通过 lambda 表达式用很短的代码来实现:

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

这个代码已经比之前的匿名方法短很多了,但是这个代码还可以更短一点:

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表达式都会被接口给定一个类型,所以每一个功能性接口都至少声明一个 abstract 方法。每一个 lambda 表达式的参数类型都必须匹配这个虚拟方法的参数。由于 default 关键字标识的方法不是虚拟方法,可以在接口中添加任意多个 default 方法。

我们可以将任意只包含一个虚拟方法的接口当作 lambda 表达式。为了确保你的接口满足这个需求,你需要在接口上添加 @FunctionalInterface 注解,如果加上注解接口中不止一个虚拟方法,编译器就会报错。如下的例子:

1
2
3
4
@FunctionalInterface
interface Converter<F, T> {
T convert(F from);
}

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

需要注意的是如果 @FunctionalInterface 这个注省略了,这些代码也还是可以工作的。

方法和构造函数引用

以上的示例代码可以通过静态方法引用进一步简化:

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

Java8 允许你使用 :: 来调用静态方法和构造函数的引用。上面的代码展示了如何引用一个静态方法。我们也可以通过同样的方法来引用对象方法:

1
2
3
4
5
class Something {
String startsWith(String s) {
return String.valueOf(s.charAt(0));
}
}

1
2
3
4
Something something = new Something();
Converter<String, String> converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted); // "J"

下面让我们来看看 :: 是如何在构造函数上起作用的。首先我们定义一个有着不同构造方法的 bean

1
2
3
4
5
6
7
8
9
10
11
class Person {
String firstName;
String lastName;

Person() {}

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

接下来我们定义一个 Person 工厂接口来创建新的 Person 对象:

1
2
3
interface PersonFactory<P extends Person> {
P create(String firstName, String lastName);
}

我们不需要手动实现一个工厂,二是可以通过构造函数的引用来完成新建 Person 对象:

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

我们通过 Person::new 来获取到了 Person 类的构造方法引用。然后 Java 编译器会根据 PersonFactory::create 的参数来自动选择合适的构造函数。

Lambda 的访问范围

相比于匿名实现的对象,lambda 表达式访问外部变量非常简单。lambda 表达式可以访问本地外部的 final 变量、成员变量和静态变量。

访问本地变量

lambda 表达式可以访问外部本地的 final 变量:

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

与匿名方式不同的是,num 变量可以不定义成 final,下面的这些代码也是可以工作的:

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

stringConverter.convert(2); // 3

然而 num 变量在编译的过程中会被隐式的编译成 final,下面的代码会出现编译错误:

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

lambda 表达式中也不能改变 num 的值。

访问成员变量和静态变量

与访问本地变量相反,在 lambda 表达式中对成员变量和静态变量可以进行读和写。这种访问变量的方式在匿名变量中也实现了:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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 的例子吗?Formula 接口定义了一个默认方法 sqrt 可以在每一个 Formula 的实例(包括匿名实现的对象)中访问。但是默这种方式在 lambda 表达式中不起作用。

默认方法不能通过 lambda 表达式访问,以下的代码不能通过编译器:

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

内置的功能性接口

Java8 包含很多的内置功能性接口。有一些是我们熟知的接口如 ComparatorRunnable。这些已经存在的接口都通过 @FunctionalInterface 接口进行了扩展,从而支持 lambda 表达式。

但是 Java8 中也有一些全新的功能性接口可以让你代码写的更轻松。其中一些来自于 Google Guava 库。即使你对这个库已经很熟悉了,但是还是应该密切注意这些接口是如何被一些有用的方法扩展的。

Predicates

Predicate 是一个参数的布尔函数。这个接口提供了很多的默认函数来组合成复杂的逻辑运算(与、非)。

1
2
3
4
5
6
7
8
9
10
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();

Functions

Function 接收一个参数产生一个结果。默认方法可以用于多个方法组成的方法链。

1
2
3
4
5

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

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

Suppliers

Supplier 根据一个给定的类属性产生一个对象。Supplier 不支持传入参数。

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

Consumers

Consumer 表示对输入的参数进行一系列的处理。

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

Comparators

Comparator 是一个在老版本的 Java 里面就经常出现的接口。 Java8 在这个接口中加入了很多的默认接口。

1
2
3
4
5
6
7
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

Optional 不是一个功能性接口,而是一个阻止 NullPointerException 异常的好方法。这是下一节中一个非常重要的概念,下面来看看 Optional 到底是如何工作的。

Optional 是一个包含了一个值的容器,这个值可以为 null,也可以不为 null。对于一个方法也许会返回一个不是 null 的值,也有时候什么都不会返回。在 Java8 中,你可以让它不返回 null, 二是返回一个 Optional 对象。

1
2
3
4
5
6
7
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 代表着一系列可以执行一个或者多个操作的元素。Stream 操作可以是中间操作,也可以是终端操作。终端操作返回的是类型确定的结果。中间操作返回的是 Stream 对象本身,所以可以继续在同一行代码里面继续调用其他的方法链。

Stream 对象可以由 java.util.Collection 的对象创建而来,比各类 listset (map 暂时不支持)。Stream 可以支持串联和并行操作。

首先让我们来看一下串联操作。首先我们从一个 StringList 中创建一个 Stream 对象:

1
2
3
4
5
6
7
8
9
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");

Java8 中的 Collections 已经被扩展了,可以通过 Collection.stream() 或者 Collection.parallelStream() 来创建 Stream 对象。下面的内容将介绍最常用的 Stream 操作。

Filter

Filter 接受一个Predicate 来过滤 Stream 中的所有元素。这个操作是一个中间操作,对过滤的结果可以调用另一个 Stream 操作(比如: forEach)。ForEach 接收一个 Consumer 参数,执行到过滤后的每一个 Stream 元素上。ForEach 是一个终端操作,所以不能在这个操作后调用其他的 Stream 操作。

1
2
3
4
5
6
stringCollection
.stream()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);

// "aaa2", "aaa1"

Sorted

Sorted 是一个中间操作,会返回排好序的 Stream。如果不传入自定义的 Comparator,那么这些元素将会按照自然顺序进行排序。

1
2
3
4
5
6
7
stringCollection
.stream()
.sorted()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);

// "aaa1", "aaa2"

需要注意的是 Sorted 只会对流里面的元素进行排序,而不会去改变原来集合里元素的顺序,在执行 Sorted 操作后,stringCollection 中元素的顺序并没有改变:

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

Map

Map 是一个中间操作,会根据给定的函数把 Stream 中的每一个元素变成另一个对象。下面的例子展示了将每一个字符串转成大写的字符串。你同样也可以使用 Map 将每一个元素转成其他的类型。这个 Stream 的类型取决与你传入到 Map 的中的方法返回的类型。

1
2
3
4
5
6
7
stringCollection
.stream()
.map(String::toUpperCase)
.sorted((a, b) -> b.compareTo(a))
.forEach(System.out::println);

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

Match

各种各样的 Match 操作可以用于判断一个给定的 Predicate 是否与 Stream 中的元素相匹配。Match 操作是一个终端操作,会返回一个布尔值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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 类型的值来表示 Stream 中元素的个数。

1
2
3
4
5
6
7
long startsWithB =
stringCollection
.stream()
.filter((s) -> s.startsWith("b"))
.count();

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

Reduce

Reduce 是一个终端操作,会根据给定的方法来操作 Stream 中所有的元素,并且返回一个 Optional 类型的值。

1
2
3
4
5
6
7
Optional<String> 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 来提高性能的操作。

首先我们创建一个很大的唯一元素的 list:

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

接下来我们分别测试一下串联和并行 Stream 操作这个 list 所花的时间。

串联排序

1
2
3
4
5
6
7
8
9
10
11
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

并行排序:

1
2
3
4
5
6
7
8
9
10
11
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()

Map

我们已经提到了 Map 是不支持 Stream 。但是 Map 已经支持很多新的、有用的方法来完成通常的任务。

1
2
3
4
5
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 可以让我们不用做 null 的检查,forEach 接受一个 Consumer 来遍历map 中的每一个元素。

下面的代码展示了如何使用使用函数在map中进行计算:

1
2
3
4
5
6
7
8
9
10
11
12

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 中的值相等时,才能删除:

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

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

下面这个方法也很有用:

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

合并 Map 中的值也相当的简单:

1
2
3
4
5
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 中,否则就会调用 Merge 函数来改变现有的值。

Date API

Java8 在 java.time 包下有全新的日期和时间的 API。这些新的日期 API完全比得上 Joda-Time,但是却不完全一样。下面的包括了这些新 API 最重要的部分。

Clock

Clock 类可以用来访问当前的日期和时间。Clock 可以获取当前的时区,可以替代 System.currentTimeMillis() 来获取当前的毫秒数。当前时间线上的时刻可以使用 Instant 类来表示,Instant 也可以创建原先的 java.util.Date 对象。

1
2
3
4
Clock clock = Clock.systemDefaultZone();long millis = clock.millis();

Instant instant = clock.instant();
Date legacyDate = Date.from(instant); // legacy java.util.Date

Timezones

时区是通过 zoneId 来表示的,zoneId 可以通过静态工厂方法访问到。时区类还定义了一个偏移量,用来在当前时刻或某时间与目标时区时间之间进行转换。

1
2
3
4
5
6
7
8
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。下面的例子为之前定义的时区创建了两个本地时间。然后我们比较两个时间并且计算两个时间之间在小时和分钟上的差异。

1
2
3
4
5
6
7
8
9
10
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

本地时间可以通过很多工厂方法来创建实例,包括转换字符串来得到实例:

1
2
3
4
5
6
7
8
9
10
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 表示一个明确的日期,比如 2017-03-11。它是不可变的,与 LocalTime 完全一致。下面的例子展示了如何在一个日期上增加或者减少天数,月份或者年。需要注意的是每次计算后返回的都是一个新的实例。

1
2
3
4
5
6
7
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 一样简单。

1
2
3
4
5
6
7
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 是不可变的,用法和 LocalDateLocalTime 一样。我们可以使用方法获取 LocalDateTime 实例中某些属性。

1
2
3
4
5
6
7
8
9
10
11

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 对象。

1
2
3
4
5
6
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 对象与格式化 LocalDateLocalTime 对象是一样的。我们可以使用自定义的格式而不用提前定义好格式.

1
2
3
4
5
6
7
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 是不可变而且是线程安全的。

更多的格式化的语法看 这里

注解

Java8 中的注解是可复用的,下面有几个例子来演示这个特性。

首先,我们定义一个注释的包装器,包装了一个有一个数组的的注解:

1
2
3
4
5
6
7
8
@interface Hints {
Hint[] value();
}

@Repeatable(Hints.class)
@interface Hint {
String value();
}

Java8 允许我们通过 @Repeatable 在相同的类型上使用多个注解。

旧用法: 使用容器进行注解

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

新用法: 使用可复用的注解

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

使用新用法时 Java 编译器隐式的使用了 @Hints 注解。这对于通过反射来读取注解非常重要。

1
2
3
4
5
6
7
8
9

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) 获取到。然而,更方便的方法则是通过 getAnnotationByType 直接获取所有使用了 @Hint 的注解。

另外,在 Java8 中使用注解可以扩展到两个新的 Target

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

(完)

微信公众号

© 2018 ray