阿里云爆款
首页 » Java » Java8学习笔记:1.函数接口

Java8学习笔记:1.函数接口

原文 http://blog.csdn.net/u013898617/article/details/79052239

2018-01-14 02:00:25阅读(483)

阿里云爆款

今天总结了下Java8函数接口,在此备注

java.util.function下共43个接口,主要是6个接口,其他都是扩展

            Function  输入参数为类型T, 输出为类型R, 记作 T -> R
            Consumer  输入参数为类型T, 输出为void, 记作 T -> void
            Supplier  没有输入参数, 输出为类型T, 记作 void -> T
            Predicate 输入参数为类型T, 输出为类型boolean, 记作 T -> boolean

            BinaryOperator 根据Comparator返回对应min和max值
            UnaryOperator 输入 T 返回 T

其他的扩展,主要针对不同多参数和不同数据类型:
            BiFunction<T,U,R> 记作 <T,U> -> R
            BiConsumer<T,U> 记作 <T,U> -> void
            BiPredicate<T,U> 记作 <T,U> -> boolean


测试类写了上面9个加DoubleBinaryOperator,权作笔记,参考即可


剩下的如下:

            BooleanSupplier 记作 void -> boolean

            DoubleConsumer 记作 double -> void
            DoubleFunction<R> 记作 double -> R
            DoublePredicate 记作 double -> boolean
            DoubleSupplier 记作 void -> double

            IntConsumer 记作 int -> void
            IntFunction<R> 记作 int -> R
            IntPredicate 记作 int -> boolean
            IntSupplier 记作 void -> int

            LongConsumer 记作 long -> void
            LongFunction<R> 记作 long -> R
            LongPredicate 记作 long -> boolean
            LongSupplier 记作 void -> long

            LongToDoubleFunction 记作 long -> double
            LongToIntFunction 记作 long -> double
            DoubleToLongFunction 记作 double -> long
            DoubleToIntFunction 记作 double -> int
            IntToLongFunction 记作 int -> long
            IntToDoubleFunction 记作 int -> double

            ToIntFunction<T> 记作 T -> int
            ToDoubleFunction<T> 记作 T -> double
            ToLongFunction<T> 记作 T -> long

            ToIntBiFunction<T,U> 记作 <T,U> -> int
            ToDoubleBiFunction<T,U> 记作 <T,U> -> double
            ToLongBiFunction<T,U> 记作 <T,U> -> long

            IntBinaryOperator 记作 <int, int> -> int
            IntUnaryOperator 记作 int -> int
            DoubleBinaryOperator 记作 <double, double> -> double
            DoubleUnaryOperator 记作 double -> double
            LongBinaryOperator 记作 <long, long> -> long
            LongUnaryOperator 记作 long -> long

            ObjDoubleConsumer<T> 记作 <T, double> -> void
            ObjIntConsumer<T>  记作 <T, int> -> void
            ObjLongConsumer<T>  记作 <T, long> -> void

单元测试:

