一文搞定Java的Lambda表达式-蒲公英云

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

什么是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);
    }
}

在这里插入图片描述

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;
    }
}

在这里插入图片描述

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为返回值。
②接口中声明对应抽象方法
③在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);
}