JDK8新特性(三)之常用内置函数式接口

我们知道Lambda表达式的前提是需要有函数式接口，而Lambda使用时不关心接口名，抽象方法名，只关心抽象方法的参数列表和返回值类型，因此为了让我们使用Lambda方便，JDK8提供了大量常用的函数式接口。常用内置函数式接口主要在java.util.function包中，下面是最常用的几个接口。

一、Supplier接口

java.util.function.Supplier<T>接口，它意味着“供给”，对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。

@FunctionalInterface
public interface Supplier<T> {

    T get();
}

供给型接口，通过Supplier接口中的get方法可以得到一个值，无参有返回的接口

使用Supplier接口作为方法参数类型，通过Lambda表达式求生int数组中的最大值。提示：接口的泛型使用java.lang.Integer类，基本使用如下：

import java.util.Arrays;
import java.util.function.Supplier;

public class Demo {

    // 使用Lambda表达式返回数组元素的最大值
    public static void main(String[] args) {
        printMax(()->{
            int[] arr={11,99,88,77,22};
            Arrays.sort(arr);
            return arr[arr.length-1];
        });
    }

    private static void printMax(Supplier<Integer> supplier){
        int max= supplier.get();
        System.out.println("max = "+max);
    }
}

执行上述代码，其输出结果为：

max = 99

二、Consumer接口

java.util.function.Consumer<T>接口则正好相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型参数决定。

@FunctionalInterface
public interface Consumer<T> {

    public abstract void accept(T t);
}

使用Lambda表达式将一个字符串转成大写的字符串

import java.util.function.Consumer;

public class Demo {

    public static void main(String[] args) {
        printHello((String str)->{
            System.out.println(str.toUpperCase());
        });
    }

    private static void printHello(Consumer<String> consumer){
        consumer.accept("Hello World!");
    }
}

执行上述代码，其输出结果为：

HELLO WORLD!

使用Lambda表达式先将一个字符串转成小写的字符串，然后再转成大写

import java.util.function.Consumer;

public class Demo {

    public static void main(String[] args) {
        printHello((String str)->{
            System.out.println(str.toLowerCase());
        },(String str)->{
            System.out.println(str.toUpperCase());
        });
    }

    private static void printHello(Consumer<String> c1,Consumer<String> c2){
        String str="Hello World!";
        c1.accept(str);
        c2.accept(str);
    }
}

执行上述代码，其输出结果为：

hello world!
HELLO WORLD!

上述代码可以使用Consumer接口的andThen方法进行简写，其简写后的示例如下：

import java.util.function.Consumer;

public class Demo {

    public static void main(String[] args) {
        printHello((String str)->{
            System.out.println(str.toLowerCase());
        },(String str)->{
            System.out.println(str.toUpperCase());
        });
    }

    private static void printHello(Consumer<String> c1,Consumer<String> c2){
        String str="Hello World!";
        c1.andThen(c2).accept(str);
    }
}

三、Function接口

java.util.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件，有参数有返回值。

@FunctionalInterface
public interface Function<T, R> {

    public abstract R apply(T t);
}

import java.util.function.Function;

public class Demo {

    public static void main(String[] args) {
        getNumber((String str)->{
            int i= Integer.parseInt(str);
            return i;
        });
    }

    private static void getNumber(Function<String,Integer> function){
        Integer num = function.apply("10");
        System.out.println("num = "+num);
    }
}

执行上述代码，其输出结果为：

num = 10

Function接口的andThen的使用示例： 

import java.util.function.Function;

public class Demo {

    public static void main(String[] args) {
        getNumber((String str)->{
            return Integer.parseInt(str);
        },(Integer i)->{
            return i*5;
        });
    }

    private static void getNumber(Function<String,Integer> f1,Function<Integer,Integer> f2{
        //Integer num = f1.apply("6");
        //Integer num2 = f2.apply(num);
        Integer num2 = f1.andThen(f2).apply("6");
        System.out.println("num2 = "+num2);
    }
}

四、Predicate接口

有时我们需要对某种类型的数据进行判断，从而得到一个boolean值结果，这时可以使用 java.util.function.Predicate<T>接口

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);
}

使用Lambda表达式判断一个人姓名是否超过3个字

import java.util.function.Predicate;

public class Demo {

    public static void main(String[] args) {
        isLongName((String name)->{
            return name.length()>3;
        });
    }

    private static void isLongName(Predicate<String> predicate){
        boolean isLong =predicate.test("徐凤年");
        System.out.println("名字超出3个字:"+isLong);
    }
}

执行上述代码，其输出结果为：

名字超出3个字:false

使用Lambda表达式判断一个字符串中即包含W，又包含H

使用Lambda表达式判断一个字符串中包含W或者包含H

使用Lambda表达式判断一个字符串中不包含W

import java.util.function.Predicate;

public class Demo {

    public static void main(String[] args) {
        test((String str)->{
            return str.contains("H");
        },(String str)->{
            return str.contains("W");
        });
    }

    private static void test(Predicate<String> p1,Predicate<String> p2){
        String str="Hello World";
        //boolean b1 =p1.test(str);
        //boolean b2 =p2.test(str);
        //if(b1&b2){
        //    System.out.println("既包含W,也包含H");
        //}

        // 使用Lambda表达式判断一个字符串中即包含W，又包含H
        boolean b1 = p1.and(p2).test(str);
        if(b1){
            System.out.println("既包含W,也包含H");
        }

        // 使用Lambda表达式判断一个字符串中包含W或者包含H
        boolean b2 = p1.or(p2).test(str);
        if(b2){
            System.out.println("包含W或者包含H");
        }

        //使用Lambda表达式判断一个字符串中不包含W
        boolean b3 = p1.negate().test("Hello");
        if(b3){
            System.out.println("不包含W");
        }
    }
}

执行上述代码，其输出结果为：

既包含W,也包含H
包含W或者包含H
不包含W