Lambda表达式应用浅析

最新推荐文章于 2023-10-11 11:24:14 发布
置顶 最新推荐文章于 2023-10-11 11:24:14 发布
阅读量437 收藏
点赞数 1
分类专栏： Java 文章标签： lambda java8 SAM Functional Interface
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenhuachong/article/details/50845819
版权

一、什么是Lambda表达式

最近研究了一下java8的一个新特性lambda表达式，发现使用lambda表达式确实能够简化我们的代码是的代码的逻辑更加清晰和简洁。以下是我整理的关于lambda表达式的知识点，在这里分享给大家，如有写的不对的地方请指出。
Lambda表达式是Java8的一个新特性，它提供了一种更加清晰和简明的方式使用Functional Interface。在代码中经常会出现各种各样的匿名内部类，使得代码变的臃肿、混乱，而lambda就是一种优雅的方式，它简化对于Functionla Interface的使用，而不需要定义匿名内部类。

二、知识背景

Annoymous Inner class

在Java里面，可以在使用的时候声明一个类的对象，并在使用时给出类的某些方法的实现，这种类叫做匿名内部类，比如在Android中的OnClickListener，代码如下：

 如上代码所示，new View.OnClickListener()就是一个匿名内部类。

Functional interface

功能接口，只含有一个抽象方法的接口，即SAM(Simple Abstract Method)，单一抽象方法。这样的接口比如：

  • 文件过滤接口－java.io.FileFilter    public abstract boolean accept(File pathname);
  • 比较接口－java.lang.Comarable    int compareTo(T another);
  • Android的OnClickListener接口－android.view.View.OnClickListener    onClick(View v);

三、Lambda表达式应用

了解了匿名内部类和功能接口下面来介绍一下lambda表达式。lambda是一种能够极大的简化声明和使用功能性接口的表达式语法，通过使用lambda表达式，可以使得代码更加的清晰和简洁。
Lambda Syntax
每个lambda表达式都包括以下三个部分：
Argument List－(int x,int y)
Arrow Token -  ->
Body - x+y
Argument部分是调用SAM方法时的入口参数;Arrow Token固定为->;Body内部可以是简单的表达式，也可是复杂的代码块。以上的例子仅仅是一个简单的表达式，用来返回输入的x和y的和，如果参数不匹配或者不是单一抽象接口都会出现编译错误。
Lambda Examples

1. Runnable Lambda
使用匿名内部类代码如下：

public static void testRunnable(){
    Thread thread = new Thread(new Runnable(){
        System.out.println(“In ”);
    });
}
使用lambda表达式代码如下 
public static void testRunnable(){
    Thread thread = new Thread(() -> {
        System.out.println(“In ”);
    });
}
2. FileFilter
使用匿名内部类代码如下：
 
public static void testFileFilter(String path){
    File file = new File(path);
    FileFilter filter = new FileFilter(){
        public boolean accept(File pathName){
            return pathName.isDirectory();
        }
    };
    File[] files = file.listFiles(filter);
}
public static void testFileFilter(String path){
    File file = new File(path);
    file.listFiles((file)->file.isDirectory);
}
3.Comparator 
private static void testComparator(){ 
    Person person1 = new Person(); 
    person1.setAge(10);
    Person person2 = new Person(); 
    person2.setAge(90); 
    Person person3 = new Person(); 
    person3.setAge(26); 
    List<Person> persons = new ArrayList<>(); 
    persons.add(person1); 
    persons.add(person2); 
    persons.add(person3); 
    Collections.sort(persons,(p1,p2) -> p1.getAge() - p2.getAge());
    for(Person p : persons){ 
         System.out.println(p.getAge()); 
    }
 }
    在这个例子当中，lambda作为Comparator参数传入sort方法，有人可能会有疑问，Comparator接口中并非只有一个simple abstract method ,即该接口不是刚才说过的Functional Interface。我们打开java.lang.Comparator接口，发现接口名字上有个标注@Functational Interface，进一步看这个标注的详细介绍会发现，该接口是从java8开始加入的，目的是声明某个接口为Functional Interface。如果该接口不是Functional Interface，即拥有超过一个抽象方法，则会抛出编译错误。而这里Comparator中还有一个抽象方法名为boolean equals（Object obj），从文档中可以看出，如果某个接口拥有一个抽象方法，同时又覆盖了Object的public方法，那么这个抽象方法并不会计算在该接口的抽象方法数量中。也就是说该接口还是一个 Functional Interface。
四、Lambda Advantages

    通过以上的几个例子，大家对lambda已经有了一定的认识，lambda除了能够简化代码行数之外，还能够使得我们的代码遵从Don’ Repeat Yourself(DRY)准则，提高代码的可读性和简洁程度。
