Java 8中的新特性有：
接口中默認方法，lambda 表達式,方法引用,重復注解，流、函數、接口、map擴展、日期中的新變化等，接下來一一介紹

1. 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() {@Overridepublic 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中的使用.

2. Lambda expressions(Lambda表達式)

通過下面實例向大家展示怎么在之前版本中對List中的String排序:

List<String> list = Arrays.asList("aa","peter","bob"); Collections.sort(list, new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {return o1.compareTo(o2);} });

通過一個靜態 Collections.sort 方法接收一個list和compare來對每個List中的元素排序.你經常發現你自己創建一個匿名Comparator類并通過它來實現排序.

為了擺脫通過創建匿名對象的方式來實現排序, Java 8帶來了更加簡潔的方式實現方式,lambda 表達式:

List<String> list = Arrays.asList("aa","peter","bob"); Collections.sort(list, (String a, String b)->{return a.compareTo(b);});

你會發現代碼更加簡潔可讀性更強. 甚至它還可以更加簡潔:

List<String> list = Arrays.asList("aa","peter","bob"); Collections.sort(list, (String a, String b)-> a.compareTo(b));

對于單行的方法體你可以直接省略{}和return關鍵字. 甚至可以使它更加簡短:

List<String> list = Arrays.asList("aa","peter","bob"); Collections.sort(list, (a, b)-> a.compareTo(b));

Java編譯器能夠自動識別參數類型所以你能夠省略它們. 讓我們更深入的了解lambda 表達式在java中更廣泛的應用.

3. Functional Interfaces(函數化接口)

lambda表達式怎么去匹配Java類型呢? 每一個lambda表達式相當于指定一個接口的類型. 一個必須定義一個抽象的方法的函數接口. 每一個lambda表達式類型都將和這個抽象方法匹配.由于默認方法并不是抽象方法，所以你可以自由的添加默認方法到你的函數接口中.

我們能夠使用任意接口作為lambda表達式,這個接口中只需要包含一個抽象的方法就可以了. 為了確保你的接口滿足需求，你需要在你接口上添加一個@FunctionalInterface注解.當你使用這個注解之后，這個接口只能定義一個抽象方法，否者編譯器會報錯 .

Example:

@FunctionalInterface interface Convertor<F,T> {T convert(F from);}Convertor<String, Integer> convertor = (from) -> Integer.valueOf(from); System.out.println(convertor.convert("123"));//123

注意@FunctionalInterface也是有效代碼.

4. Method and Constructor References(方法和構造器的引用)

上面的代碼可以通過靜態方法應用可以更加簡潔:

Convertor<String, Integer> convertor = Integer::valueOf; System.out.println(convertor.convert("123"));//123

Java 8能夠傳遞一個方法或者構造器引用通過 ::關鍵字. 上面的實例向你們展示了怎么去引用一個靜態方法. 我們也能夠引用一個普通對象方法:

