函数式编程思想及函数式接口的简单使用

最新推荐文章于 2022-08-05 14:34:48 发布

原创最新推荐文章于 2022-08-05 14:34:48 发布 · 172 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

本文深入介绍了Java中的函数式编程思想，包括Lambda表达式的使用，如参数类型和方法体的省略格式，以及常见函数式接口如Consumer、Supplier、Function和Predicate的应用。通过实例展示了如何在实际代码中使用这些接口，如Consumer的andThen方法，Function的apply方法和Predicate的逻辑操作。此外，还解释了函数式接口的概念，强调它们在Java中的重要性。

介绍

面向对象思想关注的是具备功能的对象

函数式编程思想关注的不再是对象而是功能

Lambda表达式

可以理解为用一个匿名方法对一个接口的抽象方法进行重写

标准格式

(参数类型参数名)->{方法体}

():小括号里面写的是参数数据类型参数名当多个参数是,用逗号隔开

->:代表指向动作

{}:方法体中写的内容

省略格式

1.参数可以省略参数类型 (int a, int b) (a,b)

2.如果只有参数可以省略() (int a) a

3.方法体如果只有一句话可以省略大括号 return ; 一旦省略,这几个都要省略

函数式接口

有且仅有一个抽象方法的接口接口中可以有其他方法比如默认方法,静态方法

可以使用@FunctionalInterface来验证是否是函数式接口

常用的函数式接口

Supplier接口供给型接口有返回值

Consumer接口消费型接口对数据进行操作使用

Function接口转换数据类型接口

Predicate接口判断型接口

Consumer接口

java.util.function.Consumer<T> 消费型接口消费一个数据

void accept(Tt) 接收一个数据并使用

andThen(Consumer c) 然后,继续

public class Test02_Consumer {
    public static void main(String[] args) {

//        method("HelloWorld", new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s.toUpperCase());
//            }
//        }, new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s.toLowerCase());
//            }
//        });

        //省略格式
        method("Hello World",
                s-> System.out.println(s.toUpperCase()),
                s-> System.out.println(s.toLowerCase()));
    }

    public static void method(String s, Consumer<String> c1 ,Consumer<String> c2){
//            c1.accept(s);
//            c2.accept(s);
        c1.andThen(c2).accept(s);
    }
}

Function接口

java.util.function.Function<T,R>

R apply(T t) 根据T类型获取R类型的结果可以转为引用类型

ublic class Test_Function {

    public static void main(String[] args) {

        //Lambda标准格式
        method("100",(String num)->{
            return Integer.parseInt(num);
        });

        //Lambada省略格式
        method("1000",num->Integer.parseInt(num));
        /*
             引用一个类的静态方法
             类名::静态方法
         */
        method("1000",Integer::parseInt);
    }
    public static  void method(String num , Function<String,Integer> f){
        Integer n = f.apply(num);
        System.out.println(n);
    }
}

Predicate接口

java.util.function.Predicate<T> 判断型接口

boolean test(T t)

and &&
or ||
negate !

public class Test2_Predicate {
    public static void main(String[] args) {
        method("hello world",(String s)->{
            return s.contains("h");
        },(String s)->{
            return  s.contains("w");
        });

        System.out.println("-------------------------------------");
        method("hello",s->s.contains("h"),s->s.contains("w"));

    }

    public static void method(String s , Predicate<String> p1,Predicate<String> p2){
//        boolean b1 = p1.test(s);
//        boolean b2 = p2.test(s);
//
//        if(b1 && b2){
//            System.out.println("字符串既包含H又包含 w");
//        }

//        boolean b = p1.and(p2).test(s);
//        if(b){
//            System.out.println("字符串既包含H又包含 w");
//        }

//        if(b1||b2){
//            System.out.println("字符串 包含h 或者包含w");
//        }
        boolean b3 = p1.or(p2).test(s);
//        System.out.println(b3);
        if(b3){
            System.out.println("字符串 包含h 或者包含w");
        }
    }
}

Supplier接口

java.util.function.Supplier<T> 供给型接口

T get()

public class Test_Supplier {

    public static void main(String[] args) {
        int[] arr = {3,8,2,5,0};

//        method(new Supplier<Integer>() {
//            @Override
//            public Integer get() {
//                Arrays.sort(arr);
//                return arr[arr.length -1 ];
//            }
//        });

        method(()->{
            Arrays.sort(arr);

            return arr[arr.length-1];
        });
    }
    public static void method(Supplier<Integer> s){
        Integer max = s.get();
        System.out.println(max);
    }
}