Java核心类库之（接口组成更新、方法引用、函数式接口）-阿里云开发者社区

以下博客是根据黑马视频写的Javase全集博客笔记：黑马程序员全套Java教程_Java基础入门视频教程，零基础小白自学Java必备教程

（一）Java语言基础

（二）Java面向对象编程

（三）Java核心类库之（常用API、字符串类、集合类、泛型）

（四） Java核心类库之（异常机制）

（五）Java核心类库之（字符集/编码集、File类、递归、IO流：字节流、字符流、特殊操作流）

（六）Java核心类库之（类加载器、反射机制、模块化）

（七）Java核心类库之（Lambda表达式）

（八）Java核心类库之（接口组成更新、方法引用、函数式接口）

（九）Java核心类库之（Stream流：生成、中间、终结、收集操作）

（十）Java核心类库之（多线程：实现多线程、线程同步）

（十一）Java核心类库之（网络编程：网络编程入门、UDP通信程序、TCP通信程序）

1 接口组成更新

1.1 接口组成更新概述

接口的组成

常量：public static final

抽象方法：public abstract

默认方法(Java 8)

静态方法(Java 8)

私有方法(Java 9)

1.2 接口中默认方法（JDK8）

接口中默认方法的定义格式：

格式：public default 返回值类型方法名(参数列表){}

范例：public default void show(){}

接口中默认方法的注意事项：

默认方法不是抽象方法，所以不强制被重写。但是可以被重写,重写的时候去掉default关键字

public可以省略，default不能省略：default void show(){}

1.3 接口中静态方法（JDK8）

接口中静态方法的定义格式:

格式：public static 返回值类型方法名(参数列表){}

范例：public static void show(){}

接口中静态方法的注意事项：

静态方法只能通过接口名调用, 不能通过实现类名或者对象名调用

public可以省略， static不能省略：static void show(){}

接口

package test;
public interface Inter {
    void show();
    default void method() {
        System.out.println("默认方法");
    }
//    public static void test(){
//        System.out.println("静态方法");
//    }
    static void test(){
        System.out.println("静态方法");
    }
}

实现类

package test;
public class InterImpl implements Inter{
    @Override
    public void show() {
        System.out.println("show方法");
    }
}

测试类

package test;
public class Demo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        i.show(); //show方法
        i.method(); //
//        i.test(); //报错
        Inter.test(); //静态方法,接口名调用静态方法
    }
}

1.4 接口中私有方法（JDK9）

接口中私有方法的定义格式：

格式1（非静态）：private 返回值类型方法名(参数列表){}

范例1：private void show() {}

格式2（静态）：private static 返回值类型方法名(参数列表){}

范例2：private static void method() {}

接口中私有方法的注意事项：

默认方法可以调用私有的静态方法和非静态方法

静态方法只能调用私有的静态方法

