关于java:Java编程技巧之样板代码

简介：在日常编码的过程中，能够总结出很多“样板代码”，就像”活字印刷术中的“活字”一样。当咱们编写新的代码时，须要用到这些“活字”，就把“样板代码”拷贝过去，批改替换一下就能够了，写起代码来“极为神速”。“样板代码”其实就是一种样例、一种模式、一种教训……总结的“样板代码”越多，编写代码的格局越标准、品质越高、速度越快。

作者 | 常意
起源 | 阿里技术公众号

前言

北宋科学家沈括在《梦溪笔谈》第十八卷《技能》中这样形容"活字印刷术"：

庆历中，有布衣毕昇，又为活版。其法用胶泥刻字，薄如钱唇，每字为一印，火烧令坚……若止印三、二本，未为繁难；若印数十百千本，则极为神速。

在日常编码的过程中，咱们能够总结出很多"样板代码"，就像"活字印刷术"中的"活字"一样。当咱们编写新的代码时，须要用到这些"活字"，就把"样板代码"拷贝过去，批改替换一下就能够了，写起代码来"极为神速"。"样板代码"其实就是一种样例、一种模式、一种教训……总结的"样板代码"越多，编写代码的格局越标准、品质越高、速度越快。

这里，作者总结了几种常见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@Setterpublic 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：@Mapperpublic 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); // UnsupportedOperationExceptionExampleHelper.CONST_VALUE_LIST.add(4); // UnsupportedOperationExceptionExampleHelper.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表达式；如果须要传入多个参数，则须要自定义办法接口。

原文链接
本文为阿里云原创内容，未经容许不得转载。