Java lambda 表达式

最新推荐文章于 2024-08-13 19:45:55 发布

置顶 doit_SYL

最新推荐文章于 2024-08-13 19:45:55 发布

阅读量362

点赞数

分类专栏： java lambda 文章标签： lambda 接口函数式接口

本文链接：https://blog.csdn.net/qq_35716892/article/details/84920155

版权

java lambda 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

1、什么是lamdba表达式：

很多年前，逻辑学家Alonzo Church想要形式化地表示能有效计算的数学函数。他使用了希腊字母lambda(Λ)来标记参数，实际上，权威的《数学原理》一书中就使用重音符^来表示自由变量，受此启发，Church使用大写的lambda（Λ）表示参数。从那以后带参数变量的表达式就被称为lambda表达式。

2、Java为什么要引入lambda表达式:

java在1.8中开始引入了lambda表达式。lambda表达式是一个可传递的代码块，可以在以后执行一次或多次。ambda应该就是java函数式编程的一种。（oracle官网对java各个版本说明： Java SE Specifications）

3、lambda表达式表现形式：

lambda表达形式：参数，箭头（->）以及一个表达式。如果代码要完成的计算无法放到一个表达式中，就可以像方法一样，把这些代码放在{}中,并包含显示的return语句。例如：

   (String first,String second)->{
            if(first.length()<second.length()) return -1 ;
            else if(first.length()>second.length()) return 1;
            else return 0;
        }

即使lambda表达式没有参数，仍然要提供空括号，就像无参数方法一样：

 ()-> { for (int i=100;i>=0;i--) System.out.println(i);}

如果可以推导出一个lambda表达式的参数类型，则可以忽略其类型。例如：

   Comparator<String> comp =(first,second)// 等同于（String first,String second）
                -> first.length()-second.length();

如果方法只有一个参数，而且这个参数的类型可以推到得出，那么甚至可以省略小括号：

ActionListener listener =event->System.out.println("the time is "+new Date());

无需指定lambda表达式的返回值类型。lambda表达式的返回类型总是会由上下文推导得出。

如果一个lambda表达式只在某些分支返回一个值，而在另外一些分支不返回值，这是不合法的。

4、函数式接口：

对于只有一个抽象方法的接口，需要这种接口的对象时，就可以提供一个lambda表达式，这种接口称为函数式接口（functional interface）

实际上在java中，对lambda表达式所能做的也只是能转换为函数式接口。想要用lambda表达式做某些处理，还是要为它建立一个特定的函数式接口。

ArrayList类有一个removeIf方法，它的参数就是一个Predicate。这个接口专门用来传递lambda表达式。列如，下面的语句可以将一个数组列表删除所有null值：

list.removeIf(e -> e==null);

5、方法引用;

如：假设你希望只要出现一个定时器事件就打印这个事件对象。当然，为此也可以调用：

  Timer t =new Timer(1000,event->System.out.println(event));

如果直接把println方法传递到Timer构造器就更好了：

Timer t2 =new Timer(1000,System.out::println);

假设你想对字符串排序，而不考虑字母的大小写。可以传递以下方法表达式：

Arrays.sort(strings,String::compareToIgnoreCase);

从上面我们可以看出要用:: 操作符分隔方法名与对象或类名。主要由三种情况：

object::instanceMethod
Class::StaticMethod
Class::instanceMethod

在前2种方法中，方法引用等价于提供方法参数的lambda表达式。前面已经提到，System.out.println等价于

x->System.out.println(x)

对于第三种情况，第一个参数会成为方法的目标。例如，String::compareToIgnoreCase等同于

（x,y）->x.compareToIgnoreCase(y)

类似于lambda表达式，方法引用不能独立存在，总是会转换为函数式接口的实例。

可以在方法引用中使用 this参数。例如，this::equals等同于x->this.equals(x).使用super也是合法的。下面的表达式

super::instanceMethod

6、构造器引用

构造器引用和方法引用很类似，只不过方法名为new。例如，Person::new是Person构造器的一个引用。

也可以在数组类型建立构造器引用。例如，int[]::new 是一个构造器引用，它有一个参数：数组长度。这等价于lambda表达式

x->new int[x]

java有一个限制，无法构造泛型类型的T的数组。数组构造器引用对于克服这个限制很有用。表达式new T[n]会产生错误，因为这会改为new Object[n].

