【Java8实战】函数式接口

快来打我* 2023-06-27 05:30 44阅读 0赞

##### 引言 #####

通过上一篇博客，对Lambda的基础语法已经有了一定了解。那么有个问题，那就是在哪里可以使用Lambda表达式呢? 答案是函数式接口。有点抽象了，本篇博客就来梳理一下。

##### 什么是函数式接口？ #####

一句话说，函数式接口就是只定义一个抽象方法的接口。在Java API中，有很多这样的接口，比如：Comparator和Runnable.

public interface Comparator<T> {     int compare(T o1, T o2);  } 
     
    public interface Runnable{      void run(); }

##### 函数式接口可以干什么？ #####

Lambda表达式允许你直接以内联的形式为函数式接口的抽象方法提供实现，并把整个表达式作为函数式接口的实例（具体说来，是函数式接口一个具体实现的实例）。

用匿名内部类也可以完成同样的事情，只是比较笨拙：需要提供一个实现，然后再直接内联将它实例化。

// 使用Lambda表达式
    Runnable r1 = () -> System.out.println("Hello World 1");  
    // 使用匿名内部类
    Runnable r2 = new Runnable(){      public void run(){         System.out.println("Hello World 2");     } };

##### 函数描述符 #####

函数式接口的抽象方法的签名基本上就是Lambda表达式的签名。我们将这种抽象方法叫作函数描述符。例如，Runnable接口可以看作一个什么也不接受什么也不返回（void）的函数的签名，因为它只有一个叫作run的抽象方法，这个方法什么也不接受，什么也不返回（void）。

##### 使用函数式接口 #####

Java API中已经有了几个函数式接口，比如Comparable、Runnable和 Callable。 Java 8在java.util.function包中引入了几个新的函数式接口，如：Predicate、Consumer、Function和Supplier。

###### 1. Predicate ######

java.util.function.Predicate接口定义了一个名叫test的抽象方法，它接受泛型T对象，并返回一个boolean。定义如下：

@FunctionalInterface
    public interface Predicate<T> {
    
        /**
         * Evaluates this predicate on the given argument.
         *
         * @param t the input argument
         * @return {@code true} if the input argument matches the predicate,
         * otherwise {@code false}
         */
        boolean test(T t);
    }

另外，还包含and()、or()和negate()默认方法，相当于操作符&&、||和求反。

在需要表示一个涉及类型T的布尔表达式时，就可以使用这个接口。示例如下：

//示例1：(x) -> x == 3 输入一个参数x，进行比较操作，返回一个布尔值
    public static boolean predicateTest(int value, Predicate<Integer> predicate) {
        return predicate.test(value);
    }
    
    public static void main(String[] args) {
        System.out.println(predicateTest(4, (x) -> x == 3));
    }
    
    //示例2：1-15的数中，进行条件筛选
    public static void main(String[] args) {
        int[] numbers= {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
    	List<Integer> list=new ArrayList<>();
    	for(int i:numbers) {
    	    list.add(i);
    	}
    	//大于5的数
    	Predicate<Integer> p1=i->i>5;
    	//小于20的数
    	Predicate<Integer> p2=i->i<20;
    	//能被2整除的数
    	Predicate<Integer> p3=i->i%2==0;
    	//输出同时满足p1,p2,p3的集合
    	List test=list.stream().filter(p1.and(p2).and(p3)).collect(Collectors.toList());
    	System.out.println(test.toString());
    }

###### 2. Consumer ######

java.util.function.Consumer定义了一个名叫accept的抽象方法，它接受泛型T的对象，没有返回（void）。定义如下：

@FunctionalInterface
    public interface Consumer<T> {
    
        /**
         * Performs this operation on the given argument.
         *
         * @param t the input argument
         */
        void accept(T t);
    }

你如果需要访问类型T的对象，并对其执行某些操作，就可以使用这个接口。示例如下：

//示例1：传入一个数，返回值为此数+2
    public static void main(String[] args) {
       //示例1：传入一个数，返回值为此数+2
       Consumer<Integer> consumer = x -> {
           int a = x + 2;
           System.out.println(a);// 12
       };
       consumer.accept(10);
    }
    
    //示例2：遍历一个list，返回值为每个数与5的乘积
    public static <T> void forEach(List<T> list, Consumer<T> c){
        for(T i: list){
            c.accept(i);
        }
    }
    public static void main(String[] args) {
          forEach(Arrays.asList(1,2,3,4,5), (Integer i) -> System.out.println(i * 5) );
    }

###### 3. Function ######

java.util.function.Function<T, R>接口定义了一个叫作apply的方法，它接受一个泛型T的对象，并返回一个泛型R的对象。定义如下：

@FunctionalInterface
    public interface Function<T, R> {
        R apply(T t);
    }

如果你需要定义一个Lambda，将输入对象的信息映射到输出，就可以使用这个接口，示例如下：

//示例1：输入一个数，结果返回此数+1
    public static void main(String[] args) {
        Function<Integer,Integer> test= i-> {
            System.out.println(i + 1);
            return i;
        };
        test.apply(5);
    }
    //示例2：通过传入不同的Function，实现了在同一个方法中实现不同的操作。
    public static Integer calculate(Function<Integer,Integer> test,Integer number){
        return test.apply(number);
    }
    
    public static void main(String[] args) {。
        Function<Integer,Integer> test1=i->i+1;
        Function<Integer,Integer> test2=i->i*i;
        System.out.println(calculate(test1,5));
        System.out.println(calculate(test2,5));
    }

###### 4. Supplier ######

java.util.function.Supplier接口定义了一个叫作get的方法，它接受一个泛型T的对象，并返回这个泛型T的对象。定义如下：

@FunctionalInterface
    public interface Supplier<T> {
        /**
         * Gets a result.
         *
         * @return a result
         */
        T get();
    }

如果你需要创建一个对象，就可以使用这个接口，示例如下：

public static void main(String[] args) {
        //提供一个对象
        Supplier<Person> supplierPerson = Person::new;
        //获取并设置该对象姓名属性
        Person person = supplierPerson.get();
        person.setName("zhangsan");
        System.out.println(person.getName());//zhangsan
    }

##### 总结 #####

关于这两篇博客中学习的java8的语法实例，代码已上传github，地址：

[java8学习][java8]

java8的语法在代码中用的还不够多，其实在编程过程中，思考下如何使用其新特性，可能会有事半功倍的效果，有机会需要多多实践。

[java8]: https://github.com/huzhiting/java8-learning