Java8新特性详解

亦凉 2023-09-24 21:46 48阅读 0赞

> 陈老老老板
> 
> 说明：新的专栏，本专栏专门讲Java8新特性，把平时遇到的问题与Java8的写法进行总结，需要注意的地方都标红了，一起加油。  
> **本文是介绍Java8新特性与常用方法（此篇只做大体介绍了解，之后会把重要的部分写在新的博客中）**

![89a16142f274467595ed607af72fc69d.gif_pic_center][]

**说明：** 在工作中发现[Java8新特性][Java8]的写法无处不在，必须了解学会才能看懂前辈写的代码，本篇对Java8新特性做了全面的总结。

Java 8 允许我们通过 default 关键字对接口中定义的抽象方法提供一个默认的实现。

请看下面示例代码：

interface school{
        
        
        void study();
    
        
        default string play(String name) {
        
            return "我和"+ name + "一起做游戏";
        }
    }

在上面这个接口中，我们除了定义了一个抽象方法 study，还定义了一个带有默认实现的方法 play。 我们在实现这个接口时，可以只需要实现 study方法，默认方法 play可以直接调用即可，也就是说我们可以不必强制实现 sqrt 方法。

**注：通过 default 关键字这个新特性，可以非常方便地对之前的接口做拓展，而此接口的实现类不必做任何改动，减少了耦合性。**

School school = new School() {
        
        @Override
        public void study() {
        
            system.out.println("学习中");
        }
    };

在学习 Lambda 表达式之前，我们先来看一段老版本的示例代码，其对一个含有字符串的集合进行排序：

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 集合，一个 Comparator 比较器，创建比较器对象要实现比较方式。以便对给定的 List 集合进行 排序。上面的示例代码创建了一个匿名内部类作为入参，这种类似的操作在我们日常的工作中随处可见。

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 关键代码即可。追求极致，我们还可以让它再短点：

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

List 集合现在已经添加了 sort 方法。而且 Java 编译器能够根据类型推断机制判断出参数类型。  
**注：** Lambda表达式在下一篇博客就会深入进行讲解，这个很重要。

不是每个接口都可以缩写成 Lambda 表达式。只有那些函数式接口（Functional Interface）才能缩写成 Lambda 表示式。

函数式接口（Functional Interface）就是只包含一个抽象方法的声明。针对该接口类型的所有 Lambda 表达式都会与这个抽象方法匹配。

**注：** Java 8 中允许通过 defualt 关键字来为接口添加默认方法它是不算抽象方法的，因此，你可以毫无顾忌的添加默认方法，它并不违反函数式接口（Functional Interface）的定义。一旦你添加了第二个抽象方法，编译器会立刻抛出错误提示。

**总结一下：** 只要接口中仅仅包含一个抽象方法，我们就可以将其改写为 Lambda 表达式。为了保证一个接口明确的被定义为一个函数式接口（Functional Interface），我们需要为该接口添加注解：@FunctionalInterface。

示例代码：

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

示例代码2：

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

**注：** 上面的示例代码，即使去掉 @FunctionalInterface 也是好使的，它仅仅是一种约束而已。  
这里解释一下，lambda表达式就理解为一个接口的实现方法，然后但凡是调用这个方法，就会执行lambda中写好的实现方式，这样就很好理解了。

便捷引用方法指的是，Java 8 中允许你通过 :: 关键字来引用类的方法或构造器。  
这里用代码来演示，更进一步简便的调用方法方式，之后会进行深入详解。  
这里先通过lambda进行简化，但是可以更加简化。

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

上面这段代码，通过 Java 8 的新特性，进一步简化上面的代码：

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

上面的代码简单的示例了如何引用静态方法，当然，除了静态方法，我们还可以引用普通方法：

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

接下来，我们再来看看如何通过 :: 关键字来引用类的构造器。  
首先，我们先来定义一个示例类，在类中声明两个构造器：

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

我们可以通过 :: 关键字来引用 Person 类的构造器，来代替手动去实现这个工厂接口：

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

