Lambda表达式

函数式编程 ：强调做什么，而不是以什么形式去做。

为什么使用lambda表达式

避免匿名内部类定义过多

使代码简洁

函数式接口

定义：任何接口，如果只包含有且只有一个抽象方法，那么它就是函数式接口

对于函数式接口才能用lambda表达式

lambda表达式结构

（参数列表）-> { 放方法体；}

当方法体中只有一行代码时，可以把方法体中的；、{} 和 return 省略（不能只省略一个，要省略都必须全部省略）

public interface Lambda {//定义函数式接口
 public abstract void teat();
}
public class TestLambda {
 public static void main(String[] args){
     new Lambda(){//匿名内部类
         @Override
         public void teat() {
             System.out.println("lambda1");
         }
     }.teat();
     //lambda表达式
     Lambda lambda = () -> System.out.println("lambda2");
     lambda.teat();
 }
}

参数列表内的参数可以不用加数据类型（要不加都不加）

public interface Lambda {//定义函数式接口 
 public abstract int teat(int a,int b);
}
=====================分割线=====================
public class TestLambda {
 public static void main(String[] args){
     int c = new Lambda(){//匿名内部类
         @Override
         public int teat(int a, int b) {
             return a+b;
         }
     }.teat(10,20);
     //lambda表达式
     Lambda lambda1 = (int a,int b) -> {return a+b;};//正常写法
     Lambda lambda2 = (a,b) -> {return a+b;};//只省略参数数据类型
     Lambda lambda3 = (a,b) -> a+b ;//参数数据类型和return关键字都可以省略
     int a = lambda1.teat(10,20);
     int b = lambda2.teat(100,200);
 }
}

只有一个参数的情况下可以把（）和参数数据类型省略，只留下参数引用

public interface Lambda {//定义函数式接口 int参数无返回值
 public abstract void teat(int a);
}
=======================分割线=====================
public class TestLambda {
 public static void main(String[] args){
     new Lambda(){//匿名内部类
         @Override
         public void teat(int a) {
             System.out.println(a);
         }
     }.teat(10);
     //lambda表达式
     Lambda lambda1 = (int a) -> {System.out.println(a);};//正常写法
     Lambda lambda2 = (a) -> {System.out.println(a);};//只省略参数数据类型
     Lambda lambda3 = a -> System.out.println(a) ;//最简化
     lambda1.teat(10);
     lambda2.teat(100);
 }
}

没有参数时（）必须写

示例练习:Arrarys.sort();

package lambda;

import java.util.Arrays;
import java.util.Comparator;

public class ArrSort {
    public static void main(String[] args){
      Person[] p = new Person[]{new Person("张三",29),new Person("李四",45),new Person("王五",30)} ;
//        Arrays.sort(p, new Comparator<Person>() {
//            @Override
//            public int compare(Person p1, Person p2) {
//                return p2.getAge()-p1.getAge();
//            }
//        });
        Arrays.sort(p, (p1, p2) ->  p2.getAge()-p1.getAge());

        for(Person person : p){
            System.out.println(person);
        }
    }
}

class Person{
    private String name;
    private Integer age;

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Lambda表达式

Lambda表达式

为什么使用lambda表达式

函数式接口

lambda表达式结构

示例 练习:Arrarys.sort();

推荐阅读

示例练习:Arrarys.sort();