java8 新特性 - 函数式接口

 函数式接口

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

函数式接口可以被隐式转换为 lambda 表达式。

Lambda 表达式和方法引用（实际上也可认为是Lambda表达式）上。

@FunctionalInterface 注解作用检验是否是函数式接口

 

代码练习

package com.sgl.lambda;

/**
 * 自定义函数式接口
 *
 *@FunctionalInterface 注解作用检验是否是函数式接口
 *
 * 只包含一个抽象方法的接口 ，但是可以有多个非抽象方法的接口。
 *
 * @author not_simple
 * @version 1.0
 * @date 2020/5/21 17:33
 */
@FunctionalInterface
public interface MyInterface {

    //只包含一个抽象方法的接口 ，但是可以有多个非抽象方法的接口。
    void method1();

//    void method2();

    default void say(){
        System.out.println("11");
    };
}

 

 

java 内置的四大核心函数式接口

消费型接口Consumer<T>  void accept(T t)   有参数 无返回
供给型接口Supplier<T>  T  get()           无参数  有返回
函数型接口Function<T,R>  R apply(T t)     有参数  有返回
断定型接口Predicate<T>  boolean  test(T t)  有参数  返回Boolean值

其他函数式接口

https://www.runoob.com/java/java8-functional-interfaces.html

 

代码练习

package com.sgl.lambda;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

/**
 * java 内置的四大核心函数式接口
 *
 * 消费型接口Consumer<T>  void accept(T t)   有参数 无返回
 *
 * 供给型接口Supplier<T>  T  get()           无参数  有返回
 *
 * 函数型接口Function<T,R>  R apply(T t)     有参数  有返回
 *
 * 断定型接口Predicate<T>  boolean  test(T t)  有参数  返回Boolean值
 *
 * @author not_simple
 * @version 1.0
 * @date 2020/5/21 17:31
 */
public class FunctionInterface {
//    消费型接口Consumer<T>  void accept(T t)   有参数 无返回
    @Test
    public  void test1(){
        happyTime(500, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("今年已经学习了:"+aDouble+"年了");
            }
        });
        System.out.println("****************************************************************");
        //    消费型接口Consumer<T>  void accept(T t)   有参数 无返回
        happyTime(100,year ->   System.out.println("今年已经学习了:"+year+"年了"));
    }

    private void happyTime(double i, Consumer<Double> con) {
        con.accept(i);
    }


//    断定型接口Predicate<T>  boolean  test(T t)  有参数  返回Boolean值
    @Test
    public void test2 (){
        List<String> list = Arrays.asList("北京", "天津", "南京", "东京", "西京");
        List<String> list1 = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });
        System.out.println(list1);
        System.out.println("********************");
        //断定型接口Predicate<T>  boolean  test(T t)  有参数  返回Boolean值
        List<String> list2 = filterString(list, s -> s.contains(s));
        System.out.println(list2);
    }

    //根据给定的规则，过滤集合中的字符串。此规则有Predicate的方法决定
    public List<String> filterString(List<String> list, Predicate<String> pre){
        ArrayList<String> filterList =new ArrayList<>();
        for (String s : list){
            if (pre.test(s)){
                filterList.add(s);
            }
        }

        return filterList;
    }
}