跨越 Java8

虽然 Java8 已经发布了很长的时间，而且 Java8 中有很多特性可以提升代码的效率和安全，但是大多数 Java 程序员还是没有跨过 Java8 这个坎， Benjamin 在 2014 年写下的这篇 Java8 的入门教程我觉得非常不错，或许可以帮助你跨过 Java8 这个坎。

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

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

接口的 default 方法

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

interface Formual {    
    double calculate(int a);
    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}
复制代码

在上面的例子中， Formual 接口定义了一个 default 方法 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
复制代码

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

Lambda 表达式

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

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 和一个字符串的 Comparator 用于比较传入的字符串 List。通常的做法就是实现一个匿名的 Comparator 然后传入到 sort 方法中。

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

Collections.sort(names, (String a, String b) -> {
    return b.compareTo(a);
 });
复制代码

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

Collections.sort(names, (String a, String b) -> b.compareTo(a));
复制代码

注：使用 Collections.sort(names, (a,b)->b.compareTo(a)); 也可以

用一行代码就实现了方法，省略掉了 {} 和 return 关键字。但是其实还可以更短一点：

Collections.sort(names, (a, b) -> b.compareTo(a));
复制代码

Java 编译器可以根据上下文判断出参数的类型，所以你也可以省略参数的类型。下面来探究一下 lambda 表达式更进阶的用法。

函数式接口

lambda 表达式和如何与 Java 的类型系统相匹配？每个 lambda 表达式都会被接口给定类型，所以每个 函数式接口 都至少声明一个 abstract 方法。每一个 lambda 表达式的参数类型都必须匹配这个抽象方法的参数。由于 default 关键字标识的方法不是抽象方法，可以在接口中添加任意多个 default 方法。

注：每一个 lambda 都是函数式的接口，所以使用了 @FunctionInterface 的 interface 都只能有一个抽象方法

可以将任意只包含一个抽象方法的接口当作 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
复制代码

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

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"
复制代码

注：System.out::println 引用的 println 不是静态方法，因为 System.out 是一个对象

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

class Person {
    String firstName;
    String lastName;

    Person() {}

    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
 }
复制代码

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

interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}
复制代码

不需要手动实现一个工厂，而是通过构造函数的引用来完成新建 Person 对象：

PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");
复制代码

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

注：lambda 、方法引用、构造函数引用都是由 @FunctionalInterface 的实例生成的，只有一个抽象方法的接口默认是一个 @FunctionalInterface，加了 @FunctionalInterface 注解的接口只能有一个抽象方法。

Lambda 的访问范围

相比于匿名实现的对象，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 表达式中也不能改变 num 的值。

访问成员变量和静态变量

与访问本地变量相反，在 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);
        };
    }
}
复制代码

注：外部的变量无法在 lambda 内部完成赋值操作，如果需要从 lambda 中获取到值，可以通过在外部定义一个 final 的 数组 ，将需要带出的值放在数组里面带出来。

访问默认接口方法

还记得前面的 Formula 例子吗？Formula 接口定义了一个默认方法 sqrt 可以在每一个 Formula 的实例（包括匿名实现的对象）中访问。但是默这种方式在 lambda 表达式中不起作用。

默认方法不能通过 lambda 表达式访问，下面的代码无法编译通过:

Formula formula = (a) -> sqrt( a * 100);
复制代码

内置的函数式接口

Java8 包含很多的内置函数式接口。有一些被广泛应用的接口如 Comparator 、Runnable。这些已经存在的接口都通过 @FunctionalInterface 进行了扩展，从而支持 lambda 表达式。

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

Predicates

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();
复制代码

Functions

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

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

backToString.apply("123");     // "123"
复制代码

Suppliers

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

Supplier<Person> personSupplier = Person::new;
personSupplier.get();   // new Person
复制代码

Consumers

Consumer 对输入的参数进行一系列预定义的流程进行处理。

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

