1.方法引用：

              概述：使用格式是一对 冒号 ::
              方法的引用就是用来在一定的情况下，替换Lambda表达式

      2.方法引用使用场景：

              1.如果一个Lambda表达式大括号中的代码和【另一个方法中的代码体一摸一样】
                  那么就可以使用方法引用把该方法引用过来，从而替换Lambda表达式
              2.如果Lambda表达式的大括号中的代码是调用另一个方法，
                  那么就可以使用方法引用把该方法引过来，从而替换Lambda表达式

public class Tests {

    public static void show1(){
        System.out.println("线程执行了...");
    }

    public static void main(String[] args) {
        // 创建并启动线程
        new Thread(()->{
            System.out.println("线程执行了...");
        }).start();
        /*
        * 上方代码中的Lambda表达里面的大括号中代码体和show1方法中的方法体重复了，那么我们可以使用方法引用
        * */
        new Thread(Tests::show1).start();
        System.out.println("====================================");
        // 创建并启动线程
        new Thread(()->{
            Tests.show1();
        }).start();

        /*
        * 发现上述代码中的Lambda表达式大括号里面的内容就是调用Tests类的show1方法，符合方法引用，替换Lambda表达式的场景
        * */
        new Thread(Tests::show1).start();
    }

3.方法引用的分类

@  person类

public class Person {
    public String name;

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
    public void method(String name){
        System.out.println(name);
    }
}

1.构造方法引用

构造方法引用的格式     类名::new
方法引用使用步骤：
      1.分析Lambda表达式大括号中的代码是否就是调用某个方法
      2.如果是，就是用方法引用替换Lambda表达式，如果不是，就不能替换
      3.分析引用的方法的类型
      4.确定方法的类型后，根据方法引用的格式来引用即可

public class Test1_构造方法引用 {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        /*
        * 需求：把集合中的元素转换为Person对象，并打印输出
        *
        * */
        //获取流，映射【map】，遍历【foreach】
        list.stream().map((String name)->{return new Person(name);}).forEach((Person p)->{
            System.out.println(p);
        });
        System.out.println("==================================");
        /*
        * 上述代码中，Lambda表达式大括号中的代码就是调用的Person类的带参构造方法，所以符合方法引用替换Lambda表达式
        * */
        list.stream().map(Person::new).forEach((Person p)->{
            System.out.println(p);
        });
    }
}

2.静态方法引用

 静态方法的引用       类名::方法名

public class Test2_静态方法引用 {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("111");
        list.add("222");
        list.add("333");
        list.add("444");

        // 需求：把集合中的元素转换为Integer类型，遍历输出
        list.stream().map((String s)->{
            return Integer.parseInt(s);
        }).forEach((Integer i)->{
            System.out.println(i+1);
        });
        System.out.println("===========================");

        /*
        * 上述代码中，map方法中的Lambda表达式，大括号中的代码就是调用Integer.parseInt的静态方法，符合方法引用替换Lambda表达式
        * */
        list.stream().map(Integer::parseInt).forEach((Integer i)->{
            System.out.println(i+1);
        });
    }

}

3.对象成员方法引用：带参数

 对象成员方法引用带参数       对象名::方法名

public class Test3_对象成员方法引用带参数 {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
         /*
         * 需求：把集合中的所有元素打打印输出
         * */

        list.stream().forEach((String str)->{
            System.out.println(str);
        });
        System.out.println("===============================");
        /*
        * 上述代码中，forEach方法的大括号里的代码就是调用System.out的println（）方法
        *       符合方法引用替换Lambda表达式
        * */
        list.stream().forEach(System.out::println);
    }
}

4.对象成员方法引用：不带参数

 对象成员方法引用不带参数      对象名::方法名

public class Test4_对象成员方法引用不带参数 {
    public static void main(String[] args) {

        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        /*
        * 需求：把集合中的元素转换为该元素对象的字符长度，打印输出
        * */
        list.stream().map((String str)->{
            return str.length();
        }).forEach((Integer s)->{
            System.out.println(s);
        });

        /*
        * 上述代码中，map大括号中的代码就是调用String类的length（）方法，符合方法引用替换Lambda表达式
        * 上述代码中，forEach方法的大括号里的代码就是调用System.out的println（）方法符合方法引用替换Lambda表达式
        * */
        list.stream().map(String::length).forEach(System.out::println);
    }
}