JAVA8新特性-01-Lambda表达式&方法引用&函数式接口

最新推荐文章于 2023-05-08 22:25:55 发布

战神清子

最新推荐文章于 2023-05-08 22:25:55 发布

阅读量282

点赞数

分类专栏： Java8新特性文章标签： Java8新特性

Java8新特性专栏收录该内容

4 篇文章 0 订阅

订阅专栏

JAVA8新特性-01-Lambda表达式

一，Java 8 Lambda表达式

Lambda表达式，也可以成为闭包，它是推动JAVA8发布得最重要新特性。

Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法种）。

使用Lambda表达式可以使代码更加简洁紧凑。

1.1语法

Lambda表达式语法格式如下：

（parameters）-> expression或者（parameters）->{statements;}

一下是lambda表达式的重要特征：

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

1.2Lambda表达式实例

在java8Demo.java文件输入以下代码：

java8Demo.java文件

public class Java8Demo {
    public static void main(String[] args) {
        Java8Demo demo = new Java8Demo();

        //类型声明
        MathOperation addition = (int a, int b) -> a + b;
        //不用类型声明
        MathOperation subtraction = (a, b) -> a - b;
        //大括号种返回语句
        MathOperation multiplication = (a, b) -> {
            return a * b;
        };

        //没有大括号及返回语句
        MathOperation division = (int a, int b) -> a/b;

        System.out.println("10 + 5 = " + demo.operate(10, 5, addition));
        System.out.println("10 - 5 = " + demo.operate(10, 5, subtraction));
        System.out.println("10 x 5 = " + demo.operate(10, 5, multiplication));
        System.out.println("10 / 5 = " + demo.operate(10, 5, division));

        //参数不用括号
        GreetingService greetService1 = message ->
                System.out.println("Hello" + message);

        //参数用括号
        GreetingService greetService2 = (message) ->
                System.out.println("Hello11" + message);

        greetService1.sayMessage("Runoob");
        greetService2.sayMessage("Google");

    }

    interface MathOperation {
        int operaion(int a, int b);
    }

    interface GreetingService {
        void sayMessage(String message);
    }

    private int operate(int a, int b, MathOperation mathOperation) {
        return mathOperation.operaion(a, b);
    }
}

使用Lambda表达式需要注意以下两点：

Lambda表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。在上面例子中，我们在使用各种类型的Lambda表达式来定义MathOperation接口的方法。然后我们定义了sayMessage的执行
Lambda表达式免去了使用匿名方法的麻烦，并且给予java简单但是强大的函数化的编程能力。

1.3变量作用域

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

public class Java8Demo1 {
    final static String salutation = "Hello! ";
    public static void main(String[] args){
        GreetingService greetingService = message -> {
            System.out.println(salutation + message);
        };
        greetingService.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表达式中访问外层的局部变量：

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

    public interface Converter<T1 ,T2>{
        void convert(int i);
    }
}

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

public class Java8Demo1 {
    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);
    }
}
//Error:(9, 59) java: 从lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量

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

public class Java8Demo1 {
    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","bbb");
    }

    public interface Comparator<T> {
        void com(String a, String b);
    }
}
//Error:(8, 42) java: 已在方法 main(java.lang.String[])中定义了变量 first

二，Java8方法引用

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

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

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

2.1方法引用

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

public class Car {
    @FunctionalInterface
    public interface Suppliter<T> {
        T get();
    }
    //Suppliter式jdk1.8的几口，这里和lambda一起使用了

    public static Car create(final Suppliter<Car> suppliter) {
        return suppliter.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("===========特定对象的方法引用=============");
    }
}

2.2方法引用实例

在Java8Demo1.java文件输入以下代码：

public class Car {
    public static void main(String[] args){
        List names = new ArrayList();
        names.add("Google");
        names.add("Runoob");
        names.add("Taobao");
        names.add("Baidu");
        names.add("Sina");
        names.forEach(System.out::println);
    }
}

