Lambda表达式和函数试接口的最佳实践 · LiangYongrui's Studio

1.概述

本文主要深入研究java 8中的函数式接口和Lambda表达式，并介绍最佳实践。

2.使用标准的函数式接口

包java.util.function中的函数是接口已经可以满足大部分的java开发者了。这些函数式接口足够的通用和抽象，使用他们可以简单的接收大部分的lambda表达式。开发者应该在创建自己的函数式接口前了解清楚现有的。

考虑一个接口Foo:

1 2 3 4

public interface { String method(String string); }

然后另外一个类UseFoo里面有一个用这个接口做参数的add()方法:

1 2 3

public String add(String string, Foo foo) { return foo.method(string); }

运行他可以这样写：

1 2	Foo foo = parameter -> parameter + " from lambda"; String result = useFoo.add("Message ", foo);

进一步的观察你会发现Foo接口只有一个方法，并这个这个方法接收一个参数和返回一个结果。其实Java 8 已经提供了这样一个接口Function<T,R>

我们用Function<T,R>来写的话，可以这样：

1 2 3

public String add(String string, Function<String, String> fn) { return fn.apply(string); }

运行他可以这样写

1 2	Function<String, String> fn = parameter -> parameter + " from lambda"; String result = useFoo.add("Message ", fn);

3.使用 @FunctionalInterface 注解

在你的函数式接口上用 @FunctionalInterface 。这个接口看起来是没有作用的，甚至你不加上他你的函数式接口还是能工作。

但是你想象一下，一个大工程中可能有很多个接口，其中有一个你打算作为的函数式接口，但是意外的在这个接口中添加了另一个别的抽象方法。这会导致之前用到这个接口的地方失效。

但是你用了 @FunctionalInterface 这个注解后，如果你破坏了预定义的结构编译器会触发一个错误.

所以，用这样的代码

1 2 3 4

public interface { String method(); }

来代替

1 2 3

public interface { String method(); }

4.不要在函数式接口中过度使用默认方法

函数式接口中使用默认方法是可以的：

1 2 3 4 5

public interface { String method(); default void defaultMethod() {} }

函数式接口也可以继承函数式接口，只要他们的抽象方法拥有同样的标识(signature).例如：

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public interface FooExtended extends Baz, Bar {} public interface Baz { String method(); default void defaultBaz() {} } @FunctionalInterface public interface Bar { String method(); default void defaultBar() {} }

但是像所有的普通接口一样，扩展不同的函数式接口也会有默认方法冲突的问题。例如Bar和Baz有相同的默认方法defaultCommon(),然后你就会得到一个编译错误

1	interface Foo inherits unrelated defaults for defaultCommon() from types Baz and Bar...

为了解决这个问题，deaultCommon()方法应该在Foo接口中覆盖。当然，你可以自定义方法的实现就。但是如果你想用任意一个父接口（例如Baz）的默认方法，你需要这样写

1	Baz.super.defaultCommon();

添加太多的默认方法不是一个好的设计方案。为了能够保证接口的向后兼容性，你应该在只有必要的时候才使用默认方法。

5.使用Lambda表达式来实例化函数试接口

编译器允许你使用内部类来实例化函数式接口，但是这样会让你的代码变得冗长。所以用lambda表达式更好：

1	Foo foo = parameter -> parameter + " from Foo";

用内部类：

1 2 3 4 5 6

Foo fooByIC = new Foo() { @Override public String method(String string) { return string + " from Foo"; } };

Lambda表达式可以适用于很多旧库的接口，但是这不意味着适用于全部接口。

6.避免使用函数式接口作为重载函数的参数

使用不同的方法名来避免冲突，看个例子：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

