Java_25_方法引用

方法引用

方法引用：
方法引用是为了进一步简化Lambda表达式的写法。
方法引用的格式：类型或者对象::引用的方法。
关键语法是：“::”

 小结：
    方法引用可以进一步简化Lambda表达式的写法。
    关键语法是：“::”

范例代码：

public class MethodDemo01 {
    public static void main(String[] args) {
        List<Student> stu = new ArrayList<>();
        Student st1 = new Student("Java01");
        Student st2 = new Student("Java02");
        Student st3 = new Student("Java03");
        Collections.addAll(stu,st1,st2,st3);
        stu.forEach(System.out::println);  //方法引用简化！！
    }
}
class Student {
    private String name;
    public Student() {
    }
    public Student(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String toString() {
        return name;
    }
}

静态方法引用

1. 方法引用有四种形式：

   1. 静态方法的引用。
   2. 实例方法的引用。
   3. 特定类型方法的引用。
   4. 构造器引用。

2. 静态方法的引用。

   1. 引用格式：
      类名::静态方法。
   2. 简化步骤：
      1. 定义一个静态方法，把需要简化的代码放到一个静态方法中去。
   3. 静态方法引用的注意事项
      ” 重要：被引用的方法的参数列表要和函数式接口中的抽象方法的参数列表一致。“ 小结：
      静态方法引用的格式： 类名::静态方法。
      重要：被引用的方法的参数列表要和函数式接口中的抽象方法的参数列表一致,才可以引用简化！

public class MethodDemo02 {
    public static void main(String[] args) {
        List<Student> str = new ArrayList<>();
        Student s1 = new Student("李铭",18,'男');
        Student s2 = new Student("冯龙",23,'男');
        Student s3 = new Student("王乐乐",21,'男');
        Collections.addAll(str,s1,s2,s3);
        System.out.println(str);
        Collections.sort(str,Student::compareByAge); //简化
        System.out.println(str);
    }
}

实例方法引用

1. 实例方法的引用
2. 格式： 对象::实例方法。
3. 简化步骤：
   a.定义一个实例方法，把需要的代码放到实例方法中去。
   实例方法引用的注意事项
4. 重要：被引用的方法的参数列表要和函数式接口中的抽象方法的参数列表一致。

public class MethodDemo01 {
    public static void main(String[] args) {
        List<String> lists = new ArrayList<>();
        lists.add("java1");
        lists.add("java2");
        lists.add("java3");

        // 对象是 System.out = new PrintStream();
        // 实例方法：println()
        // 前后参数正好都是一个
        lists.forEach(s -> System.out.println(s));
        lists.forEach(System.out::println);
    }
}

特定类型方法的引用

1. 特定类型方法的引用。
2. 特定类型：String ,任何类型。
   格式：特定类型::方法。
3. 注意：
   如果第一个参数列表中的形参中的第一个参数作为了后面的方法的调用者，
   并且其余参数作为后面方法的形参，那么就可以用特定类型方法引用了。

public class MethodDemo01 {
    public static void main(String[] args) {
        String[] strs = new String[]{"James", "AA", "John",
                "Patricia","Dlei" , "Robert","Boom", "Cao" ,"black" ,
                "Michael", "Linda","cao","after","sBBB"};

        // public static <T> void sort(T[] a, Comparator<? super T> c)
        // 需求：按照元素的首字符(忽略大小写)升序排序！！！
        Arrays.sort(strs, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.compareToIgnoreCase(s2);// 按照元素的首字符(忽略大小写)比较。
            }
        });
        Arrays.sort(strs, (String s1, String s2) -> {
                return s1.compareToIgnoreCase(s2);// 按照元素的首字符(忽略大小写)比较。
        });

        Arrays.sort(strs, ( s1,  s2 ) ->  s1.compareToIgnoreCase(s2));

        // 特定类型的方法引用：
        Arrays.sort(strs,  String::compareToIgnoreCase);

        System.out.println(Arrays.toString(strs));

    }
}

构造器引用

格式是：类名::new。
注意点：前后参数一致的情况下，又在创建对象就可以使用构造器引用
s -> new Student(s) => Student::new

小结：
方法引用是可遇不可求，能用则用，不能用就不要用！

public class ConstructorDemo01 {
    public static void main(String[] args) {
        List<String> lists = new ArrayList<>();
        lists.add("java1");
        lists.add("java2");
        lists.add("java3");

        // 集合默认只能转成Object类型的数组。
        Object[] objs = lists.toArray();
        System.out.println("Object类型的数组："+ Arrays.toString(objs));

        // 我们想指定转换成字符串类型的数组！！
        // 最新的写法可以结合构造器引用实现 。
        // default <T> T[] toArray(IntFunction<T[]> generator)
        String[] strs = lists.toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });

        String[] strs1 = lists.toArray(s -> new String[s] );

        String[] strs2 = lists.toArray(String[]::new);

        System.out.println("String类型的数组："+ Arrays.toString(strs2));


    }
}