大道至简，看Lambda表达式如何将方法化繁为简

lambda表达式

lambda可以看作是匿名方法

函数式接口

一个接口有且只有一个抽象方法

• 可以有成员变量
• 函数式接口允许定义顶层父类Object类里面的public方法
• 可以定义静态方法，这个静态方法一定要有方法体
• 可以有Default方法

可以在接口上添加注释@FunctionalInterface，编译器就会自动检测，按函数式接口的定义要求此接口

@FunctionalInterface
interface Lambda{
    void Test();
    static void func1(){
    
    }
    default void func2(){
    
    }

    public void boolean equals();
}

Lambda表达式的使用

    public static void main(String[] args) {
        Lambda lambda = new Lambda() {
            @Override
            public void Test() {
                System.out.println("good job");
            }
        };
        lambda.Test();

        Lambda lambda1 = () -> System.out.println("good job");
        lambda1.Test();
    }

@FunctionalInterface
interface Lambda1{
    void Test(int a);
}
        Lambda1 lambda11 = (int a) -> System.out.println(a);
        Lambda1 lambda12 = a -> System.out.println(a);

@FunctionalInterface
interface Lambda2{
    void Test(int a,int b);
}
        Lambda2 lambda2 = (int a,int b) -> System.out.println(a+b);
        Lambda2 lambda21 = (a,b) -> System.out.println(a+b);

@FunctionalInterface
interface Lambda3{
    int Test();
}
        Lambda3 lambda3 = () -> {return 10;};
        Lambda3 lambda31 = () -> 10;

@FunctionalInterface
interface Lambda4{
    int Test(int a);
}
        Lambda4 lambda4 = (int a) -> {return a;};
        Lambda4 lambda41 = a -> a;
        System.out.println(lambda41.Test(10));  //10

@FunctionalInterface
interface Lambda5{
    int Test(int a,int b);
}
        Lambda5 lambda5 = (int a,int b) -> {return a+b;};
        Lambda5 lambda51 = (a,b) -> a+b;
        System.out.println(lambda51.Test(10,2)); //12

Lambda使用场景

Lambda表达式只适用于函数式接口

abstract class Player{
    abstract void func();
}
        //匿名内部类
        Player player = new Player(){
            @Override
            void func() {
                System.out.println("匿名内部类来了");
            }
        };
        player.func();
        //Lambda表达式实现但是不行，翻译过来是Lambda表达式必须是代替一个接口的
        Player player1 = () -> System.out.println("匿名内部类来了");

变量捕获

匿名内部类的变量捕获

捕获的变量必须是一个常量或者是没有改变过的变量

class Test{
    public void func(){
        System.out.println("func()");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        //a = 99;     //No
        new Test(){
            @Override
            public void func() {
            //a = 99;  //No
                System.out.println("我是内部类，且重写了func()方法");
                System.out.println(a);
            }
        };
    }
}

Lambda的变量捕获

        int a =10;
        Lambda lambda1 = () -> {System.out.println("good job");
            System.out.println(a);};
        lambda1.Test();             //good job  
                                    //10 

Lambda在集合中使用

列举List 和 Map 中的forEach()方法
forEach()遍历集合元素

List中的forEach()

    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(5);
        list.add(8);
        list.add(10);
        list.add(9);
        list.add(2);


//匿名内部类
        list.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.print(o + " ");
            }
        });
//Lambda表达式
        list.forEach((o) -> System.out.print(o + " "));
    }

Map的forEach()方法

        HashMap<Integer,String> map = new HashMap<>();
        map.put(1,"chao");
        map.put(2,"yue");
        map.put(3,"xiao");
        map.put(4,"qiang");
        map.put(5,"yu");
//匿名内部类
        map.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer integer, String s) {
                System.out.println("Integer:"+integer+" "+"String:"+s);
            }
        });
//Lambda表达式
        map.forEach((integer, s) -> System.out.println("Integer:"+integer+" "+"String:"+s));

List的Sort()方法

        list.sort(new Comparator<Integer>() {
            @Override
            //从小到大
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });

        list.sort((o1, o2) -> o1-o2);

虽然不太关注比赛，但愿EDG守护LPL最后的荣光

标签：大道至简,int,void,System,println,out,化繁为简,Lambda
来源： https://blog.csdn.net/gjwloveforever/article/details/121179425