运维开发网

Java-lambda表达式入门看这一篇就够了

运维开发网 https://www.qedev.com 2021-06-02 09:56 出处:网络 作者: 吾仄lo咚锵
概述 Lambda表达式,也可称为闭包,是JDK8的新特性。Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中),可以使代码变的更加简洁紧凑。Lambda表达式是一个可传递的代码块,可以在以后执行一次或多次

Java-lambda表达式入门看这一篇就够了

概述

Lambda表达式,也可称为闭包,是JDK8的新特性。Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中),可以使代码变的更加简洁紧凑。Lambda表达式是一个可传递的代码块,可以在以后执行一次或多次。

名字起源是以前还没有计算机时,逻辑学家Alonzo Church想要形式化的表示能有效计算的数学函数,使用了希腊字母lambda( \lambda )来标记参数,从那以后,带参数变量的表达式就被称为lambda表达式。

lambda表达式本质是一个匿名函数,比如以下函数

public int add(int x, int y) {
    return x + y;
}

可以转换为:

(int x, int y) -> x + y;

语法

语法格式如下

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

其中()用来描述参数列表,{}用来描述方法体,->是lambda运算符,读作goes to。

可以包含显示的return语句,如:

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

可以没有参数,但()不可缺省:

()->{for(int i=0;i<10;i++)System.out.print(i);}

如果可以推导出参数类型,则可以忽略其类型:

Comparator<String>cmp=(first,second)->first.length()-second.length();

特别注意不能只在某些分支返回一个值,这是不合法的,如:

(int x)->{if(x>=0)return 1;}

常用示例:

ArrayList<Integer>list=new ArrayList<>();
Collections.addAll(list,1,2,3,4,5);
//遍历
list.forEach(e->{System.out.println(e);});
//删除指定值
list.removeIf(e->e==3);
//排序
list.sort((o1,o2)->o2-o1);
//遍历(双冒号操作符)
list.forEach(System.out::println);

函数式接口

java中又很多封装代码块的接口,如ActionListenerComparator等,lambda表达式与这些接口时兼容的。

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

比如Arrays.sort()方法,它的第二个参数需要一个Comparator实例,而Comparator就是只有一个方法的接口,所以可以使用lambda表达式替代,可以把lambda表达式看作一个函数,而不是一个对象,如:

Arrays.sort(arrays,
	(first,second)->first.length()-second.length());

lambda表达式还可以转换为接口,比如实现Runnable接口:

new Thread(() -> System.out.println("记得一键三连")).start();
Runnable r = () -> System.out.println("(。・∀・)ノ");
r.run();

再如之前提到的removeIf()方法,它的参数就是一个Predicate接口(位于java.util.function包),这个接口专门用来传递lambda表达式,如删除一个数组列表所有null值:

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

方法引用

当在Lambda表达式中直接调用了一个方法时可以使用,其写法为目标引用::方法名称。

有时候,可能已经有现成的方法可以完成你想要传递到其他代码的某个动作,如遍历打印集合:

list.forEach(e->{System.out.println(e);});

我们可以直接把现成的println方法传递给它:

list.forEach(System.out::println);

它们是等价的,是一个方法引用的写法。

再如对字符串排序而不考虑大小写,可以直接传递以下方法表达式:

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

也就是说使用双冒号操作符::来分离方法名与对象或类名:

  1. object::instanceMethod
  2. Class::staticMethod
  3. Class::instanceMethod

对于前两种情况,方法引用等价于提供方法参数的lambda表达式,如,Math::Pow等价于(x,y)->Math.pos(x,y)。

对于第三种情况,第一个参数会成为方法的目标,如String::compareToIgnoreCase等同于(x,y)->x.compareToIgnoreCase(y)。

也可以在方法中引用this参数,如this::equals等价于x->this.equals(x),同样的,使用super也是允许的。

插播反爬信息 )博主CSDN地址:https://wzlodq.blog.csdn.net/

构造器引用

构造器引用与方法引用很类似,只不过方法名为new,例如Person::new是Person类构造器的一个引用,如果有多个构造器,编译器会取决于上下文。比如有一个字符串列表,可以把他转换为一个Person对象数组,为此要在各个字符串上调用构造器。

可以用数组类型建立构造器引用,如int[]::new是一个构造器引用,它有一个参数即数组长度,等价于lambda表达式:x->new int[x];

在Java中无法构造泛型类型T的数组,而数组构造器引用就可克服这个限制。如表达式new T[n]会产生错误,因为这会改为new Object[n]。设我们需要一个Person对象数组,Stream接口有一个toArray方法可以返回Object数组:

Object[] people=stream.toArray();

以上得到的是一个Object引用数组,可以把Person[]::new传入给toArray()方法,从而得到一个Person对象数组:

Object[] people=stream.toArray(Person[]::new);

变量作用域

有时候,我们希望能够在lambda表达式中访问外围方法或类中的变量,如下面例子:

public static void printTip(String text) {
	    Runnable r = () -> System.out.println(text);
	    r.run();
	}
	public static void main(String[] args) {
	    String text="一键三连";
	    printTip(text);
	}

