Java中Lambda表达式用法介绍

lambda

lambda是一个匿名函数，我们可以把lambda表达式理解为是一段可以传递的代码。

• lambda简明的地将代码或方法作为参数传递进去执行。
• “函数式编程”其核心是把函数作为值。
• 函数式接口 ：只有一个 抽象方法的接口 称之为 函数式接口。函数式接口可以使用@functionalinterface进行注解。

lambda表达式拆分为两部分

左侧：lambda 表达式的参数列表

右侧：lambda 表达式中所需要执行的功能，即lambda体

语法格式一：无参数，无返回值

@test
public void test(){
    // () -> system.out.println("hello");
    runnable a = new runnable(){
     @override
     public void run(){
        system.out.println("hello")
    }
    };
    //等同于
    runnable a1 = () -> system.out.println("hello");
    a1.run();
}

语法格式二：有一个参数，无返回值（若只有一个参数 小括号可以省略不写）

@test
public void test(){
    //consumer被注解@functionalinterface的接口（函数式接口） 唯一抽象方法 void accept(t t);
    //左侧参数 -> 右侧执行体
    consumer<string> con = (x) -> system.out.println(x);
                         // x -> system.out.println(x);
    con.accept("hahah");
}

语法格式三：有两个以上的参数，并且lambda体中有多条语句 (若lambda体中只有一条语句，return 和 大括号都可以省略不写)

@test
public void test(){
    //comparator被注解@functionalinterface的接口 举例抽象方法 int compare(t o1,t o2);
    comparator<integer> com = (x,y) -> {
      system.out.println("hhaha0");
      return (x < y) ? -1 : ((x == y) ? 0 : 1);
    };
    com.compare(1,2);
}

注意：lambda表达式的参数类型可以省略不写，因为jvm编译器可以从上下文推断出数据类型。即“类型推断”如果要在参数里面写数据类型，都要写上。

实例

实例1：

class employee {
    private string name;
    private int age;
    private double salary;
​
    //省略 get and set and constructor
​
}
interface mypredicate<t> {
    boolean test(t t);
}
public class test{
    static list<employee> list = arrays.aslist(
            new employee("张三",10,1),
            new employee("里斯",20,1),
            new employee("王五",16,1),
            new employee("二三",30,1)
    );
    public static list<employee> filteremployee(list<employee> list,mypredicate<employee> mp){
        list<employee> emps = new arraylist<>();
        for (employee employee : list) {
            if(mp.test(employee)){
                emps.add(employee);
            }
        }
        return emps;
 }
    @org.junit.test
    public void test1(){
        //需要使用自定义的方法
        list<employee> list2 = filteremployee(list,(e) -> e.getage() >= 15);
        list2.stream().map(employee::getname).foreach(system.out::println);
    }
    @org.junit.test
    public void test2(){
        //可以使用stream进行list集合的过滤  不使用自定义接口
        list<employee> list2 = list.stream().filter((e) -> e.getage() >= 15).collect(collectors.tolist());
        list2.stream().map(employee::getname).foreach(system.out::println);
    }
}

实例2：

创建一个myfun接口使用@functionalinterface注解，并创建一个抽象方法integer getvalue(integer num);在test类对变量进行某种操作。

@functionalinterface
interface myfun{
    integer getvalue(integer num);
}
public class test{
    @org.junit.test
    public void test(){
        operation(100,num -> ++num);
    }
    /**
    * param1 num : 传入的整形数
    * param2 mf : 实现某种方式对 整形数 进行操作。
    **/
    public integer operation(integer num,myfun mf){
        return mf.getvalue(num);
    }
}

class employee {
    private string name;
    private int age;
    private double salary;
​
    @override
    public string tostring() {
        return "["+this.name+","+this.getage()+","+this.getsalary()+"]";
    }
    //省略 getter and setter  and constructor
}
​
public class test {
    list<employee> list = arrays.aslist(
            new com.bilibili.lambda.test1.employee("张三",10,1),
            new com.bilibili.lambda.test1.employee("里斯",20,1),
            new com.bilibili.lambda.test1.employee("王五",16,1),
            new employee("二三",30,1)
    );
    @org.junit.test
    public void test(){
        collections.sort(list,(e1,e2) -> {
            if(e1.getage() == e2.getage()){
                return e1.getname().compareto(e2.getname());
            }else{
                //比较年龄大小
                return integer.compare(e1.getage(),e2.getage());
            }
        });
        for (employee e: list) {
            system.out.println(e);
        }
    }
}

四大核心函数式接口

• consumer<t> : 消费性接口 void accept(t t);
• supplier<t> : 共给性接口 t get();
• function<t,r> : 函数性接口 t代表参数，r代表返回值 r apply(t t);
• predicate<t> :断言性接口 boolean test(t t);

 
class test{
    @org.junit.test
    publilc void test(){
        happy(10000,(money)->system.out.println("happy消费"+money+"元"));
    }
    public void happy(double money,consumer<double> con){
        con.accept(money);
    }
}

lambda方法引用

方法引用：若lambda体中的内同有方法已经实现了，我们可以使用“方法引用”

（可以理解为方法引用时lambda的另一种表现形式）

主要有三种语法格式：

• 对象::实例方法名
• 类::静态方法名
• 类::实例方法名

class test{
    //对象::实例方法名
    @org.junit.test
    public void test(){
        consumer<string> con = (x) -> system.out.println(x);
        con.accept("haha");
        consumer<string> con2 = system.out::println;
        con2.accept("haha");
    }
    //类::静态方法名
    @org.junit.test
    public void test2(){
        comparator<integer> com = (x,y) -> integer.compare(x,y);
        comparator<integer> com2 = integer::compare;
        com.compare(1,2);
        com2.compare(1,2);
    }
    //类::实例方法名
    @org.junit.test(){
        bipredicate<string,string> bp = (x,y) -> x.equals(y);
        bp.test("a","a");
        bipredicate<string,string> bp2 = string::equals;
    }
}

lambda构造器引用

格式：

calssname::new

class test{
    @org.junit.test
    public void test(){
        supplier<string> sup = () -> new string();
        //这里的构造器引用取决于 接口方法的参数 的个数。 此处函数式接口 t get(); 为无参抽象方法所以string在实例化时 也是实例化无参的构造方法  其他类也适用
        supplier<string> sup2 = string::new;
        string str = sup2.get();
    }
}

到此这篇关于java中lambda表达式用法介绍的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持。