jdk8新特性-Lambda表达式，方法引用

Lambda方法引用的概念

1).什么是“方法引用”：当我们使用Lambda实现一些功能时，发现已有的类库中已经有方法实现了这样的功能，这时，我们就可以引用已实现的方法来代替Lambda。(实际上就是将已有的方法传入了方法体，省略Lambda表达式)
2).常用的引用：
1).通过“对象”引用“普通成员方法”；
2).通过“类”引用“静态方法”；
3).引用“构造方法”；
4).通过“类”引用“普通成员方法”；

1. Lambda方法引用_对象引用成员方法

1).通过“对象”，引用它的“普通成员方法”：
2).示例代码：

/*
    通过"对象"，引用成员方法.
 */
//已有的类和方法。
class Student{
    public void show(){
        for (int i = 1; i <= 100 ; i++) {
            System.out.println("i = " + i);
        }
    }
}
public class Demo01 {
    public static void main(String[] args) {
        //1.制作一个线程，线程中打印1--100的所有的数字
        //使用Lambda的方式
        new Thread(()-> {
            for (int i = 1; i <= 100 ; i++) {
                System.out.println("i = " + i);
            }
        }).start();

        //这时，我们发现已有的Student类中的show()已经实现了这样的功能
        //我们就可以引用Student类的show()方法：格式：对象名::方法名
        Student stu = new Student();
        new Thread(stu::show).start();//实际上就是传入了show()方法。Thread内部就直接调用show()方法

        for (int k = 0; k < 100; k++) {
            System.out.println("k = " + k);
        }
//一个小练习
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("张三丰");
list.add("章子怡");
list.add("张无忌");
System.out.println("呵呵");

//筛选出所有张姓学员，并打印-使用Lambda
list.stream().filter(s -> s.startsWith("张"))
             .forEach(s -> System.out.println(s));//此处使用了Lambda，功能：接收一个String，打印一个String
//我们发现现有类库中，有个方法也可以做一样的事：接收一个String，打印一个String
//System.out对象的println方法具有这样的功能。
//我们就可以引用这个方法
list.stream().filter(s -> s.startsWith("张"))
             .forEach(System.out::println);//直接传入了println()方法。forEach内部也会直接调用println()方法。

    }
}

调用方法的发展：子类 --> 匿名内部类 --> Lambda --> 已有的方法(方法引用)

2. Lambda方法引用_类引用静态方法

1).通过“类名”，引用“静态方法”。
2).示例代码：

/*
    通过"类名"，引用它的"静态方法"
 */
//已有一个接口
interface IA{
    public int getMax(int a ,int b);

}
public class Demo02 {
    public static void main(String[] args) {
        //现在调用calc()方法

        //1.传入Lambda--直接重写getMax(int a,int b)方法
        calc((a,b)-> {
            return a > b ? a : b;
        });

        //2.我们发现现有类库中，有个方法实现了这个功能：Math类的静态方法"max()"
        //由于是静态方法，我们就可以直接通过"类名"引用静态方法：格式：类名::方法名
        calc(Math::max);//实际传入的是Math类的max()方法，calc方法内部调用的也不是Lambda了，而是Math的max()方法

    }
    //已有的一个方法
    public static void calc(IA a){
        int max = a.getMax(10, 20);
        System.out.println("最大值：" + max);
    }
}

3. Lambda方法引用_构造器引用

1).引用某个类的“构造方法”；
2).示例代码：

//自定义猫类
class Cat{
    private String name;
    public Cat(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return "我是一只小猫，我叫：{" +
                "name='" + name + '\'' +
                '}';
    }
}
//测试类
public class Demo03 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();//存储是猫的名字
        list.add("小花");
        list.add("小红");
        list.add("小翠");

        //将这个集合中的名字构造出对应的Cat对象，并打印
        list.stream().map(s -> new Cat(s))//将Stream<String> 转换为Stream<Cat>
                    .forEach(cat -> System.out.println(cat));

        //我们看map(s -> new Cat(s))，功能：接收一个String，返回一个Cat对象
        //而Cat类的带参构造方法也实现这个功能。这时，我们就可以引用：Cat类的带参的构造方法
        list.stream().map(Cat::new)//引用Cat的String参数的构造方法，自动匹配Cat的String参数的构造方法
                    .forEach(cat -> System.out.println(cat));
    }
}

4. Lambda方法引用_类引用成员方法【难点】

1).通过“类名”来引用它的“普通成员方法”。
2).示例代码：

//已有的一个接口
interface IA{
    public int findStr(String srcStr,String subStr);
}
//测试类
public class Demo04 {
    public static void main(String[] args) {
        //1.使用匿名内部类
        fun(new IA() {
            @Override
            public int findStr(String srcStr, String subStr) {//找第二个参数在第一个参数中出现的位置
                int index = srcStr.indexOf(subStr);
                return index;
            }
        });

        //2.使用Lambda
        fun((srcStr, subStr) -> srcStr.indexOf(subStr));//也是：找第二个参数在第一个参数中出现的位置

        //当我们的Lambda表达式中，是调用第一个参数的某个方法，将第二个参数作为调用第一个参数的方法的实参
        //这时可以使用"第一个参数的类型名::这个类中被调用的方法名"的形式引用一个类的普通方法。
        fun(String::indexOf);
    }

    //已有的一个方法
    public static void fun(IA a){
        int index = a.findStr("我爱Java", "Java");//内部："我爱Java".indexOf("Java")
        System.out.println("索引位置：" + index);
    }
}