现在来看lambda表达式中的text变量,它并不是在这个lambda表达式中定义的,实际上是printTip方法的一个参数变量。但仔细想想,lambda表达式的代码可能会在printTip调用返回很久以后才运行,而那时这个参数变量已经不存在了,如何保留text变量?

首先巩固瞎lambda表达式的理解,lmabda表达式有3个部分:一个代码块、变量、自由变量的值(指非参数而且不在代码中定义的变量)。在上面的例子中,lambda表达式有一个自由变量text,表示lambda表达式的数据结构必须存储的值(这里的字符串“一键三连”),我们称它被lambda表达式捕获(captured)。

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

lambda表达式捕获变量必须遵循的规则:捕获的变量必须实际上必须是最终变量(effectively final),最终变量是指这个变量初始化之后就不会再为它赋新值,即在lambda表达式内外都不能在修改值。

如lambda内修改:

 public static void printTip(String text) {
        Runnable r = () -> {
            System.out.println(text);
            text="修改值会报错";
        };
        r.run();
    }
    public static void main(String[] args) {
        String text="一键三连";
        printTip(text);
    }

lambda外修改:

 public static void main(String[] args) {
        for(int i=0;i<5;i++){
            //表达式外修改变量i报错
            Runnable r = () -> System.out.println(i);
            r.run();
        }
    }

此外,在方法中不能有同名的局部变量,lambda表达式也是如此:

public static void main(String[] args) {
        int first=666;
        //同名会报错
        Comparator<String> cmp=
                (first,second)->first.length()-second.length();
    }

对于lambda表达式中使用this关键字时,是指创建这个lambda表达式的方法饿this参数。

处理lambda表达式

使用lambda表达式的重点是延迟执行(deferred execution)。如果要立即执行代码的画完全可以直接执行而无需放到一个lambda表达式中,之所以希望以后在执行代码,这有很多原因,如:

  • 在一个单独的线程中运行代码
  • 多次运行代码
  • 在算法的适当位置运行代码
  • 发生某种情况时执行代码
  • 只有在必要时才运行代码

设想要重复一个动作n次,将这个动作和重复次数,传递到一个repeat方法,要接受这个lambda表达式需要选择一个函数式接口,在这里我们可以使用Runnable接口,后面给出Java API中提供的最重要的函数式接口。

publi编程客栈c static void repeat(int n,Runnable action){
        for(int i=0;i<n;i++)
            action.run();
    }
    public static void main(String[] args) {
        repeat(10,()-> System.out.println("一键三连"));
    }

函数式接口

http://www.cppcns.com
函数式接口 参数类型 返回类型 抽象方法名 描述 其他方法
Runnable void run 作为无参数或返回值的动作执行
Supplier<T> T get 提供一个T类型的值
Consumer<T> T void accept 处理一个T类型的值 addThen
BiConsumer<T,U> T,U void accept 处理T和U类型的值 adhttp://www.cppcns.comdThen
Function<T,R> T R apply 有一个T类型参数的函数 compose,addThen,idenity
BiFunctiwww.cppcns.comon<T,U,R> T,U R apply 有T和U类型参数的函数 addThen
UnaryOperator<T> T T apply 类型T上的一元操作符 compose,addThen,identity
BinaryOperator<T> T,T T apply 类型T上的二元操作符 addThen,maxBy,minBy
PreDicate<T> T boolean test 布尔值函数 add,or,negate,isEqual
BiPredicate T,U boolean test 有两个参数的布尔值函数 add,or,negate

现在让这个例子更复杂一些,我们希望知道这个动作出现在哪一次迭代中。为此需要选择一个合适的函数式接口,其中要包含一个方法,这个方法有一个int参数而且返回类型为void,如下所示:

 public interface IntConsumer{
        void accept(int value);
    }
    public static void repeat(int n,IntConsumer action){
        for(int i=0;i<n;i++)
            action.accept(i);
    }
    public static void main(String[] args) {
        repeat(10,i-> System.out.println(9-i));
    }

下表列出了基本类型int、long和double的34个可能的规范,最好使用这些特殊化规范来减少自动装箱:

函数式接口 参数类型 返回类型 抽象方法名
BooleanSupplier none boolean getAsBoolean
P P PSupplier none p p p getAs P P P
P P PConsumer p p p void accept
Obj P P PConsumer<T> T, p p p void accept
P P PFunction<T> p p p T apply
P P PToQFunction p p p q q q applyAs Q Q Q
To P P PFunction<T> T p p p applyAs P P P
To P P PBiFunction<T,U> T,U p p p applyAs P P P
P P PUnaryOperator p p p p p p applyAs P P P
P P PBinaryOperator p p p, p p p p p p applyAs P P P
P P PPredicate p p p boolean test

p phttp://www.cppcns.com p, q q q为int,long,double;

P P P, Q Q

以上就是Java-lambda表达式入门看这一篇就够了的详细内容,更多关于Java-lambda表达式入门的资料请关注我们其它相关文章!

0

精彩评论

暂无评论...
验证码 换一张
取 消