public class Java8FunctionsTest {
    public static void main(String[] args) {
        Java8FunctionsTest test = new Java8FunctionsTest();
        /**
            Function  输入参数为类型T, 输出为类型R, 记作 T -> R
            Consumer  输入参数为类型T, 输出为void, 记作 T -> void
            Supplier  没有输入参数, 输出为类型T, 记作 void -> T
            Predicate 输入参数为类型T, 输出为类型boolean, 记作 T -> boolean
            BinaryOperator 根据Comparator返回对应min和max值
            UnaryOperator 输入 T 返回 T
            如果输入参数是两个,这时可以使用
            BiFunction<T,U,R> 记作 <T,U> -> R
            BiConsumer<T,U> 记作 <T,U> -> void
            BiPredicate<T,U> 记作 <T,U> -> boolean
         */
        test.testFunction();
        test.testBiFunction();
        test.testConsumer();
        test.testBiConsumer();
        test.testSupplier();
        test.testPredicate();
        test.testBiPredicate();
        test.testBinaryOperator();
        test.testDoubleBinaryOperator();
        test.testUnaryOperator();
        /**
         * 如果输入参数是基本类型,为了避免自动拆箱装箱,可以使用
             BooleanSupplier 记作 void -> boolean
             DoubleConsumer 记作 double -> void
             DoubleFunction<R> 记作 double -> R
             DoublePredicate 记作 double -> boolean
             DoubleSupplier 记作 void -> double
             IntConsumer 记作 int -> void
             IntFunction<R> 记作 int -> R
             IntPredicate 记作 int -> boolean
             IntSupplier 记作 void -> int
             LongConsumer 记作 long -> void
             LongFunction<R> 记作 long -> R
             LongPredicate 记作 long -> boolean
             LongSupplier 记作 void -> long
             LongToDoubleFunction 记作 long -> double
             LongToIntFunction 记作 long -> double
             DoubleToLongFunction 记作 double -> long
             DoubleToIntFunction 记作 double -> int
             IntToLongFunction 记作 int -> long
             IntToDoubleFunction 记作 int -> double
             ToIntFunction<T> 记作 T -> int
             ToDoubleFunction<T> 记作 T -> double
             ToLongFunction<T> 记作 T -> long
             ToIntBiFunction<T,U> 记作 <T,U> -> int
             ToDoubleBiFunction<T,U> 记作 <T,U> -> double
             ToLongBiFunction<T,U> 记作 <T,U> -> long
             IntBinaryOperator 记作 <int, int> -> int
             IntUnaryOperator 记作 int -> int
             DoubleBinaryOperator 记作 <double, double> -> double
             DoubleUnaryOperator 记作 double -> double
             LongBinaryOperator 记作 <long, long> -> long
             LongUnaryOperator 记作 long -> long
             ObjDoubleConsumer<T> 记作 <T, double> -> void
             ObjIntConsumer<T>  记作 <T, int> -> void
             ObjLongConsumer<T>  记作 <T, long> -> void
         */
    }
    /**
     * Predicate 输入参数为类型T, 输出为类型boolean, 记作 T -> boolean
     */
    public void testPredicate(){
        Predicate<Integer> p1 = x -> x > 6;
        Predicate<Integer> p2 = x -> x > 5;
        System.out.println(p1.test(6));
        System.out.println(p1.test(7));
        System.out.println(p1.negate().test(6));
        System.out.println(p1.negate().test(7));
        System.out.println(p1.and(p2).test(6));
        System.out.println(p1.and(p2).test(7));
        System.out.println(p1.or(p2).test(5));
        System.out.println(p1.or(p2).test(6));
    }
    /**
     * Consumer< T>接口接受一个T类型参数,没有返回值
     */
    public void testConsumer(){
        UserTest userTest = new UserTest();
        Consumer<UserTest> userConsumer = user -> {
            user.setName("name");
            user.setAge(20);
        };
        System.out.println("name:" + userTest.getName() + ",agr:" + userTest.getAge());
        userConsumer.accept(userTest);
        System.out.println("name:" + userTest.getName() + ",agr:" + userTest.getAge());
    }
    public static class UserTest{
        private String name;
        private Integer age;
        public UserTest() {
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public Integer getAge() {
            return age;
        }
        public void setAge(Integer age) {
            this.age = age;
        }
    }
    /**
     * Function  输入参数为类型T, 输出为类型R, 记作 T -> R
     */
    public void testFunction(){
        String string = "123456";
        Function<String, String> function = (String str) -> str;
        Function<String, String> before = (String str) -> str + "789";
        Function<String, String> after = (String str) -> str.substring(0, str.length() - 3);
        System.out.println(function.apply("123456"));
        System.out.println(function.compose(before).apply(string));
        System.out.println(function.andThen(after).apply(string));
    }
    /**
     * Supplier  没有输入参数, 输出为类型T, 记作 void -> T
     */
    private void testSupplier() {
        Supplier<String> str = () -> "aaa";
        Supplier<Integer> integer = () -> 123;
        System.out.println(str.get());
        System.out.println(integer.get());
    }
    /**
     * BiFunction<T,U,R> 记作 <T,U> -> R
     */
    private void testBiFunction() {
        BiFunction<Integer, Double, String> function1 = (Integer a, Double b) -> a.toString() + b.toString();
        BiFunction<Byte, Double, String> function2 = (Byte a, Double b) -> a.toString() + b.toString();
        System.out.println(function1.apply(12,22.2));
        System.out.println(function1.apply(1,2.2));
    }
    /**
     * BiConsumer<T,U> 记作 <T,U> -> void
     */
    private void testBiConsumer() {
        BiConsumer<Integer, Double> function1 = (Integer a, Double b) -> System.out.println(a.toString() + "_" + b.toString());
        BiConsumer<Integer, Double> after = (Integer a, Double b) ->{
            a--;b-=1.11;
            System.out.println(a.toString() + "_" + b.toString());
        };
        function1.accept(1,22.0);
        function1.andThen(after).accept(10,11.11);
    }
    /**
     * BiPredicate<T,U> 记作 <T,U> -> boolean
     */
    private void testBiPredicate() {
        BooleanSupplier bs = () -> true;
        System.out.println(bs.getAsBoolean());
        BiPredicate<Integer, Double> biPredicate1 = (Integer a, Double b) -> a - b > 0;
        BiPredicate<Integer, Double> biPredicate2 = (Integer a, Double b) -> a + b > 0;
        System.out.println(biPredicate1.test(10, 2.22));
        System.out.println(biPredicate2.test(10, -2.22));
        System.out.println(biPredicate1.negate().test(1, 2.0));
        System.out.println(biPredicate2.negate().test(1, -2.0));
        System.out.println(biPredicate1.or(biPredicate2).test(1, 2.0));
        System.out.println( biPredicate1.and(biPredicate2).test(2, 1.0));
    }
    /**
     * BinaryOperator 根据Comparator返回对应min和max值
     */
    private void testBinaryOperator() {
        Comparator comparator = Comparator.comparingInt(o -> (Integer) o);
        System.out.println(BinaryOperator.minBy(comparator).apply(2, 1));
        System.out.println(BinaryOperator.maxBy(comparator).apply(2, 1));
    }
    /**
     * DoubleBinaryOperator 记作 <double, double> -> double
     */
    private void testDoubleBinaryOperator() {
        DoubleBinaryOperator dbo = (double a, double b) -> Double.max(a, b);
        System.out.println(dbo.applyAsDouble(2.0, 1.0));
        System.out.println(dbo.applyAsDouble(2.0, 3.0));
    }
    /**
     * UnaryOperator 输入 T 返回 T
     */
    private void testUnaryOperator() {
        UnaryOperator<String> uo = (String str) -> str;
        UnaryOperator<String> compose = (String str) -> "compose_" + str;
        UnaryOperator<String> andThen = (String str) -> str + "_andThen";
        System.out.println(uo.apply("1"));
        System.out.println(uo.compose(compose).apply("1"));
        System.out.println(uo.andThen(andThen).apply("1"));
    }
}


最新发布

CentOS专题

关于本站

5ibc.net旗下博客站精品博文小部分原创、大部分从互联网收集整理。尊重作者版权、传播精品博文,让更多编程爱好者知晓!

小提示

按 Ctrl+D 键,
把本文加入收藏夹