方法引用的学习

把已经有的方法拿过来用，当作函数时接口中抽象方法的方法体

1.引用出必须是函数式接口

2.被引用的方法必须已经存在

3.被引用方法的形参和返回值必须与抽象方法保持一致

4.被引用的方法功能要满足当前需求

        /*
         * 创建一个数组，按照倒叙排序
         * */


        //创建数组
        Integer[] arr = {2, 1, 5, 7, 3, 4};

        //匿名内部类
/*
        Arrays.sort(arr, new Comparator() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });*/

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

        //Lambda表达式
/*        Arrays.sort(arr,(Integer o1, Integer o2)->{
            return o2-o1;
        });*/

//        Arrays.sort(arr, (o1, o2) -> o2 - o1);

//        System.out.println(Arrays.toString(arr));

        //方法引用

        /*
        * 表示引用FunctionDemo里的Demo1里的subraction方法
        * 把这个方法当作抽象方法的方法体
        * */

        Arrays.sort(arr,Demo1::subraction);
        System.out.println(Arrays.toString(arr));

    }

    public static int subraction(int num1, int num2) {
        return num2 - num1;
    }

：：是什么符号？

是方法引用符

方法引用的分类

引用静态方法

格式：类名：：静态方法

范例：Integer::parseInt

ArrayList list = new ArrayList<>();
Collections.addAll(list, "1", "2", "3", "4", "5");

list.stream().map(new Function() {
    @Override
    public Integer apply(String s) {
        int i=Integer.parseInt(s);
        return i;
    }
}).forEach(s-> System.out.println(s));

list.stream().map(Integer::parseInt).forEach(s-> System.out.println(s));

引用成员方法

格式：对象：：成员方法

其他类：        其他类对象：：方法名

本类:        this：：方法名

父类：        super：：方法名

不能写在静态里，静态没用this和super

引用构造方法

格式： 类名：：new

范例： Student：：new

使用类名引用成员方法

格式： 类名：：成员方法

范例： String：：substring

规则

1.需要有函数式接口

2.被引用的方法已经存在

3.被引用方法的形参，需要跟抽象方法的第二个形参到最后一个形参保持一致，返回值需要保持一致

4、被引用方法的功能需要满足当前的需求

详解：

第一个参数：表示被引用方法的调用者，决定了可以引用的那些类中的方法

                        在Stream流里，第一个参数一般都表示流里的每一个数据

                        假设流里的数据都是字符串，把么使用这种方法进行方法引用，只能引用String这个类中的方法

第二个参数到最后一个参数：跟被引用方法的形参保持一致，如果没有第二个参数，说明被引用的方法需要是无参的成员方法

        ArrayListlist=new ArrayList<>();
        Collections.addAll(list,"aaa","bbb","ccc");
/*        list.stream()
                .map(new Function() {
                    @Override
                    public String apply(String s) {
                        return s.toUpperCase();
                    }
                })
                .forEach(s-> System.out.println(s));*/

        list.stream()
                .map(String::toUpperCase)
                .forEach(s-> System.out.println(s));

引用数组的构造方法

格式：        数据类型[] ：：new

范例：        int [] ：：new

数组的类型需要跟流中数据类型保持一致

        ArrayList list = new ArrayList<>();
        Collections.addAll(list, 1, 2, 3, 4, 5);

/*        Integer[] arr = list.stream().toArray(new IntFunction() {
            @Override
            public Integer[] apply(int value) {
                return new Integer[value];
            }
        });*/

        Integer[] arr2 = list.stream().toArray(Integer[]::new);
        System.out.println(Arrays.toString(arr2));