目录
一、Lambda表达式简介
Lambda表达式是JDK8之后的特性,要使用这个表达式,要求接口中只能有一个抽象方法。可以使用@FunctionalInterface注解来标记一个函数式接口。Lambda表达式本质上是替换匿名内部类的语法,让程序员编写代码更加简单,但是Lambda表达式可读性比较差。
Lambda表达式是面向函数式编程。面向接口中的那一个唯一的抽象方法编程。
基本语法格式:
() -> {}
二、Lambda表达式实例
(一)无参无返回值
定义一个函数式接口
@FunctionalInterface
public interface MyInter {
// 无参无返回值
void test();
}
public class TestDemo {
public static void main(String[] args) {
// 传统写法
MyInter myInter = new MyInterImpl() {
@Override
public void test() {
System.out.println("test...");
}
};
}
class MyInterImpl implements MyInter {
@Override
public void test() {
System.out.println("test...");
}
}
Lambda表达式:当方法体中只有一行代码时,可以省略{};
public class TestDemo {
public static void main(String[] args) {
// lambda表达式
MyInter myInter = () -> {
System.out.println("test...");
};
myInter.test(); // test...
// lambda表达式简化:当方法体中只有一行代码时,可以省略{};
MyInter myInter1 = () -> System.out.println("test...");
myInter1.test(); // test...
}
}
调用静态方法时传入Lambda表达式:
public class TestDemo {
public static void main(String[] args) {
// lambda表达式简化:当方法体中只有一行代码时,可以省略{};
MyInter myInter1 = () -> System.out.println("test...");
myInter1.test(); // test...
// 调用静态方法,使用lambda表达式传参
method(()->System.out.println("test2...")).test();
// test2...
// test1...
}
public static MyInter method(MyInter myInter) {
myInter.test();
return () -> System.out.println("test1...");
}
}
(二)有参无返回值
1.参数只有一个
Lambda表达式简化:参数如果只有一个,可以省略()
@FunctionalInterface
public interface MyInter {
// 只有一个参数,无返回值
void compareString(String str);
}
public class TestDemo1 {
public static void main(String[] args) {
// 匿名内部类写法
MyInter myInter = new MyInter() {
@Override
public void compareString(String str) {
System.out.println("hello".equals(str));
}
};
myInter.compareString("hello"); // true
// lambda表达式:参数名可以任意写
MyInter myInter1 = (string) -> System.out.println("hello".equals(string));
myInter1.compareString("hello"); // true
// lambda表达式简化:参数如果只有一个,可以省略()
MyInter myInter2 = str -> System.out.println("hello".equals(str));
myInter2.compareString("hello"); // true
}
}
2.参数有多个
@FunctionalInterface
public interface MyInter {
// 参数有多个,无返回值
void max(int num1, int num2);
}
public class TestDemo2 {
public static void main(String[] args) {
// 匿名内部类
MyInter myInter = new MyInter() {
@Override
public void max(int num1, int num2) {
System.out.println("最大值是:" + (num1 > num2 ? num1 : num2));
}
};
myInter.max(10, 20); // 最大值是:20
// lambda表达式
MyInter myInter1 = (a, b) -> System.out.println("最大值是:" + (a > b ? a : b));
myInter1.max(11, 12); // 最大值是:12
}
}
(三)有参有返回值
1.有一个参数
如果{}中只有一条语句,可以省略{}和return
@FunctionalInterface
public interface MyInter {
// 有一个参数,有返回值
boolean compareStr(String str);
}
public class TestDemo3 {
public static void main(String[] args) {
// 匿名内部类
MyInter myInter = new MyInter() {
@Override
public boolean compareStr(String str) {
return "world".equals(str);
}
};
System.out.println(myInter.compareStr("world"));
// lambda表达式
MyInter myInter1 = str -> {
return "world".equals(str);
};
System.out.println(myInter1.compareStr("world"));
// 简化:如果{}中只有一条语句,可以省略{}和return
MyInter myInter2 = str -> "world".equals(str);
System.out.println(myInter2.compareStr("world"));
// 简化:方法引用
MyInter myInter3 = "world"::equals;
System.out.println(myInter3.compareStr("world"));
}
}
2.有多个参数
重写的方法的形参数量,和形参类型和返回值类型,与已有的方法的相同,那么可以使用方法引用。
@FunctionalInterface
public interface MyInter {
// 有多个参数,有返回值
int max(int a,int b);
}
public class TestDemo5 {
public static void main(String[] args) {
// 匿名内部类
MyInter myInter = new MyInter() {
@Override
public int max(int a, int b) {
return a > b ? a : b;
}
};
System.out.println(myInter.max(1, 5));
// lambda表达式
MyInter myInter1 = (a, b) -> a > b ? a : b;
System.out.println(myInter1.max(2, 5));
// 重写的方法的形参数量,和形参类型和返回值类型,与已有的方法的相同,那么可以使用以下写法:
MyInter myInter2 = Math::max;
System.out.println(myInter2.max(10, 5));
}
}
3.当参数类型和返回值类型,是引用数据类型时
可以使用 类名::非静态方法
@FunctionalInterface
public interface MyInter {
// 当参数类型和返回值类型,是引用数据类型时
Object getPropertyNameValue(Teacher teacher);
}
定义一个Teacher类:
public class Teacher {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
}
public class TestDemo6 {
public static void main(String[] args) {
// 匿名内部类
MyInter myInter = new MyInter() {
@Override
public Object getPropertyNameValue(Teacher teacher) {
return teacher.getName();
}
};
Teacher teacher = new Teacher("张三",32);
System.out.println(myInter.getPropertyNameValue(teacher)); // 张三
// lambda表达式
MyInter myInter1 = (teacher1) -> {
return teacher1.getName();
};
System.out.println(myInter1.getPropertyNameValue(teacher)); // 张三
// 简化
MyInter myInter2 = (teacher1) -> teacher1.getAge();
System.out.println(myInter2.getPropertyNameValue(teacher)); // 32
// 方法引用:
MyInter myInter3 = Teacher::getName;
System.out.println(myInter3.getPropertyNameValue(teacher)); // 张三
MyInter myInter4 = Teacher::getAge;
System.out.println(myInter4.getPropertyNameValue(teacher)); // 32
}
}
本站资源均来自互联网,仅供研究学习,禁止违法使用和商用,产生法律纠纷本站概不负责!如果侵犯了您的权益请与我们联系!
转载请注明出处: 免费源码网-免费的源码资源网站 » JavaSE——Java8新特性:Lambda表达式
发表评论 取消回复