Lambda表达式

Lambda表达式注意：

如果接口只有一个抽象方法，那么这个接口是函数式接口，可以用Lambda来简化
如果我们在接口上声明@FunctionalInterface注解，那么编译器就会按照函数式接口的定义来定义接口，如果你给借口中弄两个抽象方法，那么程序编译就会报错。

案例

public class TestLambda01 {
    public static void main(String[] args) {
        Dog dog1 = new Dog() {

            @Override
            public void eat() {
                System.out.println("狗吃饭");
            }
        };
        dog1.eat();


        //无参无返回值
        Dog dog = ()->{
            System.out.println("Lambda狗吃饭");
        };
        dog.eat();

        //无参有返回值
        Person person = ()->{
            return 23;
        };
        int age = person.getAge();
        System.out.println(age);

        //有参无返回值
        Girl girl = (name)->{
            System.out.println(name);
        };
        girl.say("Andy");

        //有参有返回值
        Sum sum = (x,y)->{
            return x+y;
        };
        int result = sum.sum(3,4);
        System.out.println(result);

    }
}

interface Dog{
    void eat();
}

@FunctionalInterface
interface Person{
    int getAge();
}

@FunctionalInterface
interface Girl{
    void say(String name);
}

@FunctionalInterface
interface Sum{
    int sum(int a,int b);
}

Lambda对集合的操作

public class TestLambda02 {
    public static void main(String[] args) {
        //jdk自带的日志工具
        Logger global = Logger.getGlobal();

        List<String> list = new ArrayList<String>();
        list.add("张三");
        list.add("李四");
        list.add("Joy");
        list.add("Andy");

        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
            global.info(list+" ");
            global.info(String.valueOf(list));
        }
        System.out.println();

        for (String s: list
             ) {
            System.out.print(s + " ");
        }
        System.out.println();

        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.print(s + " ");
            }
        });
        System.out.println();

        list.forEach((String a)->{
            System.out.print(a + " ");
        });
        System.out.println();

        listSort(list);

        /*
        * Map(Key,Value)
        * Key不能重复
        * Value可以重复
        * 通过Key拿Value
        */
        Map<Integer,String> map = new HashMap<Integer,String>();
        map.put(1,"张三");
        map.put(2,"李四");
        map.put(3,"Joy");
        map.put(4,"Andy");

        map.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer integer, String s) {
                System.out.print(integer + " = " + s + " ");
            }
        });
        System.out.println();

        map.forEach((key,value)->{
            System.out.print(key + " = " + value + " ");
        });
        System.out.println();

    }

    private static void listSort(List<String> list){
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        System.out.print(list + " ");
        System.out.println();

        list.sort((a1,a2)->{
            return a1.compareTo(a2);
        });
        System.out.print(list + " ");
        System.out.println();
    }

}