Person::new 这段代码，能够直接引用 Person 类的构造器。然后 Java 编译器能够根据上下文选中正确的构造器去实现 PersonFactory.create 方法。

这里主要讲如何在 lambda 表达式中访问外部变量（包括：局部变量，成员变量，静态变量，接口的默认方法.），它与匿名内部类访问外部变量很相似。

## 1.访问局部变量 ##

在 Lambda 表达式中，我们可以访问外部的 final 类型变量，如下面的示例代码：

@FunctionalInterface
    interface Converter<F, T> {
        
        T convert(F from);
    }
    final int num = 1;
    Converter<Integer, String> stringConverter =
            (from) -> String.valueOf(from + num);
    
    stringConverter.convert(2);

与匿名内部类不同的是，我们不必显式声明 num 变量为 final 类型，下面这段代码同样有效：

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

但是 num 变量必须为隐式的 final 类型，何为隐式的 final 呢？就是说到编译期为止，num 对象是不能被改变的，如下面这段代码，就不能被编译通过：

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

在 lambda 表达式内部改变 num 值同样编译不通过，需要注意, 比如下面的示例代码：

int num = 1;
    Converter<Integer, String> converter = (from) -> {
        
    	String value = String.valueOf(from + num);
    	num = 3;
    	return value;
    };

## 2.访问成员变量和静态变量 ##

在 Lambda 表达式中对成员变量和静态变量同样拥有读写权限：  
代码示例如下：

@FunctionalInterface
        interface Converter<F, T> {
        
            T convert(F from);
        }
    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);
                };
            }
        }

## 3.访问接口的默认方法 ##

@FunctionalInterface
    interface Formula {
        
    	
    	double calculate(int a);
    
    	
    	default double sqrt(int a) {
        
    		return Math.sqrt(a);
    	}
    }

我们在接口中定义了一个带有默认实现的 sqrt 求平方根方法，在匿名内部类中我们可以很方便的访问此方法：

Formula formula = new Formula() {
        
    	@Override
    	public double calculate(int a) {
        
    		return sqrt(a * 100);
    	}
    };

**但是在 lambda 表达式中可不行,带有默认实现的接口方法，是不能在 lambda 表达式中访问的，这段代码将无法被编译通过。**

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

## 4.内置的函数式接口 ##

JDK 1.8 API 包含了很多内置的函数式接口。其中就包括我们在老版本中经常见到的 Comparator 和 Runnable，Java 8 为他们都添加了 @FunctionalInterface 注解，以用来支持 Lambda 表达式。

值得一提的是，除了 Comparator 和 Runnable 外，还有一些新的函数式接口，它们很多都借鉴于知名的 Google Guava 库。

### （1）Predicate 断言 ###

**注：** 这个会之后展开详细讲解  
Predicate 是一个可以指定入参类型，并返回 boolean 值的函数式接口。它内部提供了一些带有默认实现的方法，可以被用来组合一个复杂的逻辑判断（and, or, negate）：

Predicate<String> predicate = (s) -> s.length() > 0;
    
    predicate.test("foo");              
    predicate.negate().test("foo");     
    
    Predicate<Boolean> nonNull = Objects::nonNull;
    Predicate<Boolean> isNull = Objects::isNull;
    
    Predicate<String> isEmpty = String::isEmpty;
    Predicate<String> isNotEmpty = isEmpty.negate();

### （2）Function ###

Function 函数式接口的作用是，我们可以为其提供一个原料，他给生产一个最终的产品。通过它提供的默认方法，组合,链行处理(compose, andThen)：

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

### （3）Supplier 生产者 ###

Supplier 与 Function 不同，==它不接受入参，直接为我们生产一个指定的结果，==有点像生产者模式：

class Person {
        
        String firstName;
        String lastName;
        
        Person() {
        }
        
        Person(String firstName, String lastName) {
        
            this.firstName = firstName;
            this.lastName = lastName;
        }
    }
    
    Supplier<Person> personSupplier = Person::new;
    personSupplier.get();

### （4）Consumer 消费者 ###

对于 Consumer，我们需要提供入参，用来被消费，如下面这段示例代码：

