【jdk8新特性】函数式接口，包看包会

博客地址（点击即可访问）	github源码地址
Lamda表达式	https://github.com/zz1044063894/lambda
函数式接口	https://github.com/zz1044063894/methodInterface
方法引用和构造器引用	https://github.com/zz1044063894/qoute
Stream API	https://github.com/zz1044063894/StreamAPI
接口中的默认方法与静态方法	https://github.com/zz1044063894/static-default-method
新时间日期API	https://github.com/zz1044063894/newDateTimeAPI

概念

• 函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
• 函数式接口可以被隐式转换为 lambda 表达式。
• Lambda 表达式和方法引用（实际上也可认为是Lambda表达式）上。
  定义一个函数式接口如下代码：

@FunctionalInterface
interface GreetingService 
{
    void sayMessage(String message);
}

那么就可以使用Lambda表达式来表示该接口的一个实现(注：JAVA 8 之前一般是用匿名类实现的)：

GreetingService greetService1 = message -> System.out.println("Hello " + message);

java8之前已有的函数式接口

java.lang.Runnable
java.util.concurrent.Callable
java.security.PrivilegedAction
java.util.Comparator
java.io.FileFilter
java.nio.file.PathMatcher
java.lang.reflect.InvocationHandler
java.beans.PropertyChangeListener
java.awt.event.ActionListener
javax.swing.event.ChangeListener

java8 新增的函数式接口

java.util.function
//java.util.function 它包含了很多类，用来支持 Java的 函数式编程，该包中的函数式接口有：


1	BiConsumer<T,U>//代表了一个接受两个输入参数的操作，并且不返回任何结果

2	BiFunction<T,U,R>//代表了一个接受两个输入参数的方法，并且返回一个结果

3	BinaryOperator<T>//代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果

4	BiPredicate<T,U>//代表了一个两个参数的boolean值方法

5	BooleanSupplier//代表了boolean值结果的提供方

6	Consumer<T>//代表了接受一个输入参数并且无返回的操作

7	DoubleBinaryOperator//代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。

8	DoubleConsumer//代表一个接受double值参数的操作，并且不返回结果。

9	DoubleFunction<R>//代表接受一个double值参数的方法，并且返回结果

10	DoublePredicate//代表一个拥有double值参数的boolean值方法

11	DoubleSupplier//代表一个double值结构的提供方

12	DoubleToIntFunction//接受一个double类型输入，返回一个int类型结果。

13	DoubleToLongFunction//接受一个double类型输入，返回一个long类型结果

14	DoubleUnaryOperator//接受一个参数同为类型double,返回值类型也为double 。

15	Function<T,R>//接受一个输入参数，返回一个结果。

16	IntBinaryOperator//接受两个参数同为类型int,返回值类型也为int 。

17	IntConsumer//接受一个int类型的输入参数，无返回值 。

18	IntFunction<R>//接受一个int类型输入参数，返回一个结果 。

19	IntPredicate//接受一个int输入参数，返回一个布尔值的结果。

20	IntSupplier//无参数，返回一个int类型结果。

21	IntToDoubleFunction//接受一个int类型输入，返回一个double类型结果 。

22	IntToLongFunction//接受一个int类型输入，返回一个long类型结果。

23	IntUnaryOperator//接受一个参数同为类型int,返回值类型也为int 。

24	LongBinaryOperator//接受两个参数同为类型long,返回值类型也为long。

25	LongConsumer//接受一个long类型的输入参数，无返回值。

26	LongFunction<R>//接受一个long类型输入参数，返回一个结果。

27	LongPredicate//R接受一个long输入参数，返回一个布尔值类型结果。

28	LongSupplier//无参数，返回一个结果long类型的值。

29	LongToDoubleFunction//接受一个long类型输入，返回一个double类型结果。

30	LongToIntFunction//接受一个long类型输入，返回一个int类型结果。

31	LongUnaryOperator//接受一个参数同为类型long,返回值类型也为long。

32	ObjDoubleConsumer<T>//接受一个object类型和一个double类型的输入参数，无返回值。

33	ObjIntConsumer<T>//接受一个object类型和一个int类型的输入参数，无返回值。

34	ObjLongConsumer<T>//接受一个object类型和一个long类型的输入参数，无返回值。

35	Predicate<T>//接受一个输入参数，返回一个布尔值结果。

36	Supplier<T>//无参数，返回一个结果。

37	ToDoubleBiFunction<T,U>//接受两个输入参数，返回一个double类型结果

38	ToDoubleFunction<T>//接受一个输入参数，返回一个double类型结果

39	ToIntBiFunction<T,U>//接受两个输入参数，返回一个int类型结果。

40	ToIntFunction<T>//接受一个输入参数，返回一个int类型结果。

41	ToLongBiFunction<T,U>//接受两个输入参数，返回一个long类型结果。

42	ToLongFunction<T>//接受一个输入参数，返回一个long类型结果。

43	UnaryOperator<T>//接受一个参数为类型T,返回值类型也为T。

四大核心函数式接口：

Consumer< T>： 消费性接口 void accept(T t);

Supplier< T> ： 供给型接口 T get();

Function<T, R>： 函数式接口 R apply(T t);

Predicate< T>： 断言型接口 boolean test(T t);

下面是4大核心函数式接口使用实例，调用结果大家可以自己亲自使用一下，另外其他的函数式接口和下面例子的使用方法类似，感兴趣的可以试试其他的，下面的建议大家亲自敲一下试一下。

  //Consumer消费行接口测试
    @Test
    public void tset() {
        pay(1000, (m) -> System.out.println("景初购买学习资料花费：" + m + "元"));
    }

    public void pay(double money, Consumer<Double> consumer) {
        consumer.accept(money);
    }

    //Supplier供给型接口测试
    @Test
    public void test1() {
        List<Integer> list = getNumsList(5, () -> (int) (Math.random() * 100));
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }

    //需求：产生一些整数放入集合内
    public List<Integer> getNumsList(int num, Supplier<Integer> supplier) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            Integer integer = supplier.get();
            list.add(integer);
        }
        return list;
    }

    //Function 函数行接口：
    @Test
    public void test2() {
        Integer n = strHandler("\t\t   景初努力学习java   ", (str) -> str.trim().length());
        System.out.println(n);
    }

    //需求：处理字符串
    public Integer strHandler(String str, Function<String, Integer> function) {
        return function.apply(str);
    }

    //Predicate 断言型接口
    @Test
    public void test3() {
        List<String> list = Arrays.asList("hello", "jingchu", "world", "java", "lambda");
        List<String> res = filterStr(list, (s) -> s.length() > 4);
        for (String str : res) {
            System.out.println(str);
        }
    }

    //需求：将满足条件的字符串放入字符串集合中
    public List<String> filterStr(List<String> list, Predicate<String> predicate) {
        List<String> res = new ArrayList<>();
        for (String str : list) {
            if (predicate.test(str)) {
                res.add(str);
            }
        }
        return res;
    }