JDK版本迭代
近幾年JDK更新速度非?？?，2022年9月20號發(fā)布JDK19，作為Java語言的使用者，尤其是新入行和想要入行的朋友，不要被這么快的更新速度嚇到，更不要被販賣了焦慮，因為多數(shù)版本僅為過渡，如JDK19在2023年3月將會被JDK20替代，完全不必慌張，近幾年JDK更新如此頻繁，真正多的變化其實還在于JDK8之中。本文章為系列文章，后續(xù)內容持續(xù)推出！
從1996年1月JDK1.0正式發(fā)布到現(xiàn)在，目前有三個主流的長期支持【LTS】版本為JDK8、JDK11、JDK17，因為JDK11并沒有特別大的優(yōu)化更新，46.45%的企業(yè)還是使用2014年3月14號發(fā)布的JDK8，JDK17使用率僅在0.37%
JDK8重要更新
繼《??JDK8更新——官網(wǎng)原版詳解??》之后，本篇主要介紹一下JDK更新在編碼層面的重要變化，也就是我們一線程序員需要掌握的都有哪些，網(wǎng)絡上有許多教程，但恰恰是教程太多五花八門，不知所云，一個新特性懟六七個小時實屬浪費時間，學無涯生也有涯，很多玩意我們知道就行不需要去掌握，不要去浪費時間，結合實際工作，我總結了如下幾點：
- Lambda表達式：非常重要，一種新的編程語法，可簡化代碼，多數(shù)特性也基于該語法格式實現(xiàn)，Spring5源碼也大量使用Lambda表達式，現(xiàn)階段開發(fā)中大量使用
- 函數(shù)式接口：接口中僅包含一個抽象方法的接口，Lambda表達式需要借助函數(shù)式接口實現(xiàn)
- Stream流：新增對數(shù)據(jù)的流式操作，不存儲數(shù)據(jù)，僅用于數(shù)據(jù)計算，可以對集合、數(shù)組、文件等進行多重計算操作，開發(fā)簡單，速度快
- 接口增強：接口中可以提供默認方法
- 方法引用：可以直接引用已有Java類和對象的方法或構造器，結合Lambda表達式使編程更緊湊簡潔，減少冗余代碼
- 日期和時間類：全新日期時間API，設計合理，線程安全
- 引入Optional：用來解決空指針異常
小貼士：本篇文章主要講解Lambda表達式
Lambda表達式
Lambda表達式支持將一個方法【行為】當做參數(shù)傳遞，這種編程方式稱為【函數(shù)式編程】，這種編程方式最大的特點就是代碼緊湊，減少冗余代碼，讓編程邊的更加簡潔，而Java最大的弊端就在于代碼臃腫，在Python，Scala、JavaScript等語言中也都引入函數(shù)式編程，而Java通過Lambda表達式實現(xiàn)函數(shù)式編程勢在必行！
語法格式
Lembda表達式通過左側的參數(shù)，右側的表達式和中間的右箭頭組成：
// 有參有返回值
(parameter1,parameter12,...) -> {
expression;
...
return xxx;
}
// 無參有返回值
() -> {
expression;
...
return xxx;
}
// 有參無返回值
(parameter1,parameter12,...) -> {
expression;
...
}
// 無參無返回值
() -> {
expression;
...
}
實現(xiàn)原理
- Lambda表達式也并不是想用就用，必須依賴于函數(shù)式接口才可使用
- 函數(shù)式接口：即接口中只有一個抽象法的接口，在JDK8及以后版本都會使用 @FunctionalInterface注解修飾
- 類型推斷：Lambda表達式無需指定參數(shù)類型，程序依然可以編譯，Lambda表達式的類型依據(jù)上下文環(huán)境，由編譯器推斷出來參數(shù)類型，這就是類型推斷
重點掌握
- Lambda表達式實現(xiàn)前提
- 理解函數(shù)式接口
- Lambda表達式實現(xiàn)語法和案例
- Lambda表達式簡寫
- Lambda對集合、線程等的操作練習
無參實現(xiàn)
Lambda表達式實現(xiàn)需要依賴于函數(shù)式接口，JDK內置了一些函數(shù)式接口，使用Supplier來實現(xiàn)無參Lambda講解，至于函數(shù)式接口怎么自定義在后續(xù)單獨介紹，保證連貫性，在此不穿插函數(shù)式接口其他內容！
Supplier接口為JDK內置的供給型接口，特點為無參數(shù)但是有返回值，定義如下：
代碼：
package com.stt;
import java.util.function.Supplier;
/**
* 無參函數(shù)式接口
*/
public class NoArgsMain {
public static void main(String[] args) {
// 1、原始方式實現(xiàn)
Supplier<Integer> s1 = new Supplier<Integer>() {
@Override
public Integer get() {
return 1024;
}
};
// 通過get方法獲取返回值
System.out.println(s1.get());
// 2、通過Lambda表達是實現(xiàn)
Supplier<String> s2 = () -> {
return "Lambda實現(xiàn)";
};
// 通過get方法獲取返回值
System.out.println(s2.get());
}
}
簡化代碼：
如果Lambda表達式有返回值且代碼體只有一行代碼時，return和大括號可以省略不寫
// 1、簡化后代碼如下
public class NoArgsMain {
public static void main(String[] args) {
/*
1、函數(shù)體只有一行代碼，return可以省略
2、只有一行代碼大括號可以省略
*/
Supplier<String> s2 = () -> "Lambda實現(xiàn)";
// 通過get方法獲取返回值
System.out.println(s2.get());
}
}
// 2、如果有多行，則不可以省略
public class NoArgsMain {
public static void main(String[] args) {
// 通過Lambda表達是實現(xiàn)，因為函數(shù)體有其他代碼，不可省略return和大括號
Supplier<String> s2 = () -> {
System.out.println("我是Lambda表達式體");
return "Lambda實現(xiàn)";
};
// 通過get方法獲取返回值
System.out.println(s2.get());
}
}
有參實現(xiàn)
通過JDK內置Consumer接口實現(xiàn)，接收參數(shù)但沒有返回值，定義如下：
代碼實現(xiàn)：
package com.stt;
import java.util.function.Consumer;
public class HasArgsMain {
public static void main(String[] args){
// 1、原始實現(xiàn)
Consumer<Integer> consumer1 = new Consumer<Integer>() {
@Override
public void accept(Integer param){
// 沒有返回值
System.out.println("我是消費型接口，只進不出哦！" + param);
}
};
// 調用accpet方法消費數(shù)據(jù)
consumer1.accept(1024);
// 2、Lambda寫法，
Consumer<String> consumer2 = (str) -> {
System.out.println("我是Lambda消費型接口，" + str);
};
consumer2.accept("石添添");
}
}
簡化寫法：
public class HasArgsMain {
public static void main(String[] args) {
/*
1、如果只有一個參數(shù)則可以省略小括號
2、代碼體只有一行代碼則可以省略大括號
*/
Consumer<String> consumer2 = str -> System.out.println("我是Lambda消費型接口，" + str);
consumer2.accept("石添添");
}
}總結：
如果代碼體只有一行代碼，無論有無參數(shù)，大括號都可省略
如果有返回值，代碼體只有一行代碼則return可以省略
如果有且僅有一個參數(shù)，參數(shù)的小括號可以省略，沒有參數(shù)和有多個參數(shù)都不可省略、
有沒有那么一點點感覺，Lambda表達式簡化了代碼，讓編碼更加簡潔，接下來我們通過更多案例對比進一步理解和使用Lambda表達式
Lambda實現(xiàn)線程創(chuàng)建
通過Runnable接口創(chuàng)建線程，如果想使用Lambda那么Runnable應該是一個函數(shù)式接口，函數(shù)式接口的特點是只有一個抽象方法，Runnable接口定義如下：
代碼實現(xiàn)：
public class ThreadMain {
public static void main(String[] args) {
// 1、原始方式創(chuàng)建線程
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "線程啟動");
}
}).start();
// 2、使用Lambda表達式簡寫方式創(chuàng)建線程
new Thread(() -> System.out.println(Thread.currentThread().getName() + "線程啟動")).start();
}
}Lambda實現(xiàn)集合遍歷
集合操作新增forEach方法，接收一個Consumer類型對象，上邊【有參實現(xiàn)】中介紹了，它是一個函數(shù)式接口
代碼實現(xiàn)：
public class CollectionMain {
public static void main(String[] args){
// 創(chuàng)建集合
List<String> list = new ArrayList<>();
// 添加數(shù)據(jù)
list.add("艾斯！");
list.add("賽羅！");
list.add("杰克！");
list.add("雷歐！");
// 1、原始遍歷方式
list.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
// 2、因為Consumer是一個函數(shù)式接口，可以使用Lambad
// 思考：簡寫形式怎么實現(xiàn)呢？
list.forEach((str) -> {
System.out.println(str);
});
}
}Lambda實現(xiàn)集合排序
集合排序可以使用sort方法，sort方法接收一個Comparator類型數(shù)據(jù)
Comparator接口定義
小貼士：該接口中還有幾個默認實現(xiàn)方法和靜態(tài)方法，因為只有一個抽象方法所以也是函數(shù)式接口
代碼實現(xiàn)：
public class CollectionSortMain {
public static void main(String[] args) {
List<Person> personList = new ArrayList<>();
personList.add(new Person("李小白",24));
personList.add(new Person("張二三",21));
personList.add(new Person("王五六",30));
// 遍歷
System.out.println("排序前-------------------");
personList.forEach(person -> System.out.println(person));
// 排序，參數(shù)1 - 參數(shù)2為升序排序
System.out.println("排序后-------------------");
personList.sort(new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
return p1.getAge() - p2.getAge();
}
});
personList.forEach(person -> System.out.println(person));
// Lambda排序，參數(shù)2 - 參數(shù)1為降序排序
System.out.println("Lambda排序-------------------");
// 直接簡寫形式，只有一行代碼，大括號和return可以省略
personList.sort((p1,p2) -> p2.getAge() - p1.getAge());
personList.forEach(person -> System.out.println(person));
}
}總結
Lambda表達式簡化開發(fā)，使編碼變的簡潔。
Lambda表達式需要依賴函數(shù)式接口實現(xiàn)，一定情況下可以簡化寫法。
StreamAPI、方法引用等特性需要基于Lambda實現(xiàn)。
Lambda表達式剛開始可能不習慣，多些就好，一定要多用哦!
文章出自：??添甄??，如有轉載本文請聯(lián)系【添甄】今日頭條號。