（1）情景：现在某公司年底需要给公司的员工发一些奖励，奖励程度和在公司工作的年数有关，规则如下：a.工作1年以内的－发放2000元；b.工作1-3年的－发放5000元；c.工作3-5年的－发放10000元；d.工作5年以上的－发放20000元。
（2）代码初步实现，如下：

//定义实体类：Staff.java
public class Staff{
    private int staffId;
    private int workYears;
    private int name;
    public int getWorkYears(){
         return this.workYears;
    }
    public String getName(){
    
    }
    public void setWorkYears(int workYears){
        this.workYears = workYears;
    }
    public void setName(String name){
        this.name = name;
    }
}
//定义生产数据的静态方法
public class StaffUtil{
    public static List<Staff> createStaffList(int count){
        List<Staff> staffList = new ArrayList<Staff>();
        for(int i=0;i<count;i++){
            Staff staff = new Staff();
            staff.setName(“Kevin”+i);
            staff.setWorkYears(i);
            staffList.add(staff);
        }
    }
}
//定义测试类
public class TestLambda{
    public static void  main(String[] args){
         List staffList = StaffUtil.createStaffList(20);
         filterA(staffList);
    }
    public static void filterA(List<Staff> staffList){
        for(Staff staff:staffList){
            if(staff.getWorkYears() <= 1){
                sendMoney(staff,2000);
            }
        }
    }
    public static void filterB(List<Staff> staffList){
        for(Staff staff:staffList){
            if(staff.getWorkYears() <= 3 && staff.getWorkYears() > 1){
                sendMoney(staff,5000);
            }
        }
    }
    public static void filterC(List<Staff> staffList){
        for(Staff staff:staffList){
            if(staff.getWorkYears() <= 5 && staff.getWorkYears() > 3){
                sendMoney(staff,10000);
            }
        }
    }
    public static void filterD(List<Staff> staffList){
        for(Staff staff:staffList){
            if(staff.getWorkYears() <= 5 && staff.getWorkYears() > 3){
                sendMoney(staff,10000);
            }
        }
    }
    public static void sendMoney(Staff staff，int money){
        System.out.println(“发放”+staff.getName()+”奖金”+money+”元”);
    }
}
以上代码逻辑清晰，但是有些地方还需要继续优化：
1.代码违背了DRY准则，每个方法内部都会做一次循环
2.对于每种规则都会有一个方法与之对应，每种情况都需要实现一个方法与之对应
3.代码不够灵活，可扩展性不高“
（3）第一次修改
以下代码我们尝试将判断条件抽出来，放到另一个单独的方法中 
public class TestLambda1{
    public static void  main(String[] args){
         List staffList = StaffUtil.createStaffList(20);
         filterA(staffList);
    }
    public static void filterA(List<Staff> staffList){
        for(Staff staff:staffList){
            if(isA(staff)){
                sendMoney(staff,2000);
            }
        }
    }
    public static void filterB(List<Staff> staffList){
        for(Staff staff:staffList){
            if(isB(staff)){
                sendMoney(staff,5000);
            }
        }
    }
    public static void filterC(List<Staff> staffList){
        for(Staff staff:staffList){
            if(isC(staff)){
                sendMoney(staff,10000);
            }
        }
    }
    public static void filterD(List<Staff> staffList){
        for(Staff staff:staffList){
            if(isD(staff)){
                sendMoney(staff,10000);
            }
        }
    }
    public static boolean isA(Staff staff){
       return staff.getWorkYears() <= 1;
    }
    public static boolean isB(Staff staff){
       return staff.getWorkYears() <= 3 && staff.getWorkYears() > 1;
    }
    public static boolean isC(Staff staff){
       return staff.getWorkYears() <= 5 && staff.getWorkYears() > 3;
    }
    public static boolean isD(Staff staff){
       return staff.getWorkYears() <= 5 && staff.getWorkYears() > 3;
    }
    public static void sendMoney(Staff staff，int money){
        System.out.println(“发放”+staff.getName()+”奖金”+money+”元”);
    }
}
代码将判断条件抽出来放到方法里面是的每个判断条件得以重用，这是相对之前代码一个提高。那么对于判断条件的处理有没有更好的方法呢？
（4）匿名内部类
定义一个判断员工工作年限的接口，如下： 
public interface MyTest<T>{
    boolean test(T t);
}
public class TestLambda1{
    public static void  main(String[] args){
         List staffList = StaffUtil.createStaffList(20);
         filterA(staffList,new MyTest<Staff>(){
            @Override
            boolean test(Staff staff){
                return staff.getWorkYears() <= 1;
             }
         });
         filterA(staffList,new MyTest<Staff>(){
            @Override
            boolean test(Staff staff){
                return staff.getWorkYears() <= 3 && staff.getWorkYears() > 1;
             }
         });
         //…
    }
    public static void filterA(List<Staff> staffList,MyTest<Staff> test){
        for(Staff staff:staffList){
            if(test(staff)){
                sendMoney(staff,2000);
            }
        }
    }
    public static void filterB(List<Staff> staffList,MyTest<Staff> test){
        for(Staff staff:staffList){
            if(test(staff)){
                sendMoney(staff,5000);
            }
        }
    }
    public static void filterC(List<Staff> staffList,MyTest<Staff> test){
        for(Staff staff:staffList){
            if(test(staff)){
                sendMoney(staff,10000);
            }
        }
    }
    public static void filterD(List<Staff> staffList,MyTest<Staff> test){
        for(Staff staff:staffList){
            if(test(staff)){
                sendMoney(staff,10000);
            }
        }
    }
    public static void sendMoney(Staff staff，int money){
        System.out.println(“发放”+staff.getName()+”奖金”+money+”元”);
    }
}
上面的代码使用匿名内部类来代替刚才的方法，好处时，减少了三个方法，而且对于判断规则，没必要写死，只要在调用时给出规则即可。但是缺点是使用匿名内部类，使得代码变得臃肿无比。
（5）使用优雅的Lambda表达式
前面（4）定义了一个MyTest接口，该接口只有一个抽象方法test，结合我们前面讲到的Functional Interface，所以该接口是支持lambda表达式的。其实我们定义这个方法是没有必要的，因为java中已经定义了类似的接口供我们使用：Java.util.function.Predicate。 
public class TestLambda1{
    public static void  main(String[] args){
         List staffList = StaffUtil.createStaffList(20);
         Predicate<Staff> preA = staff -> staff.getWorkYears() <= 1;
         Predicate<Staff> preB = staff -> staff.getWorkYears() <= 3 && staff.getWorkYears() > 1;
         filterA(staffList,preA);
         filterA(staffList,preB);
         //…
    }
    public static void filterA(List<Staff> staffList,Predicate<Staff> test){
        for(Staff staff:staffList){
            if(test(staff)){
                sendMoney(staff,2000);
            }
        }
    }
    public static void filterB(List<Staff> staffList,Predicate<Staff> test){
        for(Staff staff:staffList){
            if(test(staff)){
                sendMoney(staff,5000);
            }
        }
    }
    public static void filterC(List<Staff> staffList,Predicate<Staff> test){
        for(Staff staff:staffList){
            if(test(staff)){
                sendMoney(staff,10000);
            }
        }
    }
    public static void filterD(List<Staff> staffList,Predicate<Staff> test){
        for(Staff staff:staffList){
            if(test(staff)){
                sendMoney(staff,10000);
            }
        }
    }
    public static void sendMoney(Staff staff，int money){
        System.out.println(“发放”+staff.getName()+”奖金”+money+”元”);
    }
}
怎么样代码是不是变的优雅许多了呢？

