Java内置函数式接口
只包含一个抽象方法的接口，称为函数式接口。
可以通过Lambda 表达式来创建该接口的对象。（若Lambda 表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。
在任意函数式接口上设置@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口，同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。在此之前的PPT中，我们已经定义过函数式接口，但是我们不可能每次都要自己定义函数式接口，实在是太麻烦了。所以，Java内置了函数式接口在java.util.function包下
Predicate<T> 断言型接口
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}
该类型的接口，在名称旁添加了一个泛型 T,该泛型是用于做函数参数的类型
并且该接口中的函数返回值是 boolean 所以可以断言程序执行结果是否正确
实例
package com.test.demo23;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
public class SimplePredicateExample {
public static void main(String[] args) {
// 创建一个字符串列表
List<String> words=new ArrayList<>();
words.add("apple");
words.add("banana");
words.add("cherry");
words.add("date");
words.add("fig");
// 创建一个 Predicate 实例，用于筛选长度大于等于 5 的字符串
Predicate<String> isLongWord=word->word.length()>=5;
// 使用 Predicate 进行筛选
List<String> longWords=filterWords(words,isLongWord);
// 打印输出筛选结果
System.out.println("长度大于等于 5 的单词列表: " + longWords);
}
public static List<String> filterWords(List<String> words, Predicate<String> predicate) {
List<String> filteredWords = new ArrayList<>();
for (String word : words) {
if (predicate.test(word)) {
filteredWords.add(word);
}
}
return filteredWords;
}
}
结果：
长度大于等于 5 的单词列表: [apple, banana, cherry]
Function<T,R> 函数型接口
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}
该接口中给定两个泛型，其中 T 表示当前接口函数中的参数类型 R表示接口函数中的返回值类型
函数型接口 包含 断言型接口
实例
package com.test.demo23;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
public class FunctionExample {
public static void main(String[] args) {
List<Integer> numbers= Arrays.asList(1,2,3,4,5);
// 示例 1: 创建一个 Function 实例，将整数转换为其平方
Function<Integer, Integer> squareFunction = n -> n * n;
// 使用 Function 进行转换
List<Integer> squaredNumbers = mapList(numbers, squareFunction);
System.out.println("整数的平方: " + squaredNumbers);
// 示例 2: 创建一个 Function 实例，将整数转换为字符串
Function<Integer, String> toStringFunction = n -> "Number: " + n;
// 使用 Function 进行转换
List<String> stringNumbers = mapList(numbers, toStringFunction);
System.out.println("整数转换为字符串: " + stringNumbers);
}
public static <T, R> List<R> mapList(List<T> list, Function<T, R> function) {
List<R> result = new ArrayList<>();
for (T item : list) {
result.add(function.apply(item));
}
return result;
}
}
结果：整数的平方: [1, 4, 9, 16, 25]
整数转换为字符串: [Number: 1, Number: 2, Number: 3, Number: 4, Number: 5]
Supplier<T> 供给型接口
@FunctionalInterface
public interface Supplier<T> {
T get();
}
该接口中定义一个泛型T 作为接口函数中的返回 并且该函数没有参数
实例
package com.test.demo23;
import java.util.function.Supplier;
public class SupplierExample {
public static void main(String[] args) {
// 示例 1: 创建一个 Supplier 实例，用于提供随机整数
Supplier<Integer> randomIntegerSupplier = () -> (int) (Math.random() * 100);
// 使用 Supplier 获取随机整数
int randomInt = randomIntegerSupplier.get();
System.out.println("随机整数: " + randomInt);
// 示例 2: 创建一个 Supplier 实例，用于提供当前系统时间
Supplier<Long> currentTimeSupplier = System::currentTimeMillis;
// 使用 Supplier 获取当前系统时间
long currentTime = currentTimeSupplier.get();
System.out.println("当前系统时间: " + currentTime);
}
}
结果：
随机整数: 42
当前系统时间: 1705067372784
Consumer<T> 消费型接口
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
}
该接口中定义一个泛型T 作为接口函数中的参数 并且该函数没有返回值
实例
package com.test.demo23;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
public class ConsumerExample {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
names.add("David");
// 示例 1: 创建一个 Consumer 实例，用于打印字符串
Consumer<String> printName = name -> System.out.println("Hello, " + name);
// 使用 Consumer 对列表中的每个元素执行操作
names.forEach(printName);
// 示例 2: 创建一个 Consumer 实例，用于将字符串转换为大写
Consumer<String> toUpperCase = name -> {
if (name != null) {
System.out.println("Uppercase Name: " + name.toUpperCase());
}
};
// 使用 Consumer 对列表中的每个元素执行操作
names.forEach(toUpperCase);
}
}
结果：
Hello, Alice
Hello, Bob
Hello, Charlie
Hello, David
Uppercase Name: ALICE
Uppercase Name: BOB
Uppercase Name: CHARLIE
Uppercase Name: DAVID
综合实例
package com.test.demo23;
import java.util.ArrayList;
import java.util.Random;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
public class Demo08LambdaFunction {
public static void main(String[] args) {
/*
在使用lambda表达式时，需要定义接口，但是接口中的形式相对比较单一
于是可以对该类型的接口进行统一，由Java内部提供，当开发者需要使用lambda表达式时，
可以直接调用Java提供的接口而不需要 自定义
只包含一个抽象方法的接口，称为函数式接口
Java中根据不同的情况，提供了哪些接口供开发者使用？
断言型接口
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}
该类型的接口，在名称旁添加了一个泛型 T,该泛型是用于做函数参数的类型
并且该接口中的函数返回值是 boolean 所以可以断言程序执行结果是否正确
// 函数型接口
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}
该接口中给定两个泛型，其中 T 表示当前接口函数中的参数类型 R表示接口函数中的返回值类型
函数型接口 包含 断言型接口
// 供给型接口
@FunctionalInterface
public interface Supplier<T> {
T get();
}
该接口中定义一个泛型T 作为接口函数中的返回 并且该函数没有参数
// 消费型接口
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
}
该接口中定义一个泛型T 作为接口函数中的参数 并且该函数没有返回值
*/
// Predicate
// 定义一个函数 判断某同学是否成年
// 使用lambda表达式：
Predicate<Student> predicate=(stu)->{
if (stu.age>=18)
return true;
else return false;
};
System.out.println(predicate.test(new Student("张攀",17,8)));
// 定义一个函数 判断某同学是否成年
// public interface Function<T, R> {
// R apply(T t);
// }
Function<Student,Boolean> function=(stu)->{
if (stu.age>=18)
return true;
else return false;
};
System.out.println(predicate.test(new Student("张攀",17,8)));
// 随机生成10个1-100的数据到集合返回
/*
@FunctionalInterface
public interface Supplier<T> {
T get();
}
*/
Supplier<ArrayList> supplier=()->{
ArrayList<Integer> integers = new ArrayList<>();
Random random = new Random();
for (int i = 0; i < 10; i++) {
int randInt = random.nextInt(100)+1;
integers.add(randInt);
}
return integers;
};
ArrayList list=supplier.get();
System.out.println(list);
// 将拿到的集合进行遍历打印所有的结果数据
/*
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
}
*/
Consumer<ArrayList<Integer>> consumer = (arrayList) -> {
for (Integer i : arrayList) {
System.out.println("i:"+i);
}
};
consumer.accept(list);
}
}
package com.test.demo23;
public class Student {
String name;
int age;
int score;
public Student(String name, int age, int score) {
this.name = name;
this.age = age;
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
}
333
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
