java|分享Java代码的一些小建议，脱离小白——学会优化代码50个方案 mysql|编程语言

日常写代码要多思考，多总结，加油！！
文章图片

1. 仅仅判断是否存在时，select count 比 select 具体的列，更好。我们经常遇到类似的业务场景，如，判断某个用户userId是否是会员。
「（反例）：」一些小伙伴会这样实现，先查从用户信息表查出用户记录，然后再去判断是否是会员:

="selectUserByUserId" resultMap="BaseResultMap"> selct user_id , vip_flag fromuser_info where user_id =#{userId}; boolean isVip (String userId){ UserInfo userInfo = userInfoDAp.selectUserByUserId(userId); return UserInfo!=null && "Y".equals(userInfo.getVipFlag()) }

「（正例）：」针对这种业务场景，其实更好的实现，是直接select count一下，或者select limit 1如下：

="countVipUserByUserId" resultType="java.lang.Integer"> selct count(1) fromuser_info where user_id =#{userId} and vip_flag ='Y'; boolean isVip (String userId){ int vipNum = userInfoDAp.countVipUserByUserId(userId); return vipNum>0 }

2. 复杂的if逻辑条件，可以调整顺序，让程序更高效假设业务需求是这样：如果用户是会员，并且第一次登陆时，需要发一条通知的短信。假如没有经过思考，代码很可能直接这样写了。

if(isUserVip && isFirstLogin){ sendMsgNotify(); }

假设总共有5个请求进来，isUserVip通过的有3个请求，isFirstLogin通过的有1个请求。那么以上代码，isUserVip执行的次数为5次，isFirstLogin执行的次数也是3次，如下：

文章图片

如果调整一下isUserVip和isFirstLogin的顺序呢？

if(isFirstLogin && isUserVip ){ sendMsg(); }

isFirstLogin执行的次数是5次，isUserVip执行的次数是1次，如下：

文章图片

如果你的isFirstLogin，判断逻辑只是select count 一下数据库表，isUserVip也是select count 一下数据库表的话，显然，把isFirstLogin放在前面更高效。
3.写查询Sql的时候，只查你需要用到的字段，还有通用的字段，拒绝反手的select * 「反例：」

select * from user_info where user_id =#{userId};

「正例：」

select user_id , vip_flag fromuser_info where user_id =#{userId};

「理由：」
节省资源、减少网络开销。
可能用到覆盖索引，减少回表，提高查询效率。
4. 优化你的程序，拒绝创建不必要的对象如果你的变量，后面的逻辑判断，一定会被赋值；或者说，只是一个字符串变量，直接初始化字符串常量就可以了，没有必要愣是要new String().
反例：

String s = new String ("验证码错误");

正例：

String s="验证码错误”;

注：如果这个变量不会再变化了，可以单独写一个枚举类，或者Constant接口封装；（我个人喜欢用Constant接口）
枚举类：

/** * 登录验证枚举 * * @author OfsGroup */ @Getter @AllArgsConstructor public enum AuthWayEnum { /** * password */ PASSWORD("password", 1), /** * sms */ SMS("sms", 2); final String name; final int code; }

Constant接口：

public interface LawyerConstant { String KEY_PREFIX = "ofs:uac:user:sms:lawyer:register:"; String NO_USER = "没有该用户"; String NO_LAWYER = "没有该律师"; String NO_CODE = "验证码错误"; /** 状态 */ interface STATUS { /** 禁用*/ Integer DISABLE = 0; /**启用*/ Integer ENABLE= 1; /** 注销*/ Integer LOGOFF= 2; } }

5.初始化集合时，指定容量阿里的开发手册，也明确提到这个点：

文章图片

假设你的map要存储的元素个数是15个左右，最优写法如下：

//initialCapacity = 15/0.75+1=21 Map map = new HashMap(21);

又因为hashMap的容量跟2的幂有关，所以可以取32的容量

Map map = new HashMap(32);

6.catch了异常，需要打印出具体的exception，方便更好定位问题「反例：」

