JDK8 Function用法详解最全

入口 Function<T,R>
function是传一个参数返回一个参数 这个可以用场景总结一。集合遍历对于对象的处理等等

一.原生的用法 实现接口

public class FunctionObj implements Function {
    @Override
    public Object apply(Object t) {
        return "原生的用法实现接口"+t;
    }
}  


public class Test {

    //
    public static void test(String input,Function function){
        System.out.println(function.apply(input));
    }

    public static void main(String[] args) {
        //调用
        test("123", new FunctionObj());

        //或
        Function function = new FunctionObj();
        function.apply("123");

    }
}

二.直接用函数式编程

public class Test {

    public static void main(String[] args) {
        //直接用函数式编程
        Function function1 = x -> {
            return "原生的用法实现接口" + x;
        };
        function1.apply("123");
    }
}

三.配合集合中使用 apply

public class Test3 {
    public static void main(String args[]) {
        Function<User, String> funcUserToString = (User e) -> {
            return e.getName();
        };
        List<User> userList =
                Arrays.asList(new User("A-0", 0),
                        new User("A-1", 1),
                        new User("B-2", 2),
                        new User("C-3", 3),
                        new User("D-4", 4));
        List<String> userNameList = userList.stream().map(v -> {
            return funcUserToString.apply(v);
        }).collect(Collectors.toList());
        userNameList.forEach(System.out::println);
    }
}
打印结果
A-0
A-1
B-2
C-3
D-4

三.配合集合中使用 andThen

public class Test {
    public static void main(String[] args) {
        Function<User, String> func = (User e) -> {
            return e.getName();
        };
        Function<String, String> lasterFunction = (String s) -> s.substring(0, 1).toLowerCase();

        List<User> userList =
                Arrays.asList(new User("A-1", 13),
                        new User("A-1", 25),
                        new User("A-2", 10),
                        new User("A-3", 15),
                        new User("A-4", 29));

        List<String> userNameListInitials = convertList(userList, func.andThen(lasterFunction ));
        userNameListInitials.forEach(str -> {
            System.out.print(str);
        });
    }

    public static List<String> convertList(List<User> userList, Function<User, String> func) {
        List<String> userNameList = new ArrayList<String>();
        for (User user : userList) {
            userNameList.add(func.apply(user));
        }
        return userNameList;
    }

}

andThen 是function 中默认方法， andThen 里面的行为后执行func.andThen(lasterFunction )说明
lasterFunction这个行为后执行

	default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
	        Objects.requireNonNull(after);
	        return (T t) -> after.apply(apply(t));
	    }

三.配合集合中使用 compose

 public class Test3 {

    public static void main(String args[]){
        Function<User, String> funcUserToString= (User e)-> {return e.getName();};
        Function<User, User> funcuserFirst=
                (User e)-> {int index= e.getName().indexOf("-");
                    String firstName=e.getName().substring(0,index);
                    e.setName(firstName);
                    return e;};
        List<User> UserList=
                Arrays.asList(new User("AAA--AA", 0),
                        new User("BBB--BB", 1),
                        new User("CCC--CC", 2),
                        new User("DDD--DD", 3),
                        new User("EEE--EE", 4));
        List<String> userFirstNameList= convertList(UserList,funcUserToString.compose(funcuserFirst));
        userFirstNameList.forEach(str->{System.out.print(" "+str);});
    }
    public static List<String> convertList(List<User> UserList, Function<User, String> func){
        List<String> userNameList=new ArrayList<String>();
        for(User user:UserList){
            userNameList.add(func.apply(user));
        }
        return userNameList;
    }
}

compose是调用者后执行 先执行里面的方法,funcUserToString.compose(funcuserFirst) 说明先执行
funcuserFirst的apply方法

default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

练习：

public class Test2 {

    public static void main(String args[]) {
        int a = compute(5, value -> value * value);
        int a1 = compute(5, value -> value + value);
        int a2 = compute(5, value -> value - 2);
        System.out.println(a + "" + "-" + a1 + "-" + a2);//25-10-3

        //function1.compose(function2) 先执行 function2 即是:2*2=4  后执行function1 4*3=12
        int a3 = compute(2, value -> value * 3, value -> value * value); //12

        //function1.andThen(function2) 先执行 function1 即是:2*3=6  后执行function2 6*6=36
        int a4 = compute2(2, value -> value * 3, value -> value * value);//36
        System.out.println(a3 + "-" + a4); //12-36
    }
    

    public static int compute(int a, Function<Integer, Integer> function) {
        int result = function.apply(a);
        return result;
    }

    public static int compute(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {
        return function1.compose(function2).apply(a);
    }
    //
    public static int compute2(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {
        return function1.andThen(function2).apply(a);
    }
}