package test;
public interface Inter {
    default void show1() {
        System.out.println("show1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
//        show();
        method();
        System.out.println("show1结束");
    }
    static void method1() {
        System.out.println("method1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        method();
        System.out.println("method1结束");
    }
    private void show(){
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }
    private static void method(){
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }
}

2 方法引用

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作

那么考虑一种情况: 如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，没有必要再写重复逻辑，如usePrintable(s -> System.out.println(s));中System.out.println(s)就是重复逻辑

可以通过方法引用来使用已经存在的方案

2.1 方法引用符

方法引用符

:: 该符号为引用运算符，而它所在的表达式被称为方法引用

对比分析

Lambda表达式：usePrintable(s -> System.out.println(s));

分析：拿到参数s之后通过Lambda表达式，传递给System.out.println()方法去处理

方法引用：usePrintable(System.out:println);//隐含了把s参数给println方法

分析：直接使用System.out中的println方法来取代Lambda,代码更加的简洁

推导与省略

如果使用Lambda,那么根据"可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导

如果使用方法引用，也是同样可以根据上下文进行推导

方法引用是Lambda的李生兄弟（可以使用Lambda表达式就可以使用方法引用）

范例

package test;
public class Demo {
    public static void main(String[] args) {
        //Lambda表达式
        usePrintable(i -> {
            System.out.println(i); //888
        });
        //方法引用
        usePrintable(System.out::println); //888
    }
    private static void usePrintable(Printable p) {
        p.printInt(888);
    }
}

2.2 引用类方法

常用方法引用

引用类方法

引用类的实例方法（成员方法）

引用对象的实例方法

引用构造器

引用类方法，其实就是引用类的静态方法

格式：类名::静态方法

范例：Integer::parselnt

Integer类的方法：public static int parseInt(String s)将此String转换为int类型数据

练习

接口类

package test;
public interface Converter {
    int convert(String s);
}

测试类

package test;
public class Demo {
    public static void main(String[] args) {
//        useConverter(s -> {
//            return Integer.parseInt(s);
//        });
        useConverter(s -> Integer.parseInt(s)); //666
        //引用类方法
        useConverter(Integer::parseInt); //666
        //Lambda表达式被类方法替代时，他的形式参数全部传给静态方法做参数;如s字符串传递给parseInt方法
    }
    private static void useConverter(Converter c) {
        int number = c.convert("666");
        System.out.println(number);
    }
}

2.3 引用类的实例方法（成员方法）

引用类的实例方法，其实就是引用类中的成员方法

格式：类名::成员方法

练习

接口

package test;
public interface MyString {
    String mySubString(String s,int x,int y);
}

测试类

package test;
public class Demo {
    public static void main(String[] args) {
//        useMyString((String s,int x,int y)->{
//            return s.substring(x, y); //llo
//        });
        useMyString((s,x,y)-> s.substring(x, y)); // //llo
        //引用类中的实例方法
        useMyString(String::substring); //llo
        //Lambda表达式中的形式参数(s,x,y)
        //第一个参数作为调用者
        //后面的参数全部传给实例方法作为参数
    }
    public static void useMyString(MyString m) {
        String s = m.mySubString("HelloWorld", 2, 5);
        System.out.println(s);
    }
}

2.4 引用对象的实例方法（成员方法）

引用对象的实例方法，其实就引用类中的成员方法

格式：对象名::成员方法

范例："HelloWorld"::toUpperCase

String类中的方法：public String toUpperCase()将此String所有字符转换为大写

练习

PrintString类

package test;
public class PrintString {
    //把字符串转换成大写
    public void printUpper(String s) {
        String result = s.toUpperCase();
        System.out.println(result);
    }
}

接口

package test;
public interface Printer {
    void printUpperCase(String s);
}

测试类

package test;
public class Demo {
    public static void main(String[] args) {
//        usePrinter((String s ) -> {
            String result = s.toUpperCase();
            System.out.println(result); //HELLO
//            System.out.println(s.toUpperCase());
//        });
        usePrinter(s -> System.out.println(s.toUpperCase()));
        //引用对象的实例方法
        PrintString ps = new PrintString();
        usePrinter(ps::printUpper); //HELLO
    }
    public static void usePrinter(Printer p) {
        p.printUpperCase("hello");
    }
}

2.5 引用构造器

引用构造器，就是引用构造方法

格式：类名::new

范例：Student::new

练习

测试类

package test;
public class Demo {
    public static void main(String[] args) {
//        useStudentBuilder((String name,int age) -> {
            Student s  =new Student(name,age);
            return s;
//            return new Student(name,age); //
//        });
        useStudentBuilder((name, age) -> new Student(name, age));
        useStudentBuilder(Student::new); //小黑,10
        //Lambda表达式被引用构造器代替时，他的形式参数全部传递给构造器作为参数
    }
    public static void useStudentBuilder(StudentBuilder sb) {
        Student s = sb.build("小黑", 10);
        System.out.println(s.getName() + "," + s.getAge());
    }
}

3 函数式接口

3.1 函数式接口概述

函数式接口：有且仅有一个抽象方法的接口

Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口只有确保接口中有且仅有一个抽象方法， Java中的Lambda才能顺利地进行推导

如何检测一个接口是不是函数式接口呢?

@FunctionalInterface

放在接口定义的上方:如果接口是函数式接口，编译通过；如果不是,编译失败

注意：我们自己定义函数式接口的时候，@Functionallnterface是可选的, 就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解

3.2 函数式接口作为方法的参数

需求

package test;
public class Demo {
    public static void main(String[] args) {
        //匿名内部类
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程启动了"); //Thread-0线程启动了
            }
        });
        //Lambda表达式
        startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了")); //Thread-1线程启动了
    }
    public static void startThread(Runnable r) { //Runnable为函数式接口，上方有@FunctionalInterface
//        Thread t  = new Thread(r);
//        t.start();
        new Thread(r).start();
    }
}

如果方法的参数是函数式接口，可以使用Lambda表达式作为参数传递

startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));

3.3 函数式接口作为方法的返回值

需求

package test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Demo {
    public static void main(String[] args) {
        //构造使用场景
        //定义一个集合存储字符串
        ArrayList array = new ArrayList();
        array.add("cccc");
        array.add("aa");
        array.add("b");
        array.add("dd");
        System.out.println("排序前："+array); //排序前：[cccc, aa, b, dd]
        Collections.sort(array); //排序后:[aa, b, cccc, dd]
        Collections.sort(array,getComparator()); //排序后:[b, aa, dd, cccc]
        System.out.println("排序后:"+array);
    }
    public static Comparator<String> getComparator() {
        //匿名内部类
//        Comparator<String> comp = new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length()-s2.length();
//            }
//        };
//        return comp;
//        return new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length()-s2.length();
//            }
//        };
        //Lambda表达式
//        return (String s1,String s2) ->{
//            return s1.length()-s2.length();
//        };
        return(s1,s2) -> s1.length()-s2.length();
    }
}

