大家好,又见面了,我是你们的朋友全栈君。
【前序】:
在Java8中,内置了四个核心函数接口,它们存在是Lamda表达式出现的前提,Lamda表达式想重写函数式接口中的唯一方法。
函数式接口与Lambda表达式之间的关系:lambda表达式相当于是一个行为,传入函数式接口中,进来实现各种操作,即行为参数化
它们的接口内只有一个抽象方法,每一个函数式接口都有@FunctionalInterface
注解。
【正文】:
四种函数式接口分别为:
- Consumer< T>:消费型接口
接口方法 void accept(T t):参数类型是T,无返回值 - Supplier< T>供给型接口
接口方法 T get():参数类型是T,返回T类型参数 - Function<T,R>函数型接口</T,R>
接口方法R apply(T):对类型T参数操作,返回R类型参数 - Predicate< T>段言型接口
接口方法 boolean test(T t):对类型T进行条件筛选操作,返回boolean
1.消费型接口
先看一下源码:
import java.util.Objects;
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> {
accept(t); after.accept(t); };
}
消费型接口代表了在一个输入参数上需要进行的操作。
举例1⃣️:
import java.util.function.Consumer;
public class Test {
public static void main(String[] args) {
Test consumertest = new Test();
//传入字符串,然后打印
consumertest.pass("I'm consumerFunction", (item) -> System.out.println(item));
}
//接受str字符串参数
public void pass(String str, Consumer<String> consumer) {
consumer.accept(str);
}
}
函数式接口相当于把一个行为当作参数传入一个方法中,在这个例子中,System.out.println(item)是Consumer consumer的行为,即打印出所传入的参数str。
举例2⃣️:
Consumer<Integer> consumer = x -> {
int a = x + 2;
System.out.println(a);// 12
};
consumer.accept(10);
2.供给型接口
源码:
@FunctionalInterface
public interface Supplier<T> {
/** * Gets a result. * * @return a result */
T get();
}
供给型接口提供一个给定参数类型的结果
举例:产生一些整数,并放入集合中
import java.util.function.Supplier;
public class Test {
public static void main(String[] args) {
Test consumertest = new Test();
consumertest.getNumList(10,()->(int)(Math.random()*100));
//产生一些整数,并放入集合中. int num 为产生的个数
public List<Integer> getNumList(int num, Supplier<Integer> supplier) {
List<Integer> list = new ArrayList<>();
for(int i = 0;i<num;i++) {
Integer n =supplier.get();
list.add(n);
}
return list;
}
3.函数型接口
Function接口接收一个参数,并返回单一的结果
举例:用于处理字符串
class Test{
public static void main(String[] args){
String newStr = strHandler("我是函数型接口",(str)->str.subString(2,5));
System.out.println(newStr);
}
public String strHandler(String str, Function<String,String> fun){
return fun.apply(str);
}
4.段言型接口
Predicate接口是一个布尔类型的函数,该函数只有一个输入参数
举例1⃣️:
筛选出长度大于4的字符串,并放入新的集合中
class Test{
public static void main(String[] args){
List<String> list =Arrays.asList("Hello","World","Function","Lambda","Java");
filterStr(list,(s) -> s.length()>4);
System.out.println(newList);
}
public List<String> filterStr(List<String> list,Predicate<String> pre){
List<String> newList = new ArrayList<>();
for(String str : list){
if(pre.test(str)){
newList.add(str);
}
}
return newList;
}
举例2⃣️:
自定义类,筛选出重量大于150kg的苹果
public class Apple {
private int weight;
private String color;
public Apple(int weight, String color) {
this.weight = weight;
this.color = color;
}
public Integer getWeight() {
return weight;
}
public void setWeight(Integer weight) {
this.weight = weight;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String toString() {
return "Apple{" +
"color='" + color + '\'' +
", weight=" + weight +
'}';
}
}
public class FilteringApples1 {
public static void main(String[] args) {
List<Apple> inventory = Arrays.asList(
new FilteringApples1.Apple(80, "green"),
new FilteringApples1.Apple(155, "green"),
new FilteringApples1.Apple(120, "red"));
filterApples(inventory, (a) -> a.getWeight() > 150);
System.out.println(result);
}
public List<Apple> filterApples(List<Apple> inventory,Predicate<Apple> pre) {
List<Apple> result = new ArrayList<>();
for (FilteringApples1.Apple apple : inventory) {
if (p.test(apple)) {
result.add(apple);
}
}
return result;
}
发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/127954.html原文链接:https://javaforall.cn
【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛
【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...