class Person {
        
        String firstName;
        String lastName;
    
        Person() {
        }
    
        Person(String firstName, String lastName) {
        
            this.firstName = firstName;
            this.lastName = lastName;
        }
    }
    
    Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
    greeter.accept(new Person("Luke", "Skywalker"));

### （5）Comparator ###

Comparator 在 Java 8 之前是使用比较普遍的。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);             
    comparator.reversed().compare(p1, p2);

### （6）Optional ###

**注：** 这个会之后展开详细讲解，Optional有很多常用的方法，十分实用。  
首先，Optional 它不是一个函数式接口，设计它的目的是为了防止空指针异常（NullPointerException），要知道在 Java 编程中， 空指针异常可是臭名昭著的。

让我们来快速了解一下 Optional 要如何使用！你可以将 Optional 看做是包装对象（可能是 null, 也有可能非 null）的容器。当你定义了 一个方法，这个方法返回的对象可能是空，也有可能非空的时候，你就可以考虑用 Optional 来包装它，这也是在 Java 8 被推荐使用的做法。

Optional<String> optional = Optional.of("bam");
    
    optional.isPresent();           
    optional.get();                 
    optional.orElse("fallback");    
    
    optional.ifPresent((s) -> System.out.println(s.charAt(0)));

Stream 流简单来说，我们可以使用 java.util.Stream 对一个包含一个或多个元素的集合做各种操作。这些操作可能是 中间操作 亦或是 终端操作。 终端操作会返回一个结果，而中间操作会返回一个 Stream 流。

**注：** 只能对实现了 java.util.Collection 接口的类做流的操作。Map 不支持Stream 流。  
Stream 流支持同步执行，也支持并发执行。

## 1.Filter 过滤 ##

首先，我们创建一个 List 集合：

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

Filter 的入参是一个 Predicate, 上面已经说到，Predicate 是一个断言的中间操作，它能够帮我们筛选出我们需要的集合元素。它的返参同样 是一个 Stream 流，我们可以通过 foreach 终端操作，来打印被筛选的元素：

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

**注：** foreach 是一个终端操作，它的返参是 void, 我们无法对其再次进行流操作。

## 2.Sorted 排序 ##

Sorted 同样是一个中间操作，它的返参是一个 Stream 流。另外，我们可以传入一个 Comparator 用来自定义排序，如果不传，则使用默认的排序规则。

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

需要注意，sorted 不会对 stringCollection 做出任何改变，stringCollection 还是原有的那些个元素，且顺序不变：

System.out.println(stringCollection);

## 3.Map 转换 ##

中间操作 Map 能够帮助我们将 List 中的每一个元素做功能处理。例如下面的示例，通过 map 我们将每一个 string 转成大写：

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

另外，我们还可以做对象之间的转换，业务中比较常用的是将 DO（数据库对象） 转换成 BO（业务对象） 。

## 4.Match 匹配 ##

顾名思义，match 用来做匹配操作，它的返回值是一个 boolean 类型。通过 match, 我们可以方便的验证一个 list 中是否存在某个类型的元素,主要用来校验操作。

boolean anyStartsWithA =
        stringCollection
            .stream()
            .anyMatch((s) -> s.startsWith("a"));
    
    System.out.println(anyStartsWithA);

boolean allStartsWithA =
        stringCollection
            .stream()
            .allMatch((s) -> s.startsWith("a"));
    
    System.out.println(allStartsWithA);

boolean noneStartsWithZ =
        stringCollection
            .stream()
            .noneMatch((s) -> s.startsWith("z"));
    
    System.out.println(noneStartsWithZ);

## 5.Count 计数 ##

count 是一个终端操作，它能够统计 stream 流中的元素总数，返回值是 long 类型。

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

## 6.Reduce ##

Reduce 中文翻译为：减少、缩小。  
**注：** 通过入参的 Function，我们能够将 list 归约成一个值。它的返回类型是 Optional 类型。

Optional<String> reduced =
        stringCollection
            .stream()
            .sorted()
            .reduce((s1, s2) -> s1 + "#" + s2);
    
    reduced.ifPresent(System.out::println);