如果方法的返回值是函数式接口，可以使用Lambda表达式作为结果返回

public static Comparator<String> getComparator() {
  return(s1,s2) -> s1.length()-s2.length();
}

3.4 常用函数式接口

Java 8在java.util.function包下预定义了大量的函数式接口供我们使用

重点来学习下面的4个接口

Supplier [səˈplaɪər] 接口

Consumer [kənˈsuːmər] 接口

Predicate[ˈpredɪkət] 接口

Function接口

3.4.1 Supplier接口

Supplier<T>：包含一个无参的方法

T get()方法：获得结果

该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据

Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型,那么接口中的get()方法就会生产什么类型的数据供我们使用

package test;
import java.util.function.Supplier;
public class Demo {
    public static void main(String[] args) {
//        String s = getString(() -> {
//            return "小黑";
//        });
        String s = getString(() -> "小黑");
        System.out.println(s); //小黑
        int i = getInteger(() -> 10);
        System.out.println(i); //10
    }
    //定义一个方法，返回字符数据
    public static String getString(Supplier<String> sup) {
        return sup.get();
    }
    //定义一个方法，返回整数数据
    public static Integer getInteger(Supplier<Integer> sup) {
        return sup.get();
    }
}

练习

package test;
import java.util.function.Supplier;
public class Demo {
    public static void main(String[] args) {
        int[] arr = {22, 55, 11, 44, 33};
        int maxValue = getMax(() -> {
            int max = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(maxValue); //55
    }
    public static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }
}

3.4.2 Consumer接口

Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定

Consumer ：包含两个方法

方法名说明

void accept(T t) [əkˈsept] 对给定的参数执行此操作

default Consumer<T> andThen(Consumer after) 返回一个组合的Consumer，依次执行此操作，然后执行after操作

范例

package test;
import java.util.function.Consumer;
public class Demo {
    public static void main(String[] args) {
//        operatorString("小白",(String s)->{
//            System.out.println(s); //小白
//        });
        operatorString("小白",s-> System.out.println(s)); //小白
//        operatorString("小黑",System.out::println); //小黑
//        operatorString("大熊猫",s -> {
//            System.out.println(new StringBuilder(s).reverse().toString()); //猫熊大
//        });
        operatorString("大熊猫",s -> System.out.println(new StringBuilder(s).reverse().toString())); //猫熊大
        System.out.println("---------");
        operatorString("小熊猫",s -> System.out.println(s),
            s -> System.out.println(new StringBuilder(s).reverse().toString()));
//        小熊猫
//        猫熊小
    }
    //定义一个方法，用不同的方式消费同一个字符串数据两次
    private static void operatorString(String name, Consumer<String> con1,Consumer<String> con2) {
        //1,void accept(T t) [əkˈsept]  对给定的参数执行此操作
//        con1.accept(name);
//        con2.accept(name);
        //2,Consumer<T> andThen(Consumer after)   返回一个组合的Consumer，依次执行此操作，然后执行after操作
        con1.andThen(con2).accept(name);
    }
    //定义一个方法，消费一个字符串数据
    private static void operatorString(String name, Consumer<String> con) {
        con.accept(name);
    }
}

练习

package test;
import java.util.function.Consumer;
public class Demo {
    public static void main(String[] args) {
        String[] strArray = {"小白,10", "小黑,20"};
//        printInfo(strArray,(String str) ->{
//            String name = str.split(",")[0];
//            System.out.print("姓名:"+name);
//        },(String str)->{
//            int age = Integer.parseInt(str.split(",")[1]);
//            System.out.println(",年龄:"+age);
//        });
        //姓名:小白,年龄:10
        //姓名:小黑,年龄:20
        printInfo(strArray, str -> System.out.print("姓名:" + str.split(",")[0]),
                str -> System.out.println(",年龄:" + Integer.parseInt(str.split(",")[1])));
    }
    private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2) {
        for (String str : strArray) {
            con1.andThen(con2).accept(str);
        }
    }
}

3.4.3 Predicate [predɪkeɪt] 接口

Predicate<T>接口通常用于判断参数是否满足指定的条件

常用的四个方法

方法名说明

