java基础-7 Lambda表达式

Lambda表达式

函数式编程思想概述

public class MyRunnable implements Runnable {

    @Override
    public void run(){
        System.out.println("多线程启动了！");
    }
}

    public static void main(String[] args) {
        //实现类的方式实现需求
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();

        //匿名内部类的方式改进
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程启动了！");
            }
        }).start();

        //Lambda表达式的方式改进
        new Thread(() -> {
            System.out.println("多线程启动了！");
        }).start();
    }

 Lambda表达式格式

public interface Eatable {
    void eat();
}


public static void main(String[] args) {
        //在主方法中调用useEatable方法
        Eatable e = new EatableImpl();
        useEatable(e);

        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("一天一苹果，医生远离我");
            }
        });

        //Lambda表达式
        useEatable(() -> {
            System.out.println("一天一苹果，医生远离我");
        });
    }

    private static void useEatable(Eatable e) {
        e.eat();
    }

public interface Fly {

    void flyAble(String s);
}

public class Test {
    public static void main(String[] args) {
        //在方法中调用
        Fly fly = new FlyImplements();
        userFly(fly);

        //匿名内部类的方式改进
        userFly(new Fly() {
            @Override
            public void flyAble(String s) {
                System.out.println(s);
            }
        });

        //Lambda表达式的方式改进
        userFly((String s) -> {
            System.out.println(s);
        });

    }
    public static void userFly(Fly fly){
        fly.flyAble("想带你去看晴空万里！");
    }
}

public interface AddNum {
    void add(int x, int y);
}

public class Test {
    public static void main(String[] args) {

        //Lambda表达式的方式改进
        addTest((int x, int y) -> {
            int sum = x + y;
            System.out.println(sum);
        });

    }
    public static void addTest(AddNum a){
        a.add(1, 5);
    }
}

Lambda表达式省略模式

//        useAddable((int x,int y) -> {
//            return x + y;
//        });
        //参数的类型可以省略
        useAddable((x, y) -> {
            return x + y;
        });
        //但是有多个参数的情况下，不能只省略一个
//        useAddable((x,int y) -> {
//            return x + y;
//        });

//        useFlyable((String s) -> {
//            System.out.println(s);
//        });
//        useFlyable((s) -> {
//            System.out.println(s);
//        });
        //如果参数有且仅有一个，那么小括号可以省略
//        useFlyable(s -> {
//            System.out.println(s);
//        });

        //如果代码块的语句只有一条，可以省略大括号和分号
        useFlyable(s -> System.out.println(s));

        //如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉
        useAddable((x, y) -> x + y);
    }