前面章节我们说过，stream 流是支持顺序和并行的。顺序流操作是单线程操作，而并行流是通过多线程来处理的，能够充分利用物理机 多核 CPU 的优势，同时处理速度更快。

首先，我们创建一个包含 1000000 UUID 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());
    }

分别通过顺序流和并行流，对这个 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("顺序流排序耗时: %d ms", millis));

并行流:

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("并行流排序耗时: %d ms", millis));

同样的逻辑处理，通过并行流，我们的性能提升了近 50%。完成这一切，我们需要做的仅仅是将 stream 改成了 parallelStream。

前面已经提到过 Map 是不支持 Stream 流的，因为 Map 接口并没有像 Collection 接口那样，定义了 stream() 方法。  
**注：** 我们可以对其 key, values, entry 使用 流操作，如 map.keySet().stream(), map.values().stream() 和 map.entrySet().stream().

另外, JDK 8 中对 map 提供了一些其他新特性:  
putIfAbsent():

Map<Integer, String> map = new HashMap<>();
    
    for (int i = 0; i < 10; i++) {
        
        
        
        map.putIfAbsent(i, "val" + i);
    }

map.forEach((key, value) -> System.out.println(value));

除了上面的 putIfAbsent() 和 forEach() 外，我们还可以很方便地对某个 key 的值做相关操作：

map.computeIfPresent(3, (num, val) -> val + num);
    map.get(3);             
    
    
    map.computeIfPresent(9, (num, val) -> null);
    map.containsKey(9);     
    
    
    
    map.computeIfAbsent(23, num -> "val" + num);
    map.containsKey(23);    
    
    
    map.computeIfAbsent(3, num -> "bam");
    map.get(3);             
    关于删除操作，JDK 8 中提供了能够新的 remove() API:
    
    map.remove(3, "val3");
    map.get(3);             
    
    map.remove(3, "val33");
    map.get(3);             
    如上代码，只有当给定的 key 和 value 完全匹配时，才会执行删除操作。

关于添加方法，JDK 8 中提供了带有默认值的 getOrDefault() 方法：

map.getOrDefault(42, "not found");  
    对于 value 的合并操作也变得更加简单：
    
    
    map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
    map.get(9);             
    
    
    map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
    map.get(9);

Java 8 中在包 java.time 下添加了新的日期 API. 它和 Joda-Time 库相似，但又不完全相同。接下来，我会通过一些示例代码介绍一下新 API 中 最关键的特性：

## 1.Clock ##

Clock 提供对当前日期和时间的访问。我们可以利用它来替代 System.currentTimeMillis() 方法。另外，通过 clock.instant() 能够获取一个 instant 实例， 此实例能够方便地转换成老版本中的 java.util.Date 对象。

Clock clock = Clock.systemDefaultZone();
    long millis = clock.millis();
    
    Instant instant = clock.instant();
    Date legacyDate = Date.from(instant);

## 2.Timezones 时区 ##

ZoneId 代表时区类。通过静态工厂方法方便地获取它，入参我们可以传入某个时区编码。另外，时区类还定义了一个偏移量，用来在当前时刻或某时间 与目标时区时间之间进行转换。

System.out.println(ZoneId.getAvailableZoneIds());
    
    
    ZoneId zone1 = ZoneId.of("Europe/Berlin");
    ZoneId zone2 = ZoneId.of("Brazil/East");
    System.out.println(zone1.getRules());
    System.out.println(zone2.getRules());

## 3.LocalTime ##

LocalTime 表示一个没有指定时区的时间类，例如，10 p.m.或者 17：30:15，下面示例代码中，将会使用上面创建的 时区对象创建两个 LocalTime。然后我们会比较两个时间，并计算它们之间的小时和分钟的不同。

LocalTime now1 = LocalTime.now(zone1);
    LocalTime now2 = LocalTime.now(zone2);
    
    System.out.println(now1.isBefore(now2));  
    
    long hoursBetween = ChronoUnit.HOURS.between(now1, now2);
    long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);
    
    System.out.println(hoursBetween);       
    System.out.println(minutesBetween);

