雖然 Java8 已經發布了很長的時間,並且 Java8 中有不少特性能夠提高代碼的效率和安全,可是大多數 Java 程序員仍是沒有跨過 Java8 這個坎, Benjamin 在 2014 年寫下的這篇 Java8 的入門教程我以爲很是不錯,或許能夠幫助你跨過 Java8 這個坎。html
這份教程會指導你一步一步學習 Java8 的新特性。按照前後順序,這篇文章中包括如下的內容:接口的 default
方法,lambda
表達式,方法引用,可複用註解,還有一些 API 的更新,streams
,函數式接口,map
的擴展和新的 Date
Api。java
本文沒有大段的文字,只有帶註釋的代碼片斷,但願你能喜歡!git
Java8 容許在接口中實現具體的方法,只須要在方法前加上 default
關鍵字就行。這一特性也稱之爲虛擬擴展方法。這裏是第一個例子:程序員
interface Formual {
double calculate(int a);
default double sqrt(int a) {
return Math.sqrt(a);
}
}
複製代碼
在上面的例子中,Formual
接口定義了一個 default
方法 sqrt
,接口的實現類只要須要實現 calculate
方法,sqrt
方法開箱即用。github
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
的特性優雅的完成這個功能。編程
先看一下以前版本的 Java 中如何實現對一個字符串 List 進行排序的功能:c#
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 方法中。api
相比於使用匿名方法的冗長實現,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 表達式能夠訪問本地外部的 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 庫。即便你對這個庫已經很熟悉了,可是仍是應該密切注意這些接口是如何被一些有用的方法擴展的。
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();
複製代碼
Function 接收一個參數產生一個結果。默認方法能夠用於多個方法組成的方法鏈。
Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
backToString.apply("123"); // "123"
複製代碼
Supplier 根據給定的類屬性產生一個對象,Supplier 不支持傳入參數。
Supplier<Person> personSupplier = Person::new;
personSupplier.get(); // new Person
複製代碼
Consumer 對輸入的參數進行一系列預約義的流程進行處理。
Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));
複製代碼
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
複製代碼
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 編程作好了準備。
一個 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 接受一個 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 是一箇中間操做,會返回排好序的 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 是一箇中間操做,會根據給定的函數把 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 操做能夠用於判斷一個給定的 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 是一個終端操做,會返回一個 long 值來表示 Stream 中元素的個數。
long startsWithB =
stringCollection
.stream()
.filter((s) -> s.startsWith("b"))
.count();
System.out.println(startsWithB); // 3
複製代碼
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 的定義。
在上文中提到過 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 不支持 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 函數來改變現有的值。
Java8 在 java.time 包下有全新的日期和時間的 API。這些新的日期 API徹底比得上 Joda-Time,可是卻不徹底同樣。下面的包括了這些新 API 最重要的部分。
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
複製代碼
時區是經過 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 表示一個沒有時區的時間,好比 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 表示一個明確的日期,好比 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 是不可變的,用法和 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 {}
複製代碼
(完)
關注微信公衆號,聊點其餘的