java 代码精简之道

原文地址 https://mp.weixin.qq.com/s/Icn5_RZzFHB9WsKip2ZZ6g
转载：https://lovepli.github.io/my-project/java001.html

古语有云：

道为术之灵，术为道之体；以道统术，以术得道。

其中：“道”指 “规律、道理、理论”，“术” 指“方法、技巧、技术”。意思是：“道”是 “术” 的灵魂，“术”是 “道” 的肉体；可以用 “道” 来统管 “术”，也可以从“术” 中获得“道”。工匠追求 “术” 到极致，其实就是在寻 “道”，且离悟“道” 也就不远了，亦或是已经得道，这就是 “工匠精神”——一种追求“以术得道” 的精神。如果一个工匠只满足于 “术”，不能追求“术” 到极致去悟 “道”，那只是一个靠“术” 养家糊口的工匠而已。作者根据多年来的实践探索，总结了大量的 Java 代码精简之“术”，试图阐述出心中的 Java 代码精简之“道”。

1. 利用语法

1.1. 利用三元表达式

普通：

精简：

1	String title = isMember(phone) ? "会员" : "游客";

注意：对于包装类型的算术计算，需要注意避免拆包时的空指针问题。

1.2. 利用 for-each 语句

从 Java 5 起，提供了 for-each 循环，简化了数组和集合的循环遍历。 for-each 循环允许你无需保持传统 for 循环中的索引就可以遍历数组，或在使用迭代器时无需在 while 循环中调用 hasNext 方法和 next 方法就可以遍历集合。

普通：

精简：

1.3. 利用 try-with-resource 语句

所有实现 Closeable 接口的 “资源”，均可采用 try-with-resource 进行简化。

普通：

精简：

1.4. 利用 return 关键字

利用 return 关键字，可以提前函数返回，避免定义中间变量。

普通：

精简：

1.5. 利用 static 关键字

利用 static 关键字，可以把字段变成静态字段，也可以把函数变为静态函数，调用时就无需初始化类对象。

普通：

精简：

public final class GisHelper {
    public static double distance(double lng1, double lat1, double lng2, double lat2) {
        // 方法实现代码
    }
}
double distance = GisHelper.distance(116.178692D, 39.967115D, 116.410778D, 39.899721D);

1.6. 利用 lambda 表达式

Java 8 发布以后，lambda 表达式大量替代匿名内部类的使用，在简化了代码的同时，更突出了原有匿名内部类中真正有用的那部分代码。

普通：

精简：

1.7. 利用方法引用

方法引用（::），可以简化 lambda 表达式，省略变量声明和函数调用。

普通：

Arrays.sort(nameArray, String::compareToIgnoreCase);
List<Long> userIdList = userList.stream()
    .map(UserDO::getId)
    .collect(Collectors.toList());

1.8. 利用静态导入

静态导入（import static），当程序中大量使用同一静态常量和函数时，可以简化静态常量和函数的引用。

普通：

精简：

注意：静态引入容易造成代码阅读困难，所以在实际项目中应该警慎使用。

1.9. 利用 unchecked 异常

Java 的异常分为两类：Checked 异常和 Unchecked 异常。Unchecked 异常继承了 RuntimeException ，特点是代码不需要处理它们也能通过编译，所以它们称作 Unchecked 异常。利用 Unchecked 异常，可以避免不必要的 try-catch 和 throws 异常处理。

普通：

精简：

2. 利用注解

2.1. 利用 Lombok 注解

Lombok 提供了一组有用的注解，可以用来消除 Java 类中的大量样板代码。

普通：

精简：

2.2. 利用 Validation 注解

普通：

