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

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®;

// t.start();

new Thread®.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 getComparator() {

//匿名内部类

// Comparator comp = new Comparator() {

// @Override

// public int compare(String s1, String s2) {

// return s1.length()-s2.length();

// }

// };

// return comp;

// return new Comparator() {

// @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 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 sup) {

return sup.get();

}

//定义一个方法，返回整数数据

public static Integer getInteger(Supplier 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 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 con1,Consumer con2) {

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

// con1.accept(name);

// con2.accept(name);

//2,Consumer andThen(Consumer after) 返回一个组合的Consumer，依次执行此操作，然后执行after操作

con1.andThen(con2).accept(name);

}

//定义一个方法，消费一个字符串数据

private static void operatorString(String name, Consumer con) {

con.accept(name);

}

}

最后

本人也收藏了一份Java面试核心知识点来应付面试，借着这次机会可以送给我的读者朋友们:

目录：

Java面试核心知识点

一共有30个专题，足够读者朋友们应付面试啦，也节省朋友们去到处搜刮资料自己整理的时间！

Java面试核心知识点

// });

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 con1,Consumer con2) {

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

// con1.accept(name);

// con2.accept(name);

//2,Consumer andThen(Consumer after) 返回一个组合的Consumer，依次执行此操作，然后执行after操作

con1.andThen(con2).accept(name);

}

//定义一个方法，消费一个字符串数据

private static void operatorString(String name, Consumer con) {

con.accept(name);

}

}

最后

本人也收藏了一份Java面试核心知识点来应付面试，借着这次机会可以送给我的读者朋友们:

目录：

[外链图片转存中…(img-jqI9j2Q2-1714376441164)]

Java面试核心知识点

一共有30个专题，足够读者朋友们应付面试啦，也节省朋友们去到处搜刮资料自己整理的时间！

[外链图片转存中…(img-pcnDV5tg-1714376441164)]

Java面试核心知识点

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录