luffych
关注
专栏目录
Lambda 表达式
JackLi31742的博客
05-10 379
一、Lambda 表达式的基础语法：Java8中引入了一个新的操作符 “->” 该操作符称为箭头操作符或 Lambda 操作符 * 箭头操作符将 Lambda 表达式拆分成两部分： * 是对接口的匿名内部类的代替 * 左侧：Lambda 表达式的参数列表，即接口里抽象方法的参数列表 * 右侧：Lambda 表达式中所需执行的功能，
C++中Lambda表达式浅析
qq_43341440的博客
06-13 448
1. Lambda表达式 Lambda表达式是C++11最重要也是最常用的特性之一，是现代编程语言的一个特点，简洁，提高了代码的效率并且可以使程序更加灵活 Lambda表达式就是一个匿名函数，所谓匿名函数，那自然是没有名字的函数，当一个函数只是临时使用而且比较简单的时候，就可以采用Lambda表达式 Lambda表达式的语法格式如下： 当你不需要capture捕获的时候，就直接写一个框框[] 当你不需要参数的时候，就直接写一个括号() 当年不需要返回值的时候，不用写箭头->和ret(返回值类型)
lambda 表达式推导
李度的博客
07-12 241
package com.lidl.com.lidl.web; /** * 函数式编程 * 函数式接口：任何接口只包含一个抽象方法 那么这个接口就是函数是接口 * 对于函数式接口我们可以通过lambda表达式创建接口对象 * *推导lambda表达式 * * */ public class Lambda { //22静态内部类 static class Like2...
常用的 Lambda 表达式案例解析，工作中都会用到
CRMEB小程序商城的博客
05-30 1134
我们日常工作中，Lambda 使用比较多的场景，就是集合类下的 Lambda 流操作，往往几行代码可以帮助我们实现复杂代码 接下来我们把 Lambda 流的常用方法用案列讲解一下。 ForEach 集合的遍历 forEach 方法 Collect 将操作后的对象转化为新的对象 Filter Filter 为过滤的意思，只要满足 Filter 表达式的数据就可以留下来，不满足的数据被过滤掉 Map map 方法可以让我们进行一些流的转化，比如原来流中的元素是 A，通过 map 操作，可以使返回的流中的元
lambda表达式的应用
qq_30347133的博客
10-19 190
import javax.jms.*; import java.util.ArrayList; import java.util.List; public class ListenerReceive { public static void main(String[] args) { receive(); List list=new ArrayList(); list.add(1); list.a...
Lambda表达式浅析，通俗易懂
05-15
Lambda表达式浅析
浅析Java8新特性Lambda表达式和函数式接口
08-29
Java 8 新特性 Lambda 表达式和函数式接口 Java 8 中引入的 Lambda ...函数式接口是 Lambda 表达式的基础，函数式接口可以包含默认方法、静态方法， lambda 表达式可以应用于事件处理、数据处理、Stream API 等场景。
Java8新特性之Lambda表达式浅析
09-04
四、Lambda表达式的实际应用 在Java 8中，许多库如Stream API大量使用Lambda表达式，简化了集合操作。例如，对列表排序： ```java List<String> list = Arrays.asList("a", "c", "b"); list.sort((s1, s2) -> s1....
浅析C++11新特性的Lambda表达式
09-01
C++11引入的Lambda表达式是语言更新中的一大亮点，它使得代码更加简洁和高效。Lambda表达式允许程序员在需要的地方直接定义匿名函数，无需预先声明或定义一个单独的函数。这种特性在处理函数对象时特别有用，尤其是...
Lambda表达式的应用
qq_38427272的博客
09-26 204
Lambda表达式的应用 List转Map 1、取对象的属性subDictName过滤其中的空格做为map对象的key值 Map<String, List> mapConf = userList.stream().collect(Collectors.groupingBy(User-> user.getSubDictName().replaceAll(" “,”"))); 2、过...
lambda表达式应用
yanfei464486的博客
01-10 243
首先定义一个接口 public interface Study{ void stu(); } 需要使用这个方法的时候，需要一个类对他进行实现，但是这个实现类只在一个地方用到，我们使用匿名内部类的方式来定义 public class Demo01 { public static void main(String[] args) { //匿名内部类的使用：假设一个接口的实现类只被用到一次，我们就没有必要再去创建一个类，直接写匿名内部类就好 //省事安全！
lamda表达式的应用
Pailugou的博客
02-24 165
匿名函数 C++在C11标准中引入了匿名函数,即没有名字的临时函数,又称之为lambda表达式.lambda表达式 实质上是创建一个匿名函数/对象 基本格式 [caputrue](params)opt->ret{body;}; [函数对象参数] (操作符重载函数参数) mutable 或 exception 声明 -> 返回值类型 {函数体} 比如说[]() {cout << "hello" << endl; }; 对于匿名函数,一般用于传函数参数,当然也可以直接定义
Lambda表达式简单应用
qq_43026206的博客
05-15 343
Lambda表达式的本质是：匿名函数 Lambda表达式： （input paramters） => expression; 1、当只有一个参数时，括号可以省略： 如： x = x*x; 如果没有参数，或者参数多于1个，则口号不能省略 如： （x,y） => x+y; ()=> method(); 2、当Lambda表达式有多个语句时，使用{} 如： n ...
Lambda表达式及应用
weixin_36894490的博客
04-26 695
Lambda表达式 概念 语法形式： () -> {} 组成： 括号：表示参数列表； 箭头：表示lambda运算符，读作goes to； 花括号：表示方法体。 参数列表相关概念： 参数个数：无参数，或者，1个或多个； 另外，只有一个参数时括号可以省略。 参数的类型：一般不定义参数类型，由编译器推理得到，或者特殊情况下，可以自己指定这些参数的类型。 方法体： 方法体中可以放参数相关的多句执...
Lambda表达式的使用
bakelFF的博客
05-23 886
什么是Lambda表达式？ Lambda表达式，也可称为闭包。类似于JavaScript中的闭包，它是推动Java8发布的最重要的新特性。 在哪里使用 Lambda 实现匿名内部类 函数声明与调用 Lambda表达式语法 Lambda表达式有三个部分： 1、参数列表——这里它采用了Comparator中compare方法的参数，两个Apple。 2、箭头——箭头->把参数列表与Lambda主体分隔开。 3、Lambda主体——比较两个Apple的重量。表达式就是Lambda的返回值了。
Lambda 表达式使用详解，一篇文章手把手教会你
最新发布
m0_70325779的博客
10-11 1478
记住一句话就可以了，"有且仅有一个抽象方法的接口叫函数式接口，接口上可以添加@FunctionalInterface注解"。例如我们刚才使用的 Compartor 接口，它就是一个函数式接口，我们看一下它的源码就可以知道，如下图所示，接口上就标注有 @FunctionalInterface 注解。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值