Java8新特性（内置的核心函数式接口）

时间：2021-12-05 19:10:10

前言：



1.我们知道只要使用Lambda表达式，那么一定要有函数式接口的支持；但是如果我们没使用一个Lambda表达式都要自己创建一个接口，
这样很造成很大的不便。于是java8的工程师们已经帮我们把常用的函数式接口都帮我们定义好，拿来直接使用即可。
如果不能满足你的需求，那么这时你才需要自己定义函数式接口。


下面是我们常用的函数式接口：

知识点一：消费性函数式接口

特点：

1.接受一个或者多个参数，没有返回值

典型函数式接口（常用）：

    1.Consumer<T>  
void accept(T t);//接受一个泛型类型参数无返回
2.BiConsumer<T, U>
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<T>
void accept(T t, double value);//接收两个参数，一个泛型，一个double
7.ObjIntConsumer<T> 
void accept(T t, int value);//接收两个参数，一个泛型，一个int
8.ObjLongConsumer<T>
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<Double> policy){
        policy.accept(money);
    }

知识点二：供给型函数式接口

特点：

1.没有参数（无参），提供返回值

典型函数式接口（常用）:

1. Supplier<T>
     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> T get(Supplier<T> supplier){
return supplier.get();
    }

知识点三：函数型函数式接口

特点：

1.接收一个或者多个参数，有返回值

典型函数式接口（常用）:

  1. Function<T, R> 
        R apply(T t); //接收一个泛型参数，返回一个泛型参数
2. BiFunction<T, U, R>
        R apply(T t, U u);   //接收两个泛型参数，返回泛型参数
3. DoubleFunction<R>
        R apply(double value);//接收一个double类型，返回一个泛型
4. DoubleToIntFunction
int applyAsInt(double value);
5. DoubleToLongFunction
long applyAsLong(double value);     
6. IntFunction<R> 
        R apply(int value);
7. IntToDoubleFunction
double applyAsDouble(int value);
8. IntToLongFunction
long applyAsLong(int value);     
9. LongFunction<R>    
         R apply(long value);
10.LongToDoubleFunction      
double applyAsDouble(long value);  
11.LongToIntFunction
int applyAsInt(long value);        
12.ToDoubleBiFunction<T, U>
double applyAsDouble(T t, U u);     
13.ToDoubleFunction<T>
double applyAsDouble(T value);
14.ToIntBiFunction<T, U>
int applyAsInt(T t, U u);      
15.ToIntFunction<T>
int applyAsInt(T value);   
16.ToLongBiFunction<T, U> 
long applyAsLong(T t, U u);
17.ToLongFunction<T>
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<T>
boolean test(T t);
2. BiPredicate<T, U>
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 <T>  boolean is(T t,Predicate<T> predicate){
return predicate.test(t);
    }

总结：

    1.每一中类型都给出了泛型情况，可以传入任何类型；而对于常用的类型，都单独定义了接口；例如： int 、 long 、double

标签：

相关文章