@FunctionalInterface interface Convertor<F,T> {T convert(F from);}public class Test {public static void main(String[] args) {Test test = new Test();Convertor<String, Integer> convertor = test::startWith;System.out.println(convertor.convert("123"));//1}private Integer startWith(String ori) {return Integer.valueOf(ori.substring(0, 1));} }

讓我們來看看::是怎么引用構造器的. 首先我們定義兩個構造器在一個javabean中

class Person {private String firstName;private String lastName;public Person() {}public Person(String firstName, String last) {this.firstName = firstName;this.lastName = last;}@Overridepublic String toString() {return "Person [firstName=" + firstName + ", lastName=" + lastName+ "]";}}

下一步我們創建一個工廠接口，用它來創建一個Person對象:

interface PersonFactory<P extends Person> {P getInstance(String firstName, String last); }

手動實現這個工廠接口, 我們通過構造器和每件事情關聯在一起:

PersonFactory<Person> pFactory = Person::new; Person p = pFactory.getInstance("jon", "snow"); System.out.println(p);//Person [firstName=jon, lastName=snow]

我們通過 Person::new來創建一個對Person構造器的引用. Java編譯器自動的創建一個對象通過PersonFactory.getInstance參數匹配合適的構造器.

Lambda Scopes(Lambda 的作用域)
從 lambda表達式訪問局部變量和匿名對象是相似的.你可以訪問final修飾的局部變量也能夠訪問實例化局部屬性和靜態變量.

Accessing local variables(訪問本地變量)
lambda 表達式能夠從局部讀取一個的final修飾的局部變量:

interface Convertor<T, S> {T convert(S s); }public class Test {public static void main(String[] args) {final int num =1;Convertor<Integer, String> convertor = (from) ->Integer.valueOf(from + num);System.out.println(convertor.convert("99"));//991}}

和匿名對象不同的是，在匿名對象中變量num并不需要用 final修飾. 也能正常調用:

int num =1; Convertor<Integer, String> convertor = (from) ->Integer.valueOf(from + num); System.out.println(convertor.convert("99"));//991

然而num必須隱式使用final修飾才能編譯. 下面代碼就不會編譯:

int num =1; //下面編譯報錯：Local variable num defined in an enclosing scope must be final or effectively final Convertor<Integer, String> convertor = (from) ->Integer.valueOf(from + num); System.out.println(convertor.convert("99"));//991 num = 2;

把num 寫到lambda表達式內也是被禁止的.

Accessing fields and static variables(訪問屬性和靜態變量)
與局部變量相比我們在lambda表達式中能夠讀和寫一個全局屬性和靜態變量. 這和匿名對象中是一樣的.

interface Convertor<T, S> {T convert(S s); }public class Test {static int num1 = 0;int num2 = 0;public void test() {Convertor<Integer, String> convertor = (from) ->Integer.valueOf(from + num1 + num2);System.out.println(convertor.convert("99"));//991}public static void main(String[] args) {new Test().test();//9900}}

Accessing Default Interface Methods(訪問默認的接口方法)
還記得第一個 formula 的實例嘛? 接口Formula定義一個默認的方法 sqrt，它能夠被每個formula實例包括匿名對象訪問. 它卻不適合lambda 表達式.

lambda表達式不能訪問接口的默認方法. 下面代碼不能編譯通過:

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

5. Built-in Functional Interfaces(內置函數)

JDK 1.8 API包含了許多內置函數. 它們中很多在老版本中是大家很熟悉的,像 Comparator 和Runnable. 這些接口通過 添加@FunctionalInterface注解來支持Lambda表達式.

但是Java 8 API 也添加了很多新接口使編程變的更加容易 . 這些新的函數很多是借鑒被大家所熟知的 Google Guava 函數庫.即使你很熟悉這些函數庫,你也需要關注這些方法是怎么在接口中擴展的以及它們怎么使用.

Predicates( 判斷)
判斷是傳遞一個參數返回一個布爾值. 這個接口包含各種默認的方法組成復雜的邏輯判斷單元 (and, or, negate)

Predicate<String> predicate = (s)->s.length()>3;System.out.println(predicate.test("1"));//false; System.out.println(predicate.test("1234"));//true;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);System.out.println(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> list = new ArrayList<>(); list.add("ddd2"); list.add("aaa2"); list.add("bbb1"); list.add("aaa1"); list.add("bbb3"); list.add("ccc"); list.add("bbb2"); list.add("ddd1");

在Java8中Collections已經繼承了streams ，所以你能夠通過調用Collection.stream() 和 Collection.parallelStream()來創建流.下面將給你介紹大部分流的操作 .

list.stream().filter((s)->s.length()<4).forEach(System.out::println);//ccc

Sorted(排序)
Sorted是一個中間操作，它能夠返回一個排序的流。這個元素按照自然排序，除非你傳遞一個Comparator .

list.stream().filter((s)->s.startsWith("a")).sorted().forEach(System.out::println);//aaa1 aaa2

注意 sorted 僅僅是創建一個排序后的視圖操作，并沒有操作排序返回的集合. 排序的 list并沒有受到影響:

list.forEach(System.out::print);//ddd2 aaa2 bbb1 aaa1 bbb3 ccc bbb2 ddd1

Map(映射)
中間操作 map轉換每個元素到另一個元素中通過給定的函數.下面的實例是把把每一個字符串轉換成大寫.你也可以使用map轉換每個對象的類型. 泛型流依賴你傳遞給map的泛型函數.

list.stream().map(String::toUpperCase).forEach(System.out::print); //DDD2AAA2BBB1AAA1BBB3CCCBBB2DDD1

Match(匹配)
可以使用各種匹配操作來確定是否是確定的流. 所有這些操作是終端操作并返回一個布爾值.

boolean anyStartWithA = list.stream().anyMatch((s)->s.startsWith("a")); System.out.println(anyStartWithA);//trueboolean allStartWithA = list.stream().allMatch((s)->s.startsWith("a")); System.out.println(allStartWithA);//falseboolean nonStartWithA = list.stream().noneMatch((s)->s.startsWith("a")); System.out.println(nonStartWithA);//false

Count(統計)
Count是一個終端操作返回流中元素的個數.

long startWithB = list.stream().filter((s)->s.startsWith("b")).count();// System.out.println(startWithB);//3

Reduce(合并)
這個終端操作完成一個流中元素合并操作通過給定的函數.返回的結果通過 Optional來保存值.

Optional<String> optional = list.stream().sorted().reduce((a, b)->a+" # "+b); System.out.println(optional);//Optional[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 start = System.nanoTime();long count = values.stream().sorted().count();long end = System.nanoTime();System.out.println("串行毫秒數：" + TimeUnit.NANOSECONDS.toMillis(end - start));//692

Parallel Sort(并行排序)

long start1 = System.nanoTime();longcount1 = values.parallelStream().sorted().count();long end1 = System.nanoTime();System.out.println("并行毫秒數：" + TimeUnit.NANOSECONDS.toMillis(end1 - start1));//420

你能看到上述代碼基本相同的,但是并行大約一些.你可以測試著用 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); // val33map.computeIfPresent(9, (num, val) -> null); map.containsKey(9); // falsemap.computeIfAbsent(23, num -> "val" + num); map.containsKey(23); // truemap.computeIfAbsent(3, num -> "bam"); map.get(3); // val33

下一步,我們學習怎么給定一個key怎么移除對象操作, 現在加入給一個鍵值對:

map.remove(3, "val3"); map.get(3); // val33map.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); // val9map.merge(9, "concat", (value, newValue) -> value.concat(newValue)); map.get(9); // val9concat

合并操作如果鍵值對不存在就添加到里面, 合并操作也可以用來改變存在的值.

6. Date API(日期API)

Java 8 包含一個全新的日期和時間操作API在 java.time包里面. 新的Date API 可以和 Joda-Time 包相媲美, 不過，它們并不一樣. 下面給你實例一下新日期里面主要新的API.

6.1 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

6.2 Timezones(時區)

時區被ZoneId代替. 你可以很方便的訪問通過一個靜態的工廠方法. 時區定義一個彌補了一個重要在瞬時和本地時間和日期上的轉換.

System.out.println(ZoneId.getAvailableZoneIds()); // prints all available timezone idsZoneId 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]

6.3 LocalTime(本地時間)

本地時間代表一個不包含時區的時間, 例如. 10pm 或者 17:30:15. 下面兩個實例創建兩個本地時間包含上面定義的時區. 然后我們比較兩個時間和日歷在小時和分鐘的不同之處.

LocalTime now1 = LocalTime.now(zone1); LocalTime now2 = LocalTime.now(zone2);System.out.println(now1.isBefore(now2)); // falselong 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:59DateTimeFormatter 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

6.4 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); // WEDNESDAYMonth month = sylvester.getMonth(); System.out.println(month); // DECEMBERlong 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是不可修改的且線程安全的.

7. 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 2 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); // 2Hint[] 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 {}

總結

以上是生活随笔為你收集整理的Java8新特性解析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。