Lambda表达式（Java）

1.Lambda表达式

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

        “->”（Lambda操作符）左边：Lambda表达式的所有参数。右边：Lambda体，Lambda需要执行的功能。

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("这是一个实现Runnable接口的子线程！");
    }
}
public class Test {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        //等价于
        Runnable runnable = new Runnable(){
            @Override
            public void run() {
                System.out.println("这是一个实现Runnable接口的子线程！");
            }
        };
        //等价于
        Runnable runnable1 = ()-> System.out.println
                    ("这是一个实现Runnable接口的子线程！");

        Thread thread = new Thread(myRunnable);
        thread.start();
        //等价于
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("这是一个实现Runnable接口的子线程！");
            }
        }).start();
        //等价于
        new Thread(() -> System.out.println
                   ("这是一个实现Runnable接口的子线程！")).start();


    }

        1.无参、无返回值

public interface Www {
    public abstract void print1();//无参、无返回值
}

public class WwwTest {
    public static void main(String[] args) {
        Www www1 = new Www() {
            @Override
            public void print1() {
                System.out.println("无参、无返回值");
            }
        };
        Www www2 = ()-> {System.out.println("无参、无返回值")};
        //等价于 当Lambda体只有一条语句的时候，return和{}可以省略掉
        Www www3 = ()-> System.out.println("无参、无返回值");

        //以上三种方法相当于创建一个类实现了Www接口。
        //当运行方法时，要使用对象名.print();
    }
}

        2.无参、有返回值

public interface Www {
    public abstract String print2();//无参、有返回值
    //public abstract String print3(String name);//有参、有返回值
    //public abstract String print4(String name,int i);//有多个参、有返回值
}

package lambda;

public class WwwTest {
    public static void main(String[] args) {
        Www www1 = new Www() {
            @Override
            public String print2() {
                return "无参、有返回值";
            }
        Www www2 = ()-> "无参、有返回值";
        //等价于
        Www www3 = ()->{ return  "无参、有返回值";};
        //以上三种方法相当于创建一个类实现了Www接口。
        //当运行方法时，要使用对象名.print();
    }
}

        3.有参、有返回值

public interface Www {
   public abstract String print3(String name);//有参、有返回值
}

public class WwwTest {
    public static void main(String[] args) {
        Www www1 = new Www() {

            @Override
            public String print3(String name) {
                System.out.println(name);
                return "有参、有返回值";
            }

        Www www2 = (name)->{
            System.out.println(name);
            return "有参、有返回值";
        };
        //等价于  只有一个参数时，可以省略（）
        Www www3 = name->{
            System.out.println(name);
            return "有参、有返回值";
        };
    }
}

        4.有多个参、有返回值

public interface Www {
   public abstract String print4(String name,int i);//有多个参、有返回值
}

public class WwwTest {
    public static void main(String[] args) {
        Www www1 = new Www() {
            @Override
            public String print4(String name, int i) {
                System.out.println(name+i);
                return "有多个参、有返回值";
            }
        };
        Www www2 = (name, i) -> {
            System.out.println(name+i);
            return "有多个参、有返回值";
        };
    }
}

        5.类型推断：数据类型可以省略，因为编译器可以推断得出，称为“类型推断”。

public interface Www {
   public abstract String print4(String name,int i);//有多个参、有返回值
}

public class WwwTest {
    public static void main(String[] args) {
        Www www1 = new Www() {
            @Override
            public String print4(String name, int i) {
                System.out.println(name+i);
                return "有多个参、有返回值";
            }
        };
        Www www2 = (String name,int i) -> {
            System.out.println(name+i);
            return "有多个参、有返回值";
        };

        //等价于
        Www www3 = (name, i) -> {
            System.out.println(name+i);
            return "有多个参、有返回值";
        };
    }
}

2.forEach+Lambda

        1.使用forEach和Lambda循环list集合

public class ArrayList {
    public static void main(String[] args) {
        List<String> list = new java.util.ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        System.out.println("--------------------");
        list.forEach(s -> System.out.println(s));
    }
}

        2.使用forEach和Lambda循环map集合

public class Student {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

public class HashMap1 {
    public static void main(String[] args) {
        Map<String,Student> map = new HashMap<>();
        map.put("a",new Student("张三"));
        map.put("b",new Student("李四"));
        map.put("c",new Student("王五"));
        map.forEach((key,value)-> System.out.println(key+"======"+ value.getName()));

        //使用for增强循环遍历map集合
        System.out.println("=====================");
        Set keys = map.keySet();//返回键的集合
        for (Object key : keys) {
            System.out.println(key+"====="+map.get(key).getName());//get(key)根据键返回值
        }

    }
}

3.函数接口

        只包含一个抽象方法的接口，称为函数式接口。并且可以使用lambda表达式来创建该接口的对象，可以在任意函数式接口上使用 @FunctionalInterface 注解，来检测它是否是符合函数式接口。同时javac也会包含一条声明，说明这个接口是否符合函数式接口。

        Java中的函数式编程体现就是Lambda表达式，所以函数式接口即可以适用于Lambda使用的接口。

@FunctionalInterface
public interface Www {
    public abstract void print();
}

public class WwwTest {
    public static void main(String[] args) {
        Www www1 = new Www() {
            @Override
            public void print() {
                System.out.println("aaaa");
            }
        };
        www1.print();
        Www www2 = ()-> System.out.println("aaaa");
        www2.print();

    }
}

当接口中写入两个抽象方法时，会报错。

        ·