Java基础系列-跨越 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 {}
复制代码

（完）

原文

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