【金秋打卡】第七天+Lmabda方法引用-原创手记-慕课网

课程名称：一课掌握Lambda表达式语法及应用

课程章节：第四章第一节

主讲老师：大牧莫邪

课程内容：

2变量捕获

public class APP2 {
    String s1 = "全局变量";

    //匿名内部类对于变量的访问
    public void testInnerClass(){
        String s2 = "局部变量";

        new Thread(new Runnable() {
            String s3 = "内部变量";
            @Override
            public void run() {
                //访问全局变量
                System.out.println(s1); //不能用this，this表示当前内部类的对象；
                //局部变量的访问
                System.out.println(s2); // 不能对局部变量进行数据的修改[final]
                //内部变量的访问
                System.out.println(s3);
                System.out.println(this.s3);
            }
        }).start();
    }

    //Lambda表达式捕获变量
    public void testLambda(){
        String s2 = "局部变量Lmabda";

        new Thread(() -> {
            String s3 = "内部变量Lmabda";

            //访问全局变量
            System.out.println(this.s1);  //this~表示的就是所属方法所在类型的对象
            //访问局部变量
            System.out.println(s2);  //不能修改s2，默认推到为修饰符为final
            //访问内部变量
            System.out.println(s3); //可以直接访问，可以直接修改
        }).start();
    }

    public static void main(String[] args) {
        APP2 app2 = new APP2();
        app2.testInnerClass();

        app2.testLambda();
    }
}

3Lambda表达式类型检查

public class APP3 {

    public static void test(MyInterface<String, List > inter) {
        List<String> list = inter.strange("hello", new ArrayList());
        System.out.println(list);
    }

    public static void main(String[] args) {
        //普通模式
        test(new MyInterface<String, List>() {
            @Override
            public List strange(String s, List list) {
                list.add(s);
                return list;
            }
        });

        //Lambda模式
        test((x, y) -> {
            y.add(x);
            return y;
        });
    }

}

/**
 * (x ,y)->{..}  --> test(param) --> param == MyInterface --> lambda表达式 -> MyInterface类型
 * 这个就是对lambda表达式的类型检查，MyInterface接口就是lambda表达式的目标类型(target typing)
 *
 * (x,y) -> {..} --> MyInterface.strange(T t, R r) -->MyInterface<String, List> inter -->
 *  T == String , R == List -->lambda --> (x,y) == strange(T t, R r) --> x==T==String y==R==List
 *
 *  以上就是lambda表达式的类型检查
 */

@FunctionalInterface
interface MyInterface<T, R>{
    R strange(T t, R r);
}

匿名内部类的变量捕获
Lambdab表达式中的变量捕获
看两者的区别，更好理解Lambda的优势

4方法重载和Lambda表达式

javal类型系统中重载的实现
方法重载的实现

当方法重载遇上Lambdab表达式

public class APP4 {
    interface param1{
        void outInfo(String info);
    }
    interface param2{
        void outInfo(String info);
    }

    //定义重载方法
    public void lambdaMethod(param1 param1){
        param1.outInfo("hello one");
    }
    public void lambdaMethod(param2 param2){
        param2.outInfo("hello two");
    }

    public static void main(String[] args) {
        APP4 app4 = new APP4();
        app4.lambdaMethod(new param1() {
            @Override
            public void outInfo(String info) {
                System.out.println(info);
            }
        });

        app4.lambdaMethod(new param2() {
            @Override
            public void outInfo(String info) {
                System.out.println("--------------------");
                System.out.println(info);
            }
        });

        /**
         * lambda表达式存在类型检查 -> 自动推导lambda表达式的目标类型
         * lambdaMehtod() -> 方法 ->重载方法
         *                -> param1 函数式接口
         *                -> param2 函数式接口
         *                调用方法 -> 传递lambda表达式 -> 自动推导
         *                -> param1 | param2
         */
        app4.lambdaMethod((String info) ->{
            System.out.println(info);
        });
    }
}

5:Lambda表达式方法引用

方法引用是Lambda表达式的一种语法特性
静态方法引用
实例方法引用
构造方法引用

@Data                  // get和set方法
@AllArgsConstructor    //有参构造方法
@NoArgsConstructor     //无参构造方法
class person{
    private String name;
    private String sex;
    private int age;

    public static int compareByAge(person p1, person p2){
        return p1.age - p2.age;
    }
}

class PersonUtil{
    //增加一个实例方法
    public int compareByName(person p1, person p2){
        return p1.getName().hashCode() - p2.getName().hashCode();
    }
}

/**
 * 1:静态方法的引用
 * 类型名称、方法名称() --> 类型名称：：方法名称
 *
 * 2：实例方法引用的使用
 * 创建类型对应的一个对象  -->  对象应用::实例方法名称
 */
public class Test {
    public static void main(String[] args) {
        //存储person对象列表
        List<person> personList = new ArrayList<person>();
        personList.add(new person("tom", "man", 17));
        personList.add(new person("tom", "man", 18));
        personList.add(new person("tom", "man", 19));
        personList.add(new person("tom", "man", 20));

        // 1:匿名内部类的实现方式
        Collections.sort(personList, new Comparator<person>() {
            public int compare(person o1, person o2) {
                return o1.getAge() - o2.getAge();
            }
        });
//        System.out.println(personList);
        //2：Lambda表达式的实现方式
        Collections.sort(personList, (p1,p2) -> p1.getAge() - p2.getAge());
//        System.out.println(personList);
        //3：静态方法的引用
        Collections.sort(personList, person::compareByAge);
        System.out.println(personList);
        //4：实例方法引用
        PersonUtil pu = new PersonUtil();
        Collections.sort(personList, pu::compareByName);
        System.out.println("tom".hashCode());
        System.out.println("jerry".hashCode());
        System.out.println(personList);
        //5：构造方法引用
        IPerson ip = person::new;
        person person = ip.initPerson("jerry","man",18);
        System.out.println(person);
    }
}

interface IPerson{
    //抽象方法：通过类型的构造方法初始化对象数据
    person initPerson(String name,String gender, int age);
}

课程收获：

Lambda表达式要学的东西太多了，全程光剩下记载了，在这正好做个笔记，这样以后也方便我查询浏览复习，Lambda对于初学者太不友好了，门道真多啊！，不过学东西的感觉，真爽！

革命还未成功，同志还需努力啊！