一. 常量&变量

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

在类的每个对象实例中，每个成员变量都有一份副本，而成员静态常量只有一份实例。

反例

<code>public class HttpConnection {    private final long timeout = 5L;    ...}/<code>

正例

<code>public class HttpConnection {    private static final long TIMEOUT = 5L;    ...}/<code>

1.2 尽量使用基本数据类型，避免自动装箱和拆箱

Java 中的基本数据类型double、float、long、int、short、char、boolean，分别对应包装类Double、Float、Long、Integer、Short、Character、Boolean。 JVM支持基本类型与对应包装类的自动转换，被称为自动装箱和拆箱。装箱和拆箱都是需要CPU和内存资源的，所以应尽量避免使用自动装箱和拆箱。

反例

<code>Integer sum = 0;int[] values = ...;for (int value : values) {    sum += value; // 相当于result = Integer.valueOf(result.intValue() + value);}/<code>

正例

<code>int sum = 0;int[] values = ...;for (int value : values) {    sum += value;}/<code>

1.3 如果变量的初值会被覆盖，就没有必要给变量赋初值

反例

<code>List<userdo> userList = new ArrayList<>();if (isAll) {    userList = userDAO.queryAll();} else {    userList = userDAO.queryActive();}/<userdo>/<code>

正例

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

1.4 尽量使用函数内的基本类型临时变量

在函数内，基本类型的参数和临时变量都保存在栈（Stack）中，访问速度较快；对象类型的参数和临时变量的引用都保存在栈（Stack）中，内容都保存在堆（Heap）中，访问速度较慢。在类中，任何类型的成员变量都保存在堆（Heap）中，访问速度较慢。

反例

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

正例

<code>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;    }    ...}/<code>

1.5 尽量不要在循环体外定义变量

在老版JDK中，建议“尽量不要在循环体内定义变量”，但是在新版的JDK中已经做了优化。通过对编译后的字节码分析，变量定义在循环体外和循环体内没有本质的区别，运行效率基本上是一样的。反而，根据“ 局部变量作用域最小化 ”原则，变量定义在循环体内更科学更便于维护，避免了延长大对象生命周期导致延缓回收问题 。

反例

<code>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);}/<uservo>/<userdo>/<code>

正例

<code>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);}/<uservo>/<userdo>/<code>

1.6不可变的静态常量，尽量使用非线程安全类

不可变的静态常量，虽然需要支持多线程访问，也可以使用非线程安全类。

反例

<code>public static final Map<string> CLASS_MAP;static {    Map<string> classMap = new ConcurrentHashMap<>(16);    classMap.put("VARCHAR", java.lang.String.class);    ...    CLASS_MAP = Collections.unmodifiableMap(classMap);}/<string>/<string>/<code>

正例

<code>public static final Map<string> CLASS_MAP;static {    Map<string> classMap = new HashMap<>(16);    classMap.put("VARCHAR", java.lang.String.class);    ...    CLASS_MAP = Collections.unmodifiableMap(classMap);}/<string>/<string>/<code>

1.7 不可变的成员变量，尽量使用非线程安全类

不可变的成员变量，虽然需要支持多线程访问，也可以使用非线程安全类。

反例

<code>@Servicepublic class StrategyFactory implements InitializingBean {    @Autowired    private List<strategy> strategyList;    private Map<string> strategyMap;    @Override    public void afterPropertiesSet() {        if (CollectionUtils.isNotEmpty(strategyList)) {            int size = (int) Math.ceil(strategyList.size() * 4.0 / 3);            Map<string> map = new ConcurrentHashMap<>(size);            for (Strategy strategy : strategyList) {                map.put(strategy.getType(), strategy);            }            strategyMap = Collections.unmodifiableMap(map);        }    }    ...}/<string>/<string>/<strategy>/<code>

正例

<code>@Servicepublic class StrategyFactory implements InitializingBean {    @Autowired    private List<strategy> strategyList;    private Map<string> strategyMap;    @Override    public void afterPropertiesSet() {        if (CollectionUtils.isNotEmpty(strategyList)) {            int size = (int) Math.ceil(strategyList.size() * 4.0 / 3);            Map<string> map = new HashMap<>(size);            for (Strategy strategy : strategyList) {                map.put(strategy.getType(), strategy);            }            strategyMap = Collections.unmodifiableMap(map);        }    }    ...}/<string>/<string>/<strategy>/<code>

二. 对象&类

2.1 禁止使用JSON转化对象

JSON提供把对象转化为JSON字符串、把JSON字符串转为对象的功能，于是被某些人用来转化对象。这种对象转化方式，虽然在功能上没有问题，但是在性能上却存在问题。

反例

<code>List<userdo> userDOList = ...;List<uservo> userVOList = JSON.parseArray(JSON.toJSONString(userDOList), UserVO.class);/<uservo>/<userdo>/<code>

正例

<code>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);}/<uservo>/<userdo>/<code>

2.2 采用Lambda表达式替换内部匿名类

对于大多数刚接触JDK8的同学来说，都会认为Lambda表达式就是匿名内部类的语法糖。实际上， Lambda表达式在大多数虚拟机中采用invokeDynamic指令实现，相对于匿名内部类在效率上会更高一些。

反例

<code>List<user> userList = ...;Collections.sort(userList, new Comparator<user>() {    @Override    public int compare(User user1, User user2) {        Long userId1 = user1.getId();        Long userId2 = user2.getId();        ...        return userId1.compareTo(userId2);    }});/<user>/<user>/<code>

正例

<code>List<user> userList = ...;Collections.sort(userList, (user1, user2) -> {    Long userId1 = user1.getId();    Long userId2 = user2.getId();    ...    return userId1.compareTo(userId2);});/<user>/<code>

为类指定final修饰符，可以让该类不可以被继承。如果指定了一个类为final，则该类所有的方法都是final的，Java编译器会寻找机会内联所有的final方法。内联对于提升Java运行效率作用重大，具体可参见Java运行期优化，能够使性能平均提高50%。

反例

<code>public class DateHelper {    ...}/<code>

正例

<code>public final class DateHelper {    ...}/<code>

注意：使用Spring的AOP特性时，需要对Bean进行动态代理，如果Bean类添加了final修饰，会导致异常。

Java程序员福利：金三银四，我把最近一年经历过的Java岗位面试，和一些刷过的面试题都做成了PDF，PDF都是可以免费分享给大家的，关注私信我：【101】，免费领取！

閱讀更多 Java架構師丨蘇先生 的文章

關鍵字: 码农 必备 程序员