@Getter@Setter@ToStringpublic class UserCreateVO {    @NotBlank(message = "用户名称不能为空")    private String name;    @NotNull(message = "公司标识不能为空")    private Long companyId;    ...}@Service@Validatedpublic class UserService {    public Long createUser(@Valid UserCreateVO create) {        // TODO: 创建用户        return null;    }}

精简：

@Getter
@Setter
@ToString
public class UserCreateVO {
    @NotBlank(message = "用户名称不能为空")
    private String name;
    @NotNull(message = "公司标识不能为空")
    private Long companyId;
    ...
}
@Service
@Validated
public class UserService {
    public Long createUser(@Valid UserCreateVO create) {
        // TODO: 创建用户
        return null;
    }
}

2.3. 利用 @NonNull 注解

Spring 的 @NonNull 注解，用于标注参数或返回值非空，适用于项目内部团队协作。只要实现方和调用方遵循规范，可以避免不必要的空值判断，这充分体现了阿里的 “新六脉神剑” 提倡的“因为信任，所以简单”。

普通：

精简：

2.4. 利用注解特性

注解有以下特性可用于精简注解声明：

1、当注解属性值跟默认值一致时，可以删除该属性赋值；

2、当注解只有 value 属性时，可以去掉 value 进行简写；

3、当注解属性组合等于另一个特定注解时，直接采用该特定注解。

普通：

1
2
3

@Lazy(true);
@Service(value = "userService")
@RequestMapping(path = "/getUser", method = RequestMethod.GET)

精简：

1
2
3

@Lazy
@Service("userService")
@GetMapping("/getUser")

3. 利用泛型

3.1. 泛型接口

在 Java 没有引入泛型前，都是采用 Object 表示通用对象，最大的问题就是类型无法强校验并且需要强制类型转换。

普通：

精简：

3.2. 泛型类

普通：

精简：

3.3. 泛型方法

普通：

精简：

4. 利用自身方法

4.1. 利用构造方法

构造方法，可以简化对象的初始化和设置属性操作。对于属性字段较少的类，可以自定义构造方法。

普通：

精简：

注意：如果属性字段被替换时，存在构造函数初始化赋值问题。比如把属性字段 title 替换为 nickname ，由于构造函数的参数个数和类型不变，原有构造函数初始化语句不会报错，导致把原 title 值赋值给 nickname 。如果采用 Setter 方法赋值，编译器会提示错误并要求修复。

4.2. 利用 Set 的 add 方法

利用 Set 的 add 方法的返回值，可以直接知道该值是否已经存在，可以避免调用 contains 方法判断存在。

普通：

以下案例是进行用户去重转化操作，需要先调用 contains 方法判断存在，后调用 add 方法进行添加。

精简：

‍

4.3. 利用 Map 的 computeIfAbsent 方法

利用 Map 的 computeIfAbsent 方法，可以保证获取到的对象非空，从而避免了不必要的空判断和重新设置值。

普通：

精简：

4.4. 利用链式编程

链式编程，也叫级联式编程，调用对象的函数时返回一个 this 对象指向对象本身，达到链式效果，可以级联调用。链式编程的优点是：编程性强、可读性强、代码简洁。

普通：

精简：

5. 利用工具方法

5.1. 避免空值判断

普通：

精简：

5.2. 避免条件判断

普通：

精简：

1	double result = Math.max(MIN_LIMIT, value);

5.3. 简化赋值语句

普通：

精简：

// JDK流派
public static final List<String> ANIMAL_LIST = Arrays.asList("dog", "cat", "tiger");
// Guava流派
public static final List<String> ANIMAL_LIST = ImmutableList.of("dog", "cat", "tiger");

注意：Arrays.asList 返回的 List 并不是 ArrayList ，不支持 add 等变更操作。

5.4. 简化数据拷贝

普通：

精简：

反例：

1	List<UserVO> userVOList = JSON.parseArray(JSON.toJSONString(userDOList), UserVO.class);

精简代码，但不能以过大的性能损失为代价。例子是浅层拷贝，用不着 JSON 这样重量级的武器。

1	5.5.简化异常断言

普通：

精简：

1	Assert.notNull(userId, "用户标识不能为空");

注意：可能有些插件不认同这种判断，导致使用该对象时会有空指针警告。

5.6. 简化测试用例

把测试用例数据以 JSON 格式存入文件中，通过 JSON 的 parseObject 和 parseArray 方法解析成对象。虽然执行效率上有所下降，但可以减少大量的赋值语句，从而精简了测试代码。

普通：

建议：JSON 文件名最好以被测试的方法命名，如果有多个版本可以用数字后缀表示。

5.7. 简化算法实现

一些常规算法，已有现成的工具方法，我们就没有必要自己实现了。

普通：

精简：

1	List<List<Integer>> partitionList = ListUtils.partition(valueList, PARTITION_SIZE);

1	5.8.封装工具方法

1	一些特殊算法，没有现成的工具方法，我们就只好自己亲自实现了。

普通：

比如，SQL 设置参数值的方法就比较难用，setLong 方法不能设置参数值为 null 。

// 设置参数值
if (Objects.nonNull(user.getId())) {
  statement.setLong(1, user.getId());
} else {
    statement.setNull(1, Types.BIGINT);
}
...

精简：

我们可以封装为一个工具类 SqlHelper ，简化设置参数值的代码。

6. 利用数据结构

6.1. 利用数组简化

对于固定上下限范围的 if-else 语句，可以用数组 + 循环来简化。

普通：

精简：

思考：上面的案例返回值是递增的，所以用数组简化是没有问题的。但是，如果返回值不是递增的，能否用数组进行简化呢？答案是可以的，请自行思考解决。

6.2. 利用 Map 简化

对于映射关系的 if-else 语句，可以用 Map 来简化。此外，此规则同样适用于简化映射关系的 switch 语句。

普通：

已经把方法简化为一行代码，其实都没有封装方法的必要了。

6.3. 利用容器类简化

Java 不像 Python 和 Go ，方法不支持返回多个对象。如果需要返回多个对象，就必须自定义类，或者利用容器类。常见的容器类有 Apache 的 Pair 类和 Triple 类， Pair 类支持返回 2 个对象， Triple 类支持返回 3 个对象。

普通：

精简：

6.4. 利用 ThreadLocal 简化

ThreadLocal 提供了线程专有对象，可以在整个线程生命周期中随时取用，极大地方便了一些逻辑的实现。用 ThreadLocal 保存线程上下文对象，可以避免不必要的参数传递。

普通：

由于 DateFormat 的 format 方法线程非安全（建议使用替代方法），在线程中频繁初始化 DateFormat 性能太低，如果考虑重用只能用参数传入 DateFormat 。例子如下：

可能你会觉得以下的代码量反而多了，如果调用工具方法的地方比较多，就可以省下一大堆 DateFormat 初始化和传入参数的代码。

注意：ThreadLocal 有一定的内存泄露的风险，尽量在业务代码结束前调用 remove 方法进行数据清除。

7. 利用 Optional

在 Java 8 里，引入了一个 Optional 类，该类是一个可以为 null 的容器对象。

7.1. 保证值存在

普通：

精简：

1	Integer thisValue = Optional.ofNullable(value).orElse(DEFAULT_VALUE);

7.2. 保证值合法

普通：

1 2	Integer thisValue = Optional.ofNullable(value) .filter(tempValue -> tempValue.compareTo(MAX_VALUE) <= 0).orElse(MAX_VALUE);

7.3.避免空判断

普通：

1 2	tring zipcode = Optional.ofNullable(user).map(User::getAddress) .map(Address::getCountry).map(Country::getZipcode).orElse(null);

8. 利用 Stream

流（Stream）是 Java 8 的新成员，允许你以声明式处理数据集合，可以看成为一个遍历数据集的高级迭代器。流主要有三部分构成：获取一个数据源→数据转换→执行操作获取想要的结果。每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象，这就允许对其操作可以像链条一样排列，形成了一个管道。流（Stream）提供的功能非常有用，主要包括匹配、过滤、汇总、转化、分组、分组汇总等功能。

8.1. 匹配集合数据

普通：

1	double total = accountList.stream().mapToDouble(Account::getBalance).sum();

1	8.4.转化集合数据

普通：

8.5. 分组集合数据

普通：

1	roleTotalMap = accountList.stream().collect(Collectors.groupingBy(Account::getRoleId, Collectors.summingDouble(Account::getBalance)));

1	8.7.生成范围集合

Python 的 range 非常方便，Stream 也提供了类似的方法。

普通：

9. 利用程序结构

9.1. 返回条件表达式

条件表达式判断返回布尔值，条件表达式本身就是结果。

普通：

最小化条件作用域，尽量提出公共处理代码。

普通：

9.3. 调整表达式位置

调整表达式位置，在逻辑不变的前提下，让代码变得更简洁。

普通 1：

9.4. 利用非空对象

在比较对象时，交换对象位置，利用非空对象，可以避免空指针判断。

普通：

精简：

10. 利用设计模式

10.1. 模板方法模式

模板方法模式（Template Method Pattern）定义一个固定的算法框架，而将算法的一些步骤放到子类中实现，使得子类可以在不改变算法框架的情况下重定义该算法的某些步骤。

普通：

10.2. 建造者模式

建造者模式（Builder Pattern）将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。

普通：

精简：

普通的建造者模式，实现时需要定义 DataHandler 接口，调用时需要实现 DataHandler 匿名内部类，代码较多较繁琐。而精简后的建造者模式，充分利用了函数式编程，实现时无需定义接口，直接使用 Function 接口；调用时无需实现匿名内部类，直接采用 lambda 表达式，代码较少较简洁。

10.3. 代理模式

Spring 中最重要的代理模式就是 AOP (Aspect-Oriented Programming，面向切面的编程)，是使用 JDK 动态代理和 CGLIB 动态代理技术来实现的。

普通：

精简 1：

基于 @ControllerAdvice 的异常处理：

精简 2：

基于 AOP 的异常处理：

11. 利用删除代码

“少即是多”，“少” 不是空白而是精简，“多” 不是拥挤而是完美。删除多余的代码，才能使代码更精简更完美。

11.1. 删除已废弃的代码

删除项目中的已废弃的包、类、字段、方法、变量、常量、导入、注解、注释、已注释代码、Maven 包导入、MyBatis 的 SQL 语句、属性配置字段等，可以精简项目代码便于维护。

普通：

精简：

@Service
public class ProductService {
    ...
    private ProductVO transProductDO(ProductDO productDO) {
        ProductVO productVO = new ProductVO();
        BeanUtils.copyProperties(productDO, productVO);
        return productVO;
    }
}
11.2.删除接口方法的public对于接口(interface)，所有的字段和方法都是public的，可以不用显式声明为public。普通：public interface UserDAO {
    public Long countUser(@Param("query") UserQuery query);
    public List<UserDO> queryUser(@Param("query") UserQuery query);
}

11.2. 删除接口方法的 public

对于接口 (interface)，所有的字段和方法都是 public 的，可以不用显式声明为 public 。

普通：

精简：

11.3. 删除枚举构造方法的 private

对于枚举 (menu)，构造方法都是 private 的，可以不用显式声明为 private 。

普通：

精简：

11.4. 删除 final 类方法的 final

对于 final 类，不能被子类继承，所以其方法不会被覆盖，没有必要添加 final 修饰。

普通：

精简：

11.5. 删除基类 implements 的接口

如果基类已 implements 某接口，子类没有必要再 implements 该接口，只需要直接实现接口方法即可。

普通：

精简：

11.6. 删除不必要的变量

不必要的变量，只会让代码看起来更繁琐。

普通：

精简：

想知道更多？**扫**描下面的二维码关注我

后台回复” 加群 “获取公众号专属群聊入口

【原创系列 | 精彩推荐】

朕已阅

1. 利用语法

1.2. 利用 for-each 语句

1.3. 利用 try-with-resource 语句

1.4. 利用 return 关键字

1.5. 利用 static 关键字

1.6. 利用 lambda 表达式

1.7. 利用方法引用

1.8. 利用静态导入

1.9. 利用 unchecked 异常

2. 利用注解

2.2. 利用 Validation 注解

2.3. 利用 @NonNull 注解

2.4. 利用注解特性

3. 利用泛型

3.2. 泛型类

3.3. 泛型方法

4. 利用自身方法

4.2. 利用 Set 的 add 方法

4.3. 利用 Map 的 computeIfAbsent **方法**

4.4. 利用链式编程

5. 利用工具方法

5.2. 避免条件判断

5.3. 简化赋值语句

5.4. 简化数据拷贝

5.6. 简化测试用例

5.7. 简化算法实现

6. 利用数据结构

6.2. 利用 Map 简化

6.3. 利用容器类简化

6.4. 利用 ThreadLocal 简化

7. 利用 Optional

7.1. 保证值存在

7.2. 保证值合法

8. 利用 Stream

8.1. 匹配集合数据

8.5. 分组集合数据

9. 利用程序结构

9.3. 调整表达式位置

9.4. 利用非空对象

10. 利用设计模式

10.2. 建造者模式

10.3. 代理模式

11. 利用删除代码

11.1. 删除已废弃的代码

11.2. 删除接口方法的 public

11.3. 删除枚举构造方法的 private

11.4. 删除 final 类方法的 final

11.5. 删除基类 implements 的接口

11.6. 删除不必要的变量

4.3. 利用 Map 的 computeIfAbsent 方法