public interface Adder { String add(Function<String, String> f); void add(Consumer<Integer> f); } public class AdderImpl implements Adder { @Override public String 大专栏  Lambda表达式和函数试接口的最佳实践 · LiangYongrui's Studio add(Function<String, String> f) { return f.apply("Something "); } @Override public void add(Consumer<Integer> f) {} }

但是当你尝试运行任何AddrImpl的方法时：

1	String r = adderImpl.add(a -> a + " from lambda");

你将会得到错误信息：

1 2 3 4 5

reference to add is ambiguous both method add(java.util.function.Function<java.lang.String,java.lang.String>) in fiandlambdas.AdderImpl and method add(java.util.function.Consumer<java.lang.Integer>) in fiandlambdas.AdderImpl match

为了解决这个问题，有两个办法。首先是改方法的名字：

1 2 3

String addWithFunction(Function<String, String> f); void addWithConsumer(Consumer<Integer> f);

其次是类型转化，但是不推荐这样：

1	String r = Adder.add((Function) a -> a + " from lambda");

7.不要将lambda表达式视为内部类

尽管在之前的例子里，我们都是把Lambda表达式作为内部类来代替的。但是这两个概念有个重要的不同：范围（scope）

在内部类中，他会创建一个新的范围，你可以在内部的范围中通过创建相同名称的变量来覆盖本地变量。你还可以用this关键字来引用内部类的实例。

但是在lambda表达式中，你不能覆盖外部的变量，并且你用this引用的是类的属性，而不是lambda的。
例如：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

private String value = "Enclosing scope value"; public String scopeExperiment() { Foo fooIC = new Foo() { String value = "Inner class value"; @Override public String method(String string) { return this.value; } }; String resultIC = fooIC.method(""); Foo fooLambda = parameter -> { String value = "Lambda value"; return this.value; }; String resultLambda = fooLambda.method(""); return "Results: resultIC = " + resultIC + ", resultLambda = " + resultLambda; }

如果你运行scopeExperiment()方法将得到

1	Results: resultIC = Inner class value, resultLambda = Enclosing scope value

8.保持lambda表达式短且不言自明（Self-explanatory）

如果可以的话，请使用一行结构，而不是一大块代码。Lambda应该是一种表达式，而不是一种叙述。Lambda应该精准的表达他提供的功能。

这只是风格建议，这并不会影响性能。但是一般而言这样更容易理解和使用。

这可以通过多钟方式实现，让我们仔细看看。

8.1 避免Lambda体内使用代码块

在理想的情况下，Lambda应该被写成一行。这样Lambda是一个不言自明的结构。在有参数的情况下，它声明应该用什么数据执行什么操作。

如果有一大块代码，Lambda的功能就不是那么清晰了。

按照这样的思想，应该使用下面的例子

1	Foo foo = parameter -> buildString(parameter);

1 2 3 4 5

private String buildString(String parameter) { String result = "Something " + parameter; return result; }

而不是

1 2 3 4

Foo foo = parameter -> { String result = "Something " + parameter; return result; };

8.2避免指定参数类型

大多数情况编译器是可以自动推断参数类型的。

这样做

1	(a, b) -> a.toLowerCase() + b.toLowerCase();

而不是

1	(String a, String b) -> a.toLowerCase() + b.toLowerCase();

8.3避免在单个参数周围使用括号

Lambda表达式的语法只需要在多个参数和没有参数的时候使用括号。

这样做

1	a -> a.toLowerCase();

而不是

1	(a) -> a.toLowerCase();

8.4避免使用return表达式和大括号

在一行的Lambda中，return和大括号是可选的。

这样做

1	a -> a.toLowerCase();

而不是

1	a -> {return a.toLowerCase()};

8.5使用方法引用

通常（例如前面的例子）Lambda表达式都只是调用其他地方实现的方法。这种情况下使用Java 8的另一个功能：方法引用。

所以lambda

1	a -> a.toLowerCase();

可以被这样代替：

1	String::toLowerCase;

这样不一定总是更短，但是可以增强代码的可读性

9.修改对象的变量

lambdas的主要用途之一是用于并行计算 - 这意味着它们在线程安全方面非常有用。

如果非要改变对象变量的值，可以这样

1 2 3

int[] total = new int[1]; Runnable r = () -> total[0]++; r.run();

保留此示例作为提醒，以避免可能导致意外突变的代码。

10.结论

在本文中，我们看到了Java 8的lambda表达式和函数式接口中的一些最佳实践和缺陷。尽管这些新功能具有实用性和强大功能，但它们只是工具。每个开发人员在使用它们时都应该注意