Java代码精简指南

Java代码精简之道

开发工具类分享：

Hutool
guava

创建局部变量时应该尽可能得晚

利用三元表达式

传统：

String title;
if (isMember(phone)){    
    title = "会员";
} else {
    title = "游客";
}

精简：

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

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

利用 return 关键字

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

if(condition1) return; if(condition2) return; if(condition3) return ; 将概率大的写在前面，尽可能快地进行 return ，不需要进行后续无谓的匹配（抛出异常也是同理）

传统

public static boolean hasSuper(@NonNull List<UserDO> userList) {
    boolean hasSuper = false;
    for (UserDO user : userList) {
        if (Boolean.TRUE.equals(user.getIsSuper())) {
            hasSuper = true;
            break;
        }
    }
    return hasSuper;
}

精简

public static boolean hasSuper(@NonNull List<UserDO> userList) {
    
    for (UserDO user : userList) {
        if (Boolean.TRUE.equals(user.getIsSuper())) {
            reurn ture;
        }
    }
    
    return false;
}

减少if/else嵌套

看看反例：

// 修改用户密码，这个例子只有3层嵌套，很温柔了
public boolean modifyPassword(Integer userId, String oldPassword, String newPassword) {
    if (userId != null && StringUtils.isNotBlank(newPassword) && SpringUtils.isNotBlank(oldPassword)) {
        User user = getUserById(userId);
        if (user != null) {
            if (user.getPassword().equals(oldPassword) {
                return updatePassword(userId, newPassword)
            }
        }
    }
}

看看正例：

// 修改用户密码 
Public Boolean modifyPassword(Integer userId, String oldPassword, String newPassword) {
     if (userId == null || StringUtils.isBlank(newPassword) || StringUtils.isBlank(oldPassword)) {
            return false;
     }
     User user = getUserById(userId);
     if(user == null) {
           return false;
      }
     if(!user.getPassword().equals(oldPassword) {
           return false;    
     }
     return updatePassword(userId, newPassword);
}

正例采用卫语句减少了嵌套，但是并非所有场景都适合这样改写。如果不适合，可以将关联性高的逻辑抽取成一个独立的方法减少嵌套。

try/catch-资源回收

改造前

1
2
3

InputStream inputStream = new FileInputStream(new File(""));
....
inputStream.close();

改造后

1
2
3

try(InputStream inputStream = new FileInputStream(new File(""))) {
     .........
}

利用数组简化

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

普通：

public static int getGrade(double score) {
    if (score >= 90.0D) {
        return 1;
    }
    if (score >= 80.0D) {
        return 2;
    }
    if (score >= 60.0D) {
        return 3;
    }
    if (score >= 30.0D) {
        return 4;
    }
    return 5;
}

精简：

private static final ImmutableMap<Predicate<Integer>, Integer> predict_map = ImmutableMap.<Predicate<Integer>, Integer>builder()
        .put(num -> num >= 90, 1)
        .put(num -> num >= 80, 2)
        .put(num -> num >= 70, 3)
        .build();

public static void main1(String[] args) {
    int number = 80;
    Optional optional = predict_map.entrySet().stream()
            .filter(entry -> {
                return entry.getKey().test(number);
            })
            .map(entry -> {
                return entry.getValue();
            })
            .findFirst();

    if (optional.isPresent()) {
        System.out.println(optional.get());
    }

}

利用 Map 简化

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

普通：

public static String getBiologyClass(String name) {
    switch (name) {
      case "dog" :
            return "animal";
        case "cat" :
            return "animal";
        case "lavender" :
            return "plant";
        ...
        default :
            return null;
    }
}

精简：

private static final Map<String, String> BIOLOGY_CLASS_MAP = ImmutableMap.<String, String>builder()
        .put("dog", "animal")
        .put("cat", "animal")
        .put("lavender", "plant")
        ...
        .build();

public static String getBiologyClass(String name) {
    return BIOLOGY_CLASS_MAP.get(name);
}

使用 Optional 保证值存在

普通：

Integer thisValue;
if (Objects.nonNull(value)) {
    thisValue = value;
} else {
    thisValue = DEFAULT_VALUE;
}

精简：

1 2	Integer thisValue = Optional.ofNullable(value).orElse(DEFAULT_VALUE); Integer thisValue = MoreObjects.firstNonNull(value,DEFAULT_VALUE);

使用 Stream

匹配集合数据

普通：

boolean isFound = false;
for (UserDO user : userList) {
    if (Objects.equals(user.getId(), userId)) {   
        isFound = true;
        break;
    }
}

精简：

1 2	boolean isFound = userList.stream() .anyMatch(user -> Objects.equals(user.getId(), userId));

过滤集合数据

普通

List<UserDO> resultList = new ArrayList<>();
for (UserDO user : userList) {
    if (Boolean.TRUE.equals(user.getIsSuper())) {
        resultList.add(user);
    }
}

精简

1
2
3

List<UserDO> resultList = userList.stream()
    .filter(user -> Boolean.TRUE.equals(user.getIsSuper()))
    .collect(Collectors.toList());

汇总集合数据

普通

double total = 0.0D;
for (Account account : accountList) {  
    total += account.getBalance();
}

精简

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

转化集合数据

普通

List<UserVO> userVOList = new ArrayList<>();
for (UserDO userDO : userDOList) {
    userVOList.add(transUser(userDO));
}

精简

1 2	List<UserVO> userVOList = userDOList.stream() .map(this::transUser).collect(Collectors.toList());

分组集合数据

普通

Map<Long, List<UserDO>> roleUserMap = new HashMap<>();
for (UserDO userDO : userDOList) {
    roleUserMap.computeIfAbsent(userDO.getRoleId(), key -> new ArrayList<>())
        .add(userDO);
}

精简

1 2	Map<Long, List<UserDO>> roleUserMap = userDOList.stream() .collect(Collectors.groupingBy(UserDO::getRoleId));

分组汇总集合

普通

Map<Long, Double> roleTotalMap = new HashMap<>();
for (Account account : accountList) {
    Long roleId = account.getRoleId();
    Double total = Optional.ofNullable(roleTotalMap.get(roleId)).orElse(0.0D);
    roleTotalMap.put(roleId, total + account.getBalance());
}

精简

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

利用程序结构

返回条件表达式

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

普通

public boolean isSuper(Long userId) {
    UserDO user = userDAO.get(userId);
    if (Objects.nonNull(user) && Boolean.TRUE.equals(user.getIsSuper())) {
        return true;
    }
    return false;
}

精简

public boolean isSuper(Long userId) {
    UserDO user = userDAO.get(userId);
    return Objects.nonNull(user) && Boolean.TRUE.equals(user.getIsSuper());
}