Java函数式编程

程序员文章站 2022-06-07 12:12:16

...

一、 Lambda 表达式

Lambda 表达式，也可称为闭包，Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

1.1 语法

lambda 表达式的语法格式如下：

(parameters) -> expression或(parameters) ->{statements; }

以下是lambda表达式的重要特征:

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

1.2 Lambda 表达式实例

public class Java8Tester {
    public static void main(String args[]) {
        Java8Tester tester = new Java8Tester();
        // 类型声明
        MathOperation addition = (int a, int b) -> a + b;
        // 不用类型声明
        MathOperation subtraction = (a, b) -> a - b;
        // 大括号中的返回语句
        MathOperation multiplication = (int a, int b) -> {
            return a * b;
        };
        // 没有大括号及返回语句
        MathOperation division = (int a, int b) -> a / b;
        System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
        System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
        System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
        System.out.println("10 / 5 = " + tester.operate(10, 5, division));
        // 不用括号
        GreetingService greetService1 = message ->
                System.out.println("Hello " + message);
        // 用括号
        GreetingService greetService2 = (message) ->
                System.out.println("Hello " + message);
        greetService1.sayMessage("Runoob");
        greetService2.sayMessage("Google");
    }
    interface MathOperation {
        int operation(int a, int b);
    }
    interface GreetingService {
        void sayMessage(String message);
    }
    private int operate(int a, int b, MathOperation mathOperation) {
        return mathOperation.operation(a, b);
    }
}

1.3 变量作用域

lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在lambda 内部修改定义在域外的局部变量，否则会编译错误。

public class Java8Tester {
    final static String salutation = "Hello! ";
public static void main(String args[]){
    GreetingService greetService1 = message ->
            System.out.println(salutation + message);
    greetService1.sayMessage("Runoob");
//====================相当于下面==============================
    GreetingService g = new GreetingService() {
        @Override
        public void sayMessage(String message) {
            System.out.println(salutation + message);
        }
    };
    g.sayMessage("jack");
//===========================================================
}
interface GreetingService {
    void sayMessage(String message);
}
}

lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有final 的语义）

public class Java8Tester {
    public static void main(String args[]) {
        int num = 1;
        Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
        s.convert(2);
        num = 5;
    }
    public interface Converter<T1, T2> {
        void convert(int i);
    }
}

//报错信息：Local variable num defined in an enclosing scope must be final or effectively final
//把num=5；注释掉就不报错了

在Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。

public class Java8Tester {
    public static void main(String args[]) {
        String first = "";
        Comparator<String> comparator = (first, second) -> System.out.println(Integer.compare(first.length(), second.length()));  //编译会出错

        comparator.com("aaaaa","bb");
    }
    public interface Comparator<T> {
        void com(String a,String b);
    }
}
//把String first = "";注掉就不报错了

二、方法引用

方法引用通过方法的名字来指向一个方法。

方法引用可以使语言的构造更紧凑简洁，减少冗余代码。

方法引用使用一对冒号 :: 。

下面，我们在 Car 类中定义了 4 个方法作为例子来区分 Java 中 4 种不同方法的引用。

class Car {
    @FunctionalInterface
    public interface Supplier<T> {
        T get();
    }

    //Supplier是jdk1.8的接口，这里和lamda一起使用了
    public static Car create(final Supplier<Car> supplier) {
        return supplier.get();
    }

    public static void collide(final Car car) {
        System.out.println("Collided " + car.toString());
    }

    public void follow(final Car another) {
        System.out.println("Following the " + another.toString());
    }

    public void repair() {
        System.out.println("Repaired " + this.toString());
    }

    public static void main(String[] args) {
        //构造器引用：它的语法是Class::new，或者更一般的Class< T >::new实例如下：
         Car car  = Car.create(Car::new);
         Car car1 = Car.create(Car::new);
         Car car2 = Car.create(Car::new);
         Car car3 = new Car();
        List<Car> cars = Arrays.asList(car,car1,car2,car3);
        System.out.println("===================构造器引用========================");
        //静态方法引用：它的语法是Class::static_method，实例如下：
        cars.forEach(Car::collide);
        System.out.println("===================静态方法引用========================");
        //特定类的任意对象的方法引用：它的语法是Class::method实例如下：
        cars.forEach(Car::repair);
        System.out.println("==============特定类的任意对象的方法引用================");
        //特定对象的方法引用：它的语法是instance::method实例如下：
        final Car police = Car.create(Car::new);
        cars.forEach(police::follow);
        System.out.println("===================特定对象的方法引用===================");

    }
}

