Lambda表達式詳解
1.Lambda簡介
Lambda 表達式是 JDK8 的一個新特性,可以取代大部分的匿名內部類,寫出更優雅的 Java 代碼,尤其在集合的遍歷和其他集合操作中,可以極大地優化代碼結構。
JDK 也提供了大量的內置函數式接口供我們使用,使得 Lambda 表達式的運用更加方便、高效。
package com.mage;
/**
* @param
* @author qzp
* @create 2020-03-23 0:05
*/
public class MyLambda {
public static void main(String[] args) {
//方式一實現
Person person= new Student();
int compare = person.compare(3, 2);
System.out.println(compare);
//方式二:匿名內部類
Person person1 = new Person() {
@Override
public int compare(int a, int b) {
return a-b;
}
};
System.out.println(person1.compare(5,4));
//方式三:Lambda
Person person2 =(a,b)-> a-b;
System.out.println(person2.compare(4,5));
}
}
//接口實現類
class Student implements Person{
@Override
public int compare(int a, int b) {
return a-b;
}
}
//接口
interface Person{
int compare(int a,int b);
}
2.Lambda對接口的要求
雖然使用 Lambda 表達式可以對某些接口進行簡單的實現,但並不是所有的接口都可以使用 Lambda 表達式來實現。Lambda 規定接口中只能有一個需要被實現的方法,不是規定接口中只能有一個方法
jdk 8 中有另一個新特性:default, 被 default 修飾的方法會有默認實現,不是必須被實現的方法,所以不影響 Lambda 表達式的使用。
@FunctionalInterface
修飾函數式接口的,要求接口中的抽象方法只有一個。 這個註解往往會和 lambda 表達式一起出現。
3.Lambda 基礎語法
我們這裏給出六個接口,後文的全部操作都利用這六個接口來進行闡述。
/**
* @param
* @author qzp
* @create 2020-03-23 9:03
*/
/**多參數無返回*/
@FunctionalInterface
public interface NoReturnMultiParam {
void method(int a, int b);
}
/**無參無返回值*/
@FunctionalInterface
public interface NoReturnNoParam {
void method();
}
/**一個參數無返回*/
@FunctionalInterface
public interface NoReturnOneParam {
void method(int a);
}
/**多個參數有返回值*/
@FunctionalInterface
public interface ReturnMultiParam {
int method(int a, int b);
}
/*** 無參有返回*/
@FunctionalInterface
public interface ReturnNoParam {
int method();
}
/**一個參數有返回值*/
@FunctionalInterface
public interface ReturnOneParam {
int method(int a);
}
語法形式爲 () -> {},其中 () 用來描述參數列表,{} 用來描述方法體,-> 爲 lambda運算符 ,讀作(goes to)。
import lambda.interfaces.*;
/**
* @param
* @author qzp
* @create 2020-03-23 9:03
*/
public class Test1 {
public static void main(String[] args) {
//無參無返回
NoReturnNoParam noReturnNoParam = () -> {
System.out.println("NoReturnNoParam");
};
noReturnNoParam.method();
//一個參數無返回
NoReturnOneParam noReturnOneParam = (int a) -> {
System.out.println("NoReturnOneParam param:" + a);
};
noReturnOneParam.method(6);
//多個參數無返回
NoReturnMultiParam noReturnMultiParam = (int a, int b) -> {
System.out.println("NoReturnMultiParam param:" + "{" + a +"," + + b +"}");
};
noReturnMultiParam.method(6, 8);
//無參有返回值
ReturnNoParam returnNoParam = () -> {
System.out.print("ReturnNoParam");
return 1;
};
int res = returnNoParam.method();
System.out.println("return:" + res);
//一個參數有返回值
ReturnOneParam returnOneParam = (int a) -> {
System.out.println("ReturnOneParam param:" + a);
return 1;
};
int res2 = returnOneParam.method(6);
System.out.println("return:" + res2);
//多個參數有返回值
ReturnMultiParam returnMultiParam = (int a, int b) -> {
System.out.println("ReturnMultiParam param:" + "{" + a + "," + b +"}");
return 1;
};
int res3 = returnMultiParam.method(6, 8);
System.out.println("return:" + res3);
}
}
5.Lambda 語法簡化
我們可以通過觀察以下代碼來完成代碼的進一步簡化,寫出更加優雅的代碼.
import lambda.interfaces.*;
/**
* @param
* @author qzp
* @create 2020-03-23 9:03
*/
public class Test2 {
public static void main(String[] args) {
//1.簡化參數類型,可以不寫參數類型,但是必須所有參數都不寫
NoReturnMultiParam lamdba1 = (a, b) -> {
System.out.println("簡化參數類型");
};
lamdba1.method(1, 2);
//2.簡化參數小括號,如果只有一個參數則可以省略參數小括號
NoReturnOneParam lambda2 = a -> {
System.out.println("簡化參數小括號");
};
lambda2.method(1);
//3.簡化方法體大括號,如果方法條只有一條語句,則可以省略方法體大括號
NoReturnNoParam lambda3 = () -> System.out.println("簡化方法體大括號");
lambda3.method();
//4.如果方法體只有一條語句,並且是 return 語句,則可以省略方法體大括號和return關鍵字
ReturnOneParam lambda4 = a -> a+3;
System.out.println(lambda4.method(5));
ReturnMultiParam lambda5 = (a, b) -> a+b;
System.out.println(lambda5.method(1, 1));
}
}
6.Lambda 表達式常用示例
- lambda 表達式引用方法
有時候我們不是必須要自己重寫某個匿名內部類的方法,我們可以可以利用 lambda表達式的接口快速指向一個已經被實現的方法。
語法
方法歸屬者::方法名 靜態方法的歸屬者爲類名,普通方法歸屬者爲對象
package com.mage;
/**
* @param
* @author qzp
* @create 2020-03-23 9:03
*/
//函數式接口
@FunctionalInterface
public interface ReturnOneParam {
public int method(int a);
}
package com.mage;
/**
* @param
* @author qzp
* @create 2020-03-23 9:02
*/
public class Exe {
public static void main(String[] args) {
//最原始的Lambda方式實現接口方法
ReturnOneParam lambda = a -> a*2;
System.out.println(lambda.method(3));
//方法的引用:可以快速的將一個Lambda的實現直接指向一個已經實現的方法(也就是被static修飾的方法)
ReturnOneParam lambda1 = a -> doubleNum(a);
System.out.println(lambda1.method(3));
//lambda2 引用了已經實現的 doubleNum 方法
ReturnOneParam lambda2 = Exe::doubleNum;
System.out.println(lambda2.method(3));
Exe exe = new Exe();
//lambda4 引用了已經實現的 addTwo 方法
ReturnOneParam lambda4 = exe::addTwo;
System.out.println(lambda4.method(2));
}
/**
* 要求
* 1.參數數量和類型要與接口中定義的一致
* 2.返回值類型要與接口中定義的一致
*/
public static int doubleNum(int a) {
return a * 2;
}
public int addTwo(int a) {
return a + 2;
}
}
- 構造方法的引用
一般我們需要聲明接口,該接口作爲對象的生成器,通過 類名::new 的方式來實例化對象,然後調用方法返回對象。
package com.mage;
/**
* @param
* @author qzp
* @create 2020-03-23 9:43
*/
public class Item {
private int id;
private String name;
private double price;
public Item() {
System.out.println("無參構造函數被調用");
}
public Item(int id, String name, double price) {
this.id = id;
this.name = name;
this.price = price;
System.out.println("有參構造函數被調用");
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Item{" +
"id=" + id +
", name='" + name + '\'' +
", price=" + price +
'}';
}
}
package com.mage;
/**
* @param
* @author qzp
* @create 2020-03-23 9:42
*/
interface ItemCreatorBlankConstruct {
Item getItem();
}
interface ItemCreatorParamContruct {
Item getItem(int id, String name, double price);
}
public class Exe2 {
public static void main(String[] args) {
ItemCreatorBlankConstruct creator = () -> new Item();
Item item = creator.getItem();
System.out.println(item);
ItemCreatorBlankConstruct creator2 = Item::new;
Item item2 = creator2.getItem();
System.out.println(item2);
ItemCreatorParamContruct creator3 = Item::new;
Item item3 = creator3.getItem(112, "鼠標", 135.99);
System.out.println(item3);
}
}
- lambda 表達式創建線程
我們以往都是通過創建 Thread 對象,然後通過匿名內部類重寫 run() 方法,一提到匿名內部類我們就應該想到可以使用 lambda 表達式來簡化線程的創建過程。
package com.mage.state;
/**
* @param
* @author qzp
* @create 2020-03-22 21:09
*/
public class Testyield1 {
public static void main(String[] args) {
new Thread(()->{
for (int i = 0; i < 100; i++) {
System.out.println("lanbda...."+i);
}
}).start();
for (int i = 0; i < 200; i++) {
System.out.println("main方法"+i);
if(i%3==0){
Thread.yield();
}
}
}
}
-
集合排序遍歷
對於某些集合排序,按照key遞增的方式排序,對於自定義的排序,需要實現接口Comparable,極大的不方便,而Lambda表達式可以很方便的解決這個問題,我們可以來如下代碼:
**方式一:**實現接口Compable
package com.map;
/**
* @param
* @author qzp
* @create 2020-03-22 16:45
*/
public class Emp implements Comparable<Emp>{
private Integer age;
private String name;
private double salery;
public Emp(Integer age, String name, double salery) {
this.age = age;
this.name = name;
this.salery = salery;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalery() {
return salery;
}
public void setSalery(double salery) {
this.salery = salery;
}
@Override
public String toString() {
return "Emp{" +
"age=" + age +
", name='" + name + '\'' +
", salery=" + salery +
'}';
}
//小於,返回-1;等於,返回0;大於,返回+1;
@Override
public int compareTo(Emp o) {
if(this.salery>o.salery){
return 1;
}else if(this.salery<o.salery){
return -1;
}else {
if(this.age>o.age){
return 1;
}else if(this.age<o.age){
return -1;
}else {
return 0;
}
}
}
}
package com.map;
import java.util.Map;
import java.util.TreeMap;
/**
* @param
* @author qzp
* @create 2020-03-22 16:43
*/
public class Test {
public static void main(String[] args) {
//Arraylist集合
List<Emp> emps1 = new ArrayList<>();
emps1.add(new Emp(25,"張三",10000));
emps1.add(new Emp(26,"qzp",10000));
emps1.add(new Emp(30,"李四",18000));
emps1.add(new Emp(35,"王二",20000));
//遍歷
for(Emp ss:emps1){
System.out.println(ss);
}
//TreeSet集合
//自定義主鍵,想要按照key遞增的方式排序,需要用比較器,實現接口Comparable<T>
Set<Emp> emps2 = new TreeSet<>();
emps2.add(new Emp(25,"張三",10000));
emps2.add(new Emp(26,"qzp",10000));
emps2.add(new Emp(30,"李四",18000));
emps2.add(new Emp(35,"王二",20000));
//遍歷
for(Emp ss:emps2){
System.out.println(ss);
}
//TreeMap集合
Map<Integer,String> treeMap1 = new TreeMap<>();
treeMap1.put(20,"aa");
treeMap1.put(30,"cc");
treeMap1.put(40,"dd");
//按照key遞增的方式排序
for(Integer key:treeMap1.keySet()){
System.out.println(key+"--->"+treeMap1.get(key));
}
//自定義主鍵,想要按照key遞增的方式排序,需要用比較器,實現接口Comparable<T>
Map<Emp, String> treeMap2 = new TreeMap<>();
treeMap2.put(new Emp(25,"張三",10000),"張三是一個好小夥");
treeMap2.put(new Emp(26,"qzp",10000),"qzp是一個好小夥");
treeMap2.put(new Emp(30,"李四",18000),"李四是一個積極向上小夥");
treeMap2.put(new Emp(35,"王二",20000),"王二是一個好項目經理");
for(Emp emp:treeMap2.keySet()){
System.out.println(emp);
}
}
}
方式二:Lambda表達式
package com.mage;
/**
* @param
* @author qzp
* @create 2020-03-22 17:46
*/
class Person1 {
private Integer age;
private String name;
private double salery;
public Person1(Integer age, String name, double salery) {
this.age = age;
this.name = name;
this.salery = salery;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalery() {
return salery;
}
public void setSalery(double salery) {
this.salery = salery;
}
@Override
public String toString() {
return "Person1{" +
"age=" + age +
", name='" + name + '\'' +
", salery=" + salery +
'}';
}
}
package com.mage;
import java.util.ArrayList;
/**
* @param
* @author qzp
* @create 2020-03-23 10:08
*/
public class Exe3 {
public static void main(String[] args) {
//ArrayList集合遍歷排序
ArrayList<Person1> list = new ArrayList<>();
list.add(new Person1(25,"張三",10000));
list.add(new Person1(26,"qzp",10000));
list.add(new Person1(30,"李四",18000));
list.add(new Person1(35,"王二",20000));
//降序(調用函數式接口Comparator<T>)
list.sort((o1, o2) -> o2.getAge() - o1.getAge());
System.out.println(list);
//TreeSet集合遍歷排序
TreeSet<Person1> treeSet = new TreeSet<>((o1, o2) -> {
if(o1.getSalery()>o2.getSalery()){
return 1;
}else if(o1.getSalery()<o2.getSalery()){
return -1;
}else {
if(o1.getAge()>o2.getAge()){
return 1;
}else if(o1.getAge()<o2.getAge()){
return -1;
}else {
return 0;
}
}
});
treeSet.add(new Person1(25,"張三",10000));
treeSet.add(new Person1(26,"qzp",10000));
treeSet.add(new Person1(30,"李四",18000));
treeSet.add(new Person1(35,"王二",20000));
System.out.println(treeSet);
}
}
- 遍歷集合
我們可以調用集合的 public void forEach(Consumer<? super E> action)
方法,通過 lambda 表達式的方式遍歷集合中的元素。以下是 Consumer 接口的方法以及遍歷集合的操作。Consumer 接口是 jdk 爲我們提供的一個函數式接口。
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
//....
}
package com.mage;
import java.util.ArrayList;
import java.util.Collections;
/**
* @param
* @author qzp
* @create 2020-03-23 12:13
*/
public class Exe4 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
//注意:Collections是一個工具類,不是接口
Collections.addAll(list, 1,2,3,4,5);
list.forEach(x -> {
System.out.println(x);
});
//lambda表達式 方法引用
list.forEach(System.out::println);
//添加條件輸出
list.forEach(element -> {
if (element % 2 == 0) {
System.out.println(element);
}
});
}
}
- 刪除集合中的某個元素
我們通過public boolean removeIf(Predicate<? super E> filter)
方法來刪除集合中的某個元素,Predicate 也是 jdk 爲我們提供的一個函數式接口,可以簡化程序的編寫。
ArrayList<Item> items = new ArrayList<>();
items.add(new Item(11, "小牙刷", 12.05 ));
items.add(new Item(5, "日本馬桶蓋", 999.05 ));
items.add(new Item(7, "格力空調", 888.88 ));
items.add(new Item(17, "肥皂", 2.00 ));
items.add(new Item(9, "冰箱", 4200.00 ));
items.removeIf(ele -> ele.getId() <7);
//通過 foreach 遍歷,查看是否已經刪除
items.forEach(System.out::println);
- 集合內元素的排序
在以前我們若要爲集合內的元素排序,就必須調用 sort 方法,傳入比較器匿名內部類重寫 compare 方法,我們現在可以使用 lambda 表達式來簡化代碼。
ArrayList<Item> list = new ArrayList<>();
list.add(new Item(13, "背心", 7.80));
list.add(new Item(11, "半袖", 37.80));
list.add(new Item(14, "風衣", 139.80));
list.add(new Item(12, "秋褲", 55.33));
/*
list.sort(new Comparator<Item>() {
@Override
public int compare(Item o1, Item o2) {
return o1.getId() - o2.getId();
}
});
*/
list.sort((o1, o2) -> o1.getId() - o2.getId());
System.out.println(list);
7.Lambda 表達式中的閉包問題
這個問題我們在匿名內部類中也會存在,如果我們把註釋放開會報錯,告訴我 num 值是被 final 修飾了,不能被改變。這裏我們雖然沒有標識 num 類型爲 final,但是在編譯期間虛擬機會幫我們加上 final 修飾關鍵字。
import java.util.function.Consumer;
/**
* @param
* @author qzp
* @create 2020-03-23 12:13
*/
public class Main {
public static void main(String[] args) {
int num = 10;
Consumer<String> consumer = ele -> {
System.out.println(num);
};
//num = num + 2;
consumer.accept("hello");
}
}