简介：在日常编码的过程中，能够总结出很多“样板代码”，就像”活字印刷术中的“活字”一样。当咱们编写新的代码时，须要用到这些“活字”，就把“样板代码”拷贝过去，批改替换一下就能够了，写起代码来“极为神速”。“样板代码”其实就是一种样例、一种模式、一种教训……总结的“样板代码”越多，编写代码的格局越标准、品质越高、速度越快。
作者 | 常意
起源 | 阿里技术公众号
前言
北宋科学家沈括在《梦溪笔谈》第十八卷《技能》中这样形容 ” 活字印刷术 ”：
庆历中，有布衣毕昇，又为活版。其法用胶泥刻字，薄如钱唇，每字为一印，火烧令坚……若止印三、二本，未为繁难；若印数十百千本，则极为神速。
在日常编码的过程中，咱们能够总结出很多 ” 样板代码 ”，就像 ” 活字印刷术 ” 中的 ” 活字 ” 一样。当咱们编写新的代码时，须要用到这些 ” 活字 ”，就把 ” 样板代码 ” 拷贝过去，批改替换一下就能够了，写起代码来 ” 极为神速 ”。” 样板代码 ” 其实就是一种样例、一种模式、一种教训……总结的 ” 样板代码 ” 越多，编写代码的格局越标准、品质越高、速度越快。
这里，作者总结了几种常见 Java 的 ” 样板代码 ”，心愿起到抛砖引玉的作用，心愿大家一直总结和欠缺，造成本人的样板代码库。
1. 样板代码简介
1.1. 什么是样板代码？
样板代码（Boilerplate Code），通常是指一堆具备固定模式的代码块，能够被宽泛地利用到各个程序模块。
例如，读取文件就是典型的样板代码：
try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
String line;
while (Objects.nonNull(line = reader.readLine())) {
// 解决一行
...
}
} catch (IOException e) {String message = String.format("读取文件 (%s) 异样", fileName);
log.error(message, e);
throw new ExampleException(message, e);
}1.2. 样板代码有什么用？
样板（Boilerplate），能够拆分为样例（Example）和模式（Pattern）两个单词进行了解——样例（Example）指能够当成一种规范范例，模式（Pattern）指能够作为一种解决方案。当遇到相似的案例时，就把样板代码拷贝过来，依据理论状况进行批改，该案例就被轻松解决了。
样板代码的次要作用：
- 提供一种规范样例：能够用于新人学习，可能疾速上手并应用；
- 提供一种解决方案：遇到相似案例时，能够疾速利用该计划进行解决；
- 有助于一直积攒教训：当发现一种样例代码时，都会一直地进行优化，力求达到最佳样例；
- 有助于进步代码品质：样板代码必然通过了工夫考验，存在 BUG 和出错的几率绝对比拟低；
- 有助于进步编码速度：利用样板代码编码，只是复制粘贴批改代码，编码速度大幅提高；
- 有助于对立代码款式：心中有了样板代码，就能保障每次都写出对立款式的代码。
1.3. 如何编写样板代码？
在作者以前的文章《编码方法论，赋能你我他》中，有具体的阐明和举例，这里不再累述。其中，适宜于样板代码的编写办法有：
复制粘贴生成代码
利用复制粘贴样板代码，用好了编码会事倍功半。
用文本替换生成代码
利用文本替换生成代码，能够很快生成一段新代码。
用 Excel 公式生成代码
把样板代码先公式化，传入不同的参数，生成不同的代码。
用工具或插件生成代码
很多开发工具或插件都提供一些工具生成代码，比方：生成构造方法、重载基类 / 接口办法、生成 Getter/Setter 办法、生成 toString 办法、生成数据库拜访办法……可能防止很多手敲代码。
用代码生成代码
用代码生成代码，就是本人编写代码，依照本人的样板代码格局生成代码。
1.4. 如何缩小样板代码？
样板代码 (Boilerplate Code) 具备很大的重复性，通常被认为是一种冗余而又不得不写的代码。其实不然，有些样板代码不能缩小，只是咱们还没有遇到适合的解决方案而已。通常状况下，咱们能够通过以下几种形式缩小样板代码：
1.4.1. 利用注解缩小样板代码
比方，JavaBean 模型类中的 Getter/Setter 就是样板代码，咱们能够通过 Lombok 的 @Getter/@Setter 注解来缩小这样的样板代码。
原始代码：
public class User {
private Long id;
...
public Long getId() {return id;}
public void setId(Long id) {this.id = id;}
...
}
优化代码：@Getter
@Setter
public class User {
private Long id;
...
}1.4.2. 利用框架缩小样板代码
比方，MyBatis 是一款优良的长久层框架，封装了获取数据库连贯和申明、设置参数、获取后果集等所有 JDBC 操作。MyBatis 能够通过简略的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，一般老式 Java 对象）为数据库中的记录。
原始代码：
/** 查问公司员工 */
public List< EmployeeDO> queryEmployee(Long companyId) {try (Connection connection = tddlDataSource.getConnection();
PreparedStatement statement = connection.prepareStatement(QUERY_EMPLOYEE_SQL)) {statement.setLong(1, companyId);
try (ResultSet result = statement.executeQuery()) {List< EmployeeDO> employeeList = new ArrayList<>();
while (result.next()) {EmployeeDO employee = new EmployeeDO();
employee.setId(result.getLong(1));
employee.setName(result.getString(2));
...
employeeList.add(employee);
}
return employeeList;
}
} catch (SQLException e) {String message = String.format("查问公司 (%s) 用户异样", companyId);
log.error(message, e);
throw new ExampleException(message, e);
}
}优化代码：
UserDAO.java：@Mapper
public interface UserDAO {List< EmployeeDO> queryEmployee(@Param("companyId") Long companyId);
}
UserDAO.xml：< mapper namespace="com.example.repository.UserDAO">
< select id="queryEmployee" resultType="com.example.repository.UserDO">
select id
, name
...
from t_user
where company_id = #{companyId}
< /select>
< /mapper>
1.4.3. 利用设计模式缩小样板代码
利用设计模式，能够把一些重复性代码进行封装。比方，下面的读取文件行模式代码，就能够用模板办法进行封装。原始代码：try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
String line;
while (Objects.nonNull(line = reader.readLine())) {
// 解决一行
...
}
} catch (IOException e) {String message = String.format("读取文件 (%s) 异样", fileName);
log.error(message, e);
throw new ExampleException(message, e);
}优化代码：
/* 定义方法 /
public static void readLine(String fileName, Consumer< String> lineConsumer) {
try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
String line;
while (Objects.nonNull(line = reader.readLine())) {lineConsumer.accept(line);
}
} catch (IOException e) {String message = String.format("读取文件 (%s) 异样", fileName);
log.error(message, e);
throw new ExampleException(message, e);
}}
// 应用代码
readLine("example.txt", line -> {
// 解决一行
...
});1.5. 毁灭不了的样板代码
如果样板代码能够被毁灭，那么世界上就不存在样板代码了。即使是上一节提供的缩小样板代码办法，也不能齐全的毁灭样板代码，因为这些样板代码仍旧存在于框架和模式的实现中。所以，样板代码是毁灭不了的。
既然不能毁灭样板代码，那就应该正当地利用样板代码。提炼一段样板代码，若只用二三次，未为简便；若用数十百千次，则极为神速。上面，列举了几种常见 Java 的样板代码，形容了样板代码在日常编程中如何提炼和应用。
2. 定义工具类
2.1. 罕用定义形式
通常，咱们会如下定义工具类：
/** 例子工具类 */
public class ExampleHelper {
/** 常量值 */
public final static int CONST_VALUE = 123;
/** 求和办法 */
public static int sum(int a, int b) {return a + b;}
}2.2. 存在一些问题
2.2.1. 修饰符程序不标准
通过 SonarLint 插件扫描，会呈现以下问题：
Java 语言标准倡议应用 ”static final”，而不是 ”final static”。请记住这么一条规定：动态常量，动态（static）在前，常量（final）在后。
2.2.2. 工具类能够被继承笼罩
如果咱们定义一个 MyExampleHelper 来继承 ExampleHelper：
public class MyExampleHelper extends ExampleHelper {
/** 常量值 */
public static final int CONST_VALUE = 321;
/** 求和办法 */
public static int sum(int a, int b) {return a * b;}
}会发现，MyExampleHelper 会对 ExampleHelper 中的常量和办法进行笼罩，导致咱们不晓得是不是应用了 ExampleHelper 中的常量和办法。
对于 Apache 提供的工具类，很多同学都喜爱定义雷同名称的工具类，并让这个工具类继承 Apache 的工具类，并在这个类中增加本人的实现办法。其实，我是十分不举荐这种做法的，因为你不晓得——你调用的是 Apache 工具类提供的常量和办法，还是被笼罩的常量和办法。最好的方法，就是对工具类增加 final 关键字，让这个工具类不能被继承和笼罩。
2.2.3. 工具类能够被实例化
对于 ExampleHelper 工具类，咱们能够这样应用：
int value = ExampleHelper.CONST_VALUE;
int sum = ExampleHelper.sum(1, 2);也能够被这样应用：
ExampleHelper exampleHelper = new ExampleHelper();
int value = exampleHelper.CONST_VALUE;
int sum = exampleHelper.sum(1, 2);对于工具类来说，没有必要进行实例化。所以，咱们倡议增加公有构造方法，并在办法中抛出 UnsupportedOperationException（不反对的操作异样）。
2.3. 最佳定义形式
依据以上存在问题及其解决办法，最佳定义的 ExampleHelper 工具类如下：
/** 例子工具类 */
public final class ExampleHelper {
/** 常量值 */
public static final int CONST_VALUE = 123;
/** 构造方法 */
private ExampleHelper() {throw new UnsupportedOperationException();
}
/** 求和办法 */
public static int sum(int a, int b) {return a + b;}
}3. 定义枚举类
3.1. 罕用定义形式
通常，咱们会如下定义枚举类：
/** 例子枚举类 */
public enum ExampleEnum {
/** 枚举相干 */
ONE(1, "one(1)"),
TWO(2, "two(2)"),
THREE(3, "two(3)");
/** 属性相干 */
private Integer value;
private String desc;
/** 构造方法 */
private ExampleEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
/** 获取取值 */
public Integer getValue() {return value;}
/** 获取形容 */
public String getDesc() {return desc;}
}3.2. 一些优化倡议
3.2.1. 修饰符 private 可缺省
通过 SonarLint 插件扫描，会呈现以下问题：
依据倡议，应该删除构造方法前多余的 private 修饰符。
3.2.2. 倡议应用根底类型
用包装类型 Integer 保留枚举取值，自身并没有什么问题。然而，本着能用根底类型就用根底类型的规定，所以倡议应用根底类型 int。
3.2.3. 倡议应用 final 字段
假如，咱们要实现一个静态方法，可能一不小心就把枚举值给批改了：
/** 批改取值 */
public static void modifyValue() {for (ExampleEnum value : values()) {value.value++;}
}如果调用了 modifyValue 办法，就会把枚举值批改，导致应用程序出错。为了防止这样的状况呈现，咱们倡议对字段增加 final 修饰符，从而防止字段值被歹意篡改。
3.3. 最佳定义形式
/* 例子枚举类 /
public enum ExampleEnum {
/** 枚举相干 */
ONE(1, "one(1)"),
TWO(2, "two(2)"),
THREE(3, "two(3)");
/** 字段相干 */
private final int value;
private final String desc;
/** 构造方法 */
ExampleEnum(int value, String desc) {
this.value = value;
this.desc = desc;
}
/** 获取取值 */
public int getValue() {return value;}
/** 获取形容 */
public String getDesc() {return desc;}
}4. 定义模型类
上面，以定义 User（用户）模型类为例，从 JavaBean 模式、重载构造方法、Builder 模式 3 种形式，来阐明模型类的定义方法以及优缺点。
假如：User（用户）模型类共有 4 个属性——id（标识）、name（名称）、age（年龄）、desc（形容），其中必填属性为——id（标识）、name（名称），可填属性为——age（年龄）、desc（形容）。
4.1. JavaBean 模式
JavaBean 是一个遵循特定写法的 Java 类，它通常具备如下特点：
- 必须具备一个无参的构造方法；
- 所有属性字段必须是公有的；
- 所有属性字段必须通过遵循一种命名标准的 Getter/Setter 办法凋谢进去。
通过 JavaBean 模式定义的 User（用户）模型类如下：
/** 用户类 */
public class User {
private Long id;
private String name;
private Integer age;
private String desc;
public Long getId() {return id;}
public void setId(Long id) {this.id = id;}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public Integer getAge() {return age;}
public vid setAge(Integer age) {this.age = age;}
public String getDesc() {return desc;}
public void setDesc(String desc) {this.desc = desc;}
}留神：也能够通过 Lombok 的 @Getter/@Setter 注解生成对应个 Getter/Setter 办法。
应用代码：
User user = new User();
user.setId(1L);
user.setName("alibaba");
user.setAge(102);
user.setDesc("test");
verifyUser(user);次要长处：
代码非常简单，只有公有属性字段及其私有 Getter/Setter 办法；
赋值对象代码可读性较强，明确地晓得哪个属性字段对应哪个值；
非常简单实用，被宽泛地用于 HSF、Dubbo、MyBatis 等中间件。
次要毛病：
因为能够通过 Setter 办法设置属性字段，所以不能定义为不可变类；
因为每个字段别离设置，所以不能保障字段必填，必须设置结束后进行对立验证。
4.2. 重载构造方法
通过 ” 重载构造方法 ” 定义 User（用户）模型类如下：
/** 用户类 */
public final class User {
private Long id;
private String name;
private Integer age;
private String desc;
public User(Long id, String name) {this(id, name, null);
}
public User(Long id, String name, Integer age) {this(id, name, age, null);
}
public User(Long id, String name, Integer age, String desc) {Assert.notNull(id, "标识不能为空");
Assert.notNull(name, "名称不能为空");
this.id = id;
this.name = name;
this.age = age;
this.desc = desc;
}
public Long getId() {return id;}
public String getName() {return name;}
public Integer getAge() {return age;}
public String getDesc() {return desc;}
}应用代码：
User user1 = new User(1L, "alibaba");
User user2 = new User(1L, "alibaba", 102, "test");次要长处：
- 初始化对象代码简洁，只有简略的一行代码；
- 能够定义为不可变类，初始化后属性字段值不可变更；
- 能够在构造方法内进行不可空验证。
次要毛病：
- 重载构造方法数量过多，无奈笼罩必填字段和非必填字段的所有组合；
- 初始化对象代码可读性差，无奈看出哪个属性字段对应哪个值；
- 如果删除某个字段，初始化对象代码可能不会报错，导致呈现赋值谬误问题。
4.3. Builder 模式
/** 用户类 */
public final class User {
private Long id;
private String name;
private Integer age;
private String desc;
private User(Builder builder) {
this.id = builder.id;
this.name = builder.name;
this.age = builder.age;
this.desc = builder.desc;
}
public static Builder newBuilder(Long id, String name) {return new Builder(id, name);
}
public Long getId() {return id;}
public String getName() {return name;}
public Integer getAge() {return age;}
public String getDesc() {return desc;}
public static class Builder {
private Long id;
private String name;
private Integer age;
private String desc;
private Builder(Long id, String name) {Assert.notNull(id, "标识不能为空");
Assert.notNull(name, "名称不能为空");
this.id = id;
this.name = name;
}
public Builder age(Integer age) {
this.age = age;
return this;
}
public Builder desc(String desc) {
this.desc = desc;
return this;
}
public User build() {return new User(this);
}
}
}留神：能够采纳 Lombok 的 @Builder 注解简化代码。
应用代码：
User user = User.newBuilder(1L, "alibaba").age(102).desc("test").build();次要长处：
- 明确了必填参数和可选参数，在构造方法中进行验证；
- 能够定义为不可变类，初始化后属性字段值不可变更；
- 赋值代码可读性较好，明确晓得哪个属性字段对应哪个值；
- 反对链式办法调用，相比于调用 Setter 办法，代码更简洁。
次要毛病：
- 代码量较大，多定义了一个 Builder 类，多定义了一套属性字段，多实现了一套赋值办法；
- 运行效率低，须要先创立 Builder 实例，再赋值属性字段，再创立指标实例，最初拷贝属性字段。
5. 定义汇合常量
在编码中，常常应用到各种汇合常量，比方 List(列表)常量、Set(汇合)常量、Map(映射)常量等。
5.1. 一般定义形式
定义代码：
最简略的办法，就是间接定义一个一般的汇合常量。
/** 例子工具类 */
public final class ExampleHelper {
/** 常量值列表 */
public static final List< Integer> CONST_VALUE_LIST = Arrays.asList(1, 2, 3);
/** 常量值汇合 */
public static final Set< Integer> CONST_VALUE_SET = new HashSet<>(Arrays.asList(1, 2, 3));
/** 常量值映射 */
public static final Map< Integer, String> CONST_VALUE_MAP;
static {CONST_VALUE_MAP = new HashMap<>(MapHelper.DEFAULT);
CONST_VALUE_MAP.put(1, "value1");
CONST_VALUE_MAP.put(2, "value2");
CONST_VALUE_MAP.put(3, "value3");
}
...
}应用代码：
应用也很不便，间接通过 ” 类名. 常量名 ” 应用。
// 应用常量值汇合
List< Integer> constValueList = ExampleHelper.CONST_VALUE_LIST;
Set< Integer> constValueSet = ExampleHelper.CONST_VALUE_SET;
Map< Integer, String> constValueMap = ExampleHelper.CONST_VALUE_MAP;5.2. 存在次要问题
通过 SonarLint 插件扫描，会呈现以下问题：
因为一般的汇合对象（如 ArrayList、HashMap、HashSet 等）都是可变汇合对象，即使是定义为动态常量，也能够通过操作方法进行批改。所以，下面办法定义的汇合常量，并不是真正意义上的汇合常量。其中，Arrays.asList 办法生成的外部 ArrayList 不能执行 add/remove/clear 办法，然而能够 set 办法，也属于可变汇合对象。
// 操作常量列表
ExampleHelper.CONST_VALUE_LIST.remove(3); // UnsupportedOperationException
ExampleHelper.CONST_VALUE_LIST.add(4); // UnsupportedOperationException
ExampleHelper.CONST_VALUE_LIST.set(1, 20); // [1,20,3]
ExampleHelper.CONST_VALUE_LIST.clear(); // UnsupportedOperationException
// 操作常量汇合
ExampleHelper.CONST_VALUE_SET.remove(3); // [1,2]
ExampleHelper.CONST_VALUE_SET.add(3); // [1,2,3]
ExampleHelper.CONST_VALUE_SET.clear(); // []
// 操作常量映射
ExampleHelper.CONST_VALUE_MAP.remove(3); // {1:"value1",2:"value2"}
ExampleHelper.CONST_VALUE_MAP.put(3, "value3"); // {1:"value1",2:"value2",3:"value3"}
ExampleHelper.CONST_VALUE_MAP.clear(); // []5.3. 最佳定义形式
在 JDK 中，Collections 工具类中提供一套办法，用于把可变汇合对象变为不可变（不可批改，批改时会抛出 UnsupportedOperationException 异样）汇合对象。所以，能够利用这套办法定义汇合动态常量。
/** 例子工具类 */
public final class ExampleHelper {
/** 常量值列表 */
public static final List< Integer> CONST_VALUE_LIST = Collections.unmodifiableList(Arrays.asList(1, 2, 3));
/** 常量值汇合 */
public static final Set< Integer> CONST_VALUE_SET = Collections.unmodifiableSet(new HashSet<>(Arrays.asList(1, 2, 3)));
/** 常量值映射 */
public static final Map< Integer, String> CONST_VALUE_MAP;
static {Map< Integer, String> valueMap = new HashMap<>(MapHelper.DEFAULT);
valueMap.put(1, "value1");
valueMap.put(2, "value2");
valueMap.put(3, "value3");
CONST_VALUE_MAP = Collections.unmodifiableMap(valueMap);
}
...
}6. 定义数组常量
上一章介绍了如何定义汇合常量，这一章就来介绍一下如何定义数组常量。
6.1. 定义私有数组常量
定义代码：
个别人定义数组常量，就会像上面代码一样，定义一个私有数组常量。
/** 例子工具类 */
public final class ExampleHelper {
/** 常量值数组 */
public static final int[] CONST_VALUES = new int[] {1, 2, 3};
...
}应用代码：
应用也很不便，间接通过 ” 类名. 常量名 ” 应用。
// 应用常量值数组
int[] constValues = ExampleHelper.CONST_VALUES;存在问题：
然而，能够通过下标批改数组值，导致数组常量的值可变。所以，这种办法定义的数组常量，并不是一个真正意义上的数组常量。
// 批改常量值数组
ExampleHelper.CONST_VALUES[1] = 20; // [1, 20, 3]6.2. 定义私有汇合常量
定义代码：
能够通过上一章定义汇合常量的办法，返回一个私有汇合常量。
/** 例子工具类 */
public final class ExampleHelper {
/** 常量值列表 */
public static final List< Integer> CONST_VALUE_LIST =
Collections.unmodifiableList(Arrays.asList(1, 2, 3));
...
}应用代码：
要想得到数组常量，就把汇合常量转化为数组常量。
// 应用常量值列表
int[] constValues = ExampleHelper.CONST_VALUE_LIST.stream()
.mapToInt(Integer::intValue).toArray();存在问题：
每一次都会把汇合常量转化为数组常量，导致程序运行效率升高。
6.3. 最佳定义形式
最佳法 ” 公有数组常量 + 私有克隆办法 ” 的解决方案。如下代码所示：先定义一个公有数组常量，保障不会被外部类应用；在定义一个获取数组常量办法，并返回一个数组常量的克隆值。
定义代码：
这里，提供一个 ” 公有数组常量 + 私有克隆办法 ” 的解决方案。如下代码所示：先定义一个公有数组常量，保障不会被外部类应用；在定义一个获取数组常量办法，并返回一个数组常量的克隆值。
/** 例子工具类 */
public final class ExampleHelper {
/** 常量值数组 */
private static final int[] CONST_VALUES = new int[] {1, 2, 3};
/** 获取常量值数组办法 */
public static int[] getConstValues() {return CONST_VALUES.clone();
}
...
}应用代码：
因为每次返回的是一个克隆数组，即使批改了克隆数组的常量值，也不会导致原始数组常量值的批改。
// 应用常量值办法
int[] constValues = ExampleHelper.getConstValues(); // [1, 2, 3]
constValues[1] = 20; // [1, 20, 3]
constValues = ExampleHelper.getConstValues(); // [1, 2, 3]7. 定义多条件表达式
7.1. 利用运算符 &&（或 ||）间接拼接
定义代码：
有时候，咱们会判断很多条件，需要用 &&（或 ||）连贯多个条件表达式。
/** 获取审核后果办法 */
private static Integer getAuditResult(AuditDataVO data) {if (isPassed(data.getAuditItem1())
&& isPassed(data.getAuditItem2())
...
&& isPassed(data.getAuditItem11())) {return AuditResult.PASSED;}
return AuditResult.REJECTED;
}存在问题：
通过 SonarLint 插件扫描，会存在 2 个问题：
其中，圈复杂度（Cyclomatic complexity，CC）也称为条件复杂度，是一种掂量代码复杂度的规范，其符号为 V(G)。
麦凯布最早提出一种称为“根底门路测试”（Basis Path Testing）的软件测试形式，测试程序中的每一线性独立门路，所需的测试用例个数即为程序的圈复杂度。
圈复杂度能够用来掂量一个模块断定构造的复杂程度，其数量上体现为独立门路的条数，也可了解为笼罩所有的可能状况起码应用的测试用例个数。
7.2. 利用运算符 = 和 &&（或 ||）级联拼接
定义代码：
那么，就把 &&（或 ||）连接符拆开，利用运算符 = 和 &&（或 ||）级联进行拼接。
/** 获取审核后果办法 */
private static AuditResult getAuditResult(AuditDataVO data) {boolean isPassed = isPassed(data.getAuditItem1());
isPassed = isPassed && isPassed(data.getAuditItem2());
...
isPassed = isPassed && isPassed(data.getAuditItem11());
if (isPassed) {return AuditResult.PASSED;}
return AuditResult.REJECTED;
}存在问题：
通过 SonarLint 插件扫描，还存在 1 个问题：
也就是，利用运算符 = 和 &&（或 ||）级联进行拼接，并不能缩小办法的圈复杂度。
7.3. 利用动静无参数 Lambda 表达式列表
定义代码：
上面，利用动静无参数 Lambda 表达式列表优化，即把每个条件表达式作为 BooleanSupplier 对象存在列表中，而后顺次执行条件表达式得出最初后果。
/** 获取审核后果办法 */
private static AuditResult getAuditResult(AuditDataVO data) {List< BooleanSupplier> supplierList = new ArrayList<>();
supplierList.add(() -> isPassed(data.getAuditItem1()));
supplierList.add(() -> isPassed(data.getAuditItem2()));
...
supplierList.add(() -> isPassed(data.getAuditItem11()));
for (BooleanSupplier supplier : supplierList) {if (!supplier.getAsBoolean()) {return AuditResult.REJECTED;}
}
return AuditResult.PASSED;
}存在问题：
通过 SonarLint 插件扫描，没有提醒任何问题。然而，每次都动静增加 Lambda 表达式，就会导致程序效率低下。那么，有没有把 Lambda 表达式动态化的办法呢？
7.4. 利用动态有参数 Lambda 表达式列表
定义代码：
要想固化 Lambda 表达式，就必须动静传入 AuditDataVO 对象。这里，采纳 Predicate<AuditDataVO> 来接管 Lambda 表达式，在 Lambda 表达式中指定 AuditDataVO 对象 data。而后，在 for 循环中，顺次指定 AuditDataVO 对象 data，并计算表达式的值。
/
** 审核后果断言列表 */
private static final List< Predicate<AuditDataVO>> AUDIT_RESULT_PREDICATE_LIST =
Collections.unmodifiableList(Arrays.asList(data -> isPassed(data.getAuditItem1()),
data -> isPassed(data.getAuditItem2()),
...
data -> isPassed(data.getAuditItem11())));
/** 获取审核后果办法 */
private static AuditResult getAuditResult(AuditDataVO data) {for (Predicate< AuditDataVO> predicate : AUDIT_RESULT_PREDICATE_LIST) {if (!predicate.test(data)) {return AuditResult.REJECTED;}
}
return AuditResult.PASSED;
}实用条件：
- 适宜于 &&（或 ||）连贯大量条件表达式的状况；
- 适宜于每个条件表达式都须要传入雷同参数的状况，如果每个条件表达式传入参数不同，只能应用动静无参数 Lambda 表达式列表办法；
- 如果须要传入两个参数，能够应用 BiPredicate 类型来接管 Lambda 表达式；如果须要传入多个参数，则须要自定义办法接口。
原文链接
本文为阿里云原创内容，未经容许不得转载。