实例中我们将System.out::println方法作为静态方法来引用。

三，Java8函数式接口

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

函数式接口可以被隐式转换未Lambda表达式。

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

JDK1.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

JDK1.8新增的函数接口

java.util.function

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

序号	接口&描述
1	BiConsumer<T,U> 代表了一个接受两个输入参数的操作，并且不返回任何结果
2	BiFunction<T,U,R> 代表了一个接受两个输入参数的方法，并且返回一个结果
3	BinaryOperator 代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果
4	BiPredicate<T,U> 代表了一个两个参数的boolean值方法
5	BooleanSupplier 代表了boolean值结果的提供方
6	Consumer 代表了接受一个输入参数并且无返回的操作
7	DoubleBinaryOperator 代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。
8	DoubleConsumer 代表一个接受double值参数的操作，并且不返回结果。
9	DoubleFunction 代表接受一个double值参数的方法，并且返回结果
10	DoublePredicate 代表一个拥有double值参数的boolean值方法
11	DoubleSupplier 代表一个double值结构的提供方
12	DoubleToIntFunction 接受一个double类型输入，返回一个int类型结果。
13	DoubleToLongFunction 接受一个double类型输入，返回一个long类型结果
14	DoubleUnaryOperator 接受一个参数同为类型double,返回值类型也为double。
15	Function<T,R> 接受一个输入参数，返回一个结果。
16	IntBinaryOperator 接受两个参数同为类型int,返回值类型也为int 。
17	IntConsumer 接受一个int类型的输入参数，无返回值。
18	IntFunction 接受一个int类型输入参数，返回一个结果。
19	IntPredicate 接受一个int输入参数，返回一个布尔值的结果。
20	IntSupplier 无参数，返回一个int类型结果。
21	IntToDoubleFunction 接受一个int类型输入，返回一个double类型结果。
22	IntToLongFunction 接受一个int类型输入，返回一个long类型结果。
23	IntUnaryOperator 接受一个参数同为类型int,返回值类型也为int 。
24	LongBinaryOperator 接受两个参数同为类型long,返回值类型也为long。
25	LongConsumer 接受一个long类型的输入参数，无返回值。
26	LongFunction 接受一个long类型输入参数，返回一个结果。
27	LongPredicate R接受一个long输入参数，返回一个布尔值类型结果。
28	LongSupplier 无参数，返回一个结果long类型的值。
29	LongToDoubleFunction 接受一个long类型输入，返回一个double类型结果。
30	LongToIntFunction 接受一个long类型输入，返回一个int类型结果。
31	LongUnaryOperator 接受一个参数同为类型long,返回值类型也为long。
32	ObjDoubleConsumer 接受一个object类型和一个double类型的输入参数，无返回值。
33	ObjIntConsumer 接受一个object类型和一个int类型的输入参数，无返回值。
34	ObjLongConsumer 接受一个object类型和一个long类型的输入参数，无返回值。
35	Predicate 接受一个输入参数，返回一个布尔值结果。
36	Supplier 无参数，返回一个结果。
37	ToDoubleBiFunction<T,U> 接受两个输入参数，返回一个double类型结果
38	ToDoubleFunction 接受一个输入参数，返回一个double类型结果
39	ToIntBiFunction<T,U> 接受两个输入参数，返回一个int类型结果。
40	ToIntFunction 接受一个输入参数，返回一个int类型结果。
41	ToLongBiFunction<T,U> 接受两个输入参数，返回一个long类型结果。
42	ToLongFunction 接受一个输入参数，返回一个long类型结果。
43	UnaryOperator 接受一个参数为类型T,返回值类型也为T。

3.1函数式接口实例

Predicate接口式一个函数式接口，它接受一个输入参数T，返回一个布尔值结果。该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非）。

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

我们可以通过以下实例来了解函数式接口Predicate的使用。

public class Java8Demo2 {
    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 + " ");
             }
         }
    }
}