一文搞定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>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);
}

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