最簡單的Lambda入門教程
Lambda簡介
Lambda作為函數語言程式設計中的基礎部分,在其他程式語言(例如:Scala)中早就廣為使用,但在JAVA領域中發展較慢,直到java8,才開始支援Lambda。
拋開數學定義不看,直接來認識Lambda。Lambda表示式本質上是匿名方法,其底層還是通過invokedynamic指令來生成匿名類來實現。它提供了更為簡單的語法和寫作方式,允許你通過表示式來代替函式式介面。在一些人看來,Lambda就是可以讓你的程式碼變得更簡潔,完全可以不使用——這種看法當然沒問題,但重要的是lambda為Java帶來了閉包。得益於Lamdba對集合的支援,通過Lambda在多核處理器條件下對集合遍歷時的效能提高極大,另外我們可以以資料流的方式處理集合——這是非常有吸引力的。
Lambda語法
Lambda的語法極為簡單,類似如下結構:
(parameters) -> expression
或者
(parameters) -> { statements; }
Lambda表示式由三部分組成:
- paramaters:類似方法中的形參列表,這裡的引數是函式式接口裡的引數。這裡的引數型別可以明確的宣告也可不宣告而由JVM隱含的推斷1。另外當只有一個推斷型別時可以省略掉圓括號。
- ->:可理解為“被用於”的意思
- 方法體:可以是表示式也可以程式碼塊,是函式式接口裡方法的實現。程式碼塊可返回一個值或者什麼都不反回,這裡的程式碼塊塊等同於方法的方法體。如果是表示式,也可以返回一個值或者什麼都不反回。
我們通過以下幾個示例來做說明:
//示例1:不需要接受引數,直接返回10
()->10
//示例2:接受兩個int型別的引數,並返回這兩個引數相加的和
(int x,int y)->x+y;
//示例2:接受x,y兩個引數,該引數的型別由JVM根據上下文推斷出來,並返回兩個引數的和
(x,y)->x+y;
//示例3:接受一個字串,並將該字串列印到控制到,不反回結果
(String name)->System.out.println(name);
//示例4:接受一個推斷型別的引數name,並將該字串列印到控制檯
name->System.out.println(name);
//示例5:接受兩個String型別引數,並分別輸出,不反回
(String name,String sex)->{System.out.println(name);System.out.println(sex)}
//示例6:接受一個引數x,並返回該該引數的兩倍
x->2*x
Lambda用在哪裡
在[函式式介面][1]中我們知道Lambda表示式的目標型別是函式性介面——每一個Lambda都能通過一個特定的函式式介面與一個給定的型別進行匹配。因此一個Lambda表示式能被應用在與其目標型別匹配的任何地方,lambda表示式必須和函式式介面的抽象函式描述一樣的引數型別,它的返回型別也必須和抽象函式的返回型別相容,並且他能丟擲的異常也僅限於在函式的描述範圍中。
接下來,我們看一個自定義的函式式介面示例:
@FunctionalInterface
interface Converter<F, T>{
T convert(F from);
}
首先用傳統的方式來使用該介面:
Converter<String ,Integer> converter=new Converter<String, Integer>() {
@Override
public Integer convert(String from) {
return Integer.valueOf(from);
}
};
Integer result = converter.convert("200");
System.out.println(result);
很顯然這沒任何問題,那麼接下里就是Lambda上場的時刻,用Lambda實現Converter介面:
Converter<String ,Integer> converter=(param) -> Integer.valueOf(param);
Integer result = converter.convert("101");
System.out.println(result);
通過上例,我想你已經對Lambda的使用有了個簡單的認識,下面,我們在用一個常用的Runnable做演示:
在以前我們可能會寫下這種程式碼:
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello lambda");
}
}).start();
在某些情況下,大量的匿名類會讓程式碼顯得雜亂無章。現在可以用Lambda來使它變得簡潔:
new Thread(() -> System.out.println("hello lambda")).start();
方法引用
方法引用是Lambda表示式的一個簡化寫法。所引用的方法其實是Lambda表示式的方法體的實現,其語法結構為:
ObjectRef::methodName
左邊可以是類名或者例項名,中間是方法引用符號”::”,右邊是相應的方法名。方法引用被分為三類:
1. 靜態方法引用
在某些情況下,我們可能寫出這樣的程式碼:
public class ReferenceTest {
public static void main(String[] args) {
Converter<String ,Integer> converter=new Converter<String, Integer>() {
@Override
public Integer convert(String from) {
return ReferenceTest.String2Int(from);
}
};
converter.convert("120");
}
@FunctionalInterface
interface Converter<F,T>{
T convert(F from);
}
static int String2Int(String from) {
return Integer.valueOf(from);
}
}
這時候如果用靜態引用會使的程式碼更加簡潔:
Converter<String, Integer> converter = ReferenceTest::String2Int;
converter.convert("120");
2. 例項方法引用
我們也可能會寫下這樣的程式碼:
public class ReferenceTest {
public static void main(String[] args) {
Converter<String, Integer> converter = new Converter<String, Integer>() {
@Override
public Integer convert(String from) {
return new Helper().String2Int(from);
}
};
converter.convert("120");
}
@FunctionalInterface
interface Converter<F, T> {
T convert(F from);
}
static class Helper {
public int String2Int(String from) {
return Integer.valueOf(from);
}
}
}
同樣用例項方法引用會顯得更加簡潔:
Helper helper = new Helper();
Converter<String, Integer> converter = helper::String2Int;
converter.convert("120");
3. 構造方法引用
現在我們來演示構造方法的引用。首先我們定義一個父類Animal:
class Animal{
private String name;
private int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void behavior(){
}
}
接下來,我們在定義兩個Animal的子類:Dog、Bird
public class Bird extends Animal {
public Bird(String name, int age) {
super(name, age);
}
@Override
public void behavior() {
System.out.println("fly");
}
}
class Dog extends Animal {
public Dog(String name, int age) {
super(name, age);
}
@Override
public void behavior() {
System.out.println("run");
}
}
隨後我們定義工廠介面:
interface Factory<T extends Animal> {
T create(String name, int age);
}
接下來我們還是用傳統的方法來建立Dog類和Bird類的物件:
Factory factory=new Factory() {
@Override
public Animal create(String name, int age) {
return new Dog(name,age);
}
};
factory.create("alias", 3);
factory=new Factory() {
@Override
public Animal create(String name, int age) {
return new Bird(name,age);
}
};
factory.create("smook", 2);
僅僅為了建立兩個物件就寫了十多號程式碼,現在我們用建構函式引用試試:
Factory<Animal> dogFactory =Dog::new;
Animal dog = dogFactory.create("alias", 4);
Factory<Bird> birdFactory = Bird::new;
Bird bird = birdFactory.create("smook", 3);
這樣程式碼就顯得乾淨利落了。通過Dog::new這種方式來穿件物件時,Factory.create函式的簽名選擇相應的造函式。
Lambda的域以及訪問限制
域即作用域,Lambda表示式中的引數列表中的引數在該Lambda表示式範圍內(域)有效。在作用Lambda表示式內,可以訪問外部的變數:區域性變數、類變數和靜態變數,但操作受限程度不一。
訪問區域性變數
在Lambda表示式外部的區域性變數會被JVM隱式的編譯成final型別,因此只能訪問外而不能修改。
public class ReferenceTest {
public static void main(String[] args) {
int n = 3;
Calculate calculate = param -> {
//n=10; 編譯錯誤
return n + param;
};
calculate.calculate(10);
}
@FunctionalInterface
interface Calculate {
int calculate(int value);
}
}
訪問靜態變數和成員變數
在Lambda表示式內部,對靜態變數和成員變數可讀可寫。
public class ReferenceTest {
public int count = 1;
public static int num = 2;
public void test() {
Calculate calculate = param -> {
num = 10;//修改靜態變數
count = 3;//修改成員變數
return n + param;
};
calculate.calculate(10);
}
public static void main(String[] args) {
}
@FunctionalInterface
interface Calculate {
int calculate(int value);
}
}
Lambda不能訪問函式介面的預設方法
java8增強了介面,其中包括介面可新增default關鍵詞定義的預設方法,這裡我們需要注意,Lambda表示式內部不支援訪問預設方法。
Lambda實踐
在[函式式介面][2]一節中,我們提到java.util.function包中內建許多函式式介面,現在將對常用的函式式介面做說明。
Predicate介面
輸入一個引數,並返回一個
Boolean值,其中內建許多用於邏輯判斷的預設方法:
@Test
public void predicateTest() {
Predicate<String> predicate = (s) -> s.length() > 0;
boolean test = predicate.test("test");
System.out.println("字串長度大於0:" + test);
test = predicate.test("");
System.out.println("字串長度大於0:" + test);
test = predicate.negate().test("");
System.out.println("字串長度小於0:" + test);
Predicate<Object> pre = Objects::nonNull;
Object ob = null;
test = pre.test(ob);
System.out.println("物件不為空:" + test);
ob = new Object();
test = pre.test(ob);
System.out.println("物件不為空:" + test);
}
Function介面
接收一個引數,返回單一的結果,預設的方法(andThen)可將多個函式串在一起,形成複合Funtion(有輸入,有輸出)
結果,
@Test
public void functionTest() {
Function<String, Integer> toInteger = Integer::valueOf;
//toInteger的執行結果作為第二個backToString的輸入
Function<String, String> backToString = toInteger.andThen(String::valueOf);
String result = backToString.apply("1234");
System.out.println(result);
Function<Integer, Integer> add = (i) -> {
System.out.println("frist input:" + i);
return i * 2;
};
Function<Integer, Integer> zero = add.andThen((i) -> {
System.out.println("second input:" + i);
return i * 0;
});
Integer res = zero.apply(8);
System.out.println(res);
}
Supplier介面
返回一個給定型別的結果,與Function不同的是,Supplier不需要接受引數(供應者,有輸出無輸入)
@Test
public void supplierTest() {
Supplier<String> supplier = () -> "special type value";
String s = supplier.get();
System.out.println(s);
}
Consumer介面
代表了在單一的輸入引數上需要進行的操作。和Function不同的是,Consumer沒有返回值(消費者,有輸入,無輸出)
@Test
public void consumerTest() {
Consumer<Integer> add5 = (p) -> {
System.out.println("old value:" + p);
p = p + 5;
System.out.println("new value:" + p);
};
add5.accept(10);
}
以上四個介面的用法代表了java.util.function包中四種類型,理解這四個函式式介面之後,其他的介面也就容易理解了,現在我們來做一下簡單的總結:
Predicate用來邏輯判斷,Function用在有輸入有輸出的地方,Supplier用在無輸入,有輸出的地方,而Consumer用在有輸入,無輸出的地方。你大可通過其名稱的含義來獲知其使用場景。
Stream
Lambda為java8帶了閉包,這一特性在集合操作中尤為重要:java8中支援對集合物件的stream進行函式式操作,此外,stream api也被整合進了collection api,允許對集合物件進行批量操作。
下面我們來認識Stream。
Stream表示資料流,它沒有資料結構,本身也不儲存元素,其操作也不會改變源Stream,而是生成新Stream.作為一種操作資料的介面,它提供了過濾、排序、對映、規約等多種操作方法,這些方法按照返回型別被分為兩類:凡是返回Stream型別的方法,稱之為中間方法(中間操作),其餘的都是完結方法(完結操作)。完結方法返回一個某種型別的值,而中間方法則返回新的Stream。中間方法的呼叫通常是鏈式的,該過程會形成一個管道,當完結方法被呼叫時會導致立即從管道中消費值,這裡我們要記住:Stream的操作儘可能以“延遲”的方式執行,也就是我們常說的“懶操作”,這樣有助於減少資源佔用,提高效能。對於所有的中間操作(除sorted外)都是執行在延遲模式下。
Stream不但提供了強大的資料操作能力,更重要的是Stream既支援序列也支援並行,並行使得Stream在多核處理器上有著更好的效能。
Stream的使用過程有著固定的模式:
- 建立Stream
- 通過中間操作,對原始Stream進行“變化”並生成新的Stream
- 使用完結操作,生成最終結果
也就是
建立——>變化——>完結
Stream的建立
對於集合來說,可以通過呼叫集合的stream()或者parallelStream()來建立,另外這兩個方法也在Collection介面中實現了。對於陣列來說,可以通過Stream的靜態方法of(T … values)來建立,另外,Arrays也提供了有關stream的支援。
除了以上基於集合或者陣列來建立Stream,也可以通過Steam.empty()建立空的Stream,或者利用Stream的generate()來建立無窮的Stream。
下面我們以序列Stream為例,分別說明Stream幾種常用的中間方法和完結方法。首先建立一個List集合:
List<String> lists=new ArrayList<String >();
lists.add("a1");
lists.add("a2");
lists.add("b1");
lists.add("b2");
lists.add("b3");
lists.add("o1");
中間方法
過濾器(Filter)
結合Predicate介面,Filter對流物件中的所有元素進行過濾,該操作是一箇中間操作,這意味著你可以在操作返回結果的基礎上進行其他操作。
public static void streamFilterTest() {
lists.stream().filter((s -> s.startsWith("a"))).forEach(System.out::println);
//等價於以上操作
Predicate<String> predicate = (s) -> s.startsWith("a");
lists.stream().filter(predicate).forEach(System.out::println);
//連續過濾
Predicate<String> predicate1 = (s -> s.endsWith("1"));
lists.stream().filter(predicate).filter(predicate1).forEach(System.out::println);
}
排序(Sorted)
結合Comparator介面,該操作返回一個排序過後的流的檢視,原始流的順序不會改變。通過Comparator來指定排序規則,預設是按照自然順序排序。
public static void streamSortedTest() {
System.out.println("預設Comparator");
lists.stream().sorted().filter((s -> s.startsWith("a"))).forEach(System.out::println);
System.out.println("自定義Comparator");
lists.stream().sorted((p1, p2) -> p2.compareTo(p1)).filter((s -> s.startsWith("a"))).forEach(System.out::println);
}
對映(Map)
結合Function介面,該操作能將流物件中的每個元素對映為另一種元素,實現元素型別的轉換。
public static void streamMapTest() {
lists.stream().map(String::toUpperCase).sorted((a, b) -> b.compareTo(a)).forEach(System.out::println);
System.out.println("自定義對映規則");
Function<String, String> function = (p) -> {
return p + ".txt";
};
lists.stream().map(String::toUpperCase).map(function).sorted((a, b) -> b.compareTo(a)).forEach(System.out::println);
}
在上面簡單介紹了三種常用的操作,這三種操作極大簡化了集合的處理。接下來,介紹幾種完結方法:
完結方法
“變換”過程之後,需要獲取結果,即完成操作。下面我們來看相關的操作:
匹配(Match)
用來判斷某個predicate是否和流物件相匹配,最終返回Boolean型別結果,例如:
public static void streamMatchTest() {
//流物件中只要有一個元素匹配就返回true
boolean anyStartWithA = lists.stream().anyMatch((s -> s.startsWith("a")));
System.out.println(anyStartWithA);
//流物件中每個元素都匹配就返回true
boolean allStartWithA
= lists.stream().allMatch((s -> s.startsWith("a")));
System.out.println(allStartWithA);
}
收集(Collect)
在對經過變換之後,我們將變換的Stream的元素收集,比如將這些元素存至集合中,此時便可以使用Stream提供的collect方法,例如:
public static void streamCollectTest() {
List<String> list = lists.stream().filter((p) -> p.startsWith("a")).sorted().collect(Collectors.toList());
System.out.println(list);
}
計數(Count)
類似sql的count,用來統計流中元素的總數,例如:
public static void streamCountTest() {
long count = lists.stream().filter((s -> s.startsWith("a"))).count();
System.out.println(count);
}
規約(Reduce)
reduce方法允許我們用自己的方式去計算元素或者將一個Stream中的元素以某種規律關聯,例如:
public static void streamReduceTest() {
Optional<String> optional = lists.stream().sorted().reduce((s1, s2) -> {
System.out.println(s1 + "|" + s2);
return s1 + "|" + s2;
});
}
執行結果如下:
a1|a2
a1|a2|b1
a1|a2|b1|b2
a1|a2|b1|b2|b3
a1|a2|b1|b2|b3|o1
並行Stream VS 序列Stream
到目前我們已經將常用的中間操作和完結操作介紹完了。當然所有的的示例都是基於序列Stream。接下來介紹重點戲——並行Stream(parallel Stream)。並行Stream基於Fork-join並行分解框架實現,將大資料集合切分為多個小資料結合交給不同的執行緒去處理,這樣在多核處理情況下,效能會得到很大的提高。這和MapReduce的設計理念一致:大任務化小,小任務再分配到不同的機器執行。只不過這裡的小任務是交給不同的處理器。
通過parallelStream()建立並行Stream。為了驗證並行Stream是否真的能提高效能,我們執行以下測試程式碼:
首先建立一個較大的集合:
List<String> bigLists = new ArrayList<>();
for (int i = 0; i < 10000000; i++) {
UUID uuid = UUID.randomUUID();
bigLists.add(uuid.toString());
}
測試序列流下排序所用的時間:
private static void notParallelStreamSortedTest(List<String> bigLists) {
long startTime = System.nanoTime();
long count = bigLists.stream().sorted().count();
long endTime = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
System.out.println(System.out.printf("序列排序: %d ms", millis));
}
測試並行流下排序所用的時間:
private static void parallelStreamSortedTest(List<String> bigLists) {
long startTime = System.nanoTime();
long count = bigLists.parallelStream().sorted().count();
long endTime = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
System.out.println(System.out.printf("並行排序: %d ms", millis));
}
結果如下:
序列排序: 13336 ms
並行排序: 6755 ms
看到這裡,我們確實發現效能提高了約麼50%,你也可能會想以後都用parallel Stream不久行了麼?實則不然,如果你現在還是單核處理器,而資料量又不算很大的情況下,序列流仍然是這種不錯的選擇。你也會發現在某些情況,序列流的效能反而更好,至於具體的使用,需要你根據實際場景先測試後再決定。
懶操作
上面我們談到Stream儘可能以延遲的方式執行,這裡通過建立一個無窮大的Stream來說明:
首先通過Stream的generate方法來一個自然數序列,然後通過map變換Stream:
//遞增序列
class NatureSeq implements Supplier<Long> {
long value = 0;
@Override
public Long get() {
value++;
return value;
}
}
public void streamCreateTest() {
Stream<Long> stream = Stream.generate(new NatureSeq());
System.out.println("元素個數:"+stream.map((param) -> {
return param;
}).limit(1000).count());
}
執行結果為:
元素個數:1000
我們發現開始時對這個無窮大的Stream做任何中間操作(如:filter,map等,但sorted不行)都是可以的,也就是對Stream進行中間操作並生存一個新的Stream的過程並非立刻生效的(不然此例中的map操作會永遠的執行下去,被阻塞住),當遇到完結方法時stream才開始計算。通過limit()方法,把這個無窮的Stream轉為有窮的Stream。