boolean test(T t) 对给定的参数进行判断(判断逻辑由Lambda表达式实现，返回一个布尔值

default Predicate<T> negate() 返回一个逻辑的否定，对应逻辑非

default Predicate <T> and(Predicate other) 返回一个组合判断，对应短路与

default Predicate <T> or(Predicate other) 返回一个组合判断，对应短路或

范例

package test;
import java.util.function.Predicate;
public class Demo {
    public static void main(String[] args) {
//        boolean b1 = checkString("hello",(String s) ->{
//            return s.length()>8;
//        });
        boolean b1 = checkString("hello", s -> s.length() > 8);
        System.out.println(b1); //1：false，2：true
        boolean b2 = checkString("hello",s->s.length()>8,s -> s.length()<15);
        System.out.println(b2); //3:false,4:true
        boolean b3 = checkString("hellojava",s->s.length()>8,s -> s.length()<15);
        System.out.println(b3); //3:true,4:true
    }
    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre) {
        //1,boolean test(T t)   对给定的参数进行判断(判断逻辑由L ambda表达式实现，返回一个布尔值
//        return pre.test(s);
//        return !pre.test(s); //输出相反的，不过用下一个方法
        //2,default Predicate<T> negate()   返回一个逻辑的否定，对应逻辑非
        return pre.negate().test(s);
    }
    //同一个结果给出两个不同的判断条件，最后把这两个判断结果做逻辑与的结果作为最终结果
    private static boolean checkString(String s,Predicate<String> pre1,Predicate<String> pre2) {
//        boolean b1 = pre1.test(s);
//        boolean b2 = pre2.test(s);
//        boolean b = b1 && b2;
//        return b;
        //3,default Predicate <T> and(Predicate other)  返回一个组合判断，对应短路与
//        return pre1.and(pre2).test(s); //源码：return (t) -> test(t) && other.test(t);
        //default Predicate <T> or(Predicate other)   返回一个组合判断，对应短路或
        return pre1.or(pre2).test(s); //源码：return (t) -> test(t) || other.test(t);
    }
}

练习

package test;
import java.util.ArrayList;
import java.util.function.Predicate;
public class Demo {
    public static void main(String[] args) {
        String[] strArray = {"小黑,50", "大熊猫,40", "小白,20", "奥特曼,100"};
        ArrayList<String> array = myFilter(strArray, s -> s.split(",")[0].length() > 2,
                s -> Integer.parseInt(s.split(",")[1]) > 33);
        for(String str:array) {
            System.out.println(str);
//            大熊猫,40
//            奥特曼,100
        }
    }
    public static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {
        //定义一个集合
        ArrayList<String> array = new ArrayList<String>();
        //遍历数组
        for (String str : strArray) {
            if (pre1.and(pre2).test(str)) {
                array.add(str);
            }
        }
        return array;
    }
}

3.4.4 Function接口

Function<T,R>接口通常用于对参数进行处理,转换（处理逻辑由Lambda表达式实现），然后返回一个新的值

常用的两个方法

方法名说明

R apply(T t) 将此函数应用于给定的参数

default <V> Function andThen(Function after) 返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果

案例

package test;
import java.util.function.Function;
public class Demo {
    public static void main(String[] args) {
        convert("100", s -> Integer.parseInt(s)); //100
//        convert("100",Integer::parseInt); //100
        convert(100, i -> String.valueOf(i + 566)); //666
        convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566)); //666
    }
    //定义一个方法，把一个字符串转换成int类型，在控制台输出
    public static void convert(String s, Function<String, Integer> fun) {
        //1,R apply(T t)  将此函数应用于给定的参数
//        Integer i = fun.apply(s);
        int i = fun.apply(s);
        System.out.println(i);
    }
    //定义一个方法，把一个int类型的数据加上一个整数之后，转换为字符串在控制台输出
    public static void convert(int i, Function<Integer, String> fun) {
        String s = fun.apply(i);
        System.out.println(s);
    }
    //定义一个方法，把一个字符串转换成int类型，把int类型的数据加上一个整数之后，转换为字符串在控制台输出
    public static void convert(String s, Function<String, Integer> fun1, Function<Integer, String> fun2) {
        //Integer i = fun.apply(s);
        //String ss = fun.apply(i);
        //2,default <V> Function andThen(Function after)  返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果
        String ss = fun1.andThen(fun2).apply(s);//源码：return (T t) -> after.apply(apply(t));相当于上两步
        System.out.println(ss);
    }
}

练习

package test;
import java.util.function.Function;
public class Demo {
    public static void main(String[] args) {
        String s = "小黑,20";
        convert(s, ss -> ss.split(",")[1], ss -> Integer.parseInt(ss), i -> i + 70); //90
    }
    public static void convert(String s, Function<String, String> fun1, Function<String, Integer> fun2, Function<Integer, Integer> fun3) {
        int i = fun1.andThen(fun2).andThen(fun3).apply(s);
        System.out.println(i);
    }
}

Java核心类库之（接口组成更新、方法引用、函数式接口）

热门文章

最新文章

相关课程

相关电子书

相关实验场景