AI智能
改变未来
当前位置：爱站程序员基地 > 全栈知识 > Java开发 > 正文

Java 代码精简之道 (上)

2021-06-06 分类：Java开发 评论(0)

1.利用语法

1.1.利用三元表达式

普通：

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

精简：

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

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

1.2.利用 for-each 语句

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

普通：

double[] values = ...;
for(int i = 0; i < values.length; i++) {
    double value = values[i];
    // TODO: 处理value
}
List<Double> valueList = ...;
Iterator<Double> iterator = valueList.iterator();
while (iterator.hasNext()) {
    Double value = iterator.next();
    // TODO: 处理value
}

精简：

double[] values = ...;
for(double value : values) {
    // TODO: 处理value
}

List<Double> valueList = ...;
for(Double value : valueList) {
    // TODO: 处理value
}


1.3.利用 try-with-resource 语句

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

普通：

BufferedReader reader = null;
try {
    reader = new BufferedReader(new FileReader(\"cities.csv\"));
    String line;
    while ((line = reader.readLine()) != null) {
        // TODO: 处理line
    }
} catch (IOException e) {
    log.error(\"读取文件异常\", e);
} finally {
    if (reader != null) {
        try {
            reader.close();
        } catch (IOException e) {
            log.error(\"关闭文件异常\", e);
        }
    }
}

精简：

try (BufferedReader reader = new BufferedReader(new FileReader(\"test.txt\"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        // TODO: 处理line
    }
} catch (IOException e) {
    log.error(\"读取文件异常\", e);
}


1.4.利用 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())) {
            return true;
        }
    }
    return false;
}

1.5.利用 static 关键字

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

普通：

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

精简：

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 表达式大量替代匿名内部类的使用，在简化了代码的同时，更突出了原有匿名内部类中真正有用的那部分代码。

普通：

new Thread(new Runnable() {
    public void run() {
        // 线程处理代码
    }
}).start();

精简：

new Thread(() -> {
    // 线程处理代码
}).start();

1.7.利用方法引用

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

普通：

Arrays.sort(nameArray, (a, b) -> a.compareToIgnoreCase(b));
List<Long> userIdList = userList.stream()
    .map(user -> user.getId())
    .collect(Collectors.toList());

精简：

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

1.8.利用静态导入

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

普通：

List<Double> areaList = radiusList.stream().map(r -> Math.PI * Math.pow(r, 2)).collect(Collectors.toList());
...

精简：

import static java.lang.Math.PI;
import static java.lang.Math.pow;
import static java.util.stream.Collectors.toList;

List<Double> areaList = radiusList.stream().map(r -> PI * pow(r, 2)).collect(toList());
...

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


1.9.利用 unchecked 异常

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

普通：

@Service
public class UserService {
    public void createUser(UserCreateVO create, OpUserVO user) throws BusinessException {
        checkOperatorUser(user);
        ...
    }
    private void checkOperatorUser(OpUserVO user) throws BusinessException {
        if (!hasPermission(user)) {
            throw new BusinessException(\"用户无操作权限\");
        }
        ...
    }
    ...
}

@RestController
@RequestMapping(\"/user\")
public class UserController {
    @Autowired
    private UserService userService;

    @PostMapping(\"/createUser\")
    public Result<Void> createUser(@RequestBody @Valid UserCreateVO create, OpUserVO user) throws BusinessException {
        userService.createUser(create, user);
        return Result.success();
    }
    ...
}

精简：

@Service
public class UserService {
    public void createUser(UserCreateVO create, OpUserVO user) {
        checkOperatorUser(user);
        ...
    }
    private void checkOperatorUser(OpUserVO user) {
        if (!hasPermission(user)) {
            throw new Busine***untimeException(\"用户无操作权限\");
        }
        ...
    }
    ...
}

@RestController
@RequestMapping(\"/user\")
public class UserController {
    @Autowired
    private UserService userService;

    @PostMapping(\"/createUser\")
    public Result<Void> createUser(@RequestBody @Valid UserCreateVO create, OpUserVO user) {
        userService.createUser(create, user);
        return Result.success();
    }
    ...
}

2.利用注解

2.1.利用 Lombok 注解

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

普通：

public class UserVO {
    private Long id;
    private String name;
    public Long getId() {
        return this.id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getName() {
        return this.name;
    }
    public void setName(String name) {
        this.name = name;
    }
    ...
}

普通：

@Getter
@Setter
@ToString
public class UserVO {
    private Long id;
    private String name;
    ...
}

2.2.利用 @NonNull 注解

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

普通：

public List<UserVO> queryCompanyUser(Long companyId) {
    // 检查公司标识
    if (companyId == null) {
        return null;
    }

    // 查询返回用户
    List<UserDO> userList = userDAO.queryByCompanyId(companyId);
    return userList.stream().map(this::transUser).collect(Collectors.toList());
}

Long companyId = 1L;
List<UserVO> userList = queryCompanyUser(companyId);
if (CollectionUtils.isNotEmpty(userList)) {
    for (UserVO user : userList) {
        // TODO: 处理公司用户
    }
}

精简：

public @NonNull List<UserVO> queryCompanyUser(@NonNull Long companyId) {
    List<UserDO> userList = userDAO.queryByCompanyId(companyId);
    return userList.stream().map(this::transUser).collect(Collectors.toList());
}

Long companyId = 1L;
List<UserVO> userList = queryCompanyUser(companyId);
for (UserVO user : userList) {
    // TODO: 处理公司用户
}


2.3.利用注解特性

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

1、当注解属性值跟默认值一致时，可以删除该属性赋值；2、当注解只有value属性时，可以去掉value进行简写；3、当注解属性组合等于另一个特定注解时，直接采用该特定注解。

普通：

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

精简：

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

3.利用泛型

3.1.泛型接口

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

普通：

public interface Comparable {
    public int compareTo(Object other);
}

@Getter
@Setter
@ToString
public class UserVO implements Comparable {
    private Long id;

    @Override
    public int compareTo(Object other) {
        UserVO user = (UserVO)other;
        return Long.compare(this.id, user.id);
    }
}

精简：

public interface Comparable<T> {
    public int compareTo(T other);
}

@Getter
@Setter
@ToString
public class UserVO implements Comparable<UserVO> {
    private Long id;

    @Override
    public int compareTo(UserVO other) {
        return Long.compare(this.id, other.id);
    }
}


3.2.泛型类

普通：

@Getter
@Setter
@ToString
public class IntPoint {
    private Integer x;
    private Integer y;
}

@Getter
@Setter
@ToString
public class DoublePoint {
    private Double x;
    private Double y;
}

精简：

@Getter
@Setter
@ToString
public class Point<T extends Number> {
    private T x;
    private T y;
}

3.3.泛型方法

普通：

public static Map<String, Integer> newHashMap(String[] keys, Integer[] values) {
    // 检查参数非空
    if (ArrayUtils.isEmpty(keys) || ArrayUtils.isEmpty(values)) {
        return Collections.emptyMap();
    }

    // 转化哈希映射
    Map<String, Integer> map = new HashMap<>();
    int length = Math.min(keys.length, values.length);
    for (int i = 0; i < length; i++) {
        map.put(keys[i], values[i]);
    }
    return map;
}
...

精简：

public static <K, V> Map<K, V> newHashMap(K[] keys, V[] values) {
    // 检查参数非空
    if (ArrayUtils.isEmpty(keys) || ArrayUtils.isEmpty(values)) {
        return Collections.emptyMap();
    }

    // 转化哈希映射
    Map<K, V> map = new HashMap<>();
    int length = Math.min(keys.length, values.length);
    for (int i = 0; i < length; i++) {
        map.put(keys[i], values[i]);
    }
    return map;
}

赞(0) 打赏
未经允许不得转载：爱站程序员基地 » Java 代码精简之道 (上)
标签：

相关推荐

热门文章

热门标签

源码 (2093)Java开发 (1438)Python开发 (1301)vps商家 (1289)阿里云盘 (1267)夸克网盘 (1255)Linux (1189)JavaScript (1119)PHP开发 (1058)计算机网络 (1055)MySQL (1015)Go语言 (985)UI/UE (975)CSS (970)人工智能 (933)Shell (930)安卓 (891)Android开发 (873)C# (861)ASP (815)网站架构 (798)IOS开发 (782)JQuery (759)Oracle (684)网络资源 (575)实用工具 (267)微信 (250)C语言/C++ (245)百度网盘 (208)github (132)