JAVA 8 新特性實用總JAVA 8 新特性實用總結
JAVA 8 新特性實用總結
作為一個工作兩年多的 老 程序猿，雖然一開始就使用 jdk1.8 作為學習和使用的版本，隨著技術的迭代，現有的 JDK 版本從兩年前到現在，已經飛速發(fā)展到了 JDK 15 。真的感覺有點學不動了，更新速度太快了，不過相比于現有系統(tǒng)以及國內趨勢。大多公司還是采用最基礎的 1.8 作為線上環(huán)境來使用。也是沒有任何問題的，不過我們真的 會使用 JAVA8 嗎？
https://www.oracle.com/java/technologies/java-se-glance.html
新特性概述
本小結主要從 Lambda 表達式入手，由淺入深，按照實用性作為排行，逐步講解新特性帶給開發(fā)人員的快樂，如何更好的簡化代碼，優(yōu)化可讀性。這才是我們學習總結這一小節(jié)的一個目的。
你會使用遍歷循環(huán)？
從最基礎的循環(huán)開始，循環(huán)無非是我們剛學習的時候就需要接觸 for 這個最基本的循環(huán)結構，而且在后面的工作總都會大量使用的一個結構，如何更好的簡化它呢？
- // 建立測試集合
- List<Integer> list = Arrays.asList(1, 2, 2, 3, 4, 5, 5, 6);
- // 基礎循環(huán)
- System.out.println("----------------------------1 基礎循環(huán)");
- for (int i = 0; i < list.size(); i++) {
- System.out.println(list.get(i));
- }
- // 語法糖方式
- System.out.println("----------------------------2 迭代器語法糖");
- for (Integer i : list) {
- System.out.println(i);
- }
- // lambda 表達式簡寫
- System.out.println("----------------------------3 lambda");
- list.forEach(item -> System.out.println(item));
- // 使用lambda 方法引用
- System.out.println("----------------------------4 lambda");
- list.forEach(System.out::println);
- // 以下為編譯后語法糖的代碼
- Iterator var4 = list.iterator();
- while(var4.hasNext()) {
- Integer i = (Integer)var4.next();
- System.out.println(i);
- }
從上面的代碼我們可以看出，隨著 lambda 方式的引入，代碼變得越來越簡化，而且更加容易讀懂，寫的東西也越來越少，
- 第一種方式則是我們常規(guī)的操作方式，一般適用于需要
下標邏輯的業(yè)務中。 - 第二種則是迭代器語法糖，對于開發(fā)者而言寫起來便捷，不過對于代碼的編譯而言，編譯后的代碼任是迭代器的方式，只不過語法簡單了。
- lambda 則是一種函數式的表達方式，item 作為我們循環(huán)的參數，而箭頭后則是我們需要執(zhí)行的代碼塊，一句代碼完全不必使用
{} - lambda
方法引用則是一種全新的方式，引用二字經常被我們使用，一般在對象的引用處有表達的含義，簡而言之就是一個值可以從一個地方引用過來使用，但是現在，方法完全可以被看做一個值一樣，也可以隨意拿過來使用~
forEach
可能朋友們就會有疑惑，為什么 forEach 的地方就可以使用 lambda 表達式呢，其他地方怎么不行？我們來看看源碼
- default void forEach(Consumer<? super T> action) {
- Objects.requireNonNull(action);
- for (T t : this) {
- action.accept(t);
- }
- }
我們發(fā)現 Consumer 是一個接口，內部仍然使用 for語法糖 形式來執(zhí)行集合，調用了 accept 方法。
Consumer
消費者接口，適用于入參處理，無返回值
- @FunctionalInterface
- public interface Consumer<T> {
- void accept(T t);
發(fā)現這個接口和其他接口唯一的不同點就是 @FunctionalInterface
其實這個注解就是來告訴編譯器，這個接口下的 accept 方法可以使用函數式寫法來描述。有了這個注解的定義，我們就可以愉快的使用函數式lambda 表達式了。
消費者接口 作為JDK 自帶的函數式接口，所處于 java.util.function 包下，并且支持鏈式操作，
接受一個指定的泛型，內部處理后，無返回值
- // 無返回的處理
- Consumer<String> custom = (str) -> System.out.println("first" + str);
- Consumer<String> desc = custom.andThen((str) -> System.out.println("second" + str));
- desc.accept("hello");
- --------------------------
- firsthello
- secondhello
稍稍總結一下lambda 的基礎語法：
（參數）-> 一行執(zhí)行代碼
（參數）-> {多行執(zhí)行代碼}
單個參數完全可以省略參數的括號。
default
默認實現，子類無需重寫接口定義的關鍵詞
上面的Consumer使用中，我們發(fā)現，有一個默認實現的接口，順便來說明一下
- default Consumer<T> andThen(Consumer<? super T> after) {
- Objects.requireNonNull(after);
- return (T t) -> { accept(t); after.accept(t); };
- }
default 提供默認的實現方式，實現類無需重寫這個方法的定義，而可以直接使用。
方法引用
把方法也可以作為值一樣來引用使用。
- // 使用lambda 方法引用
- System.out.println("----------------------------4 lambda");
- list.forEach(System.out::println);
博主這里的理解是：引用的方法需要與定義處： default void forEach(Consumer<? super T> action)
所需要的lambda 表達式具有相同的入參個數與返回類型，才可以引用。
例如： Consumer 接口接受的lambda 形式為： item -> System.out.println(item)
而我們引用的 System.out::println 剛好具備這樣的形式。
- public void println(Object x) {
- String s = String.valueOf(x);
- synchronized (this) {
- print(s);
- newLine();
- }
- }
優(yōu)雅判空
我們都知道，JAVA 里面最討厭的一個異常就是 NPE=NullPointerException 空指針異常，為了避免空指針異常，我們經常不少使用 if 作為判斷，這樣的判斷多了就容易讓人看著惱火。例如如下代碼：
- Person person = new Person("test", 1);
- if (person != null) {
- if (person.getName() != null) {
- System.out.println("123" + person.getName());
- } else {
- // do something
- }
- } else {
- // do something
- }
假設我們有一個 person 對象，首先判斷它是否為空，如果不為空，則取值，而后再獲取 name 成員變量，不為空則拼接打印。這樣兩層判斷的邏輯在代碼里經常會見到，學習了 Optional 以后，我們的以上邏輯就可以修改為如下：
- // 最佳實踐
- Optional.ofNullable(person).map(p -> p.getName()).map(string -> string.concat("123")).ifPresent(System.out::println);
Function
入參并返回一個指定類型，可以理解為轉換。
首先發(fā)現 map 接受一個 Function<? super T, ? extends U> mapper ,具體如何使用Function
- @FunctionalInterface
- public interface Function<T, R> {
- R apply(T t);
- // 鏈式轉換
- Function<String,Integer> stringToInteger = Integer::valueOf;
- // andThen 將前一個處理的返回值作為后一個處理的入參
- Function<String,String> integerToString = stringToInteger.andThen(Integer::toHexString);
- String hex = integerToString.apply("123");
- System.out.println(hex);// 7b
Optional
優(yōu)雅判斷空，并且執(zhí)行對應操作
Optional 對于 NPE 有著很好的解決方式，可以解決我們多重if 的優(yōu)化，不僅美觀，而且非常優(yōu)雅。
- // 如果person 為null 則觸發(fā)異常
- Optional.of(person);
- // 如果person1 為 null 則返回empty
- Optional.ofNullable(person1);
以上是創(chuàng)建實例的兩種方式，一般常用第二種，第一種如果有 null 的情況則會觸發(fā) NPE 到頭來還是沒有處理掉這個異常，所以不建議使用。
- private Optional() {
- this.value = null;
- }
- isPresent(): 如果不為空則返回true。
- get(): 獲取當前包含的值，若是value=null 則拋出NPE
- orElse(T other): 如果當前實例包含值為null,則返回other;
- ifPresent(Consumer<? super T> consumer): 若當前實例不為空，則執(zhí)行這個消費者consumer,否則返回EMPTY
Stream
stream 作為 JAVA8 最核心的內容，融匯貫通的掌握其精髓，對開發(fā)者而言，無非是一把打開新世界大門的鑰匙。從宏觀的角度來講，一個語言處理最多的就是數據的集合，比如 List<?>
filter
過濾器，過濾出你想要的集合元素。
- List<Integer> list = Arrays.asList(1, 2, 3, 3, 4, 5, 5, 6);
- // 篩選偶數
- long num = list.stream().filter(item -> item % 2 == 0).count(); // 3
這里通過簡單的篩選，篩選的條件是偶數，并且最終統(tǒng)計它的個數。
這里的 filter 接受一個 filter(Predicate<? super T> predicate)
count 簡而言之了，就是統(tǒng)計前方表達式所產生的新集合個數。
Predicate
斷言，也是一個函數式接口，可以使用lambda 表達式。
- @FunctionalInterface
- public interface Predicate<T> {
- boolean test(T t);
Predicate 主要實現其 test 接口，通過邏輯執(zhí)行，返回一個 boolean 來判斷當前元素是否可用。
- // 斷言字符串長度大于0
- Predicate<String> stringEmpty = (str) -> str.length() > 0;
- Predicate<String> startHello = (str) -> str.startsWith("hello");
- System.out.println("test 空字符=" + stringEmpty.test(""));
- System.out.println("test hello=" + stringEmpty.test("hello"));
- // and 合并兩個檢驗接口，同時滿足即可 or 只要有一個滿足即可
- System.out.println("test and hello world=" + stringEmpty.and(startHello).test("hello world"));
- System.out.println("test or world=" + stringEmpty.or(startHello).test("world"));
- ----------------------
- test 空字符=false
- test hello=true
- test and hello world=true
- test or world=true
map
map 可以理解為映射，處理每個元素，并且返回任何類型。支持鏈式map,
上層map的返回值作為下層map的參數值。
- List<Person> people = Arrays.asList(new Person("hello", 1), new Person("world", 2));
- // 將每一個元素的name 組裝成一個新的集合。
- List<String> names = people.stream().map(item -> item.getName()).collect(Collectors.toList());
- System.out.println(names);
- // 多重map處理
- List<String> concat = people.stream().map(item -> item.getName()).map(name -> name.concat("-concat")).collect(Collectors.toList());
- System.out.println(concat);
- -------------------
- [hello, world]
- [hello-concat, world-concat]
map 接受一個 map(Function<? super T, ? extends R> mapper) 我們上面已經討論過這個了。
sorted
對元素進行排序，可以使用默認，也可以自定義排序規(guī)則。
- List<String> sortedList = Arrays.asList("acc", "dee", "zdd", "wee", "abb", "ccd");
- // 默認排序，字典順序，第一個字母相同，則比較第二個
- List<String> sorted = sortedList.stream().sorted().collect(Collectors.toList());
- System.out.println(sorted);
- // 自定義實現，只比較第一個字符
- List<String> sorted2 = sortedList.stream().sorted((str1, str2) -> str1.charAt(1) - str2.charAt(1)).collect(Collectors.toList());
- System.out.println(sorted2);
- ---------------------------
- [abb, acc, ccd, dee, wee, zdd]
- // 可以發(fā)現自定義的排序沒有比較第二個字母
- [acc, abb, ccd, dee, wee, zdd]
我們發(fā)現 sorted 接受一個 Comparator<? super T> comparator
Comparator
比較器，也是函數式接口，不必多說，自然可以使用lambda
- @FunctionalInterface
- public interface Comparator<T> {
- int compare(T o1, T o2);
- Comparator<String> comparator = (str1, str2) -> str1.charAt(0) - str2.charAt(0);
- // 自定義比較第一位字母
- int a = comparator.compare("abb", "acc");
- System.out.println(a);
- // 再次比較，如果第一個返回0，則直接返回結果，否則進行二次比較
- int b = comparator.thenComparing((str1, str2) -> str1.charAt(1) - str2.charAt(1)).compare("abb", "acc");
- System.out.println(b);
- ------------------------------
- 0
- -1
比較器返回一個int 值，這個int 則表示兩個元素的排列順序，按照 ASCII表 指示的值大小，如果兩個元素的差值 a-b>0 則 a在前，b在后
allMatch/anyMatch
同樣，Match 用來處理當前序列中，全部滿足、或者部分滿足，返回一個布爾值
- List<String> sortedList = Arrays.asList("acc", "dee", "zdd", "wee", "abb", "ccd");
- // 所有的元素都斷言通過，就返回true,否則false
- boolean startWithA = sortedList.stream().allMatch(str -> str.startsWith("a"));
- System.out.println(startWithA);
- // 只要有一個滿足就返回true
- boolean hasA = sortedList.stream().anyMatch(str -> str.startsWith("a"));
- System.out.println(hasA);
- ------------------------
- false
- true
以上就是 stream 常用的一些總結，總結了一些非常常用的，未總結到的內容下期補充。
其他
這里提一下局部變量final 語義。
自定義函數式接口
模仿以上的任意一個函數接口，我們可以寫出這樣的一個轉換接口，將指定類型轉換為指定類型
- @FunctionalInterface
- public interface FunctionInterface<A, R> {
- R cover(A t);
- }
通過自定義函數接口，我們可以寫出如下代碼，來進行轉換，不過涉及到一些參數的改變。
- // num 局部變量如果在lambda 中使用，則隱式含有final 語義
- final int num = 1;
- FunctionInterface<String, Integer> function4 = (val) -> Integer.valueOf(val + num);
- Integer result4 = function4.cover("12");
- // num = 2; // 這里不能改變，修改則不能通過編譯