LocalTime 提供多个静态工厂方法，目的是为了简化对时间对象实例的创建和操作，包括对时间字符串进行解析的操作等。

LocalTime late = LocalTime.of(23, 59, 59);
    System.out.println(late);       
    
    DateTimeFormatter germanFormatter =
        DateTimeFormatter
            .ofLocalizedTime(FormatStyle.SHORT)
            .withLocale(Locale.GERMAN);
    
    LocalTime leetTime = LocalTime.parse("13:37", germanFormatter);
    System.out.println(leetTime);

## 4.LocalDate ##

LocalDate 是一个日期对象，例如：2014-03-11。它和 LocalTime 一样是个 final 类型对象。下面的例子演示了如何通过加减日，月，年等来计算一个新的日期。

LocalDate, LocalTime, 因为是 final 类型的对象，每一次操作都会返回一个新的时间对象。
    
    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);

也可以直接解析日期字符串，生成 LocalDate 实例。（和 LocalTime 操作一样简单）

DateTimeFormatter germanFormatter =
        DateTimeFormatter
            .ofLocalizedDate(FormatStyle.MEDIUM)
            .withLocale(Locale.GERMAN);
    
    LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);
    System.out.println(xmas);

## 5.LocalDateTime ##

LocalDateTime 是一个日期-时间对象。你也可以将其看成是 LocalDate 和 LocalTime 的结合体。操作上，也大致相同。

LocalDateTime 同样是一个 final 类型对象。

LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);
    
    DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
    System.out.println(dayOfWeek);      
    
    Month month = sylvester.getMonth();
    System.out.println(month);          
    
    
    long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
    System.out.println(minuteOfDay);

如果再加上的时区信息，LocalDateTime 还能够被转换成 Instance 实例。Instance 能够被转换成老版本中 java.util.Date 对象。

Instant instant = sylvester
            .atZone(ZoneId.systemDefault())
            .toInstant();
    
    Date legacyDate = Date.from(instant);
    System.out.println(legacyDate);     
    格式化 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);

注意：和 java.text.NumberFormat 不同，新的 DateTimeFormatter 类是 final 类型的，同时也是线程安全的。更多细节请查看这里

在 Java 8 中，注解是可以重复的。Java 8 中，通过 @Repeatable，允许我们对同一个类使用多重注解。让我通过下面的示例代码，来看看到底是咋回事。

首先，我们定义一个包装注解，里面包含了一个有着实际注解的数组：

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

第一种形态：使用注解容器（老方法）

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

第二种形态：使用可重复注解（新方法）

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

使用第二种形态，Java 编译器能够在内部自动对 @Hint 进行设置。这对于需要通过反射来读取注解信息时，是非常重要的。

Hint hint = Person.class.getAnnotation(Hint.class);
    System.out.println(hint);                   
    
    Hints hints1 = Person.class.getAnnotation(Hints.class);
    System.out.println(hints1.value().length);  
    
    Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);
    System.out.println(hints2.length);

尽管我们绝对不会在 Person 类上声明 @Hints 注解，但是它的信息仍然是可以通过 getAnnotation(Hints.class) 来读取的。 并且，getAnnotationsByType 方法会更方便，因为它赋予了所有 @Hints 注解标注的方法直接的访问权限。

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

> **总结：Java8新特性是必须了解学习的内容,总结这大体的十条让你有一个全面的认识，之后会一一详细进行讲解。希望对您有帮助，感谢阅读**
> 
> **结束语：裸体一旦成为艺术，便是最圣洁的。道德一旦沦为虚伪，便是最下流的。  
> 勇敢去做你认为正确的事，不要被世俗的流言蜚语所困扰。**

[89a16142f274467595ed607af72fc69d.gif_pic_center]: https://img-blog.csdnimg.cn/89a16142f274467595ed607af72fc69d.gif#pic_center
[Java8]: https://so.csdn.net/so/search?q=Java8%E6%96%B0%E7%89%B9%E6%80%A7&spm=1001.2101.3001.7020