Comparators

Comparator 是在老版本的 Java 中就经常被使用的接口， Java8 在这个接口中加入了很多的默认方法。

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

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"
复制代码

注：这些内置的函数式接口都加上了 @FuncationalInterface 注解，算是一个语法糖，为不同类型的函数式方法提供了便捷方式，不用重头定义，在后面的 Stream 编程的各个阶段所需要的函数式接口都不同，这些内置的接口也为 Stream 编程做好了准备。

Streams

一个 java.util.Stream 代表着一系列可以执行一个或者多个操作的元素。 Stream 操作可以是中间操作，也可以是终端操作。终端操作返回的是类型确定的结果。中间操作返回的是 Stream 对象本身，可以继续在同一行代码里面继续调用其他的方法链。

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

首先来看一下串联操作，通过 List 对象创建一个 Stream 对象：

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 操作。

stringCollection
    .stream()
    .filter((s) -> s.startsWith("a"))
    .forEach(System.out::println);
// "aaa2", "aaa1"
复制代码

注：每一个 stream 在执行 forEach 等终端操作之后就不能再继续接 filter 等中间操作。

Sorted

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

stringCollection
    .stream()
    .sorted()
    .filter((s) -> s.startsWith("a"))
    .forEach(System.out::println);
// "aaa1", "aaa2"
复制代码

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

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

Map

Map是一个中间操作，会根据给定的函数把 Stream 中的每一个元素变成另一个对象。下面的例子展示了将每一个字符串转成大写的字符串。你同样也可以使用 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"
复制代码

Match

各种各样的 Match 操作可以用于判断一个给定的 Predicate 是否与 Stream 中的元素相匹配。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 值来表示 Stream 中元素的个数。

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

System.out.println(startsWithB);    // 3
复制代码

Reduce

Reduce是一个终端操作，会根据给定的方法来操作 Stream 中所有的元素，并且返回一个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"
复制代码

注：ifPresent 方法接受一个 Consumer 类型的对象，System.out::println 是一个方法引用，而且 println 是一个接收一个参数且不返回值得函数，刚好符合 Consumer 的定义。

并行 Streams

在上文中提到过 Stream 可以是串联的也可以是并行的。 Stream 的串行操作是在单线程上进行的，并行操作是在多线程上并发进行的。

下面的例子展示了使用并行 Stream 来提高程序性能性能。

首先初始化一个有很多元素的 list，其中每个元素都是唯一的:

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 所花的时间。

串联排序：

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()。

Map

前面已经提到 Map 不支持 Stream ，但是 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 可以不用做 null 的检查，forEach 接受一个 Consumer 来遍历 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
复制代码

如果当前的键对应的值不存在，那么就会将输入的值直接放入 Map 中，否则就会调用 Merge 函数来改变现有的值。

Date API

Java8 在 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

时区是通过 zoneId 来表示的，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 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 完全一致。下面的例子展示了如何在一个日期上增加或者减少天数，月份或者年。需要注意的是每次计算后返回的都是一个新的实例。

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 是不可变的，用法和 LocalDate 和 LocalTime 一样。可以使用方法获取 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 对象与格式化 LocalDate 和 LocalTime 对象是一样的，可以使用自定义的格式而不用提前定义好格式.

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 中的注解是可复用的，下面有几个例子来演示这个特性。

首先，定义一个注释的包装器，包装了一个数组的的注解:

@Retention(RetentionPolicy.RUNTIME)
@Target(value={ElementType.TYPE})
@interface Hints {
    Hint[] value();
}

@Repeatable(Hints.class)
@interface Hint {
    String value();
}
复制代码

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

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

@Hints({@Hint("hint1"), @Hint("hint2")})
class Person {}
复制代码

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

@Hint("hint1")@Hint("hint2")
class Person {}
复制代码

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

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

@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@interface MyAnnotation {}
复制代码

（完）

原文

关注微信公众号，聊点其他的