目录
一、Lambda 表达式的基础语法
- 一、Lambda 表达式的基础语法
- 二、使用Lambda 表达式的注意事项
- 三、函数式接口的理解
- 四、Lambda 表达式的基础语法示例
- 1、基础语法一:无参数,无返回值
- 2、基础语法二:有一个参数,并且无返回值
- 3、基础语法三:有一个参数,并且无返回值(若只有一个参数,小括号可以省略不写)
- 4、基础语法四:有两个以上的参数,有返回值,并且 Lambda 体中有多条语句
- 5、基础语法五:若 Lambda 体中只有一条语句, return 和 大括号都可以省略不写
- 6、基础语法六: Lambda 表达式的参数列表的数据类型可以省略不写
- 五、Lambda 表达式的基础练习
- 六、Lambda 表达式的总结
- Java8中引入了一个新的操作符 “->”, 该操作符称为箭头操作符或 Lambda 操作符。
- 箭头操作符将 Lambda 表达式拆分成两部分:
- 左侧:Lambda 表达式的参数列表。
- 右侧:Lambda 表达式中所需执行的功能, 即 Lambda 体。
- Lambda 表达式需要“函数式接口”的支持。
1、理解
- 接口中只有一个抽象方法的接口,称为 函数式接口。
- 可以使用注解 @FunctionalInterface 修饰,可以检查是否是函数式接口。
2、例如:Runnable接口就是一个函数式接口
3、例如:Consumer接口就是一个函数式接口
4、例如:Comparator接口就是一个函数式接口
-
示例代码如下:
package com.xz.springboot_java8.day2; /** * @description: Lambda 表达式的基础语法一:无参数,无返回值 * @author: xz * @create: 2021-08-24 20:04 */ public class Test1 { public static void main(String[] args) { generalMethod(); System.out.println("=============="); lambdaMethod(); } //匿名内部类方式 public static void generalMethod(){ Runnable r=new Runnable() { @Override public void run() { System.out.println("Hello World!"); } }; r.run(); } //lambda表达式方式(无参数,无返回值格式) public static void lambdaMethod(){ Runnable r=()-> System.out.println("Hello Lambda!"); r.run(); } }
-
输出结果如下:
-
示例代码如下:
package com.xz.springboot_java8.day2; import java.util.function.Consumer; /** * @description: Lambda 表达式的基础语法二:有一个参数,并且无返回值 * @author: xz * @create: 2021-08-24 20:15 */ public class Test2 { public static void main(String[] args) { generalMethod(); System.out.println("--------"); lambdaMethod(); } //匿名内部类方式(有一个参数,并且无返回值) public static void generalMethod(){ Consumer consumer= new Consumer() { @Override public void accept(String str) { System.out.println(str); } }; consumer.accept("Hello World!"); } //lambda表达式方式(有一个参数,并且无返回值) public static void lambdaMethod(){ Consumer con = (x) -> System.out.println(x); con.accept("Hello Lambda!"); } }
-
输出结果如下:
-
示例代码如下:
package com.xz.springboot_java8.day2; import java.util.function.Consumer; /** * @description: Lambda 表达式的基础语法三: * 有一个参数,并且无返回值(若只有一个参数,小括号可以省略不写) * @author: xz * @create: 2021-08-24 20:30 */ public class Test3 { public static void main(String[] args) { generalMethod(); System.out.println("================"); lambdaMethod(); } //匿名内部类方式(有一个参数,并且无返回值) public static void generalMethod(){ Consumer consumer= new Consumer() { @Override public void accept(String str) { System.out.println(str); } }; consumer.accept("Hello World!"); } //lambda表达式方式(有一个参数,并且无返回值) //若只有一个参数,小括号可以省略不写 public static void lambdaMethod(){ Consumer con = x -> System.out.println(x); con.accept("Hello Lambda!"); } }
-
输出结果如下:
- 示例代码如下:
package com.xz.springboot_java8.day2; import java.util.Comparator; /** * @description: Lambda 表达式的基础语法四: * 有两个以上的参数,有返回值,并且 Lambda 体中有多条语句 * @author: xz * @create: 2021-08-24 20:45 */ public class Test4 { public static void main(String[] args) { generalMethod(); System.out.println("========================="); lambdaMethod(); } //匿名内部类方式(有两个以上的参数,有返回值,并且有多条语句) public static void generalMethod(){ Comparator comparator= new Comparator() { @Override public int compare(Integer o1, Integer o2) { System.out.println("Hello World!"); System.out.println(Integer.compare(o1, o2)); return Integer.compare(o1,o2); } }; comparator.compare(10,20); } //lambda表达式方式(有两个以上的参数,有返回值,并且有多条语句) public static void lambdaMethod(){ Comparator com = (x, y) -> { System.out.println("Hello Lambda!"); System.out.println(Integer.compare(x, y)); return Integer.compare(x, y); }; com.compare(10,20); } }
- 输出结果如下:
- 示例代码如下:
package com.xz.springboot_java8.day2; import java.util.Comparator; /** * @description: Lambda 表达式的基础语法五: * 若 Lambda 体中只有一条语句, return 和 大括号都可以省略不写 * @author: xz * @create: 2021-08-24 20:58 */ public class Test5 { public static void main(String[] args) { int a1=generalMethod(); System.out.println(a1); System.out.println("========================="); int a2=lambdaMethod(); System.out.println(a2); } //匿名内部类方式(有两个以上的参数,有返回值并且只有一条语句) public static int generalMethod(){ Comparator comparator= new Comparator() { @Override public int compare(Integer o1, Integer o2) { return Integer.compare(o1,o2); } }; return comparator.compare(10,20); } //lambda表达式方式(有两个以上的参数,有返回值并且只有一条语句) //若 Lambda 体中只有一条语句, return 和 大括号都可以省略不写 public static int lambdaMethod(){ Comparator com = (x, y) -> Integer.compare(x, y); return com.compare(10,20); } }
- 输出结果如下:
-
示例代码如下:
package com.xz.springboot_java8.day2; import java.util.Comparator; /** * @description: Lambda 表达式的基础语法六: * Lambda 表达式的参数列表的数据类型可以省略不写, * 因为JVM编译器通过上下文推断出,数据类型,即“类型推断” * * 示例: * (Integer x, Integer y) -> Integer.compare(x, y); * 可以省略参数类型如下: * (x,y) -> Integer.compare(x, y); * @author: xz * @create: 2021-08-24 21:12 */ public class Test6 { public static void main(String[] args) { int a1=generalMethod(); System.out.println(a1); System.out.println("========================="); int a2=lambdaMethod(); System.out.println(a2); } //匿名内部类方式(有两个以上的参数,有返回值并且只有一条语句) public static int generalMethod(){ Comparator comparator= new Comparator() { @Override public int compare(Integer o1, Integer o2) { return Integer.compare(o1,o2); } }; return comparator.compare(10,20); } //Lambda表达式的参数列表的数据类型可以省略不写 public static int lambdaMethod(){ //Comparator com = (Integer x,Integer y) -> Integer.compare(x,y); Comparator com = (x,y) -> Integer.compare(x, y); return com.compare(10,20); } }
-
输出结果如下:
习题1:调用Collections.sort()方法,通过定制排序比较两个Employee(先按年龄比,年龄相同按薪资比),使用Lambda作为参数传递。
1、创建一个Employee 类。代码如下:
public class Employee {
private int id;//id
private String name;//名称
private int age;//年龄
private Double salary; //薪水
public Employee() { }
public Employee(int id, String name, int age, Double salary) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
//getter、setter及toString方法此处省略
......
}
2、需求及测试代码如下:
public class Test1 {
public static void main(String[] args) {
//初始化员工数据并转成list
List emps = Arrays.asList(
new Employee(1, "张三", 25, 3333.33),
new Employee(2, "李四", 38, 5555.55),
new Employee(3, "王五", 18, 2222.22),
new Employee(4, "赵六", 45, 8888.88),
new Employee(3, "xz", 18, 1111.11)
);
getEmployeeInfo(emps);
}
public static void getEmployeeInfo(List emps){
Collections.sort(emps,(o1,o2)->{
if(o1.getAge() ==o2.getAge()){//年龄相同按薪资比
return o1.getSalary().compareTo(o2.getSalary());
}else{//按年龄比
return Integer.compare(o1.getAge(),o2.getAge());
}
});
//遍历
for (Employee emp : emps) {
System.out.println(emp);
}
}
}
3、运行main函数,输出结果如下:
习题2: 声明函数式接口,接口中声明抽象方法,public String getvalue(String str); 声明类Test2,类中编写方法使用接口作为参数,将一个字符串转成大写,并作为方法的返回值。 再将一个字符串的第2个和第4个索引位置进行截取子串。
1、声明名称为MyInterface的函数式接口,代码如下:
package com.xz.springboot_java8.day3.interfaces;
/**
* @description: 声明函数式接口
*/
@FunctionalInterface
public interface MyInterface {
String getvalue(String str);
}
2、需求及测试代码如下:
package com.xz.springboot_java8.day3;
import com.xz.springboot_java8.day3.interfaces.MyInterface;
public class Test2 {
public static void main(String[] args) {
getResult();
}
/**
* 获取结果方法
*/
public static void getResult(){
//将一个字符串转成大写
String str1= strHandler("sdkljakdjlksa",(x) -> x.toUpperCase() );
System.out.println(str1);
//将字符串的第2个和第4个索引位置进行截取子串。
String str2=strHandler("sdkljakdjlksa",(x)->x.substring(2,5));
System.out.println(str2);
}
/**
* 声明类Test2,类中编写方法使用接口作为参数,并作为方法的返回值。
* @return
*/
public static String strHandler(String str, MyInterface myInterface){
return myInterface.getvalue(str);
}
}
3、运行main函数,输出结果如下:
习题3: 声明一个带两个泛型的函数式接口,泛型类型为, T为参数,R为返回值 接口中声明对应的抽象方法 在Test3类中声明方法,使用接口作为参数,计算两个long型参数的和 再计算两个long型参数的乘积。
1、声明名称为MyInterface2的函数式接口,泛型类型为,代码如下:
package com.xz.springboot_java8.day3.interfaces;
/**
* 声明函数式接口
*/
@FunctionalInterface
public interface MyInterface2 {
public R getValue(T t1, T t2);
}
2、需求及测试代码如下:
public class Test3 {
public static void main(String[] args) {
getResult();
}
/**
* 获取结果方法
*/
public static void getResult(){
long sumValue= getCompute(25l,30l,(x,y)->x+y);
System.out.println("两数之和="+sumValue);
long rideValue= getCompute(25l,30l,(x,y)->x*y);
System.out.println("两数之积="+rideValue);
}
/**
* 在Test3类中声明方法,使用接口作为参数,计算两个long型参数的和
* @return
*/
public static Long getCompute(Long l1,Long l2, MyInterface2 myInterface2){
return myInterface2.getValue(l1,l2);
}
}
3、运行main函数,输出结果如下:
- 由以上示例可知,每次使用lambda表达式都需要创建函数式接口。而实际中java已经创建好了函数式接口,直接使用即可。