我要评论引入
函数式编程中“函数”类似于数学中的函数（强调做什么），只要输入的数据一致返回的结果也是一致的
函数式编程解决了什么问题？什么是函数式编程？
使用lambda函数替代吗某些匿名内部类对象，从而让程序代码更简洁，可读性更好。
一：lambda
1、认识lambda表达式
- jdk8开始新增的一种语法形式，它表示函数。
- 可以用于替代匿名内部类对象，从而让程序更简洁，可读性更好。
- 注意：lambda表达式只能替代函数式接口的匿名内部类！！！！。
什么是函数式接口
- 有且仅有一个抽象方法的接口。
思考：为什么只能替代函数式接口的匿名内部类，分析：函数式接口只能有一个抽象方法，在简化的时候，会找到这个抽象方法并为这个方法重写。如果有多个抽象方法，简化后：编译器不知道要为那个抽象方法重写。
lambda表达式的书写格式
(参数列表) -> { 表达式或语句块 }(参数列表)：定义 lambda 表达式接受的参数。参数的类型通常可以由编译器推断，因此可以省略。->：称为 lambda 操作符 或 箭头操作符。它将参数列表与 lambda 主体分隔开。{ 表达式或语句块 }：lambda 表达式的主体，包含要执行的代码。- 如果表达式或语句块：只有一句{ }可以省略，否则不可省略。
test类：代码1演示了：注意：lambda表达式只能替代函数式接口的匿名内部类！！！！。
public class test {
public static void main(string[] args) {
system.out.println("______________抽象类的匿名内部类_____________");
animal animal = new animal() {
@override
public void cry() {
system.out.println("猫喵喵喵~~");
}
};
animal.cry();
system.out.println("______________简化抽象类的匿名内部类（报错）_____________");
//lambda简化匿名内部类
//下面代码出错，lambda表达式只能替代函数式接口的匿名内部类！！！！。
// animal animal = ()->{
// system.out.println("猫喵喵喵~~");
// };
system.out.println("______________接口的匿名内部类_____________");
swim s = new swim() {
@override
public void swiming() {
system.out.println("狗游游游~~");
}
};//分号不能忘
s.swiming();
system.out.println("______________简化函数式接口的匿名内部类_____________");
swim s1 = () -> {
system.out.println("狗游游游~~");
};
s1.swiming();
}
}
//动物类
abstract class animal {
abstract void cry();
}
//写一个游泳接口
@functionalinterface //声明函数式接口 ，函数式接口只能有一个抽象方法，
// 如果有多个抽象方法，使用注解声明后会报错
interface swim {
void swiming();
}
/*
输出：
______________抽象类的匿名内部类_____________
猫喵喵喵~~
______________简化抽象类的匿名内部类（报错）_____________
______________接口的匿名内部类_____________
狗游游游~~
______________简化函数式接口的匿名内部类_____________
狗游游游~~
*/2、lambda实战实例、省略规则
1.使用lambda简化comparator接口的匿名内部类
2.lambda表达式的省略规则
作用：用于进一步简化lambda表达式写法。
具体规则：
- 参数类型全部可以省略不写。
- 如果只有一个参数，参数类型省略的同时“（）”也可以省略，但是对个参数不能省略“（）”。
- 如果lambda表达式中只有一行代码，大括号可以不写，同时要省略分号“；” 如果这行代码是return语句，也必须去掉return。
代码2：下面是comparator接口sort对学生对象排序的代码简化过程。在上篇文章匿名内部类中给过这个代码的完整版本。
// arrays.sort( s, new comparator<student>() {
// @override
// public int compare(student o1, student o2) {
// return o1.getage() - o2.getage();
// }
// });
// arrays.sort( s, (student o1, student o2) -> {
// return o1.getage() - o2.getage();
// });
// arrays.sort( s, ( o1, o2) -> {
// return o1.getage() - o2.getage();
// });
arrays.sort( s, ( o1, o2) -> o1.getage() - o2.getage());二、方法引用
1、静态方法引用
静态方法引用（static method reference） 是一种特殊的语法，用于直接引用一个类的静态方法，并将其作为函数式接口的实例。它是 lambda 表达式的更简洁替代形式。
语法：
类名::静态方法名
类名: 定义了静态方法的类的名称。::方法引用操作符。静态方法名: 要引用的静态方法的名称，不带括号()和参数。
使用场景
如果某个lambda表达式里只是调用一个静态方法，并且“—>”前后参数的形式一致，（就像是下面的例子，->两边都是o1、o2）就可以使用静态方法引用。
代码3：下面代码演示了静态方法引用的使用场景
student 类
public class student {
private string name;
private int age;
//构造器
public student(string name, int age) {
this.name = name;
this.age = age;
}
public void setage(int age) {
this.age = age;
}
public void setname(string name) {
this.name = name;
}
public string getname() {
return name;
}
public int getage() {
return age;
}
@override
public string tostring() {
return "student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//静态 方法引用
public static int compare(student o1, student o2){
return o1.getage() - o2.getage();
}
}test类
import java.util.arrays;
public class test {
public static void main(string[] args) {
student []s = new student[5];
s[0] = new student("张三", 18);
s[1] = new student("李四", 19);
s[2] = new student("张三", 50);
s[3] = new student("李白", 5);
s[4] = new student("王五", 10);
print(s);
// arrays.sort(s,(o1, o2)-> o1.getage() - o2.getage());
// arrays.sort(s, (o1, o2)->student.compare(o1, o2));
//静态方法引用
arrays.sort(s,student::compare);
system.out.println("-------排序后：-------");
print(s);
}
//打印姓名和年龄
public static void print(student []s){
for (int i = 0; i < s.length; i++){
system.out.println(s[i]);
}
}
}2、实例方法引用
语法
对象名::实例方法
使用场景
如果某个lambda表达式里只是通过对象名称调用一个实例方法，并且“—>”前后参数的形式一致，就可以使用实例方法引用。
代码4：演示了实例引用使用场景
student类
public class student {
private string name;
private int age;
//构造器
public student(string name, int age) {
this.name = name;
this.age = age;
}
public student() {
}
public void setage(int age) {
this.age = age;
}
public void setname(string name) {
this.name = name;
}
public string getname() {
return name;
}
public int getage() {
return age;
}
@override
public string tostring() {
return "student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//实例方法方法引用
public int compare(student o1, student o2){
return o1.getage() - o2.getage();
}
}test类
import java.util.arrays;
public class testt {
public static void main(string[] args) {
student []s = new student[5];
s[0] = new student("张三", 18);
s[1] = new student("李四", 19);
s[2] = new student("张三", 50);
s[3] = new student("李白", 5);
s[4] = new student("王五", 10);
system.out.println("-------排序前：-------");
print(s);
student t = new student();
//实例方法引用：对象名::实例方法名
//前提：->前后参数形式一致，才能使用实例方法引用
arrays.sort(s, t::compare);
system.out.println("-------排序后：-------");
print(s);
}
//打印姓名和年龄
public static void print(student []s){
for (int i = 0; i < s.length; i++){
system.out.println(s[i]);
}
}
}
/*
输出结果：
-------排序前：-------
student{name='张三', age=18}
student{name='李四', age=19}
student{name='张三', age=50}
student{name='李白', age=5}
student{name='王五', age=10}
-------排序后：-------
student{name='李白', age=5}
student{name='王五', age=10}
student{name='张三', age=18}
student{name='李四', age=19}
student{name='张三', age=50}
*/3、特定类型方法的引用
语法
特定类型的名称::方法
使用场景
如果某个lambda表达式里只是调用了一个特定类型的实例方法，并且前面参数列表中的第一个参数是作为方法主调，后面的所有参数都是作为该实例方法的入参的，则此时就可以使用特定类型的方法引用。
代码5：演示特定方法引用的使用场景。
test类
import java.util.arrays;
import java.util.comparator;
public class test {
public static void main(string[] args) {
//给英语名称排序
string[] name = {"tom", "jerry", "bobi", "曹操", "mike","angela","dlei","jack","andy","cao"};
system.out.println("排序前：" + arrays.tostring(name));
//把这个数组进行排序：
// arrays.sort(name);
// system.out.println(arrays.tostring(name));
//要求，忽略大小写进行排序（java官方默认是按照ascii码进行排序的）所以我们的要求官方默认搞不懂，
// 需要我们自定义排序规则
// arrays.sort(name, new comparator<string>() {
// @override
// public int compare(string o1, string o2) {
// return o1.comparetoignorecase(o2); //java已经为我们提供了字符串按照首字母忽略大小写比较方法：comparetoignorecase
// }
// });
//lambda简化
// arrays.sort(name, (o1, o2)->o1.comparetoignorecase(o2));
//特定类型方法引用：类型名::方法名
arrays.sort(name, string::comparetoignorecase);
system.out.println("排序后：" + arrays.tostring(name));
arrays.sort(name, string::comparetoignorecase);
}
}
/*
输出结果：
排序前：[tom, jerry, bobi, 曹操, mike, angela, dlei, jack, andy, cao]
排序后：[andy, angela, bobi, cao, dlei, jack, jerry, mike, tom, 曹操]
*/4、构造器引用
构造器引用（constructor reference） 是一种特殊的语法，用于引用一个类的构造器，并将其作为函数式接口的实例。它允许你将“创建对象”这个行为当作一个函数来传递，是 lambda 表达式的简洁替代。
语法：
类名::new
使用场景
如果某个lambda表达式里只是在创建对象，并且“—>”前后参数情况一致，就可以使用构造器引用。
代码6：理解构造器引用
test类：
public class test {
public static void main(string[] args) {
// carfactory cf = new carfactory() {
// @override
// public car getcar(string name) {
// return new car(name);
// }
// };
//创建对象
// car c = cf.getcar("法拉利");
//简化
// carfactory cf = name-> new car(name);
//用构造器引用简化
carfactory cf = car::new;
car c = cf.getcar("法拉利");
system.out.println(c);
}
}
interface carfactory{
car getcar(string name); //接口中的抽象方法，返回值类型为car
}
class car{
private string name;
public car(string name) {
this.name = name;
}
public car(){}
public void setname(string name) {
this.name = name;
}
public string getname() {
return this.name;
}
//重新tostring
@override
public string tostring() {
return "car{" +
"name='" + name + '\'' +
'}';
}
}
/*
输出结果：
car{name='法拉利'}
*/到此这篇关于java中的函数式编程lambda、方法引用详解的文章就介绍到这了,更多相关java函数式编程内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论