如何让Java代码更优雅

第三方工具类

Stringutil collectionUtils

如何让Java代码更优雅

对象的判断

// 判断集合或map是否为空 
CollectionUtils.isEmpty(collection)和CollectionUtils.isNotEmpty(collection)
// 判断对象是否为null
Objects.isnull()

list频繁进行contains 操作 转换为Set 效率更高

ArrayList<Integer> list = otherService.getList();
Set<Integer> set = new HashSet(list);
for (int i = 0; i <= Integer.MAX_VALUE; i++) {
    // 时间复杂度O(1)
    set.contains(i);
}

当成员变量值无需改变时，尽量定义为静态常量

如果变量的初值会被覆盖，就没有必要给变量赋初值 ，方法是循环体除外

List<UserDO> userList;
if (isAll) {
    userList = userDAO.queryAll();
} else {
    userList = userDAO.queryActive();
}

局部变量最小化，避免了延长大对象生命周期导致延缓回收问题
UserVO userVO;
List<UserDO> userDOList = ...;
List<UserVO> userVOList = new ArrayList<>(userDOList.size());
for (UserDO userDO : userDOList) {
    userVO = new UserVO();
    userVO.setId(userDO.getId());
    ...
    userVOList.add(userVO);
}
正例
List<UserDO> userDOList = ...;
List<UserVO> userVOList = new ArrayList<>(userDOList.size());
for (UserDO userDO : userDOList) {
    UserVO userVO = new UserVO();
    userVO.setId(userDO.getId());
    ...
    userVOList.add(userVO);
}

尽量使用方法内的基本类型临时变量

public final class Accumulator {
    private double result = 0.0D;
    public void addAll(@NonNull double[] values) {
        for(double value : values) {
            result += value;
        }
    }
    ...
}
// 正例：
public final class Accumulator {
    private double result = 0.0D;
    public void addAll(@NonNull double[] values) {
        double sum = 0.0D;
        for(double value : values) {
            sum += value;
        }
        result += sum;
    }
    ...
}

尽量指定类的final修饰符

为类指定final修饰符，可以让该类不可以被继承。如果指定了一个类为final，则该类所有的方法都是final的，Java编译器会寻找机会内联所有的final方法

尽量使用基本数据类型作为方法参数类型，避免不必要的装箱、拆箱和空指针判断

尽量减少方法的重复调用

List<UserDO> userList = ...;
for (int i = 0; i < userList.size(); i++) {
    ...
}
// 正例
List<UserDO> userList = ...;
int userLength = userList.size();
for (int i = 0; i < userLength; i++) {
    ...
}

不要使用循环拷贝数组

尽量使用System.arraycopy拷贝数组推荐使用System.arraycopy拷贝数组，也可以使用Arrays.copyOf拷贝数组

int[] sources = new int[] {1, 2, 3, 4, 5};
int[] targets = new int[sources.length];
for (int i = 0; i < targets.length; i++) {
    targets[i] = sources[i];
}
// 正例
int[] sources = new int[] {1, 2, 3, 4, 5};
int[] targets = new int[sources.length];
System.arraycopy(sources, 0, targets, 0, targets.length);

在多线程中，尽量使用线程安全类

private volatile int counter = 0;
public void access(Long userId) {
    synchronized (this) {
        counter++;
    }
    ...
}
// 正例
private final AtomicInteger counter = new AtomicInteger(0);
public void access(Long userId) {
    counter.incrementAndGet();
    ...
}

尽量减少同步代码块范围

private volatile int counter = 0;
public synchronized void access(Long userId) {
  counter++;
    ... // 非同步操作
}

// 正例
private volatile int counter = 0;
public void access(Long userId) {
    synchronized (this) {
        counter++;
    }
    ... // 非同步操作
}

不要使用集合实现来赋值静态成员变量

private static Map<String, Integer> map = new HashMap<String, Integer>() {
    {
        put("a", 1);
        put("b", 2);
    }
};

private static List<String> list = new ArrayList<String>() {
    {
        add("a");
        add("b");
    }
};

// 正例 使用静态代码块 类初始化时就会完成赋值 ，如果使用代码块 ，每次new 对象时都会调用
private static Map<String, Integer> map = new HashMap<>();
static {
    map.put("a", 1);
    map.put("b", 2);
};

private static List<String> list = new ArrayList<>();
static {
    list.add("a");
    list.add("b");
};

建议使用 try-with-resources 语句

private void handle(String fileName) {
    BufferedReader reader = null;
    try {
        String line;
        reader = new BufferedReader(new FileReader(fileName));
        while ((line = reader.readLine()) != null) {
            ...
        }
    } catch (Exception e) {
        ...
    } finally {
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException e) {
                ...
            }
        }
    }
}


private void handle(String fileName) {
    try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
        String line;
        while ((line = reader.readLine()) != null) {
            ...
        }
    } catch (Exception e) {
        ...
    }
}

尽量避免在循环中捕获异常

禁止使用构造方法 BigDecimal(double) 会造成精度问题

BigDecimal value = new BigDecimal(0.1D); // 0.100000000000000005551115...


BigDecimal value = BigDecimal.valueOf(0.1D);; // 0.1

枚举的属性字段必须是私有不可变

入股能改变枚举值会发生变化

public enum UserStatus {
    DISABLED(0, "禁用"),
    ENABLED(1, "启用");

    private final int value;
    private final String description;

    private UserStatus(int value, String description) {
        this.value = value;
        this.description = description;
    }

    public int getValue() {
        return value;
    }

    public String getDescription() {
        return description;
    }
}

小心String.split(String regex)

"a.ab.abc".split("."); // 结果为[]
"a|ab|abc".split("|"); // 结果为["a", "|", "a", "b", "|", "a", "b", "c"]

// 部分字符需要转义
"a.ab.abc".split("\\."); // 结果为["a", "ab", "abc"]
"a|ab|abc".split("\\|"); // 结果为["a", "ab", "abc"]