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 return 0;
}

可以没有参数，但()不可缺省：
()->{for(int i=0;i<10;i++)System.out.print(i);}

如果可以推导出参数类型，则可以忽略其类型：
Comparatorcmp=(first,second)->first.length()-second.length();

特别注意不能只在某些分支返回一个值，这是不合法的，如：
(int x)->{if(x>=0)return 1;}

常用示例：

ArrayListlist=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中又很多封装代码块的接口，如ActionListener、Comparator等，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 cmp=
                (first,second)->first.length()-second.length();
    }

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

处理lambda表达式

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

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

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

public static void repeat(int n,Runnable action){
        for(int i=0;i System.out.println("一键三连"));
    }

函数式接口

函数式接口	参数类型	返回类型	抽象方法名	描述	其他方法
Runnable	无	void	run	作为无参数或返回值的动作执行
Supplier	无	T	get	提供一个T类型的值
Consumer	T	void	accept	处理一个T类型的值	addThen
BiConsumer	T,U	void	accept	处理T和U类型的值	addThen
Function	T	R	apply	有一个T类型参数的函数	compose,addThen,idenity
BiFunction	T,U	R	apply	有T和U类型参数的函数	addThen
UnaryOperator	T	T	apply	类型T上的一元操作符	compose,addThen,identity
BinaryOperator	T,T	T	apply	类型T上的二元操作符	addThen,maxBy,minBy
PreDicate	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 System.out.println(9-i));
    }

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

函数式接口	参数类型	返回类型	抽象方法名
BooleanSupplier	none	boolean	getAsBoolean
$P$Supplier	none	$p$	getAs$P$
$P$Consumer	$p$	void	accept
Obj$P$Consumer	T,$p$	void	accept
$P$Function	$p$	T	apply
$P$ToQFunction	$p$	$q$	applyAs$Q$
To$P$Function	T	$p$	applyAs$P$
To$P$BiFunction	T,U	$p$	applyAs$P$
$P$UnaryOperator	$p$	$p$	applyAs$P$
$P$BinaryOperator	$p$,$p$	$p$	applyAs$P$
$P$Predicate	$p$	boolean	test

$p$,$q$为int,long,double；
$P$, Q Q

以上就是Java-lambda表达式入门看这一篇就够了的详细内容，更多关于Java-lambda表达式入门的资料请关注脚本之家其它相关文章！