一文搞定Java的Lambda表达式

素颜马尾好姑娘i 2022-12-15 06:14 202阅读 0赞

> 写在前面的话：“在成功的道路上，活力是需要的，志向是可贵的，但更重要的是那毫无情趣的近乎平常的坚守的毅力和勇气。”你好，我是梦阳辰，未来我和你一起成长。

**什么是Lambda表达式？**  
Lambda是一个**匿名函数**，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。

Lambda允许把函数作为一个方法的参数（函数作为参数传递到方法中）。  
**为什么要使用Lambda表达式？**  
可以写出更简洁的，更灵活的代码。作为一种更紧凑的代码风格，是java的语言表达能力得到了提升。

**对比：**

import java.util.Comparator;
    import java.util.TreeSet;
    
    public class LambdaTest { 
        //原来的匿名内部类
    
        public void test1(){ 
            Comparator<Integer> com  = new Comparator<Integer>() { 
                @Override
                public int compare(Integer o1, Integer o2) { 
                    return Integer.compare(o1,o2);
                }
            };
            TreeSet<Integer> ts  = new TreeSet<>(com);
        }
    
        //Lambda表达式
        public void test2(){ 
            Comparator<Integer> com  = (x,y) ->Integer.compare(x,y);
            TreeSet<Integer> ts  = new TreeSet<>(com);
        }
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70_pic_center]

**3.Lambda表达式的基础语法**  
Java8中引入了一个新的操作符“->"该操作符称为箭头操作符或Lambda操作符。  
箭头操作符将Lambda表达式拆分为两个部分。

**左侧**：Lambda 表达式列表（接口中方法中的参数列表）。

**右侧**：表达式中所需执行的功能（接口中实现的代码）。

**语法格式：**

1.抽象方法，无参，无返回值  
() -> System.out.println(“Hello Lambda”);

2.有一个参数，无返回值  
(x) ->System.out.println(x);

public void test1(){ 
    Consumer<String> con = (x) -> System.out.println(x);
    con.accept("fda");
    }

3.有一个参数，小括号可以省略不写。

4.有两个以上的参数，并且Lambda体中，有多条语句，有返回值。  
Compatator com = (x,y) ->\{  
System.out.println(“函数式接口”);  
return Integer.compare(x,y);  
\};

public void test2(){ 
    Compatator<Integer> com = (x,y) ->{ 
    	System.out.println("函数式接口");
    	return Integer.compare(x,y);
    };
    }

5.有两个以上的参数，并且Lambda体中，只有一条语句，return和大括号都可以省略不写。

com = (x,y) -> Integer.compare(x,y);

6.Lambda表达式的参数列表的数据类型可以省略不写，因为JVM编译器可以通过上下文推断。

lambda 表达式只能引用标记了 final 的外层局部变量（final可以省略），这就是说**不能**在 lambda 内部**修改**定义在**域外的局部变量**，否则会编译错误。

Lambda表达式需要函数式接口的支持

**函数式接口**：接口中只有一个抽象方法的接口，称为函数式接口。

使用注解@FunctionalInterface修饰，可以检查接口是否是函数式接口。

**案例1：实现数据运算**：

@FunctionalInterface
    public interface Myfun { 
        public Integer getValue(Integer num);//抽象方法
    }

public class Test { 
        public static void main(String[] args) { 
          Integer num=  operation(100,x->x*x);//乘
          Integer num2=  operation(100,x->{ 
              int result = x+900;return result;});//乘
            System.out.println(num2);
        }
    
        /** * 对数据进行操作 * @param num * @param mf * @return */
        public  static Integer operation(Integer num,Myfun mf){ 
            return  mf.getValue(num);
        }
    }

**进阶练习：**  
**1.调用Collections.sort()方法**，通过定制排序比较两个Employee(先按年龄比，年龄相同  
按姓名比)，使用Lambda作为参数传递。

import java.util.*;
    
    public class Test { 
        public static void main(String[] args) { 
            List<Employee> list  = Arrays.asList(
                    new Employee("MengYangChen",18,2000),
                    new Employee("Meng",21,1000),
                    new Employee("MenaYang",21,20000)
            );
    
           /* Comparator<Employee> a = new Comparator() { @Override public int compare(Object o1, Object o2) { return ; } }*/
    
    
           /* Comparator<Employee> e = (x,y)->{ if(x.getAge()==y.getAge()){ return x.getName().compareTo(y.getName()); } return Integer.compare(x.getAge(),y.getAge());};*/
    
    
            Collections.sort(list,(x,y)->{ 
                if(x.getAge()==y.getAge()){ 
                    return x.getName().compareTo(y.getName());
                }
                return Integer.compare(x.getAge(),y.getAge());});
    
            Iterator<Employee> it  = list.iterator();
            while (it.hasNext()){ 
                System.out.println(it.next().getName());
            }
         }
    }

public class Employee { 
        private String name;
        private int age;
        private double salary;
    
        public Employee(String name, int age, double salary) { 
            this.name = name;
            this.age = age;
            this.salary = salary;
        }
    
        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 double getSalary() { 
            return salary;
        }
    
        public void setSalary(double salary) { 
            this.salary = salary;
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70_pic_center 1]

**2.①声明函数式接口**，接口中声明抽象方法，public String getValue(String str);  
②声明类TestLambda ，类中编写方法使用**接口作为参数**，将一个字符串转换成大写，  
并作为方法的返回值。  
③再将一个字符串的第2个和第4个索引位置进行截取子串。

@FunctionalInterface
    public interface Myfunction { 
       public String getValue(String str);
    }

public class Test { 
        public static void main(String[] args) { 
           String upper  = operate("abc",str->str.toUpperCase());
        }
    
        //对两个double类型数据进行操作
        public static String operate (String str,Myfunction Myfun){ 
        	return Myfun.getValue(str);
        }
    }

**3.①声明一个带两个泛型的函数式接口**，泛型类型为<T,R>T为参数，R为返回值。  
②接口中声明对应抽象方法  
③在TestLambda类中声明方法，使用接口作为参数，计算两个long型参数的和。-  
④再计算两个long型参数的乘积。-

package Chapters6.Lambda3;
    
    public class Test { 
        public static void main(String[] args) { 
            operate(100,200,(x,y)->x+y);//加
            operate(100,200,(x,y)->x*y);//乘
        }
    
        //对两个double类型数据进行操作
        public static void operate (double a,double b,Myfunction<Double,Double> myfun){ 
            System.out.println(myfun.getValue(a,b));
        }
    }

package Chapters6.Lambda3;
    
    @FunctionalInterface
    public interface Myfunction <T,R>{ 
        public R getValue(T t1,T t2);
    }

> 无论你正遭遇着什么，你都要从落魄中站起来重振旗鼓，要继续保持热忱，要继续保持微笑，就像从未受伤过一样。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70_pic_center 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70_pic_center 3]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/57af747611e54949a521dea7b1d9aee7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/251fa7fffa90472faae46174b34a5011.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/01c1ac2b13d74cada8074175b42fa74b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/3f335f2fcc294e3791cf19378d1764fa.png