JDK8：函数型接口，方法的引用，构造器及数组的引用

JDK8

1. 函数式接口

四大内置函数型接口：

• 消费型接口：Consumer 方法：void accept(T t)
• 供给型接口：Supplier 方法：T get()
• 函数型接口：Function<T,R> 方法：R apply(T t)
• 断定型接口：Predicate 方法：boolean test(T t)

代码：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
public class Demo01 {
    public static void main(String[] args) {
        List<Integer> list = List.of(1,2,3,4,5,6,7,8);
        //forEach遍历使用Consumer接口
        list.forEach(i-> System.out.print(i+" "));//1 2 3 4 5 6 7 8
        System.out.println();
        //使用消费型接口
        testConsumer(3,5,s-> System.out.println("两数之和为"+s));//两数之和为8
        //使用供给型接口 随机生成[1,10]之间的整数，存在List中
        System.out.println(testSupplier(10,()->(int)(Math.random()*10)+1));//[9, 6, 8, 5, 5, 3, 6, 3, 10, 2]
        //使用函数式接口
        System.out.println(testFunction("hahhahaha",str->str.substring(2,6)));//hhah
        //使用判定型接口
        System.out.println(testPredicate(list,i->i>5));//[6, 7, 8]
    }
    //消费型接口 Consumer<T>
    //void accept(T t)
    public static void testConsumer(int a, int b, Consumer<Integer> consumer){
        consumer.accept(a+b);
    }
    //供给型接口 Supplier<T>
    //T get()
    public static List<Integer> testSupplier(int n, Supplier<Integer> supplier){
        List<Integer> list = new ArrayList<>();
        for (int i=1;i<=n;i++){
            list.add(supplier.get());
        }
        return list;
    }
    //函数型接口 Function<T,R>
    //R apply(T t)
    public static String testFunction(String s, Function<String,String> func){
        return func.apply(s);
    }
    //判定型接口 Predicate<T>
    //boolean test<T t>
    public static List<Integer> testPredicate(List<Integer> ls,Predicate<Integer> pre){
        List<Integer> list = new ArrayList<>();
        ls.forEach(i->{
            if (pre.test(i)){
               list.add(i);
            }
        });
        return list;
    }
}

2. 方法引用

为了简化Lambda表达式，可以使用方法引用，他是lambda表达式的另一种表现形式。

方法引用有以下三种方式：

• 对象::成员方法，使用要求如下：
  • lambda体是否通过引用另外一个方法实现的
  • 抽象方法的参数列表作为方法内部所引用的方法的参数列表时，且所引用方法的返回值类型与抽象方法的返回值类型保持一致
• 类名::静态方法，使用要求如下：
  • lambda体是否通过引用另外一个方法实现的
  • lambda的参数列表与返回值匹配引用方法的参数列表与返回值类型
  • 是静态方法
• 类名::成员方法，使用要求如下：
  • lambda体是否通过引用另外一个方法实现的
  • 抽象方法的参数列表的第一个参数作为调用内部所引用方法的对象存在
  • 抽象方法参数列表的第二个参数及以后与所引用方法的参数列表保持一致，返回值类型保持一致
  • 是成员方法

代码：

import java.util.ArrayList;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
public class Demo02 {
    public static void main(String[] args) {
        System.out.println(test01(100));//[100]
        System.out.println(test02(10,15));//15
        System.out.println(test03("zhangsan","zhangsan"));//true
    }
    //对象::成员方法
    //实现容器添加某一个整数
    public static List<Integer> test01(int a){
        List<Integer> list = new ArrayList<>();
        Consumer<Integer> con = list::add;
        con.accept(a);
        return list;
    }
    //类名::静态方法
    //实现得出两个整数中的最大值
    public static int test02(int a,int b){
        BiFunction<Integer,Integer,Integer> bf = Math::max;
        return bf.apply(a,b);
    }
    //类名::成员方法
    //实现判断两个字符串是否相等
    public static boolean test03(String s1,String s2){
        BiPredicate<String,String> bpre = String::equals;
        return bpre.test(s1,s2);
    }
}

3. 构造器引用及数组的引用

import java.util.Arrays;
import java.util.function.Function;
import java.util.function.Supplier;
public class Demo03 {
    public static void main(String[] args) {
        //构造器引用: 数据类型::new
        //创建一个String对象  空构造
        Supplier<String> sup = String::new;
        //创建一个String对象  带参构造，参数为String类型
        Function<String,String> fun = String::new;
        //数组引用:  数组类型[]::new
        //构建一个长度为5的String数组
        Function<Integer,String[]> f = String[]::new;
        System.out.println(Arrays.toString(f.apply(5)));//默认[null, null, null, null, null]
    }
}