• Lambda表达式的省略模式

    public static void main(String[] args) {
//        useAddable((int x,int y) -> {
//            return x + y;
//        });
        //参数的类型可以省略
        useAddable((x, y) -> {
            return x + y;
        });
        //但是有多个参数的情况下，不能只省略一个
//        useAddable((x,int y) -> {
//            return x + y;
//        });

//        useFlyable((String s) -> {
//            System.out.println(s);
//        });
//        useFlyable((s) -> {
//            System.out.println(s);
//        });
        //如果参数有且仅有一个，那么小括号可以省略
//        useFlyable(s -> {
//            System.out.println(s);
//        });

        //如果代码块的语句只有一条，可以省略大括号和分号
        useFlyable(s -> System.out.println(s));

        //如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉
        useAddable((x, y) -> x + y);
    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

• Lambda表达式的注意事项

public class LambdaDemo {
    public static void main(String[] args) {
//        useInter(() -> {
//            System.out.println("好好学习天天向上");
//        });

        //使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
        useInter(() -> System.out.println("好好学习天天向上"));

        //必须有上下文环境，才能推导出Lambda对应的接口
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("匿名内部类");
//            }
//        }).start();

//        Runnable r = () -> System.out.println("Lambda表达式");
//        new Thread(r).start();

        new Thread(() -> System.out.println("Lambda表达式")).start();
    }

    private static void useInter(Inter i) {
        i.show();
    }
}

• Lambda表达式和匿名内部类的区别

• 方法引用

public interface ShowTest {
    void show(String s);
}

public class Test {
    public static void main(String[] args) {
        //lambda表达式正常格式
        useShow((s)->{
            System.out.println(s);
        });
        //lambda表达式省略格式
        useShow((s)->System.out.println(s));
        //方法引用，可推导的就是可省略的
        useShow(System.out::println);
    }

    public static void useShow(ShowTest st){
        st.show("光辉岁月");
    }
}

/*
光辉岁月
光辉岁月
光辉岁月
*/

• 方法引用符

public interface ShowTest {
    void show(String s);
}

public class Test {
    public static void main(String[] args) {
        //lambda表达式正常格式
        useShow((s)->{
            System.out.println(s);
        });
        //lambda表达式省略格式
        useShow((s)->System.out.println(s));
        //方法引用，可推导的就是可省略的
        useShow(System.out::println);
    }

    public static void useShow(ShowTest st){
        st.show("光辉岁月");
    }
}

/*
光辉岁月
光辉岁月
光辉岁月
*/

• 引用类方法

public interface ShowTest {
    int transform(String s);
}

public class Test {
    public static void main(String[] args) {
        //lambda表达式
        useTrans((String s) -> {
            return Integer.parseInt(s);
        });

        //lambda表达式省略模式
        useTrans((s) -> Integer.parseInt(s));

        //引用类方法
        //Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数
        useTrans(Integer::parseInt);
    }

    public static void useTrans(ShowTest st){
        int num = st.transform("251");
        System.out.println(num);
    }
}

• 引用对象的实例方法

  

public class CountTest {

    public int countLen(String str){
        return str.length();
    }
}

public interface ShowTest {
    int count(String s);
}

public class Test {
    public static void main(String[] args) {
        //lambda表达式
        useCount((String s) -> {
            return s.length();
        });

        //lambda表达式省略模式
        useCount((s) ->s.length());

        //引用对象的实例方法
        CountTest ct = new CountTest();
        useCount(ct::countLen);
        //Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数
    }

    public static void useCount(ShowTest st){
        int num = st.count("往后余生");
        System.out.println(num);
    }
}

/*
4
4
4
*/

• 引用类的实例方法

public interface ShowTest {
    String subString(String s, int x, int y);
}

public class Test {
    public static void main(String[] args) {
        //lambda表达式
        useSubString((String s, int x, int y)->{
            String str = s.substring(x, y);
            return str;
        });

        //lambda表达式省略模式
        useSubString((s, x, y)-> s.substring(x, y));

        //引用类的实例方法
        //第一个参数作为调用者
        //后面的参数全部传递给改方法作为参数
        //Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数
        useSubString(String::substring);
    }

    public static void useSubString(ShowTest st){
        String str = st.subString("余生，请多指教！",0 , 7);
        System.out.println(str);
    }
}

/*
余生，请多指教
余生，请多指教
余生，请多指教
*/

• 引用构造器

public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

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

    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 interface StudentBuild {
    Student build(String name, int age);
}


public class Test {
    public static void main(String[] args) {
        //匿名内部类
        useStudentBuild(new StudentBuild() {
            @Override
            public Student build(String name, int age) {
                Student stu = new Student(name, age);
                return stu;
            }
        });

        //lambda表达式
        useStudentBuild((String name,int age) ->{
            Student stu = new Student(name, age);
            return stu;
        });

        //lambda表达式省略模式
        useStudentBuild((name,age) ->new Student(name, age));

        //引用构造器
        useStudentBuild(Student::new);
        //Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数

    }

    public static void useStudentBuild(StudentBuild sb){
        Student stu = sb.build("李茂贞", 25);
        System.out.println(stu.toString());
    }
}


/*
Student{name='李茂贞', age=25}
Student{name='李茂贞', age=25}
Student{name='李茂贞', age=25}
Student{name='李茂贞', age=25}
*/