New functional interface with new features in Java 8

Java8 type features

New functional interface with new features in Java 8

Introduction

Functional interface: When there is only one abstract method in the interface, there can be multiple non-abstract methods; you can use the annotation @FunctionalInterface to modify, so you can check whether it is a functional interface;

use

Since the use condition of Lambda expression must have functional support, it can be used in Lambda expression;

Functional interface before Java 8

Common ones are:

java.lang.Runnable
java.util.concurrent.Callable
java.util.Comparator
java.io.FileFilter

Four new functional interfaces in Java 8

1. Consumer<T>: Consumer interface

void accept(T t); //Accept an input parameter and no return operation

application

public static void main(String[] args) {
    happy(100,(m) -> System.out.println("买衣服花了" + m + "元"));
}

private static void happy(double money, Consumer<Double> consumer) {
   consumer.accept(money);
}

operation result:

I spent 100 yuan on clothes

2.Supplier<T>: Supply interface

T get(); //No parameters, return a result.

Case: Random field generates a data and saves it in the collection


    public static void main(String[] args) {
        List<Integer> numList = getNumList(10, () -> (int) (Math.random() * 100));
        for (Integer num : numList) {
            System.out.println(num);
        }
    }

    //产生一个随机数，并存储在List中
    private static List<Integer> getNumList(int num, Supplier<Integer> supplier) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            list.add(supplier.get());
        }
        return list;
    }

operation result:

21
78
96
23
61
33
69
69
94
85

3. Function<T,R>: functional interface

R apple(T t); //Accept an input parameter and return a result.

Case: Handling strings


    public static void main(String[] args) {
        String result = getStr("  hello   world", (x) -> x.replaceAll(" ", ""));
        System.out.println(result);

    }

    private static String getStr(String s, Function<String, String> function) {
        return function.apply(s);
    }

operation result:

helloworld

4. Predicate<T>: assertion type interface

boolean test(T t);//Accepts an input parameter and returns a boolean result.

Case: Put the String that meets the conditions into the collection

public static void main(String[] args) {
        List<String> list = Arrays.asList("android", "ios", "h5", "Java", "php", "python");
        List<String> strings = addStr(list, (s) -> s.length() > 3);
        for (String str : strings
        ) {
            System.out.println(str);
        }


        //不是Lambda表达式
        addStr(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() > 3;
            }
        });
    }

    private static List<String> addStr(List<String> stringList, Predicate<String> predicate) {
        List<String> result = new ArrayList<>();

        for (String str : stringList) {
            if (predicate.test(str)) {
                result.add(str);
            }
        }
        return result;
    }

operation result:

android
Java
python

Of course, in addition to the above four categories, there are many, but they are all under the java.util.function package, which contains many categories to support functional programming in Java;