###前言:
1.我们知道只要使用Lambda表达式,那么一定要有函数式接口的支持;但是如果我们没使用一个Lambda表达式都要自己创建一个接口,
这样很造成很大的不便。于是java8的工程师们已经帮我们把常用的函数式接口都帮我们定义好,拿来直接使用即可。
如果不能满足你的需求,那么这时你才需要自己定义函数式接口。
下面是我们常用的函数式接口:
###知识点一:消费性函数式接口
####特点:
1.接受一个或者多个参数,没有返回值
####典型函数式接口(常用):
1.Consumer
void accept(T t);//接受一个泛型类型参数无返回
2.BiConsumer
void accept(T t, U u);//接受两个泛型类型参数无返回
3.DoubleConsumer
void accept(double value);//接收double类型,无返回
4.IntConsumer
void accept(int value);//接收int类型,无返回
5.LongConsumer
void accept(long value);//接收long类型,无返回
6.ObjDoubleConsumer
void accept(T t, double value);//接收两个参数,一个泛型,一个double
7.ObjIntConsumer
void accept(T t, int value);//接收两个参数,一个泛型,一个int
8.ObjLongConsumer
void accept(T t, long value);//接收两个参数,一个泛型,一个long
####举例:这里使用Consumer举例,接收一个参数无返回值,其他的用法基本相同
//需求:消费给定的monkey,但是消费方式没有给定,需要具体消费的时候指定
@org.junit.Test
public void test1(){
//消费100,洗澡
consumerMonkey(100,(m) -> System.out.println("洗澡花费了100元"));
//消费200,吃饭
consumerMonkey(200,(m) -> System.out.println("洗澡花费了200元"));
}
/**
* 消费monkey,但是没有指定出使用什么方式消费
* */
*
public static void consumerMonkey(double money, Consumer policy){
policy.accept(money);
}
###知识点二:供给型函数式接口
####特点:
1.没有参数(无参),提供返回值
####典型函数式接口(常用):
1. Supplier
T get(); //无参,返回泛型
2. BooleanSupplier
boolean getAsBoolean(); //无参,返回boolean
3. DoubleSupplier
double getAsDouble(); //无参,返回double
4. LongSupplier
long getAsLong(); //无参,返回long
####举例:以 Supplier 接收泛型类型为例,其他都基本一致
@org.junit.Test
public void test2(){
// 返回给定的String类型
String s = get(() -> "Hello world !");
System.out.println(s); //打印hello world !
// 返回给定类型的 int 数据
int i = get(() -> 123);
System.out.println(i); //打印123
}
/**
* 获取给定类型的对象,在调用的时候指定类型
* */
public static T get(Supplier supplier){
return supplier.get();
}
###知识点三:函数型函数式接口
####特点:
1.接收一个或者多个参数,有返回值
####典型函数式接口(常用):
1. Function
R apply(T t); //接收一个泛型参数,返回一个泛型参数
2. BiFunction
R apply(T t, U u); //接收两个泛型参数,返回泛型参数
3. DoubleFunction
R apply(double value);//接收一个double类型,返回一个泛型
4. DoubleToIntFunction
int applyAsInt(double value);
5. DoubleToLongFunction
long applyAsLong(double value);
6. IntFunction
R apply(int value);
7. IntToDoubleFunction
double applyAsDouble(int value);
8. IntToLongFunction
long applyAsLong(int value);
9. LongFunction
R apply(long value);
10.LongToDoubleFunction
double applyAsDouble(long value);
11.LongToIntFunction
int applyAsInt(long value);
12.ToDoubleBiFunction
double applyAsDouble(T t, U u);
13.ToDoubleFunction
double applyAsDouble(T value);
14.ToIntBiFunction
int applyAsInt(T t, U u);
15.ToIntFunction
int applyAsInt(T value);
16.ToLongBiFunction
long applyAsLong(T t, U u);
17.ToLongFunction
long applyAsLong(T value);
####举例:以 Function接收一个泛型类型,返回一个泛型类型为例,其他都基本一致
@org.junit.Test
public void test3(){
//需求1:接收一个String,返回一个name等于给定String的Student对象
Student student = handleOperator("XiangYang", (t) -> new Student(t));
System.out.println(student); //打印:Student{name='XiangYang', age=0}
//需求二:就收一个String,返回List,并且list中包含传入的String
List list1 = handleOperator("XiangYang", (t) -> {
List list = new ArrayList<>();
list.add(t);
return list;
});
System.out.println(list1); //打印:[XiangYang]
}
class Student{
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student(String name) {
this.name = name;
}
public Student(int age) {
this.age = age;
}
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
###知识点四:断定性函数式接口
####特点:
1.接收一个或者多个参数,返回一个boolean类型
####常用的函数式接口:
1. Predicate
boolean test(T t);
2. BiPredicate
boolean test(T t, U u);
3. DoublePredicate
boolean test(double value);
4. IntPredicate
boolean test(int value);
5. LongPredicate
boolean test(long value);
####举例:以 Predicate 为例
@org.junit.Test
public void test4(){
//判断给定的整数是否大于50
boolean b = is(80, (n) -> n > 50);
System.out.println(b); //打印:true
}
public static boolean is(T t,Predicate predicate){
return predicate.test(t);
}
###总结:
1.每一中类型都给出了泛型情况,可以传入任何类型;而对于常用的类型,都单独定义了接口;例如: int 、 long 、double
本人博客:https://elfgirl.top/