说说Java 8中的Lambda表达式

最新推荐文章于 2025-08-15 22:56:20 发布

原创最新推荐文章于 2025-08-15 22:56:20 发布 · 160 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #c# #scala

本文深入探讨了Java 8中的Lambda表达式，介绍了通过FunctionalInterface实现Lambda的方式，并展示了Lambda的语法与使用方法。此外，还分析了Java Lambda的一些限制及其带来的问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Lambda表达式做为”匿名函数”实现高阶函数的途径，地位早就已被业界所承认，应用也相当广泛，可以说Lambda表达式已经成为现代编程语言的必备特性之一。看人家.NET平台上的C#码农和Java平台上的Scala码农早就玩的炉火纯青，.NET 4.0后使用lambda表达式甚至几乎成为所有类库和框架的标配。而Java上的lambda由原先计划中的Java7一直推到Java8才将发布，也由此可见Java语言的不思进取和现在已经离现代编程语言群体有多么遥远了。
早在2010年，Oracle发布了Java Lambda的第一版语法，立即遭受一片骂声。该语法类似这样：

int i1 = #()(3).();
Integer i2 = #()(3).();
int i3 = #(int x)( x + 1 ).(3);
int i4 = #(Number x)(x.intValue()).(new Float(3.0f));
Object o = #()(3);

虽然这样的语法在编译器的层面支持起来相当简单，不过折磨的却是开发人员，这中lambda语法与Java风格相差太远，单句过长不简洁，在一片长单词中出现一堆符号也会让人困惑不已。所以在后来，Java选择了学习C#和Scala的Lambda语法（http://www.infoq.com/cn/news/2011/09/java-lambda ）这让人又对Java上实现优美的Lambda表达式燃起了一些希望。

言归正传，现在来说说Java8中的Lambda。

1．Functional Interface

Java8中实现Lambda表达式的方法是使用Functional Interface。Functional Interface是一个只包含一个抽象方法的接口，例如java.lang.Runnable就是一个Functional Interface，其中abstract关键字是可选的，因为run方法本身包含了一个空的方法体：

public abstract void run();

或是自定义一个

public interface Func {
    R invoke(T arg);
}

同时需要使用新的Annotation：@FunctionalInterface 进行标记，编译器会在编译时进行检查，原理类似于@Override，呵呵。
使用Functional Interface实际上就是说Java依旧选择了匿名类来实现Lambda，虽然和C#的委托+匿名函数的做法不尽相同，但是也终于是实现了。不过对于实现高阶函数来说，没有匿名函数和闭包的支持终究使用起来有那么些别扭。

2.语法

Java Lambda语法如下：

(int x, int y) -> { return x + y; }
(x, y) -> x + y
x -> x * x
() -> x
x -> { System.out.println(x); }

对于C#程序员来说，一切都很熟悉（包括类型推演等完全照搬，只是把“=>”换成了“->”），相比于第一版Java lambda的语法，已经是相当大的改进了,这个可以鼓励一下。

3.使用方法

举例，某些方法例如Arrays.sort，接收类型为Comparator的参数，以前的话需要写很多代码：

Arrays.sort(strings, new Comparator() {
    public int compare(String s1, String s2) {
        int result = Integer.compare(s1.length(),s2.length());
        return result;
    }));

现在，中间的new Comparator()…就可以写成

Arrays.sort(strings, (s1 , s2) -> Integer.compare(s1.length(),s2.length());

对于不需要返回值的lambda语句，可以写成

Runnable r = () -> { System.out.println("Running!"); }

4.Java中Lambda表达式的硬伤

硬伤都是来源于Java Lambda中的限制

4.1 Checked Exception

首当其冲就是Checked Exception，Java Lambda规定如果Lambda中抛出了异常，那么这个异常一定要在Functional Interface中的abstract方法上定义。

void appendAll(Iterable values, Appendable out)
        throws IOException { // 与lambda中的exception无关
        values.forEach(s -> {
        out.append(s); // 错误：这里不能抛出异常，因为Consumer.accept(T)没有如此约定
    });
}

Checked Exception作为Java代码中的强制约定（方法契约的一部分），假如Lambda表达式中需要抛出异常而Functional Interface中又没有约定，对不起，请重新定义一个吧：

Public Interface RunnableWithException{
    Public abstract void run () throws IOException;
}

异常类型千变万化，难道每一个异常都需要重新定义一个新的Interface？如果使用统一的thows Exception，那使用Checked Exception又有何意义？这的确是一个很尴尬的问题。

4.2 闭包中不支持非final的变量

对于操作lambda表达式外的变量，Java Lambda规定了闭包所使用的lambda函数体外的变量必须是“实际上是final的”，也就是说：

int x = 5;
return y -> x + y;

这样的语句是合法的，因为y -> x+y; 中虽然使用了x，但是x的值并没有改变过，所以称之为“实际上是final”的，在这里Java会默认int x = 5前面有一个final。

至于为什么要这么规定，可以参考这篇文章《警惕匿名方法造成的变量共享》，C#中lambda表达式形成的闭包中类级别的变量是可以共享的，而Java为了某些原因则限制了内部匿名类中的变量或引用必须是final（据说是final会直接放到GC根上而不允许改动）。

然后由此举出一个不合法的例子：

int count = 0;
List strings = Arrays.asList("a", "b", "c");
strings.forEach(s -> {
    count++; // 错误：不能更改count的值
});

看出来了没，这样的限制简直是反人类啊。

4.3 无法使用lambda实例化抽象类

曾经在Java7的时候，lambda还是使用SAM(Single Abstract Method)而不是Functional Interface来实现的。如果一个类型为SAM类型，则意味着它 1) 是抽象类型（即接口或抽象类），且 2) 只有一个未实现的方法。目前Java平台的类库及框架中存在着大量的SAM类型，如果这样使用的话，无疑方便了类库的升级和兼容工作。而且还有些更方便的用法，比如：

Func[] array = new Func[10];
for (int i = 0; i < array.length; i++) {
    final int temp = i;
    array[i] = int x -> x + temp ;
}

这样子可以一下子创建了许多实现Func接口的实例。

但是在Java8中则更改了使用SAM的实现方式，原因是设计者认为每次使用Lambda 的时候都会执行一些隐藏代码：抽象类的构造函数（http://mail.openjdk.java.net/pipermail/lambda-dev/2013-March/008441.html ）。
所以你的代码必须从优美的：

Ordering order = (a, b) -> ...;
CacheLoader loader = (key) -> ...;

更改成：

Ordering order = Ordering.from((a, b) -> ...);
CacheLoader loader = CacheLoader.from((key) -> ...);

真是痛苦。