工作四年，分享50个让你代码更好的小建议

/**
 * BigDecimal的工具类
 */
public class BigDecimalUtils {
 
    public static  BigDecimal 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. 函数不要过度封装，言简意赅即可。

「反例：」

// 函数封装
public static boolean isUserVip(Boolean isVip) { return Boolean.TRUE.equals(isVip);
}

// 使用代码
boolean isVip = isVip(user.getUserVip());

「正例：」

boolean isVip = Boolean.TRUE.equals(user.getUserVip());

函数不要过度封装，把意思表达清楚即可。并且，方法调用会引起入栈和出栈，导致消耗更多的CPU和内存，过度封装，会损耗性能的！

23. 如果变量的初值一定会被覆盖，就没有必要给变量赋初值。

「反例:」

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

「正例：」

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

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

看下这个浮点数计算的例子吧：

public class DoubleTest {
    public static void main(String[] args) {
        System.out.println(0.1+0.2);
        System.out.println(1.0-0.8);
        System.out.println(4.015*100);
        System.out.println(123.3/100);

        double amount1 = 3.15;
        double amount2 = 2.10; if (amount1 - amount2 == 1.05){
            System.out.println("OK");
        }
    }
}

运行结果：

0.30000000000000004
0.19999999999999996
401.49999999999994
1.2329999999999999

因为计算机是以二进制存储数值的，对于浮点数也是。对于计算机而言，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.asLis的时候，对原始数组的修改会影响到我们获得的那个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资源流

应该大家都有过这样的经历，windows系统桌面如果打开太多文件或者系统软件，就会觉得电脑很卡。当然，我们linux服务器也一样，平时操作文件，或者数据库连接，IO资源流如果没关闭，那么这个IO资源就会被它占着，这样别人就没有办法用了，这就造成资源浪费。

所以使用完IO流，记得关闭哈。可以使用try-with-resource关闭的：

/*
 * 关注公众号，捡田螺的小男孩
 */
try (FileInputStream inputStream = new FileInputStream(new File("jay.txt")) {
    // use resources   
} catch (FileNotFoundException e) {
    log.error(e);
} catch (IOException e) {
    log.error(e);
}

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 id limit #{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也是会有资源消耗的。

30. 修改对外老接口的时候，思考接口的兼容性。

很多bug都是因为修改了对外老接口，但是却不做兼容导致的。关键这个问题多数是比较严重的，可能直接导致系统发版失败的。新手程序员很容易就犯这个错误了哦~

所以，如果你的需求是在原来接口上修改，，尤其这个接口是对外提供服务的话，一定要考虑接口兼容。举个例子吧，比如dubbo接口，原本是只接收A，B参数，现在你加了一个参数C，就可以考虑这样处理。

//老接口
void oldService(A,B);{
  //兼容新接口，传个null代替C
  newService(A,B,null);
}

//新接口，暂时不能删掉老接口，需要做兼容。
void newService(A,B,C);

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() 强转的坑

public class ArrayListTest {
    public static void main(String[] args) {
        Listlist = new ArrayList(1);
        list.add("公众号：捡田螺的小男孩");
        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,同时考虑线程池是否隔离
		
		

			为什么优先使用线程池？使用线程池有这几点好处呀
		
		

			

				它帮我们管理线程，避免增加创建线程和销毁线程的资源损耗。
			
			

				提高响应速度。
			
			

				重复利用。
			
		
		

			同时呢，尽量不要所有业务都共用一个线程池，需要考虑线程池隔离。就是不同的关键业务，分配不同的线程池，然后线程池参数也要考虑恰当哈。之前写过几篇线程池的，觉得还不错，有兴趣的朋友可以看一下哈
		
		

			36. 优化程序结构，尽量减少方法的重复调用
		
		

			「反例：」
		
public static void listDetail(ListuserInfoList) { for (int i = 0; i < userInfoList.size(); i++) { //重复调用userList.size()方法了 } }
		

			「正例：」
		
public static void listDetail(ListuserInfoList) {
        int length = userInfoList.size(); for (int i = 0; i < length; i++) { //减少调用userList.size()方法，只在length变量调了一次。 } }
		

			37，直接大文件或者一次性从数据库读取太多数据到内存，可能导致OOM问题
		
		

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

			读取文件的话，一般文件不会太大，才使用Files.readAllLines()。为什么呢？因为它是直接把文件都读到内存的，预估下不会OOM才使用这个吧，可以看下它的源码：
		
public static ListreadAllLines(Path path, Charset cs) throws IOException {
    try (BufferedReader reader = newBufferedReader(path, cs)) {
        Listresult = 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 ListcopyMergeList(Listuser1List, Listuser2List) {
     ListuserList = new ArrayList<>(user1List.size() + user2List.size()); for (UserInfo user : user1List) {
         userList.add(user);
     } for (UserInfo user : user2List) {
         userList.add(user);
     } return user1List;
 }
		

			「正例：」
		
public ListcopyMergeList(Listuser1List, Listuser2List) {
     ListuserList = 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等都是线性安全的
			
		
		

			42. 使用spring事务功能时，注意这几个事务未生效的坑
		
		

			日常业务开发中，我们经常跟事务打交道，事务失效主要有以下几个场景：
		
		

			

				底层数据库引擎不支持事务
			
			

				在非public修饰的方法使用
			
			

				rollbackFor属性设置错误
			
			

				本类方法直接调用
			
			

				异常被try...catch吃了，导致事务失效。
			
		
		

			「反例：」
		
public class TransactionTest{
  public void A(){
    //插入一条数据
    //调用方法B (本地的类调用，事务失效了)
    B();
  }
  
  @Transactional
  public void B(){
    //插入数据
  }
}
		

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

			43. 使用Executors声明线程池，newFixedThreadPool的OOM问题
		
ExecutorService executor = Executors.newFixedThreadPool(10); for (int i = 0; i < Integer.MAX_VALUE; i++) { executor.execute(() -> {
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    //do nothing
                }
            });
        }
		

			IDE指定JVM参数：-Xmx8m -Xms8m
		
		

			运行结果：
		
 
		

			我们看下源码，其实newFixedThreadPool使用的是无界队列！
		
public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue());
}

public class LinkedBlockingQueueextends AbstractQueueimplements BlockingQueue, java.io.Serializable {
    ...
    /**
     * Creates a {@code LinkedBlockingQueue} with a capacity of
     * {@link Integer#MAX_VALUE}. */
    public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }
...
}
		

			 
			

				newFixedThreadPool线程池的核心线程数是固定的，它使用了近乎于无界的LinkedBlockingQueue阻塞队列。当核心线程用完后，任务会入队到阻塞队列，如果任务执行的时间比较长，没有释放，会导致越来越多的任务堆积到阻塞队列，最后导致机器的内存使用不停的飙升，造成JVM OOM。
			
 
		
		

			44. catch住异常后，尽量不要使用e.printStackTrace(),而是使用log打印。
		
		

			「反例：」
		
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 Vectororders = 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 Vectororders = 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(duringChristmas){
   img = redPacketChristmasSkin;
}else if(duringSpringFestival){
   img =  redSpringFestivalSkin;
}
		

			如果到了元宵节的时候，运营小姐姐突然又有想法，红包皮肤换成灯笼相关的，这时候，是不是要去修改代码了，重新发布了？从一开始，实现一张红包皮肤的配置表，将红包皮肤做成配置化呢？更换红包皮肤，只需修改一下表数据就好了。
		
		

			49，.直接迭代需要使用的集合,无须在额外操作
		
		

			直接迭代需要使用的集合，无需通过其它操作获取数据，比较典型就是Map的迭代遍历：
		
		

			「反例：」
		
Map userMap = ...; for (Long userId : userMap.keySet()) {
    UserDO user = userMap.get(userId);
    ...
}
		

			「正例：」
		
Map userMap = ...; for (Map.Entry userEntry : userMap.entrySet()) {
    Long userId = userEntry.getKey();
    UserDO user = userEntry.getValue();
    ...
}
		

			50. 策略模式+工厂方法优化冗余的if else
		
		

			「反例：」
		
String medalType = "guest"; if ("guest".equals(medalType)) {
        System.out.println("嘉宾勋章");
     } else if ("vip".equals(medalType)) {
        System.out.println("会员勋章");
    } else if ("guard".equals(medalType)) {
        System.out.println("展示守护勋章");
    }
    ...
		

			首先，我们把每个条件逻辑代码块，抽象成一个公共的接口，我们根据每个逻辑条件，定义相对应的策略实现类，可得以下代码：
		
//勋章接口
public interface IMedalService {
    void showMedal();
}

//守护勋章策略实现类
public class GuardMedalServiceImpl implements IMedalService {
    @Override
    public void showMedal() {
        System.out.println("展示守护勋章");
    }
}
//嘉宾勋章策略实现类
public class GuestMedalServiceImpl implements IMedalService {
    @Override
    public void showMedal() {
        System.out.println("嘉宾勋章");
    }
}
//VIP勋章策略实现类
public class VipMedalServiceImpl implements IMedalService {
    @Override
    public void showMedal() {
        System.out.println("会员勋章");
    }
}
		

			接下来，我们再定义策略工厂类，用来管理这些勋章实现策略类，如下：
		
//勋章服务工产类
public class MedalServicesFactory {

    private static final Map map = new HashMap<>();
    static {
        map.put("guard", new GuardMedalServiceImpl());
        map.put("vip", new VipMedalServiceImpl());
        map.put("guest", new GuestMedalServiceImpl());
    }
    public static IMedalService getMedalService(String medalType) { return map.get(medalType);
    }
}
		

			优化后，正例如下：
		
ublic class Test {
    public static void main(String[] args) {
        String medalType = "guest";
        IMedalService medalService = MedalServicesFactory.getMedalService(medalType);
        medalService.showMedal();
    }
}
		

			Reference
		
[1]
		

			Java编码技巧之高效代码50例: https://developer.aliyun.com/article/739987
		
 [2]
		

			写代码有这些想法，同事才不会认为你是复制粘贴程序员: https://juejin.cn/post/6844904033572896775
		
 [3]
		

			写代码有这16个好习惯，可以减少80%非业务的bug: https://juejin.cn/post/6899077803665260557#heading-12
		
 [4]
		

			Java日常开发的21个坑，你踩过几个？: https://juejin.cn/post/6910831193931923463#heading-31
		
 [5]
		

			if-else代码优化的八种方案: https://juejin.cn/post/6844904083665453063