try{ // do something }catch(Exception e){ log.info("没有查询到数据"); }

「正例：」

try{ // do something }catch(Exception e){ throw new ServiceException("没有查询到数据，异常：",e); //把exception打印出来 }

7. 打印日志的时候，对象没有覆盖Object的toString的方法，直接把类名打印出来了。(当然，你要用断点看参数也行) 我们在打印日志的时候，经常想看下一个请求参数对象request是什么。于是很容易有类似以下这些代码：

publick Response dealWithRequest(Request request){ log.info("请求参数是：".request.toString) }

打印结果如下：

请求参数是：local.Request@49476842

这是因为对象的toString方法，默认的实现是“类名@散列码的无符号十六进制”。所以你看吧，这样子打印日志就没啥意思啦，你都不知道打印的是什么内容。
所以一般对象(尤其作为传参的对象），「都覆盖重写toString()方法」：

class Request {private String age; private String name; @Override public String toString() { return "Request{" + "age='" + age + '\'' + ", name='" + name + '\'' + '}'; } }publick Response dealWithRequest(Request request){ log.info("请求参数是：".request.toString) }

打印结果如下：

请求参数是：Request{age='23', name='gxl'}

8. 一个方法，拒绝过长的参数列表。假设有这么一个公有方法，形参有四个。。。

public void getUserInfo（String name,String age,String sex,String mobile){ // do something ... }

所以呢，一般一个方法的参数，一般不宜过长。过长的参数列表，不仅看起来不优雅，并且接口升级时，可能还要考虑新老版本兼容。如果参数实在是多怎么办呢？
不要犹豫，直接用DTO对象包装一下这些参数~如下：

public void getUserInfo（UserInfoParamDTO userInfoParamDTO){ // do something ... }class UserInfoParamDTO{ private String name; private String age; private String sex; private String mobile; }

用个DTO对象包装一下，即使后面有参数变动，也可以不用动对外接口了，好处杠杠的。
9. 使用缓冲流，减少IO操作「反例：」

/** *@desc: 复制一张图片文件 */ public class MainTest { public static void main(String[] args) throws FileNotFoundException { long begin = System.currentTimeMillis(); try (FileInputStream input = new FileInputStream("C:/456.png"); FileOutputStream output = new FileOutputStream("C:/789.png")) { byte[] bytes = new byte[1024]; int i; while ((i = input.read(bytes)) != -1) { output.write(bytes,0,i); } } catch (IOException e) { log.error("复制文件发生异常",e); } log.info("常规流读写，总共耗时ms："+(System.currentTimeMillis() - begin)); } }

运行结果：

常规流读写，总共耗时ms:52

使用FileInputStream、FileOutputStream实现文件读写功能，是没有什么问题的。但是呢，可以使用缓冲流BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream等，减少IO次数，提高读写效率。

?
如果是不带缓冲的流，读取到一个字节或者字符的，就会直接输出数据了。而带缓冲的流，读取到一个字节或者字符时，先不输出，而是等达到缓冲区的最大容量，才一次性输出。
?

「正例：」

/** *@desc: 复制一张图片文件 */ public class MainTest { public static void main(String[] args) throws FileNotFoundException { long begin = System.currentTimeMillis(); try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("C:/456.png")); BufferedOutputStreambufferedOutputStream = new BufferedOutputStream(new FileOutputStream("C:/789.png"))) { byte[] bytes = new byte[1024]; int i; while ((i = input.read(bytes)) != -1) { output.write(bytes,0,i); } } catch (IOException e) { log.error("复制文件发生异常",e); } log.info("总共耗时ms"+(System.currentTimeMillis() - begin)); } }

运行结果：

缓冲流读写，总共耗时ms:12

10. 优化你的程序逻辑，比如前面已经查到的数据，在后面的方法也用到的话，是可以把往下传参的，减少方法调用/查表「反例：」

public Response dealRequest(Request request){UserInfo userInfo = userInfoDao.selectUserByUserId(request.getUserId); if(Objects.isNull(request)){ return ; }insertUserVip(request.getUserId); }private int insertUserVip（String userId）{ //又查了一次 UserInfo userInfo = userInfoDao.selectUserByUserId(request.getUserId); //插入用户vip流水 insertUserVipFlow(userInfo); .... }

很显然，以上程序代码，已经查到
userInfo，然后又把userId传下去，又查多了一次。。。实际上，可以把userInfo传下去的，这样可以省去一次查表操作，程序更高效。

「正例：」

public Response dealRequest(Request request){UserInfo userInfo = userInfoDao.selectUserByUserId(request.getUserId); if(Objects.isNull(request)){ return ; }insertUserVip(userInfo); }private int insertUserVip（UserInfo userInfo）{ //插入用户vip流水 insertUserVipFlow(userInfo); .... }

11. 不要为了方便，直接在代码中使用0,1等魔法值，应该要用enum枚举代替。「反例：」

if("0".equals(userInfo.getVipFlag)){ //非会员，提示去开通会员 tipOpenVip(userInfo); }else if("1".equals(userInfo.getVipFlag)){ //会员，加勋章返回 addMedal（userInfo）; }

「正例：」

if(UserVipEnum.NOT_VIP.getCode.equals(userInfo.getVipFlag)){ //非会员，提示去开通会员 tipOpenVip(userInfo); }else if(UserVipEnum.VIP.getCode.equals(userInfo.getVipFlag)){ //会员，加勋章返回 addMedal（userInfo）; }@Getter /** * 是否为会员账号 */ public enum UserVipEnum {NOT_VIP("0","非会员"), VIP("1","会员"), ; private String code; private String desc; UserVipEnum(String code, String desc) { this.code = code; this.desc = desc; } }

写代码的时候，不要一时兴起，就直接使用魔法值哈。使用魔法值，维护代码起来很难受的。

12. 当成员变量值不会改变时，优先定义为静态常量「反例：」

public class Task { private final long timeout = 10L; ... }

「正例：」

public class Task { private static final long TIMEOUT = 10L; ... }

?
因为如果定义为static，即类静态常量，在每个实例对象中，它只有一份副本。如果是成员变量，每个实例对象中，都各有一份副本。显然，如果这个变量不会变的话，定义为静态常量更好一些。
?

13. 注意检验空指针，不要轻易相信业务，说正常逻辑某个参数不可能为空。

NullPointerException 在我们日常开发中非常常见，我们代码开发过程中，一定要对空指针保持灵敏的嗅觉。

主要有这几类空指针问题：

包装类型的空指针问题
级联调用的空指针问题
Equals方法左边的空指针问题
ConcurrentHashMap 类似容器不支持 k-v为null
集合，数组直接获取元素
对象直接获取属性

「反例：」

public class NullPointTest { public static void main(String[] args) { String s = null; if (s.equals("666")) { //s可能为空，会导致空指针问题 System.out.println(""); } } }

15. 采用Lambda表达式替换内部匿名类，使代码更优雅

JDK8出现了新特性-Lambda表达式。Lambda表达式不仅比匿名内部类更加优雅，并且在大多数虚拟机中，都是采用invokeDynamic指令实现，相对于匿名内部类，效率也更高

「反例：」

public void sortUserInfoList(List userInfoList){ userInfoList.sort(new Comparator() { @Override public int compare(UserInfo user1, UserInfo user2) { Long userId1 = user1.getUserId(); Long userId2 = user2.getUserId(); return userId1.compareTo(userId2); }}); }

「正例：」

public void sortUserInfoList(List userInfoList){ userInfoList.sort((user1, user2) -> { Long userId1 = user1.getUserId(); Long userId2 = user2.getUserId(); return userId1.compareTo(userId2); }); }

16. 通知类（如发邮件，有短信）的代码，建议异步处理。假设业务流程这样：需要在用户登陆时，添加个短信通知它的粉丝。很容易想到的实现流程如下：

文章图片

假设提供sendMsgNotify服务的系统挂了，或者调用sendMsgNotify失败了，那么用户登陆就失败了。。。一个通知功能导致了登陆主流程不可用，明显的捡了芝麻丢西瓜。那么有没有鱼熊掌兼得的方法呢？有的，给发短信接口捕获异常处理，或者另开线程异步处理，如下：

文章图片

因此，添加通知类等不是非主要，可降级的接口时，应该静下心来考虑是否会影响主要流程，思考怎么处理最好。
17. 处理Java日期时，当心YYYY格式设置的问题。日常开发中，我们经常需要处理日期。我们要当时日期格式化的时候，年份是大写YYYY的坑。

Calendar calendar = Calendar.getInstance(); calendar.set(2019, Calendar.DECEMBER, 31); Date testDate = calendar.getTime(); SimpleDateFormat dtf = new SimpleDateFormat("YYYY-MM-dd"); System.out.println("2019-12-31 转 YYYY-MM-dd 格式后 " + dtf.format(testDate));

运行结果：

2019-12-31 转 YYYY-MM-dd 格式后 2020-12-31

?
为什么明明是2019年12月31号，就转了一下格式，就变成了2020年12月31号了？因为YYYY是基于周来计算年的，它指向当天所在周属于的年份，一周从周日开始算起，周六结束，只要本周跨年，那么这一周就算下一年的了。正确姿势是使用yyyy格式。

18. 如果一个类确定不会被继承，不会拿来搞AOP骚操作，可以指定final修饰符，如用final修饰一个工具类。「正例：」

public final class Tools { public static void testFinal(){ System.out.println("工具类方法"); } }

一个类指定了final修饰符，它不会被继承了，并且其所有方法都是final的了。Java编译器会找机会内联所有的final方法，提升了Java运行效率。
19. static静态变量不要依赖spring实例化变量，可能会导致初始化出错之前看到项目有类似的代码。静态变量依赖于spring容器的bean。

private static SmsService smsService = SpringContextUtils.getBean(SmsService.class);

这个静态的smsService有可能获取不到的，因为类加载顺序不是确定的，而以上的代码，静态的smsService初始化强制依赖spring容器的实例了。正确的写法可以这样，如下：

private static SmsServicesmsService =null; //使用到的时候采取获取 public static SmsService getSmsService(){ if(smsService==null){ smsService = SpringContextUtils.getBean(SmsService.class); } return smsService; }

20. 与类成员变量无关的方法，应当声明成静态方法有些方法，与实例成员变量无关，就可以声明为静态方法。这一点，工具类用得很多。
「反例」：

/** * BigDecimal的工具类 */ public class BigDecimalUtils { publicBigDecimal ifNullSetZERO(BigDecimal in) { return in != null ？ in : BigDecimal.ZERO; } public BigDecimal sum(BigDecimal ...in){ BigDecimal result = BigDecimal.ZERO; for (int i = 0; i < in.length; i++){ result = result.add(ifNullSetZERO(in[i])); } return result; }

因为BigDecimalUtils工具类的方法都没有static修饰，所以，你要使用的时候，每次都要new一下啦,那不就耗资源去「反复创建对象」了嘛！！

BigDecimalUtils bigDecimalUtils = new BigDecimalUtils（）; bigDecimalUtils.sum(a,b);

所以可以声明成静态变量，使用的时候，直接类名.方法调用即可，正例如下：

/** * BigDecimal的工具类 */ public class BigDecimalUtils { public staticBigDecimal ifNullSetZERO(BigDecimal in) { return in != null ？ in : BigDecimal.ZERO; } public static BigDecimal sum(BigDecimal ...in){ BigDecimal result = BigDecimal.ZERO; for (int i = 0; i < in.length; i++){ result = result.add(ifNullSetZERO(in[i])); } return result; }

21. 不要用一个Exception捕捉所有可能的异常。「反例:」

public void test(){ try{ //…抛出 IOException 的代码调用 //…抛出 SQLException 的代码调用 }catch(Exception e){ //用基类 Exception 捕捉的所有可能的异常，如果多个层次都这样捕捉，会丢失原始异常的有效信息哦 log.info(“Exception in test,exception:{}”, e); } }

「正例：」

public void test(){ try{ //…抛出 IOException 的代码调用 //…抛出 SQLException 的代码调用 }catch(IOException e){ //仅仅捕捉 IOException log.info(“IOException in test,exception:{}”, e); }catch(SQLException e){ //仅仅捕捉 SQLException log.info(“SQLException in test,exception:{}”, e); } }

22.关于大家认为最简单的i++和++i; 很多人包括我在内以前都是认为++i是先自增再赋值，i++是先赋值再自增的；其实不是这样子的，其实不管i++还是++i都是先自增再赋值的，那为什么++i可以输出计算后的值呢，这就要考虑到i++的一个逻辑了，它是先创建了一个临时变量存放返回的值，再就行计算，下面是它的逻辑代码；

int temp = i; i = i + 1; return temp;

证明以及更详细的i++及++i可以看这个博客：https://blog.csdn.net/android_cai_niao/article/details/106027313
23. 如果变量的初值一定会被覆盖，就没有必要给变量赋初值。「反例:」

List userList = new ArrayList<>(); if (isAll) { userList = userInfoDAO.queryAll(); } else { userList = userInfoDAO.queryActive(); }

「正例：」

List userList ; if (isAll) { userList = userInfoDAO.queryAll(); } else { userList = userInfoDAO.queryActive(); }

24.金额数值计算要使用BigDecimal

?
因为计算机是以二进制存储数值的，对于浮点数也是。对于计算机而言，0.1无法精确表达，这就是为什么浮点数会导致精确度缺失的。因此，金额计算，一般都是用BigDecimal
类型 ?

System.out.println(new BigDecimal(0.1).add(new BigDecimal(0.2)));

//output: 0.3000000000000000166533453693773481063544750213623046875

其实，使用 BigDecimal 表示和计算浮点数，必须使用字符串的构造方法来初始化 BigDecimal，并且，还要关注BigDecimal的几位小数点，它有八种舍入
模式等
25. 注意Arrays.asList的几个坑

「基本类型不能作为 Arrays.asList方法的参数，否则会被当做一个参数。」

public class ArrayAsListTest { public static void main(String[] args) { int[] array = {1, 2, 3}; List list = Arrays.asList(array); System.out.println(list.size()); } }

//运行结果

1

「Arrays.asList 返回的 List 不支持增删操作。」

public class ArrayAsListTest { public static void main(String[] args) { String[] array = {"1", "2", "3"}; List list = Arrays.asList(array); list.add("5"); System.out.println(list.size()); } }

// 运行结果

Exception in thread "main" java.lang.UnsupportedOperationException at java.util.AbstractList.add(AbstractList.java:148) at java.util.AbstractList.add(AbstractList.java:108) at object.ArrayAsListTest.main(ArrayAsListTest.java:11)

Arrays.asList 返回的 List 并不是我们期望的 java.util.ArrayList，而是 Arrays 的内部类ArrayList。内部类的ArrayList没有实现add方法，而是父类的add方法的实现，是会抛出异常的呢。

「使用Arrays.asList的时候，对原始数组的修改会影响到我们获得的那个List」

public class ArrayAsListTest { public static void main(String[] args) { String[] arr = {"1", "2", "3"}; List list = Arrays.asList(arr); arr[1] = "4"; System.out.println("原始数组"+Arrays.toString(arr)); System.out.println("list数组" + list); } }

//运行结果

原始数组[1, 4, 3] list数组[1, 4, 3]

26，及时关闭IO资源流

try{ …… …… XXX.close(); // use resources } catch (FileNotFoundException e1) { log.error(e1); } catch (IOException e2) { log.error(e2); }

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

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

public class AccumulatorUtil {private double result = 0.0D; //反例 public void addAllOne( double[] values) { for(double value : values) { result += value; } } //正例，先在方法内声明一个局部临时变量，累加完后，再赋值给方法外的成员变量 public void addAl1Two(double[] values) { double sum = 0.0D; for(double value : values) { sum += value; } result += sum; } }

28. 如果数据库一次查询的数量过多，建议分页处理。如果你的Sql一次性查出来的数据量比较多，建议分页处理。
「反例：」

select user_id,name,age from user_info ;

「正例：」

select user_id,name,age from user_info limit #{offset},#{pageSize};

如果偏移量特别大的时候，查询效率就变得低下。可以这接种方式优化：

//方案一：返回上次查询的最大记录(偏移量) select id，name from user_info where id>10000 limit #{pageSize}.

//方案二：order by + 索引 select id，name from user_info order by idlimit #{offset},#{pageSize}

29. 尽量减少对变量的重复计算一般我们写代码的时候，会以以下的方式实现遍历：

for (int i = 0; i < list.size; i++){}

如果list数据量比较小那还好。如果list比较大时，可以优化成这样：

for (int i = 0,length = list.size; i < length; i++){}

理由：
对方法的调用，即使是只有一个语句，也是有有消耗的，比如创建栈帧。如果list比较大时，多次调用list.size也是会有资源消耗的。
31 代码采取措施避免运行时错误（如数组边界溢出，被零除等）日常开发中，我们需要采取措施规避数组边界溢出，被零整除，空指针等运行时错误。
类似代码比较常见:

String name = list.get(1).getName(); //list可能越界，因为不一定有2个元素哈

所以，应该采取措施，预防一下数组边界溢出，「正例：」

if(CollectionsUtil.isNotEmpty(list)&& list.size()>1){ String name = list.get(1).getName(); }

32. 注意 ArrayList.toArray() 强转的坑

String[] array21 = (String[])list.toArray(); //类型转换异常

因为返回的是Object类型，Object类型数组强转String数组，会发生ClassCastException。解决方案是，使用toArray()重载方法toArray(T[] a)

String[] array1 = list.toArray(new String[0]); //可以正常运行

33. 尽量不在循环里远程调用、或者数据库操作，优先考虑批量进行。远程调用操作或者数据库操作都是比较耗网络、IO资源的，所以尽量不在循环里远程调用、不在循环里操作数据库，能批量一次性查回来尽量不要循环多次去查。（但是呢，也不要一次性查太多数据哈，要分批500一次酱紫）
「正例：」

remoteBatchQuery(param);

「反例：」

for(int i=0; i



 
34. 写完代码，脑洞一下多线程执行会怎样，注意并发一致性问题 我们经常见的一些业务场景，就是先查下有没有记录，再进行对应的操作（比如修改）。但是呢，(查询+修改)合在一起不是原子操作哦，脑洞下多线程，就会发现有问题了，

 「反例：」

 
if(isAvailable(ticketId){//非原子操作 
1、给现金增加操作 
2、deleteTicketById(ticketId) 
}else{ 
return "没有可用现金券";

}


 为了更容易理解它，看这个流程吧：

 1.线程A加现金
 2.线程B加现金
 3.线程A删除票标志
 4.线程B删除票标志
 显然这样存在并发问题，正例应该利用数据库删除操作的原子性，如下：

 
if(deleteAvailableTicketById(ticketId) == 1){ //原子操作
1、给现金增加操作 
}else{ 
return “没有可用现金券” 
}


 
35 多线程异步优先考虑恰当的线程池，而不是new thread,同时考虑线程池是否隔离 为什么优先使用线程池？使用线程池有这几点好处呀

 
 它帮我们管理线程，避免增加创建线程和销毁线程的资源损耗。
 提高响应速度。
 重复利用。

 
 同时呢，尽量不要所有业务都共用一个线程池，需要考虑线程池隔离。就是不同的关键业务，分配不同的线程池，然后线程池参数也要考虑恰当哈。

 
37，直接大文件或者一次性从数据库读取太多数据到内存，可能导致OOM问题 如果一次性把大文件或者数据库太多数据达到内存，是会导致OOM的。所以，为什么查询DB数据库，一般都建议分批。

 读取文件的话，一般文件不会太大，才使用Files.readAllLines()。为什么呢？因为它是直接把文件都读到内存的，预估下不会OOM才使用这个吧，可以看下它的源码：

 
public static List readAllLines(Path path, Charset cs) throws IOException {
try (BufferedReader reader = newBufferedReader(path, cs)) {
List result = new ArrayList<>();

for (;
;
) {
String line = reader.readLine();

if (line == null)
break;

result.add(line);

}
return result;

}
}


 如果是太大的文件，可以使用Files.line()按需读取，当时读取文件这些，一般是使用完需要关闭资源流的哈。

 
38. 调用第三方接口，需要考虑异常处理，安全性，超时重试这几个点。 日常开发中，经常需要调用第三方服务，或者分布式远程服务的的话，需要考虑：

 
 异常处理（比如，你调别人的接口，如果异常了，怎么处理，是重试还是当做失败）
 超时（没法预估对方接口一般多久返回，一般设置个超时断开时间，以保护你的接口）
 重试次数（你的接口调失败，需不需要重试，需要站在业务上角度思考这个问题）

 
 简单一个例子，你一个http请求调别人的服务，需要考虑设置connect-time，和retry次数。

 
39 不要使用循环拷贝集合，尽量使用JDK提供的方法拷贝集合 
 ? JDK提供原生API方法，可以直接指定集合的容量，避免多次扩容损耗性能。
 这些方法的底层调用System.arraycopy方法实现，进行数据的批量拷贝效率更高。 ?

 
 「反例：」

 
public List copyMergeList(List user1List, List user2List) {
List userList = new ArrayList<>(user1List.size() + user2List.size());

for (UserInfo user : user1List) {
userList.add(user);

}
for (UserInfo user : user2List) {
userList.add(user);

}return user1List;

 }


 「正例：」

 
public List copyMergeList(List user1List, List user2List) {
List userList = new ArrayList<>(user1List.size() + user2List.size());

userList.addAll(user1List);

userList.addAll(user2List);

return user1List;

 }


 
40. 对于复杂的代码逻辑，添加清楚的注释 写代码的时候，是没有必要写太多的注释的，好的方法变量命名就是最好的注释。但是，如果是业务逻辑很复杂的代码，真的非常有必要写清楚注释。清楚的注释，更有利于后面的维护。

 
41. 多线程情况下，考虑线性安全问题 在高并发情况下，HashMap可能会出现死循环。因为它是非线性安全的，可以考虑使用ConcurrentHashMap。所以这个也尽量养成习惯，不要上来反手就是一个new HashMap();


 
 Hashmap、Arraylist、LinkedList、TreeMap等都是线性不安全的；
 Vector、Hashtable、ConcurrentHashMap等都是线性安全的；
 这个我以前考虑过了，感觉如果自己不想麻烦的话，直接使用ConcurrentHashMap是最好的；

 
 
42. 使用spring事务功能时，注意这几个事务未生效的坑 日常业务开发中，我们经常跟事务打交道，事务失效主要有以下几个场景：

 
 底层数据库引擎不支持事务
 在非public修饰的方法使用
 rollbackFor属性设置错误
 本类方法直接调用
 异常被try…catch吃了，导致事务失效。

 
 「反例：」

 
public class TransactionTest{
public void A(){
//插入一条数据
//调用方法B (本地的类调用，事务失效了)
B();

}@Transactional
public void B(){
//插入数据
}
}


 「注解的事务方法给本类方法直接调用，事务失效」

 
44. catch住异常后，尽量不要使用e.printStackTrace(),而是使用log打印。 【java|分享Java代码的一些小建议，脱离小白——学会优化代码50个方案】「反例：」

 
try{
// do what you want
}catch(Exception e){
e.printStackTrace();

}


 「正例：」

 
try{
// do what you want
}catch(Exception e){
log.info("你的程序有异常啦",e);

}


 
45. 接口需要考虑幂等性 接口是需要考虑幂等性的，尤其抢红包、转账这些重要接口。最直观的业务场景，就是用户连着点两次，你的接口有没有hold住。

 一般幂等技术方案有这几种:

 
 查询操作
 唯一索引
 token机制，防止重复提交
 数据库的delete/update操作
 乐观锁
 悲观锁
 Redis、zookeeper
 分布式锁（以前抢红包需求，用了Redis分布式锁）
 状态机幂等

 
 
46. 对于行数比较多的函数，建议划分小函数，增强可读性。 「反例：」

 
public class Test {
private String name;

private Vector orders = new Vector();
public void printOwing() {
//print banner
System.out.println("****************");

System.out.println("*****customer Owes *****");

System.out.println("****************");
//calculate totalAmount
Enumeration env = orders.elements();

double totalAmount = 0.0;

while (env.hasMoreElements()) {
Order order = (Order) env.nextElement();

totalAmount += order.getAmout();

}//print details
System.out.println("name:" + name);

System.out.println("amount:" + totalAmount);

}
}


 「正例：」

 
public class Test {
private String name;

private Vector orders = new Vector();
public void printOwing() {//print banner
printBanner();

//calculate totalAmount
double totalAmount = getTotalAmount();

//print details
printDetail(totalAmount);

}void printBanner(){
System.out.println("****************");

System.out.println("*****customer Owes *****");

System.out.println("****************");

}double getTotalAmount(){
Enumeration env = orders.elements();

double totalAmount = 0.0;

while (env.hasMoreElements()) {
Order order = (Order) env.nextElement();

totalAmount += order.getAmout();

}
return totalAmount;

}void printDetail(double totalAmount){
System.out.println("name:" + name);

System.out.println("amount:" + totalAmount);

}}


 一个过于冗长的函数或者一段需要注释才能让人理解用途的代码，可以考虑把它切分成一个功能明确的函数单元，并定义清晰简短的函数名，这样会让代码变得更加优雅。

 
47. 你的关键业务代码，一般建议搞点日志保驾护航。 关键业务代码无论身处何地，都应该有足够的日志保驾护航。

 比如：你实现转账业务，转个几百万，然后转失败了，接着客户投诉，然后你还没有打印到日志，想想那种水深火热的困境下，你却毫无办法。。。

 那么，你的转账业务都需要那些日志信息呢？至少，方法调用前，入参需要打印需要吧，接口调用后，需要捕获一下异常吧，同时打印异常相关日志吧，如下：

 
public void transfer(TransferDTO transferDTO){
log.info("invoke tranfer begin");

//打印入参
log.info("invoke tranfer,paramters:{}",transferDTO);

try {
res=transferService.transfer(transferDTO);

}catch(Exception e){
log.error("transfer fail,cifno:{}，account：{}",transferDTO.getCifno（），
transferDTO.getaccount（）)
log.error("transfer fail,exception:{}",e);

}
log.info("invoke tranfer end");

}


 除了打印足够的日志，我们还需要注意一点是，日志级别别混淆使用，别本该打印info的日志，你却打印成error级别，告警半夜三更催你起来排查问题就不好了。

 
48.if-else的优化方案 这里我推荐使用map集合，工厂模式，枚举类
 我还没有研究好所有的，看到这里的小伙伴可以直接按照标题搜索学习QAQ

 
 有兴趣的小伙伴可以看这个博客： if-else的八种策略
 https://blog.csdn.net/qq_45401061/article/details/104718289

 
 
49、多余的import 类，局部变量，没引用是不是应该删除 如果看到代码存在没使用的import 类，没被使用到的局部变量等，就删掉吧，如下这些：

 这些没被引用的局部变量，如果没被使用到，就删掉吧，它又不是陈年的女儿红，留着会越发醇香。它还是会一起被编译的，就是说它还是耗着资源的呢。
  

文章图片 



 
50.我觉得看到这里你们心里面肯定要有自己的思考，自己在实际开发中有那些代码需要优化的 
你们也可以记录下来


 注：本文部分摘抄自公众号：捡田螺的小男孩


		  	

    
    




    
    
    


推荐阅读

           
                  
              
                  如何使用JavaScript/jQuery创建自动调整textarea的大小（） 
                
                   
                
              
            

                  
              
                  你马上能想到的日本女星是谁？ 
                
                   
                
              
            

                  
              
                  CC气垫在护肤品什么时候用 
                
                   
                
              
            

                  
              
                  老年夫妻每个月都要互相检查皮肤吗？ 
                
                   
                
              
            

                  
              
                  光电子 股票000050深天马，股票000开头是什么板块 
                
                   
                
              
            

                  
              
                  ug按某一距离创建基准平面的方法 
                
                   
                
              
            

                  
              
                  Machine|scikit-learn-分类模型评价标准 
                
                   
                
              
            

                  
              
                  怎么画灯笼好看又简单 
                
                   
                
              
            

                  
              
                  科二右倒库最好记的方法 
                
                   
                
              
            

                  
              
                  遥感主成分分析应用,主成分分析在经济问题中的应用 
                
                   
                
              
            

                  
              
                  wps怎么一次性查找多个 
                
                   
                
              
            

                  
              
                  凤求凰夫妇返场,价值2676点券,值不值得入手？ 
                
                   
                
              
            

                  
              
                  四季养生食谱煲汤大全 江浙地区四季养生食谱 
                
                   
                
              
            

                  
              
                  冬枣|关于“吃”的8个真相，据说只有5％的吃货能全部答对！ 
                
                   
                
              
            

                  
              
                  请问什么人不能喝樱桃酒 
                
                   
                
              
            

                  
              
                  缴款通知书号码怎么查 缴款账号名称哪里修改，账户名称与缴款单位名称不符 
                
                   
                
              
            

                  
              
                  左心房右心室是什么意思 
                
                   
                
              
            

                  
              
                  如何区分光电鼠标和激光鼠标 怎么区分光电鼠标和激光鼠标 
                
                   
                
              
            

                  
              
                  Redis需要安装吗 redis需要make 
                
                   
                
              
            

                  
              
                  Redis如何实现持久化? 
                
                   
                
              
            

          

mysql|mysql（InnoDB的主键采用聚簇索引，二级索引不采用聚簇索引） 
 微服务|RabbitMQ之消息可靠性、死信交换机、惰性队列及集群 
 研发管理|学习笔记(06):21天搞定分布式Python网络爬虫-爬虫前奏小结和作业 
 研发管理|学习笔记（47):150讲轻松搞定Python网络爬虫-爬虫前奏小结和作业 
 java|iOS 高刷屏监控 + 优化（从理论到实践全面解析） 
 大数据|一次关于架构的“嘴炮” 
 大数据|自动拦截 50% crash，字节自研 Fastbot 如何助力今日头条稳定性测试 
 c++|一文读懂 Android FFmpeg 视频解码过程与实战分析 
 java|【Rust日报】2022-03-21 Firefox 现在约 10% 的代码为 Rust