三、函数式接口

函数式接口(FunctionalInterface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

函数式接口可以被隐式转换为lambda表达式。

函数式接口可以现有的函数友好地支持 lambda。

JDK 1.8之前已有的函数式接口:

java.lang.Runnable
java.util.concurrent.Callable
java.security.PrivilegedAction
java.util.Comparator
java.io.FileFilter
java.nio.file.PathMatcher
java.lang.reflect.InvocationHandler
java.beans.PropertyChangeListener
java.awt.event.ActionListener
javax.swing.event.ChangeListener

JDK 1.8 新增加的函数接口：

java.util.function

java.util.function 它包含了很多类，用来支持 Java的函数式编程，该包中的函数式接口有：

BiConsumer<T,U>

代表了一个接受两个输入参数的操作，并且不返回任何结果

BiFunction<T,U,R>

代表了一个接受两个输入参数的方法，并且返回一个结果

BinaryOperator<T>

代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果

BiPredicate<T,U>

代表了一个两个参数的boolean值方法

BooleanSupplier

代表了boolean值结果的提供方

Consumer<T>

代表了接受一个输入参数并且无返回的操作

DoubleBinaryOperator

代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。

DoubleConsumer

代表一个接受double值参数的操作，并且不返回结果。

DoubleFunction<R>

代表接受一个double值参数的方法，并且返回结果

DoublePredicate

代表一个拥有double值参数的boolean值方法

DoubleSupplier

代表一个double值结构的提供方

DoubleToIntFunction

接受一个double类型输入，返回一个int类型结果。

DoubleToLongFunction

接受一个double类型输入，返回一个long类型结果

DoubleUnaryOperator

接受一个参数同为类型double,返回值类型也为double。

Function<T,R>

接受一个输入参数，返回一个结果。

IntBinaryOperator

接受两个参数同为类型int,返回值类型也为int 。

IntConsumer

接受一个int类型的输入参数，无返回值。

IntFunction<R>

接受一个int类型输入参数，返回一个结果。

IntPredicate

接受一个int输入参数，返回一个布尔值的结果。

IntSupplier

无参数，返回一个int类型结果。

IntToDoubleFunction

接受一个int类型输入，返回一个double类型结果。

IntToLongFunction

接受一个int类型输入，返回一个long类型结果。

IntUnaryOperator

接受一个参数同为类型int,返回值类型也为int 。

LongBinaryOperator

接受两个参数同为类型long,返回值类型也为long。

LongConsumer

接受一个long类型的输入参数，无返回值。

LongFunction<R>

接受一个long类型输入参数，返回一个结果。

LongPredicate

R接受一个long输入参数，返回一个布尔值类型结果。

LongSupplier

无参数，返回一个结果long类型的值。

LongToDoubleFunction

接受一个long类型输入，返回一个double类型结果。

LongToIntFunction

接受一个long类型输入，返回一个int类型结果。

LongUnaryOperator

接受一个参数同为类型long,返回值类型也为long。

ObjDoubleConsumer<T>

接受一个object类型和一个double类型的输入参数，无返回值。

ObjIntConsumer<T>

接受一个object类型和一个int类型的输入参数，无返回值。

ObjLongConsumer<T>

接受一个object类型和一个long类型的输入参数，无返回值。

Predicate<T>

接受一个输入参数，返回一个布尔值结果。

Supplier<T>

无参数，返回一个结果。

ToDoubleBiFunction<T,U>

接受两个输入参数，返回一个double类型结果

ToDoubleFunction<T>

接受一个输入参数，返回一个double类型结果

ToIntBiFunction<T,U>

接受两个输入参数，返回一个int类型结果。

ToIntFunction<T>

接受一个输入参数，返回一个int类型结果。

ToLongBiFunction<T,U>

接受两个输入参数，返回一个long类型结果。

ToLongFunction<T>

接受一个输入参数，返回一个long类型结果。

UnaryOperator<T>

接受一个参数为类型T,返回值类型也为T。

函数式接口实例

Predicate <T> 接口是一个函数式接口，它接受一个输入参数 T，返回一个布尔值结果。

该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非）。

该接口用于测试对象是 true 或 false。

我们可以通过以下实例（Java8Tester.java）来了解函数式接口 Predicate <T> 的使用：

public class Java8Tester {
    public static void main(String args[]){
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

        // Predicate<Integer> predicate = n -> true
        // n 是一个参数传递到 Predicate 接口的 test 方法
        // n 如果存在则 test 方法返回 true

        System.out.println("输出所有数据:");

        // 传递参数 n
        eval(list, n->true);

        // Predicate<Integer> predicate1 = n -> n%2 == 0
        // n 是一个参数传递到 Predicate 接口的 test 方法
        // 如果 n%2 为 0 test 方法返回 true

        System.out.println("输出所有偶数:");
        eval(list, n-> n%2 == 0 );

        // Predicate<Integer> predicate2 = n -> n > 3
        // n 是一个参数传递到 Predicate 接口的 test 方法
        // 如果 n 大于 3 test 方法返回 true

        System.out.println("输出大于 3 的所有数字:");
        eval(list, n-> n > 3 );
    }

    public static void eval(List<Integer> list, Predicate<Integer> predicate) {
        for(Integer n: list) {

            if(predicate.test(n)) {
                System.out.println(n + " ");
            }
        }
    }
}

四、default默认方法

Java 8 新增了接口的默认方法。

简单说，默认方法就是接口可以有实现方法，而且不需要实现类去实现其方法。

我们只需在方法名前面加个default关键字即可实现默认方法。

为什么要有这个特性？

首先，之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类，目前的java 8之前的集合框架没有foreach方法，通常能想到的解决办法是在JDK里给相关的接口添加新的方法及实现。然而，对于已经发布的版本，是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。

4.1语法

默认方法语法格式如下：

public interface vehicle {
    default void print() {
        System.out.println("我是一辆车!");
    }
}

4.2多个默认方法

一个接口有默认方法，考虑这样的情况，一个类实现了多个接口，且这些接口有相同的默认方法，以下实例说明了这种情况的解决方法：

public interface vehicle {
    default void print() {
        System.out.println("我是一辆车!");
    }
}
public interface fourWheeler {
    default void print() {
        System.out.println("我是一辆四轮车!");
    }
}

第一个解决方案是创建自己的默认方法，来覆盖重写接口的默认方法：

public class Car implements vehicle, fourWheeler {

    @Override
    public void print() {
        System.out.println("我是一辆四轮汽车!");
    }
}

第二种解决方案可以使用 super 来调用指定接口的默认方法：

public class Car implements vehicle, fourWheeler {
    @Override
    public void print() {
        vehicle.super.print();
    }
}

4.3 静态默认方法

Java 8 的另一个特性是接口可以声明（并且可以提供实现）静态方法。例如：

public interface vehicle {
    default void print() {
        System.out.println("我是一辆车!");
    }
    // 静态方法
    static void blowHorn() {
        System.out.println("按喇叭!!!");
    }
}

4.4 默认方法实例

public class Java8Tester {
    public static void main(String args[]) {
        Vehicle vehicle = new Car();
        vehicle.print();
    }
}

interface Vehicle {
    default void print() {
        System.out.println("我是一辆车!");
    }

    static void blowHorn() {
        System.out.println("按喇叭!!!");
    }
}

interface FourWheeler {
    default void print() {
        System.out.println("我是一辆四轮车!");
    }
}

class Car implements Vehicle, FourWheeler {
    public void print() {
        Vehicle.super.print();
        FourWheeler.super.print();
        Vehicle.blowHorn();
        System.out.println("我是一辆汽车!");
    }
}

执行以上脚本，输出结果为：

我是一辆车!
我是一辆四轮车!
按喇叭!!!
我是一辆汽车!

Java函数式编程

一、 Lambda 表达式

1.1 语法

1.2 Lambda 表达式实例

1.3 变量作用域

二、方法引用

三、函数式接口

函数式接口实例

四、default默认方法

4.1语法

4.2多个默认方法

4.3 静态默认方法

4.4 默认方法实例

JAVA编程实现随机生成指定长度的密码功能【大小写和数字组合】

Vue函数式组件-你值得拥有

mongo分布式锁Java实现方法(推荐)

Java NIO网络编程制作简易聊天室

Android编程计算函数时间戳的相关方法总结

Java编程访问权限的控制代码详解

Java编程基于快速排序的三个算法题实例代码

Java编程复用类代码详解

Java编程实现的模拟行星运动示例

Java编程Nashorn实例代码