Person[] people=stream.toArray(Person[]::new);调用这个构造器我们就可以得到一个正确类型的数组，然后填充这个数组并返回。

7、变量的作用域;

lambda表达式有三个部分：

一个代码块；
参数；
自由变量的值，这是指非参数而且不在代码中定义的变量

关于代码块以及自由变量值有一个术语:闭包(closure)。在java中，lambda表达式就是闭包。

lambda表达式可以捕获外围作用域中的变量的值。在java中，lambda表达式中只能引用值不会改变的变量。之所以有这个限制是有原因的，如果lambda表达式中改变变量，并发执行多个动作时就会不安全。

lambda表达式中捕获的变量必须实际上是最终变量（effective final）；

在lambda中不能有俩个同名的局部变量；

在一个lambda中使用this关键字时，是指创建这个lambda表达式的方法的this参数。

public class Application {
    public static void main(String[] args) {
       new Application().init();
    }
    public  void init()
    {
        ActionListener listener=event->{
            System.out.println(this.toString());
        };
        new Timer(100,listener).start();
    }
}

表达式this.soString()会调用Application对象的toString方法，而不是ActionListener实例的方法。

8、处理lambda表达式

使用lambda表达式的重点是延迟执行（deferred execution）。毕竟想要立即执行代码，完全可以直接执行，而无需把它包装在一个lambda表达式中，之所以希望以后再执行代码，这有很多原因，如：

在一个单独的线程中运行代码；
多次运行代码；
在算法的适当位置运行代码（例如，排序中的比较操作）；
发生某种情况时执行代码
只在必要时才执行代码

来看一个简单的例子：重复一个动作n次：

public class Application {
    public static void main(String[] args) {
      // new Application().init();
        repeat(10, ()-> System.out.println("测试"));
    }
    public  static void repeat(int n,Runnable action)
    {
        for(int i=0;i<n;i++) action.run();
    }
}

调用action.run()时会执行这个lambda表达式的主体

下面我们可以用我们自己定义的函数式接口，来打印当前迭代的位置：

public interface IntConsumer {
    void myaccept(int value);
}

  public static void main(String[] args) {
      // new Application().init();
    //    repeat(10, ()-> System.out.println("测试90"));
        repeat2(10, (i)-> System.out.println("测试"+(9-i)));
    }


    public  static void repeat2(int n,IntConsumer action)
    {
        for(int i=0;i<n;i++) action.myaccept(i);
    }

如果设计我们自己的接口，其中只有一个抽象方法，可以用

@FunctionalInterface 注解来标注这个接口，这样做有俩个优点：如果我们无意中增加了另一个非抽象方法，编译器会产生一个错误消息。另外javadoc页也会指出你的接口是一个函数式接口。

当然并不是必须使用@FunctionalInterface这个注解，根据定义，任何有一个抽象方法的接口都是函数式接口。

在大多数情况下我们可以使用java API内置的函数式接口，而不需要我们自己来定义我们的函数式接口。

常用函数式接口：

9、Comparator

Comparator接口中包含很多方便的静态方法来创建比较器。这些方法可以用于lambda表达式或方法引用。

静态comparing方法，它可以将类型T映射为一个可比较的类型，如对于Person对象数组，可以按照名字对这些对象排序：

Arrays.sort(people,Comparator.comparing(Person::getName))

还可以把比较器与thenComparing方法串起来。如：

Arrays.sort(people,Comparator.comparing(Person::getName).thenComparing(Person::getFirstName))

如果俩个Person对象的name相同就会使用第二个比较器。

10、接口和抽象方法：

在java8中接口可以申明非抽象方法。（但一般不这么做）

public interface myTest {
   //可以为接口方法提供一个默认实现，必须用 default 修饰符标记这样一个方法
   default    int add()
   {
       return 0;
   }

//在接口中增加静态方法
 static  int add()
   {
       return 0;
   }
}

使用抽象类表示通用属性存在这样一个问题：每个类只能扩展于一个类。假设Employee类已经扩展于一个类，列如Person，它就不能再像下面这样扩展第二个类了;

calss Employee extends Person,Comparable // this is error

但每个类可以像下面这样实现多个接口;

calss Employee extends Person implements Comparable // ok