java8
Java 8 Tutorial
接口的默认方法(Default Methods for Interfaces)
Lambda 表达式(Lambda expressions)
函数式接口(Functional Interfaces)
方法和构造函数引用(Method and Constructor References)
Lamda 表达式作用域(Lambda Scopes)
访问局部变量
访问字段和静态变量
访问默认接口方法
内置函数式接口(Built-in Functional Interfaces)
Predicate
Function
Supplier
Consumer
Comparator
Optional
Streams(流)
Filter(过滤)
Sorted(排序)
Map(映射)
Match(匹配)
Count(计数)
Reduce(规约)
Parallel Streams(并行流)
Sequential Sort(串行排序)
Parallel Sort(并行排序)
Maps
Date API(日期相关 API)
Clock
Timezones(时区)
LocalTime(本地时间)
LocalDate(本地日期)
LocalDateTime(本地日期时间)
Annotations(注解)
粉丝福利
Java 8 Tutorial
欢迎阅读我对 Java 8 的介绍。本教程将逐步指导您完成所有新语言功能。 在简短的代码示例的基础上，您将学习如何使用默认接口方法，lambda 表达式，方法引用和可重复注释。 在本文的最后，您将熟悉最新的 API 更改，如流，函数式接口(Functional Interfaces)，Map 类的扩展和新的 Date API。 没有大段枯燥的文字，只有一堆注释的代码片段。接口的默认方法(Default Methods for Interfaces)Java 8 使我们能够通过使用 default 关键字向接口添加非抽象方法实现。 此功能也称为虚拟扩展方法。
interface Formula{
double calculate(int a);
default double sqrt(int a) { return Math.sqrt(a); }
}
复制代码
Formula 接口中除了抽象方法计算接口公式还定义了默认方法 sqrt。 实现该接口的类只需要实现抽象方法 calculate。 默认方法 sqrt 可以直接使用。当然你也可以直接通过接口创建对象，然后实现接口中的默认方法就可以了，我们通过代码演示一下这种方式。
public class Main {
public static void main(String[] args) { // 通过匿名内部类方式访问接口 Formula formula = new Formula() { @Override public double calculate(int a) { return sqrt(a * 100); } };
System.out.println(formula.calculate(100)); // 100.0 System.out.println(formula.sqrt(16)); // 4.0
}
}
复制代码
formula 是作为匿名对象实现的。该代码非常容易理解，6 行代码实现了计算 sqrt(a * 100)。在下一节中，我们将会看到在 Java 8 中实现单个方法对象有一种更好更方便的方法。
译者注： 不管是抽象类还是接口，都可以通过匿名内部类的方式访问。不能通过抽象类或者接口直接创建对象。对于上面通过匿名内部类方式访问接口，我们可以这样理解：一个内部类实现了接口里的抽象方法并且返回一个内部类对象，之后我们让接口的引用来指向这个对象。
Lambda 表达式(Lambda expressions)
首先看看在老版本的 Java 中是如何排列字符串的：
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); }});
复制代码
只需要给静态方法 Collections.sort 传入一个 List 对象以及一个比较器来按指定顺序排列。通常做法都是创建一个匿名的比较器对象然后将其传递给 sort 方法。
在 Java 8 中你就没必要使用这种传统的匿名对象的方式了，Java 8 提供了更简洁的语法，lambda 表达式：
names.sort((a, b) -> b.compareTo(a));
复制代码
函数式接口(Functional Interfaces)
@FunctionalInterfacepublic interface Converter<F, T> { T convert(F from);}
复制代码
// TODO 将数字字符串转换为整数类型Converter<String, Integer> converter = (from) -> Integer.valueOf(from);Integer converted = converter.convert("123");System.out.println(converted.getClass()); //class java.lang.Integer
复制代码
方法和构造函数引用(Method and Constructor References)
Converter<String, Integer> converter = Integer::valueOf;Integer converted = converter.convert("123");System.out.println(converted.getClass()); //class java.lang.Integer
复制代码
Java 8 允许您通过::关键字传递方法或构造函数的引用。 上面的示例显示了如何引用静态方法。 但我们也可以引用对象方法：
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"
复制代码
接下来看看构造函数是如何使用::关键字来引用的，首先我们定义一个包含多个构造函数的简单类：
class Person { String firstName; String lastName;
Person() {}
Person(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; }}
复制代码
接下来我们指定一个用来创建 Person 对象的对象工厂接口：
interface PersonFactory<P extends Person> { P create(String firstName, String lastName);}
复制代码
这里我们使用构造函数引用来将他们关联起来，而不是手动实现一个完整的工厂：
PersonFactory<Person> personFactory = Person::new;Person person = personFactory.create("Peter", "Parker");
复制代码
我们只需要使用 Person::new 来获取 Person 类构造函数的引用，Java 编译器会自动根据 PersonFactory.create 方法的参数类型来选择合适的构造函数。
Lamda 表达式作用域(Lambda Scopes)
访问局部变量我们可以直接在 lambda 表达式中访问外部的局部变量：
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); }; }}
复制代码
访问默认接口方法
还记得第一节中的 formula 示例吗？ Formula 接口定义了一个默认方法 sqrt，可以从包含匿名对象的每个 formula 实例访问该方法。 这不适用于 lambda 表达式。
无法从 lambda 表达式中访问默认方法,故以下代码无法编译：
Formula formula = (a) -> sqrt(a * 100);
复制代码
内置函数式接口(Built-in Functional Interfaces)
JDK 1.8 API 包含许多内置函数式接口。 其中一些借口在老版本的 Java 中是比较常见的比如： Comparator 或 Runnable，这些接口都增加了 @FunctionalInterface 注解以便能用在 lambda 表达式上。
但是 Java 8 API 同样还提供了很多全新的函数式接口来让你的编程工作更加方便，有一些接口是来自 Google Guava 库里的，即便你对这些很熟悉了，还是有必要看看这些是如何扩展到 lambda 上使用的。PredicatePredicate 接口是只有一个参数的返回布尔类型值的 断言型 接口。该接口包含多种默认方法来将 Predicate 组合成其他复杂的逻辑（比如：与，或，非）：
Predicate<String> predicate = (s) -> s.length() > 0;
predicate.test("foo"); // truepredicate.negate().test("foo"); // false
Predicate<Boolean> nonNull = Objects::nonNull;Predicate<Boolean> isNull = Objects::isNull;
Predicate<String> isEmpty = String::isEmpty;Predicate<String> isNotEmpty = isEmpty.negate();
复制代码
FunctionFunction 接口接受一个参数并生成结果。默认方法可用于将多个函数链接在一起（compose, andThen）：
Function<String, Integer> toInteger = Integer::valueOf;Function<String, String> backToString = toInteger.andThen(String::valueOf);backToString.apply("123"); // "123"
复制代码
SupplierSupplier 接口产生给定泛型类型的结果。 与 Function 接口不同，Supplier 接口不接受参数。
Supplier<Person> personSupplier = Person::new;personSupplier.get(); // new Person
复制代码
ConsumerConsumer 接口表示要对单个输入参数执行的操作。
Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);greeter.accept(new Person("Luke", "Skywalker"));
复制代码
ComparatorComparator 是老 Java 中的经典接口， Java 8 在此之上添加了多种默认方法：
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); // > 0comparator.reversed().compare(p1, p2); // < 0
复制代码
Optional
Optional 不是函数式接口，而是用于防止 NullPointerException 的漂亮工具。这是下一节的一个重要概念，让我们快速了解一下 Optional 的工作原理。
Optional 是一个简单的容器，其值可能是 null 或者不是 null。在 Java 8 之前一般某个函数应该返回非空对象但是有时却什么也没有返回，而在 Java 8 中，你应该返回 Optional 而不是 null。
//of（）：为非null的值创建一个OptionalOptional<String> optional = Optional.of("bam");// isPresent（）： 如果值存在返回true，否则返回falseoptional.isPresent(); // true//get()：如果Optional有值则将其返回，否则抛出NoSuchElementExceptionoptional.get(); // "bam"//orElse（）：如果有值则将其返回，否则返回指定的其它值optional.orElse("fallback"); // "bam"//ifPresent（）：如果Optional实例有值则为其调用consumer，否则不做处理optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b"
复制代码
Streams(流)
java.util.Stream 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回 Stream 本身，这样你就可以将多个操作依次串起来。Stream 的创建需要指定一个数据源，比如 java.util.Collection 的子类，List 或者 Set， Map 不支持。Stream 的操作可以串行执行或者并行执行。
首先看看 Stream 是怎么用，首先创建实例代码的用到的数据 List：
List<String> stringList = new ArrayList<>();stringList.add("ddd2");stringList.add("aaa2");stringList.add("bbb1");stringList.add("aaa1");stringList.add("bbb3");stringList.add("ccc");stringList.add("bbb2");stringList.add("ddd1");
复制代码
Java 8 扩展了集合类，可以通过 Collection.stream() 或者 Collection.parallelStream() 来创建一个 Stream。下面几节将详细解释常用的 Stream 操作：
Filter(过滤)
过滤通过一个 predicate 接口来过滤并只保留符合条件的元素，该操作属于中间操作，所以我们可以在过滤后的结果来应用其他 Stream 操作（比如 forEach）。forEach 需要一个函数来对过滤后的元素依次执行。forEach 是一个最终操作，所以我们不能在 forEach 之后来执行其他 Stream 操作。
// 测试 Filter(过滤) stringList .stream() .filter((s) -> s.startsWith("a")) .forEach(System.out::println);//aaa2 aaa1
复制代码
Sorted(排序)
排序是一个 中间操作，返回的是排序好后的 Stream。如果你不指定一个自定义的 Comparator 则会使用默认排序。
// 测试 Sort (排序)stringList .stream() .sorted() .filter((s) -> s.startsWith("a")) .forEach(System.out::println);// aaa1 aaa2
复制代码
需要注意的是，排序只创建了一个排列好后的 Stream，而不会影响原有的数据源，排序之后原数据 stringCollection 是不会被修改的：
System.out.println(stringList);// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1
复制代码
Map(映射)
中间操作 map 会将元素根据指定的 Function 接口来依次将元素转成另外的对象。
下面的示例展示了将字符串转换为大写字符串。你也可以通过 map 来将对象转换成其他类型，map 返回的 Stream 类型是根据你 map 传递进去的函数的返回值决定的。
// 测试 Map 操作 stringList .stream() .map(String::toUpperCase) .sorted((a, b) -> b.compareTo(a)) .forEach(System.out::println);// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"
复制代码
Match(匹配)
Stream 提供了多种匹配操作，允许检测指定的 Predicate 是否匹配整个 Stream。所有的匹配操作都是 最终操作 ，并返回一个 boolean 类型的值。
// 测试 Match (匹配)操作boolean anyStartsWithA = stringList .stream() .anyMatch((s) -> s.startsWith("a"));System.out.println(anyStartsWithA); // true
boolean allStartsWithA = stringList .stream() .allMatch((s) -> s.startsWith("a"));
System.out.println(allStartsWithA); // false
boolean noneStartsWithZ = stringList .stream() .noneMatch((s) -> s.startsWith("z"));
System.out.println(noneStartsWithZ); // true
复制代码
Count(计数)
计数是一个 最终操作，返回 Stream 中元素的个数，返回值类型是 long。
//测试 Count (计数)操作 long startsWithB = stringList .stream() .filter((s) -> s.startsWith("b")) .count(); System.out.println(startsWithB); // 3
复制代码
Reduce(规约)
这是一个 最终操作 ，允许通过指定的函数来讲 stream 中的多个元素规约为一个元素，规约后的结果是通过 Optional 接口表示的：
//测试 Reduce (规约)操作Optional<String> reduced = stringList .stream() .sorted() .reduce((s1, s2) -> s1 + "#" + s2);
reduced.ifPresent(System.out::println);//aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2
复制代码
译者注： 这个方法的主要作用是把 Stream 元素组合起来。它提供一个起始值（种子），然后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第 n 个元素组合。从这个意义上说，字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。例如 Stream 的 sum 就相当于 Integer sum = integers.reduce(0, (a, b) -> a+b);也有没有起始值的情况，这时会把 Stream 的前面两个元素组合起来，返回的是 Optional。
// 字符串连接，concat = "ABCD"String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat); // 求最小值，minValue = -3.0double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min); // 求和，sumValue = 10, 有起始值int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);// 求和，sumValue = 10, 无起始值sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();// 过滤，字符串连接，concat = "ace"concat = Stream.of("a", "B", "c", "D", "e", "F"). filter(x -> x.compareTo("Z") > 0). reduce("", String::concat);
复制代码
上面代码例如第一个示例的 reduce()，第一个参数（空白字符）即为起始值，第二个参数（String::concat）为 BinaryOperator。这类有起始值的 reduce() 都返回具体的对象。而对于第四个示例没有起始值的 reduce()，由于可能没有足够的元素，返回的是 Optional，请留意这个区别。
Parallel Streams(并行流)
前面提到过 Stream 有串行和并行两种，串行 Stream 上的操作是在一个线程中依次完成，而并行 Stream 则是在多个线程上同时执行。
下面的例子展示了是如何通过并行 Stream 来提升性能：
首先我们创建一个没有重复元素的大表：
int max = 1000000;List<String> values = new ArrayList<>(max);for (int i = 0; i < max; i++) { UUID uuid = UUID.randomUUID(); values.add(uuid.toString());}
复制代码
Maps
前面提到过，Map 类型不支持 streams，不过 Map 提供了一些新的有用的方法来处理一些日常任务。Map 接口本身没有可用的 stream（）方法，但是你可以在键，值上创建专门的流或者通过 map.keySet().stream(),map.values().stream()和 map.entrySet().stream()。
此外,Maps 支持各种新的和有用的方法来执行常见任务。
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));//val0 val1 val2 val3 val4 val5 val6 val7 val8 val9
复制代码
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
复制代码
Date API(日期相关 API)
Java 8 在 java.time 包下包含一个全新的日期和时间 API。新的 Date API 与 Joda-Time 库相似，但它们不一样。以下示例涵盖了此新 API 的最重要部分。译者对这部分内容参考相关书籍做了大部分修改。
译者注(总结)：
Clock 类提供了访问当前日期和时间的方法，Clock 是时区敏感的，可以用来取代 System.currentTimeMillis() 来获取当前的微秒数。某一个特定的时间点也可以使用 Instant 类来表示，Instant 类也可以用来创建旧版本的 java.util.Date 对象。
在新 API 中时区使用 ZoneId 来表示。时区可以很方便的使用静态方法 of 来获取到。 抽象类 ZoneId（在 java.time 包中）表示一个区域标识符。 它有一个名为 getAvailableZoneIds 的静态方法，它返回所有区域标识符。
jdk1.8 中新增了 LocalDate 与 LocalDateTime 等类来解决日期处理方法，同时引入了一个新的类 DateTimeFormatter 来解决日期格式化问题。可以使用 Instant 代替 Date，LocalDateTime 代替 Calendar，DateTimeFormatter 代替 SimpleDateFormat。
Clock
Clock 类提供了访问当前日期和时间的方法，Clock 是时区敏感的，可以用来取代 System.currentTimeMillis() 来获取当前的微秒数。某一个特定的时间点也可以使用 Instant 类来表示，Instant 类也可以用来创建旧版本的 java.util.Date 对象。
Clock clock = Clock.systemDefaultZone();long millis = clock.millis();System.out.println(millis);//1552379579043Instant instant = clock.instant();System.out.println(instant);Date legacyDate = Date.from(instant); //2019-03-12T08:46:42.588ZSystem.out.println(legacyDate);//Tue Mar 12 16:32:59 CST 2019
复制代码
Timezones(时区)
在新 API 中时区使用 ZoneId 来表示。时区可以很方便的使用静态方法 of 来获取到。 抽象类 ZoneId（在 java.time 包中）表示一个区域标识符。 它有一个名为 getAvailableZoneIds 的静态方法，它返回所有区域标识符。
//输出所有区域标识符System.out.println(ZoneId.getAvailableZoneIds());
ZoneId zone1 = ZoneId.of("Europe/Berlin");ZoneId zone2 = ZoneId.of("Brazil/East");System.out.println(zone1.getRules());// ZoneRules[currentStandardOffset=+01:00]System.out.println(zone2.getRules());// 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); // -3System.out.println(minutesBetween); // -239
复制代码
LocalTime 提供了多种工厂方法来简化对象的创建，包括解析时间字符串.
LocalTime late = LocalTime.of(23, 59, 59);System.out.println(late); // 23:59:59DateTimeFormatter 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();//获取现在的日期System.out.println("今天的日期: "+today);//2019-03-12LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);System.out.println("明天的日期: "+tomorrow);//2019-03-13LocalDate yesterday = tomorrow.minusDays(2);System.out.println("昨天的日期: "+yesterday);//2019-03-11LocalDate independenceDay = LocalDate.of(2019, Month.MARCH, 12);DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();System.out.println("今天是周几:"+dayOfWeek);//TUESDAY
复制代码
从字符串解析一个 LocalDate 类型和解析 LocalTime 一样简单,下面是使用 DateTimeFormatter 解析字符串的例子：
String str1 = "2014==04==12 01时06分09秒"; // 根据需要解析的日期、时间字符串定义解析所用的格式器 DateTimeFormatter fomatter1 = DateTimeFormatter .ofPattern("yyyy==MM==dd HH时mm分ss秒");
LocalDateTime dt1 = LocalDateTime.parse(str1, fomatter1); System.out.println(dt1); // 输出 2014-04-12T01:06:09
String str2 = "2014$$$四月$$$13 20小时"; DateTimeFormatter fomatter2 = DateTimeFormatter .ofPattern("yyy$$$MMM$$$dd HH小时"); LocalDateTime dt2 = LocalDateTime.parse(str2, fomatter2); System.out.println(dt2); // 输出 2014-04-13T20:00
复制代码
再来看一个使用 DateTimeFormatter 格式化日期的示例
LocalDateTime rightNow=LocalDateTime.now();String date=DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(rightNow);System.out.println(date);//2019-03-12T16:26:48.29DateTimeFormatter formatter=DateTimeFormatter.ofPattern("YYYY-MM-dd HH:mm:ss");System.out.println(formatter.format(rightNow));//2019-03-12 16:26:48
复制代码
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 是不可变的，所以它是线程安全的。 关于时间日期格式的详细信息在这里。
Annotations(注解)
在 Java 8 中支持多重注解了，先看个例子来理解一下是什么意思。 首先定义一个包装类 Hints 注解用来放置一组具体的 Hint 注解：
@interface Hints { Hint[] value();}@Repeatable(Hints.class)@interface Hint { String value();}
复制代码
Java 8 允许我们把同一个类型的注解使用多次，只需要给该注解标注一下 @Repeatable 即可。
例 1: 使用包装类当容器来存多个注解（老方法）
@Hints({@Hint("hint1"), @Hint("hint2")})class Person {}
复制代码
例 2：使用多重注解（新方法）
@Hint("hint1")@Hint("hint2")class Person {}
复制代码
第二个例子里 java 编译器会隐性的帮你定义好 @Hints 注解，了解这一点有助于你用反射来获取这些信息：
Hint hint = Person.class.getAnnotation(Hint.class);System.out.println(hint); // nullHints 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);
复制代码
即便我们没有在 Person 类上定义 @Hints 注解，我们还是可以通过 getAnnotation(Hints.class) 来获取 @Hints 注解，更加方便的方法是使用 getAnnotationsByType 可以直接获取到所有的 @Hint 注解。 另外 Java 8 的注解还增加到两种新的 target 上了：
@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})@interface MyAnnotation {}
复制代码
粉丝福利
微信搜一搜「 码上代码」回复【面试资料】，【技术书籍】有我准备的一线大厂面试资料和简历模板和 java 必看技术书籍
大家好，感谢各位人才能看到这里的都是您已是佼佼者我会持续为大家做技术分享预知下篇如何请点赞、收藏和评论，我们下期见！
评论