本文转自阿里技术站,感谢阿里前辈提供的技术知识,微信关注 "阿里技术" 公众号即可实时学习。
1.常量&变量
1.1.直接赋值常量值,禁止声明新对象
直接赋值常量值,只是创建了一个对象引用,而这个对象引用指向常量值。
反例:
#错误方式:包装类声明对象并赋值 Long i = new Long(1L); String s = new String("abc");
正例:
#包装类直接赋值 Long i = 1L; String s = "abc";
1.2.当成员变量值无需改变时,尽量定义为静态常量
在类的每个对象实例中,每个成员变量都有一份副本,而成员静态常量只有一份实例。
反例:
#timeout为成员变量(常量),但是有一份副本 public class HttpConnection { private final long timeout = 5L; ... }
正例:
#如果是一个常量,我们不需要副本,即设置静态成员变量(常量)加载一次就好 public class HttpConnection { private static final long TIMEOUT = 5L; ... }
1.3.尽量使用基本数据类型,避免自动装箱和拆箱
Java 中的基本数据类型double、float、long、int、short、char、boolean,分别对应包装类Double、Float、Long、Integer、Short、Character、Boolean。
JVM支持基本类型与对应包装类的自动转换,被称为自动装箱和拆箱。装箱和拆箱都是需要CPU和内存资源的,所以应尽量避免使用自动装箱和拆箱。
反例:
#基本类型与包装类的自动转换是消耗CPU资源的,程序运行时会造成一定的cpu压力 Integer sum = 0; int[] values = ...; for (int value : values) { // 相当于result = Integer.valueOf(result.intValue() + value); sum += value; }
正例:
#确定好使用的类型,以免给cpu施压 int sum = 0; int[] values = ...; for (int value : values) { sum += value; }
1.4.如果变量的初值会被覆盖,就没有必要给变量赋初值
如果代码内会对变量的初值进行覆盖,那变量就不必赋予初值。
反例:
#代码运行时会覆盖userList,故无需赋予初值 List<UserDO> userList = new ArrayList<>(); if (isAll) { userList = userDAO.queryAll(); } else { userList = userDAO.queryActive(); }
正例:
#不需要赋予初值 List<UserDO> userList; if (isAll) { userList = userDAO.queryAll(); } else { userList = userDAO.queryActive(); }
1.5.尽量使用函数内的基本类型临时变量(#重点)
在函数内,基本类型的参数和临时变量都保存在栈(Stack)中,访问速度较快;对象类型的参数和临时变量的引用都保存在栈(Stack)中,内容都保存在堆(Heap)中,访问速度较慢。
在类中,任何类型的成员变量都保存在堆(Heap)中,访问速度较慢。
反例:
#result为类的成员变量,保存在堆中,访问较慢 public final class Accumulator { private double result = 0.0D; public void addAll(@NonNull double[] values) { for(double value : values) { result += value; } } ... }
正例:
#定义局部变量sum,只操作一次成员变量 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; } ... }
1.6.尽量不要在循环体外定义变量(#重点)
新版的JDK中已经做了优化,通过对编译后的字节码分析,变量定义在循环体外和循环体内没有本质的区别,运行效率基本上是一样的。
反而,根据“ 局部变量作用域最小化 ”原则,变量定义在循环体内更科学更便于维护,避免了延长大对象生命周期导致延缓回收问题 。
反例:
#userVO定义在循环体外,延长了对象的生命周期以致回收延缓 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定义在循环体内部 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); }
1.7.不可变的静态常量,尽量使用非线程安全类
不可变的静态常量,虽然需要支持多线程访问,也可以使用非线程安全类。
反例:
public static final Map<String, Class> CLASS_MAP; static {
#线程安全类 ConsurrentHashMap Map<String, Class> classMap = new ConcurrentHashMap<>(16); classMap.put("VARCHAR", java.lang.String.class); ... CLASS_MAP = Collections.unmodifiableMap(classMap); }
正例:
public static final Map<String, Class> CLASS_MAP; static { #使用非线程安全类 HashMap Map<String, Class> classMap = new HashMap<>(16); classMap.put("VARCHAR", java.lang.String.class); ... CLASS_MAP = Collections.unmodifiableMap(classMap); }
1.8.不可变的成员变量,尽量使用非线程安全类
不可变的成员变量,虽然需要支持多线程访问,也可以使用非线程安全类。
反例:
@Service public class StrategyFactory implements InitializingBean { @Autowired #成员变量List private List<Strategy> strategyList; private Map<String, Strategy> strategyMap; @Override public void afterPropertiesSet() { if (CollectionUtils.isNotEmpty(strategyList)) { #List的size没有变化 int size = (int) Math.ceil(strategyList.size() * 4.0 / 3); #可以不用线程安全类 Map<String, Strategy> map = new ConcurrentHashMap<>(size); for (Strategy strategy : strategyList) { map.put(strategy.getType(), strategy); } strategyMap = Collections.unmodifiableMap(map); } } ... }
正例:
@Service public class StrategyFactory implements InitializingBean { @Autowired private List<Strategy> strategyList; private Map<String, Strategy> strategyMap; @Override public void afterPropertiesSet() { if (CollectionUtils.isNotEmpty(strategyList)) { int size = (int) Math.ceil(strategyList.size() * 4.0 / 3); #可以用非线程安全类 Map<String, Strategy> map = new HashMap<>(size); for (Strategy strategy : strategyList) { map.put(strategy.getType(), strategy); } strategyMap = Collections.unmodifiableMap(map); } } ...
2.对象&类
2.1.禁止使用JSON转化对象
JSON提供把对象转化为JSON字符串、把JSON字符串转为对象的功能,于是被某些人用来转化对象。这种对象转化方式,虽然在功能上没有问题,但是在性能上却存在问题。
反例:
List<UserDO> userDOList = ...; #对象转化字符,转List List<UserVO> userVOList = JSON.parseArray(JSON.toJSONString(userDOList), UserVO.class);
正例:
List<UserDO> userDOList = ...; List<UserVO> userVOList = new ArrayList<>(userDOList.size()); #最基本的for循环转换 for (UserDO userDO : userDOList) { UserVO userVO = new UserVO(); userVO.setId(userDO.getId()); ... userVOList.add(userVO); }
2.2.尽量不使用反射赋值对象
用反射赋值对象,主要优点是节省了代码量,主要缺点却是性能有所下降。
反例:
List<UserDO> userDOList = ...; List<UserVO> userVOList = new ArrayList<>(userDOList.size()); for (UserDO userDO : userDOList) { UserVO userVO = new UserVO(); #映射复制新对象 BeanUtils.copyProperties(userDO, userVO); userVOList.add(userVO); }
正例:
List<UserDO> userDOList = ...; List<UserVO> userVOList = new ArrayList<>(userDOList.size()); #最基本的for循环 for (UserDO userDO : userDOList) { UserVO userVO = new UserVO(); userVO.setId(userDO.getId()); ... userVOList.add(userVO); }
2.3.采用Lambda表达式替换内部匿名类
大多数刚接触JDK8的同学来说,都会认为Lambda表达式就是匿名内部类的语法糖。实际上, Lambda表达式在大多数虚拟机中采用invokeDynamic指令实现,相对于匿名内部类在效率上会更高一些。
反例:
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); } });
正例:
List<User> userList = ...; Collections.sort(userList, (user1, user2) -> { Long userId1 = user1.getId(); Long userId2 = user2.getId(); ... return userId1.compareTo(userId2); });