Java并沒有衰落.大家對它的認識才剛剛開始
很高興能在此給大家分享Java8的新特性，這篇文章將一步一步帶你了解Java8的所有新特性，我將通過簡單的實體代碼向大家展示介面中默認方法，lambda 運算式,方法參考,重復注解的使用. 看過這篇文章之后你將了解流、函式、介面、map擴展、日期中的新變化.不廢話，放碼過來!
Default Methods for Interfaces(介面中的默認方法)
Java 8準許我們在介面中增加一個通過default關鍵字修飾的非抽象的方法. 這個特性被我們稱為擴展方法. 下面舉例說明:
interface Formula {
double calculate(int a);
default double sqrt(int a) {
return Math.sqrt(a);
}
}
介面Formula 中除了抽象方法calculate 其中還定義了非抽象方法sqrt. 實作類里面繼承了抽象方法calculate. 而默認方法可以直接呼叫.
Formula formula = new Formula() {
@Override
public double calculate(int a) {
return sqrt(a * 100);
}
};
formula.calculate(100); // 100.0
formula.sqrt(16); // 4.0
formula是一個繼承Formula 介面的匿名物件. 實體代碼十分詳細: 僅僅6行代碼實作了一個簡單的 sqrt(a * 100)計算. 在接下來的章節, 將給大家介紹更加完善的方案實作單個方法物件在Java8中的使用.
Lambda expressions(Lambda運算式)
通過下面實體向大家展示怎么在之前版本中對List中的String排序:
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和compare來對每個List中的元素排序.你經常發現你自己創建一個匿名Comparator類并通過它來實作排序.
為了擺脫通過創建匿名物件的方式來實作排序, 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關鍵字. 甚至可以使它更加簡短:
Collections.sort(names, (a, b) -> b.compareTo(a));
Java編譯器能夠自動識別引數型別所以你能夠省略它們. 讓我們更深入的了解lambda 運算式在java中更廣泛的應用.
Functional Interfaces(函式化介面)
lambda運算式怎么去匹配Java型別呢? 每一個lambda運算式相當于指定一個介面的型別. 一個必須定義一個抽線的方法的函式介面. 每一個lambda運算式型別都將和這個抽象方法匹配.由于默認方法并不是抽象方法，所以你可以自由的添加默認方法到你的函式介面中.
我們能夠使用任意介面作為lambda運算式,這個介面中只需要包含一個抽象的方法就可以了. 為了確保你的介面滿足需求，你需要在你介面上添加一個@FunctionalInterface注解.當你使用這個注解之后，這個介面只能定義一個抽象方法，否者編譯器會報錯 .
Example:
@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也是有效代碼.
Method and Constructor References(方法和構造器的參考)
上面的代碼可以通過靜態方法應用可以更加簡潔:
Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted); // 123
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"
讓我們來看看::是怎么參考構造器的的. 首先我們定義兩個構造器在一個javabean中:
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引數匹配合適的構造器.
Lambda Scopes(Lambda 的作用域)
從 lambda運算式訪問區域變數和匿名物件是相似的.你可以訪問final修飾的區域變數也能夠訪問實體化區域屬性和靜態變數.
Accessing local variables(訪問本地變數)
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;
把num 寫到lambda運算式內也是被禁止的.
Accessing fields and static variables(訪問屬性和靜態變數)
與區域變數相比我們在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);
};
}
}
Accessing Default Interface Methods(訪問默認的介面方法)
還記得第一個 formula 的實體嘛? 介面Formula定義一個默認的方法 sqrt，它能夠被每個formula實體包括匿名物件訪問. 它卻不適合lambda 運算式.
lambda運算式不能訪問介面的默認方法. 下面代碼不能編譯通過:
Formula formula = (a) -> sqrt( a * 100);
Built-in Functional Interfaces(內置函式)
DK 1.8 API包含了許多內置函式. 它們中很多在老版本中是大家很熟悉的,像 Comparator 和Runnable. 這些介面通過 添加@FunctionalInterface注解來支持Lambda運算式.
但是Java 8 API 也添加了很多新介面使編程變的更加容易 . 這些新的函式很多是借鑒被大家所熟知的 Google Guava 函式庫.即使你很熟悉這些函式庫,你也需要關注這些方法是怎么在介面中擴展的以及它們怎么使用.
Predicates( 判斷)
判斷是傳遞一個引數回傳一個布林值. 這個介面包含各種默認的方法組成復雜的邏輯判斷單元 (and, or, negate)
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(函式)
函式接收一個引數回傳一個結果. 默認方法能夠鏈式呼叫 (compose, andThen).
Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
backToString.apply("123"); // "123"
Suppliers(生產者)
Suppliers回傳一個給定的泛型型別的結果. 不像函式, Suppliers不需要傳遞引數.
Supplier<Person> personSupplier = Person::new;
personSupplier.get(); // new Person
Consumers(消費者)
Consumers代表在一個輸入引數上執行一項操作.
Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));
Comparators(比較)
Comparators在老版本中大家都比較熟悉. 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); // > 0
comparator.reversed().compare(p1, p2); // < 0
Optionals(選項)
Optionals 并不是一個函式介面, 相反的它的作用就是避免出現空指標例外.它是一個很重要的概念對以一部分,然我們來快速了解它.
Optional是一個簡單的容器里面包含有慷訓者非空的值.想象一下如果有一個方法能夠回傳一個慷訓者一個非空的值 . 在Java8中你可以通過回傳一個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"
Streams
java.util.Stream代表一個元素序列，在它上面能夠進行一種或多種操作. Stream操作可以包括對中間部分或者終端部分進行操作. 終端操作能夠回傳一個確定的型別, 中間操作能回傳流的本身你能夠通過多種方法呼叫某一行. Streams 可以通過一個源來創建, 例如. 像 java.util.Collection中的lists 或 sets (maps 不支持)都可以創建流. Stream 能夠串行操作也能并行操作.
首先看下流怎么進行序列操作. 我們先通過一個包含字串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");
在Java8中Collections已經繼承了streams ，所以你能夠通過in Java 8 are extended so you can simply create 呼叫Collection.stream() 和 Collection.parallelStream()來創建流.下面將給你介紹大部分流的操作 .
Filter(過濾)
Filter接收一個判斷用來過濾流中的所有元素. 這個操作是中間操作，它能夠使我們對結果進行另一個流操作(forEach) . ForEach接受一個consumer操作對每一個過濾的流元素中. ForEach是一個終端操作. 它回傳值void,所以我們不能呼叫另一個函式操作.
stringCollection
.stream()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
// "aaa2", "aaa1"
Sorted(排序)
Sorted是一個中間操作，它能夠回傳一個排序的流.這個元素按照自然排序除非你傳遞一個Comparator .
stringCollection
.stream()
.sorted()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
// "aaa1", "aaa2"
注意 sorted 僅僅是創建一個排序后的視圖操作，并沒有操作排序回傳的集合. 排序的 stringCollection并沒有受到影響:
System.out.println(stringCollection);
// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1
Map(映射)
中間操作 map轉換每個元素到另一個元素中通過給定的函式.下面的實體是把把每一個字串轉換成大寫.你也可以使用map轉換每個物件的型別. 泛型流依賴你傳遞給map的泛型函式.
stringCollection
.stream()
.map(String::toUpperCase)
.sorted((a, b) -> b.compareTo(a))
.forEach(System.out::println);
// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"
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 startsWithB =
stringCollection
.stream()
.filter((s) -> s.startsWith("b"))
.count();
System.out.println(startsWithB); // 3
Reduce(合并)
這個終端操作完成一個流中元素合并操作通過給定的函式.回傳的結果通過 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"
Parallel Streams(并行流)
上文提到過流可以是串行的也可以是并行的. 串行的序列操作是單執行緒的,而并行流是在多個執行緒上進行操作.
下面的實體向你展示通過并行流增加性能.
首先創建一個元素出現次數唯一的大的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());
}
現在測驗它的排序所消耗的時間.
Sequential Sort(串行排序)
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
Parallel Sort(并行排序)
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%.你可以測驗著用 parallelStream()操作代替stream().
Map(映射)
上文提到map并不支持流操作. 但是新的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方法對傳統的非空檢驗 ; forEach 方法遍歷map中每一個值進行consumer操作.
這個實體展示了怎么利用函式在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
下一步,我們學習怎么給定一個key怎么移除物件操作, 現在加入給一個鍵值對:
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
合并操作如果鍵值對不存在就添加到里面, 合并操作也可以用來改變存在的值.
Date API(日期API)
Java 8 包含一個全新的日期和時間操作API在 java.time包里面. 新的Date API 可以和 Joda-Time 包相媲美, 不過，它們并不一樣. 下面給你實體一下新日期里面主要新的API.
Clock(時鐘)
時鐘提供了訪問現在的日期和時間的方法. 時鐘意思到時區將可能替代 System.currentTimeMillis() 來獲取現在的毫秒數. 這樣一個瞬時點在時間線上用類 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代替. 你可以很方便的訪問通過一個靜態的工廠方法. 時區定義一個彌補了一個重要在瞬時和本地時間和日期上的轉換.
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可以從各種工廠方法簡單的創建新實體, 包含格式化的字串.
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(本地日期)
本地日期代表了清晰的日期 , 例如. 2014-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 from 和決議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也是不可變的,它作業原理和 LocalTime、LocalDate作業原理一樣.我們能夠利用方法獲取一個屬性從date-time:
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
傳統的 timezone 能夠轉換成一個 instant. Instants 也能夠很輕松轉換成一個傳統的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
格式化date-times 就是格式化dates 和 times一樣.我們也可以使用預先定義的格式才創建定制的格式 .
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中可重復使用.讓我們通過實體來深入了解.
首先, 我們定義一個包裝注解,它包含一個實際的注解陣列:
@interface Hints {
Hint[] value();
}
@Repeatable(Hints.class)
@interface Hint {
String value();
}
Java 8使我們能夠使用一樣的注解通過@Repeatable注解定義.
Variant 1: 使用容器注解(old school)
@Hints({@Hint("hint1"), @Hint("hint2")})
class Person {}
Variant 2: 使用重復注解(new school)
@Hint("hint1")
@Hint("hint2")
class Person {}
使用variant 2java編譯器會隱式的設定 一個@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
雖然我們從來沒有定義 @Hints注解在 Person 類上,它一直能獲取到通過 getAnnotation(Hints.class). 然而,這里有更方便的方法getAnnotationsByType它能夠直接訪問所有的 @Hint 注解.
此外使用Java8注解是擴展的兩個新的目標:
@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@interface MyAnnotation {}
我的Java 8新特征實體到此結束. 如果你想學習 JDK 8 API所有新特性和類, 可以關注公眾號：程式零世界 它幫你了解所有的新類和一些隱藏的新特性在 JDK 8,像 Arrays.parallelSort, StampedLock 和CompletableFuture等等.
我希望我的這篇文章能夠幫助你,同時也希望你讀后有所識訓.你也可以通過公眾號：程式零世界 向我反饋意見.
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/178300.html
標籤：Java