2.2.引用静态方法

一.引用静态方法的格式：

• 上述图片中Integer是整型的包装类，parseInt是Integer类里的静态方法，parseInt方法的作用是把字符串转为整数，parseInt是静态的，可以类名.方法名进行调用，也可以使用类名::静态方法名（方法引用）进行调用

---

二.练习：

题目：

解法一：

import java.util.ArrayList;
import java.util.Collections;
​
public class Main {
    public static void main(String[] args) {
        //1.创建字符串集合
        ArrayList<String> list1=new ArrayList<>();
​
        //2.添加元素
        Collections.addAll(list1,"1","2","3","4","5");
​
        //3.创建整型集合
        ArrayList<Integer> list2=new ArrayList<>();
​
        //4.遍历list1集合将其内容修改为整型并添加到list2集合中
        for (String s : list1) {
            int i = Integer.parseInt(s);
            list2.add(i);
        }
​
        //5.遍历list2集合
        System.out.println(list2); //运行结果为[1, 2, 3, 4, 5]
    }
}

解法一较为繁琐。

解法二：使用stream流里的map方法

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;
​
public class Main {
    public static void main(String[] args) {
        //1.创建字符串集合
        ArrayList<String> list=new ArrayList<>();
​
        //2.添加元素
        Collections.addAll(list,"1","2","3","4","5");
​
        //3.把list集合中的元素的数据类型都变为整型
        /*函数式接口Function的泛型有两个，
          第一个泛型是当前流里的类型，本例中list集合调用stream流，所以stream流里的类型就是list集合里的数据的类型，
          第二个泛型是要转化成的类型*/
        list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                //s就是流里面的元素即集合list中的每一个元素，此时要把list集合中的元素的类型全部变成整型
                int i = Integer.parseInt(s);
                return i; //apply方法结束后就把list集合中的数据变为整数了
            }
        }).forEach(s-> System.out.println(s));
    }
}

注意事项：

Function是一个函数式接口(Function接口是一个函数式接口，而且此时是创建了Function接口的匿名内部类，这里可以用lambda表达式进行简化，就不做演示了)，Function接口有两个泛型:在本例中第一个泛型是当前流里的数据的类型（调用该流的数据的类型就是第一个泛型的类型），第二个泛型是要转化成的类型

调用完map方法后可以new一个Function接口：

但是由于Function接口有两个泛型，此时只能确定第一个泛型类型是流里面的数据的类型，第二个泛型是要被转换为的数据类型，需要人为指定。系统默认为第二个泛型是顶级父类类型Object：

本例中第二个泛型需要被指定为Integer型：

由于Function接口中有一个抽象方法apply，此时就需要重写apply方法，快捷方式就是点击右上角红色感叹号，会弹出出错的地方，此时找到重写apply方法的那一条，右击后->显示快速修复->实现方法->根据需求重写apply方法，apply方法的形参类型需要和Function接口中第一个泛型类型保持一致（apply方法只有一个形参）。

还有一个地方报错就是缺;，在报错地方补上;即可。

解法三：使用方法引用来简化解法二里的代码

之所以使用方法引用来简化代码，是为了使代码看起来更简洁。

map方法里Function接口是函数式接口，所以在Function处可以使用方法引用，

要引用的方法需要满足以下要求：

1.被引用的方法需要已经存在，没有的话就需要自行编写 2.被引用的方法的形参和返回值需要跟抽象方法的形参和返回值保持一致 3.被引用的方法的功能需要满足当前的需求

Function接口中的抽象方法是apply方法，在map方法中已经对apply方法进行了重写，map方法里的apply方法的形参只有一个，且该形参类型是String型，apply方法的返回值是Integer型，apply方法的功能是把形参的字符串转化为整数

->此时就要找形参只有一个且该形参类型是String型，返回值为Integer型，且功能是把形参的字符串转化为整数的方法

->在Java中存在这样的方法，就是Integer类里的只有一个形参的parseInt方法：

只有一个形参的parseInt方法的方法体是返回一个parseInt方法，但这个parseInt方法有两个形参，功能也是把形参里的字符串转化为整数：

->所以可以引用Integer类里只有一个形参的parseInt方法:

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Consumer;
​
public class Main {
    public static void main(String[] args) {
        //1.创建字符串集合
        ArrayList<String> list=new ArrayList<>();
​
        //2.添加元素
        Collections.addAll(list,"1","2","3","4","5");
​
        //3.把list集合中的元素的数据类型都变为整型
        /*通过分析map方法里可以直接引用Integer类里只有一个形参的parseInt方法，
          把Integer类里只有一个形参的parseInt方法当作函数式接口Function里的
          抽象方法的方法体 */
        list.stream().map(Integer::parseInt).forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
    }
}

Consumer接口是一个函数式接口，而且此时是创建了Consumer接口的匿名内部类，所以可以使用lambda表达式简化，简化后：

import java.util.ArrayList;
import java.util.Collections;
​
public class Main {
    public static void main(String[] args) {
        //1.创建字符串集合
        ArrayList<String> list=new ArrayList<>();
​
        //2.添加元素
        Collections.addAll(list,"1","2","3","4","5");
​
        //3.把list集合中的元素的数据类型都变为整型
        /*通过分析map方法里可以直接引用Integer类里只有一个形参的parseInt方法，
          把Integer类里只有一个形参的parseInt方法当作函数式接口Function里的
          抽象方法的方法体 */
        list.stream()
                .map(Integer::parseInt)
                .forEach(integer -> System.out.println(integer) );
    }
}

解法四：

package com.itheima.a01myfunction;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.stream.Stream;
​
public class FunctionDemo2 {
    public static void main(String[] args) {
        /*
         方法引用（引用静态方法）
         格式：
           类名::静态方法名 */
​
        //1.创建集合
        ArrayList<String> list=new ArrayList<>();
​
        //2.添加元素
        Collections.addAll(list,"1","2","3","4","5");
​
        //3.获取stream流
        Stream<String> stream = list.stream();
​
        //4.遍历
        /* s代表流里面的数据，此时list集合获取了stream流，
           所以s代表list集合中的数据 */
        stream.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                int result = Integer.parseInt(s); //此处不是函数式接口，不能用方法引用
                System.out.println(result);
            }
        });
    }
}
​

Consumer接口是一个函数式接口，而且此时是创建了Consumer接口的匿名内部类，所以可以使用lambda表达式简化，简化后：

package com.itheima.a01myfunction;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;
​
public class FunctionDemo2 {
    public static void main(String[] args) {
        /*
         方法引用（引用静态方法）
         格式：
           类名::静态方法名 */
​
        //1.创建集合
        ArrayList<String> list=new ArrayList<>();
​
        //2.添加元素
        Collections.addAll(list,"1","2","3","4","5");
​
        //3.获取stream流
        Stream<String> stream = list.stream();
​
        //4.遍历
        /* s代表流里面的数据，此时list集合获取了stream流，
           所以s代表list集合中的数据 */
        stream.forEach( s -> {
                int result = Integer.parseInt(s); //此处不是函数式接口，不能用方法引用
                System.out.println(result);
        });
    }
}

​

---