工作四年，分享50個讓你代碼更好的小建議

前言

工作四年，看過很多思考不夠深入的代碼，因此寫一下總結(jié)吧，50個讓你代碼更好的小建議。其中的一些點，我以前的文章也寫過啦，這次主要匯總一下。希望大家日常寫代碼多點思考，多點總結(jié)，加油！同時哪里有不對的，也望指出，感謝哈~

• 公眾號：「撿田螺的小男孩」

1. 僅僅判斷是否存在時，select count 比 select 具體的列，更好。

我們經(jīng)常遇到類似的業(yè)務(wù)場景，如，判斷某個用戶userId是否是會員。

「（反例）：」  一些小伙伴會這樣實現(xiàn)，先查從用戶信息表查出用戶記錄，然后再去判斷是否是會員:

<select id="selectUserByUserId" resultMap="BaseResultMap">
     selct user_id , vip_flag from  user_info where user_id =#{userId};
 </select>

boolean isVip (String userId){
 UserInfo userInfo = userInfoDAp.selectUserByUserId(userId);
 return UserInfo!=null && "Y".equals(userInfo.getVipFlag())
}

「（正例）：」 針對這種業(yè)務(wù)場景，其實更好的實現(xiàn)，是直接select count一下，或者select limit 1如下：

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

2. 復(fù)雜的if邏輯條件，可以調(diào)整順序，讓程序更高效

假設(shè)業(yè)務(wù)需求是這樣：如果用戶是會員，并且第一次登陸時，需要發(fā)一條通知的短信。假如沒有經(jīng)過思考，代碼很可能直接這樣寫了。

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

假設(shè)總共有5個請求進來，isUserVip通過的有3個請求，isFirstLogin通過的有1個請求。那么以上代碼，isUserVip執(zhí)行的次數(shù)為5次，isFirstLogin執(zhí)行的次數(shù)也是3次，如下：

如果調(diào)整一下isUserVip和isFirstLogin的順序呢？

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

isFirstLogin執(zhí)行的次數(shù)是5次，isUserVip執(zhí)行的次數(shù)是1次，如下：

如果你的isFirstLogin，判斷邏輯只是select count 一下數(shù)據(jù)庫表，isUserVip也是select count 一下數(shù)據(jù)庫表的話，顯然，把isFirstLogin放在前面更高效。

3. 寫查詢Sql的時候，只查你需要用到的字段，還有通用的字段，拒絕反手的select *

「反例：」

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

「正例：」

 select user_id , vip_flag from  user_info where user_id =#{userId};

「理由：」

• 節(jié)省資源、減少網(wǎng)絡(luò)開銷。
• 可能用到覆蓋索引，減少回表，提高查詢效率。

4. 優(yōu)化你的程序，拒絕創(chuàng)建不必要的對象

如果你的變量，后面的邏輯判斷，一定會被賦值；或者說，只是一個字符串變量，直接初始化字符串常量就可以了，沒有必要愣是要new String().

反例：

String s = new String ("歡迎關(guān)注公眾號：撿田螺的小男孩");

正例：

String s=  "歡迎關(guān)注公眾號：撿田螺的小男孩 ”;

5. 初始化集合時，指定容量

阿里的開發(fā)手冊，也明確提到這個點：

假設(shè)你的map要存儲的元素個數(shù)是15個左右，最優(yōu)寫法如下

 //initialCapacity = 15/0.75+1=21
 Map map = new HashMap(21);
 
 又因為hashMap的容量跟2的冪有關(guān)，所以可以取32的容量
 Map map = new HashMap(32);

6.catch了異常，需要打印出具體的exception，方便更好定位問題

「反例：」

try{
  // do something
}catch(Exception e){
  log.info("撿田螺的小男孩，你的程序有異常啦");
}

「正例：」

try{
  // do something
}catch(Exception e){
  log.info("撿田螺的小男孩，你的程序有異常啦：",e); //把exception打印出來
}

「理由：」

• 反例中，并沒有把exception出來，到時候排查問題就不好查了啦，到底是SQl寫錯的異常還是IO異常，還是其他呢？所以應(yīng)該把exception打印到日志中哦~

7. 打印日志的時候，對象沒有覆蓋Object的toString的方法，直接把類名打印出來了。

我們在打印日志的時候，經(jīng)常想看下一個請求參數(shù)對象request是什么。于是很容易有類似以下這些代碼：

publick Response dealWithRequest(Request request){
   log.info("請求參數(shù)是：".request.toString)
}

打印結(jié)果如下：

請求參數(shù)是：local.Request@49476842

這是因為對象的toString方法，默認(rèn)的實現(xiàn)是“類名@散列碼的無符號十六進制”。所以你看吧，這樣子打印日志就沒啥意思啦，你都不知道打印的是什么內(nèi)容。

所以一般對象(尤其作為傳參的對象），「都覆蓋重寫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("請求參數(shù)是：".request.toString)
}

打印結(jié)果如下：

請求參數(shù)是：Request{age='26', name='公眾號：撿田螺的小男孩'}

8. 一個方法，拒絕過長的參數(shù)列表。

假設(shè)有這么一個公有方法，形參有四個。。。

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

如果現(xiàn)在需要多傳一個version參數(shù)進來，并且你的公有方法是類似dubbo這種對外提供的接口的話，那么你的接口是不是需要兼容老版本啦？

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

/**
 * 新接口調(diào)這里
 */
public void getNewUserInfo（String name,String age,String sex,String mobile，String version){
  // do something ...
}

所以呢，一般一個方法的參數(shù)，一般不宜過長。過長的參數(shù)列表，不僅看起來不優(yōu)雅，并且接口升級時，可能還要考慮新老版本兼容。如果參數(shù)實在是多怎么辦呢？可以用個DTO對象包裝一下這些參數(shù)呢~如下：

public void getUserInfo（UserInfoParamDTO userInfoParamDTO){
  // do something ...
}

class UserInfoParamDTO{
  private String name;
  private String age; 
  private String sex;
  private String mobile;
}

用個DTO對象包裝一下，即使后面有參數(shù)變動，也可以不用動對外接口了，好處杠杠的。

9. 使用緩沖流，減少IO操作

「反例：」

/**
 *  公眾號：撿田螺的小男孩
 *  @desc: 復(fù)制一張圖片文件
 */
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("復(fù)制文件發(fā)生異常",e);
        }
        log.info("常規(guī)流讀寫，總共耗時ms："+(System.currentTimeMillis() - begin));
    }
}

運行結(jié)果：

常規(guī)流讀寫，總共耗時ms:52

使用FileInputStream、FileOutputStream實現(xiàn)文件讀寫功能，是沒有什么問題的。但是呢，可以使用緩沖流BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream等，減少IO次數(shù)，提高讀寫效率。

?

如果是不帶緩沖的流，讀取到一個字節(jié)或者字符的，就會直接輸出數(shù)據(jù)了。而帶緩沖的流，讀取到一個字節(jié)或者字符時，先不輸出，而是等達到緩沖區(qū)的最大容量，才一次性輸出。

?

「正例：」

/**
 *  公眾號：撿田螺的小男孩
 *  @desc: 復(fù)制一張圖片文件
 */
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"));
        BufferedOutputStream  bufferedOutputStream = 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("復(fù)制文件發(fā)生異常",e);
        }
        log.info("總共耗時ms"+(System.currentTimeMillis() - begin));
    }
}

運行結(jié)果：

緩沖流讀寫，總共耗時ms:12

10. 優(yōu)化你的程序邏輯，比如前面已經(jīng)查到的數(shù)據(jù)，在后面的方法也用到的話，是可以把往下傳參的，減少方法調(diào)用/查表

「反例：」

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);
      ....
}

很顯然，以上程序代碼，已經(jīng)查到 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等魔法值，應(yīng)該要用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）;
}

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. 當(dāng)成員變量值不會改變時，優(yōu)先定義為靜態(tài)常量

「反例：」

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

「正例：」

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

?

因為如果定義為static，即類靜態(tài)常量，在每個實例對象中，它只有一份副本。如果是成員變量，每個實例對象中，都各有一份副本。顯然，如果這個變量不會變的話，定義為靜態(tài)常量更好一些。

?

13. 注意檢驗空指針，不要輕易相信業(yè)務(wù)，說正常邏輯某個參數(shù)不可能為空。

NullPointerException 在我們?nèi)粘ｉ_發(fā)中非常常見，我們代碼開發(fā)過程中，一定要對空指針保持靈敏的嗅覺。

主要有這幾類空指針問題：

• 包裝類型的空指針問題
• 級聯(lián)調(diào)用的空指針問題
• Equals方法左邊的空指針問題
• ConcurrentHashMap 類似容器不支持 k-v為 null。
• 集合，數(shù)組直接獲取元素
• 對象直接獲取屬性

「反例：」

public class NullPointTest {
    public static void main(String[] args) {
        String s = null;
        if (s.equals("666")) { //s可能為空，會導(dǎo)致空指針問題
            System.out.println("公眾號：撿田螺的小男孩，干貨滿滿");
        }
    }
}

14，捕獲到的異常，不能忽略它，至少打點日志。

「反例：」

public static void testIgnoreException() throws Exception {
    try {       
        // 搞事情
    } catch (Exception e) {    
        //捕獲了異常，啥事情不做，日志也不打？？
    }
}

「正例：」

public static void testIgnoreException() {
    try {
        // 搞事情
    } catch (Exception e) {     
        log.error("異常了，聯(lián)系開發(fā)小哥哥看看哈",e); 
    }
}

15. 采用Lambda表達式替換內(nèi)部匿名類，使代碼更優(yōu)雅

JDK8出現(xiàn)了新特性-Lambda表達式。Lambda表達式不僅比匿名內(nèi)部類更加優(yōu)雅，并且在大多數(shù)虛擬機中，都是采用invokeDynamic指令實現(xiàn)，相對于匿名內(nèi)部類，效率也更高

「反例：」

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

「正例：」

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

16. 通知類（如發(fā)郵件，有短信）的代碼，建議異步處理。

假設(shè)業(yè)務(wù)流程這樣：需要在用戶登陸時，添加個短信通知它的粉絲。很容易想到的實現(xiàn)流程如下：

假設(shè)提供sendMsgNotify服務(wù)的系統(tǒng)掛了，或者調(diào)用sendMsgNotify失敗了，那么用戶登陸就失敗了。。。一個通知功能導(dǎo)致了登陸主流程不可用，明顯的撿了芝麻丟西瓜。那么有沒有魚熊掌兼得的方法呢？有的，給發(fā)短信接口捕獲異常處理，或者另開線程異步處理，如下：

因此，添加通知類等不是非主要，可降級的接口時，應(yīng)該靜下心來考慮是否會影響主要流程，思考怎么處理最好。

17. 處理Java日期時，當(dāng)心YYYY格式設(shè)置的問題。

日常開發(fā)中，我們經(jīng)常需要處理日期。我們要當(dāng)時日期格式化的時候，年份是大寫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 轉(zhuǎn) YYYY-MM-dd 格式后 " + dtf.format(testDate));

運行結(jié)果：

2019-12-31 轉(zhuǎn) YYYY-MM-dd 格式后 2020-12-31

?

為什么明明是2019年12月31號，就轉(zhuǎn)了一下格式，就變成了2020年12月31號了？因為YYYY是基于周來計算年的，它指向當(dāng)天所在周屬于的年份，一周從周日開始算起，周六結(jié)束，只要本周跨年，那么這一周就算下一年的了。正確姿勢是使用yyyy格式。

?

18. 如果一個類確定不會被繼承，不會拿來搞AOP騷操作，可以指定final修飾符，如用final修飾一個工具類。

「正例：」

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

一個類指定了final修飾符，它不會被繼承了，并且其所有方法都是final的了。Java編譯器會找機會內(nèi)聯(lián)所有的final方法，提升了Java運行效率。

19. static靜態(tài)變量不要依賴spring實例化變量，可能會導(dǎo)致初始化出錯

之前看到項目有類似的代碼。靜態(tài)變量依賴于spring容器的bean。

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

這個靜態(tài)的smsService有可能獲取不到的，因為類加載順序不是確定的，而以上的代碼，靜態(tài)的smsService初始化強制依賴spring容器的實例了。正確的寫法可以這樣，如下：

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

20. 與類成員變量無關(guān)的方法，應(yīng)當(dāng)聲明成靜態(tài)方法

有些方法，與實例成員變量無關(guān)，就可以聲明為靜態(tài)方法。這一點，工具類用得很多。「反例如下」：

/**
 * BigDecimal的工具類
 */
public class BigDecimalUtils {
 
    public  BigDecimal 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一下啦,那不就耗資源去「反復(fù)創(chuàng)建對象」了嘛！！

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

所以可以聲明成靜態(tài)變量，使用的時候，直接類名.方法調(diào)用即可，正例如下：

/**
 * 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 的代碼調(diào)用
        //…拋出 SQLException 的代碼調(diào)用
    }catch(Exception e){
        //用基類 Exception 捕捉的所有可能的異常，如果多個層次都這樣捕捉，會丟失原始異常的有效信息哦
        log.info(“Exception in test,exception:{}”, e);
    }
}

「正例：」

public void test(){
    try{
        //…拋出 IOException 的代碼調(diào)用
        //…拋出 SQLException 的代碼調(diào)用
    }catch(IOException e){
        //僅僅捕捉 IOException
        log.info(“IOException in test,exception:{}”, e);
    }catch(SQLException e){
        //僅僅捕捉 SQLException
        log.info(“SQLException in test,exception:{}”, e);
    }
}

22. 函數(shù)不要過度封裝，言簡意賅即可。

「反例：」

// 函數(shù)封裝
public static boolean isUserVip(Boolean isVip) {
    return Boolean.TRUE.equals(isVip);
}

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

「正例：」

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

函數(shù)不要過度封裝，把意思表達清楚即可。并且，方法調(diào)用會引起入棧和出棧，導(dǎo)致消耗更多的CPU和內(nèi)存，過度封裝，會損耗性能的！

23. 如果變量的初值一定會被覆蓋，就沒有必要給變量賦初值。

「反例:」

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

「正例：」

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

24.金額數(shù)值計算要使用BigDecimal

看下這個浮點數(shù)計算的例子吧：

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");
        }
    }
}

運行結(jié)果：

0.30000000000000004
0.19999999999999996
401.49999999999994
1.2329999999999999

?

因為計算機是以二進制存儲數(shù)值的，對于浮點數(shù)也是。對于計算機而言，0.1無法精確表達，這就是為什么浮點數(shù)會導(dǎo)致精確度缺失的。因此，金額計算，一般都是用BigDecimal 類型

?

System.out.println(new BigDecimal(0.1).add(new BigDecimal(0.2)));
//output:
0.3000000000000000166533453693773481063544750213623046875

其實，使用 BigDecimal 表示和計算浮點數(shù)，必須使用字符串的構(gòu)造方法來初始化 BigDecimal，并且，還要關(guān)注BigDecimal的幾位小數(shù)點，它有八種舍入模式等

25.  注意Arrays.asList的幾個坑

• 「基本類型不能作為 Arrays.asList方法的參數(shù)，否則會被當(dāng)做一個參數(shù)。」

public class ArrayAsListTest {
    public static void main(String[] args) {
        int[] array = {1, 2, 3};
        List list = Arrays.asList(array);
        System.out.println(list.size());
    }
}
//運行結(jié)果
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());
    }
}

// 運行結(jié)果
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 的內(nèi)部類ArrayList。內(nèi)部類的ArrayList沒有實現(xiàn)add方法，而是父類的add方法的實現(xiàn)，是會拋出異常的呢。

• 「使用Arrays.asLis的時候，對原始數(shù)組的修改會影響到我們獲得的那個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("原始數(shù)組"+Arrays.toString(arr));
        System.out.println("list數(shù)組" + list);
    }
}

//運行結(jié)果
原始數(shù)組[1, 4, 3]
list數(shù)組[1, 4, 3]

26，及時關(guān)閉IO資源流

應(yīng)該大家都有過這樣的經(jīng)歷，windows系統(tǒng)桌面如果打開太多文件或者系統(tǒng)軟件，就會覺得電腦很卡。當(dāng)然，我們linux服務(wù)器也一樣，平時操作文件，或者數(shù)據(jù)庫連接，IO資源流如果沒關(guān)閉，那么這個IO資源就會被它占著，這樣別人就沒有辦法用了，這就造成資源浪費。

所以使用完IO流，記得關(guān)閉哈。可以使用try-with-resource關(guān)閉的：

/*
 * 關(guān)注公眾號，撿田螺的小男孩
 */
try (FileInputStream inputStream = new FileInputStream(new File("jay.txt")) {
    // use resources   
} catch (FileNotFoundException e) {
    log.error(e);
} catch (IOException e) {
    log.error(e);
}

27. 盡量使用函數(shù)內(nèi)的基本類型臨時變量

?

• 在方法函數(shù)內(nèi)，基本類型參數(shù)以及臨時變量，都是保存在棧中的，訪問速度比較快。
• 對象類型的參數(shù)和臨時變量的引用都保存在棧中，內(nèi)容都保存在堆中，訪問速度較慢。
• 在類中，任何類型的成員變量都保存在堆（Heap）中，訪問速度較慢。

?

public class AccumulatorUtil {

    private double result = 0.0D;
    //反例
    public void addAllOne( double[] values) {
        for(double value : values) {
            result += value;
        }
    }
    //正例，先在方法內(nèi)聲明一個局部臨時變量，累加完后，再賦值給方法外的成員變量
    public void addAl1Two(double[] values) {
        double sum = 0.0D;
        for(double value : values) {
            sum += value;
        }
        result += sum;
    }
}

28. 如果數(shù)據(jù)庫一次查詢的數(shù)量過多，建議分頁處理。

如果你的Sql一次性查出來的數(shù)據(jù)量比較多，建議分頁處理。

「反例：」

select user_id,name,age from user_info ;

「正例：」

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

如果偏移量特別大的時候，查詢效率就變得低下。可以這接種方式優(yōu)化：

//方案一 ：返回上次查詢的最大記錄(偏移量)
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}

//方案三：在業(yè)務(wù)允許的情況下限制頁數(shù)：

29. 盡量減少對變量的重復(fù)計算

一般我們寫代碼的時候，會以以下的方式實現(xiàn)遍歷：

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

}

如果list數(shù)據(jù)量比較小那還好。如果list比較大時，可以優(yōu)化成這樣：

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

}

理由：

• 對方法的調(diào)用，即使是只有一個語句，也是有有消耗的，比如創(chuàng)建棧幀。如果list比較大時，多次調(diào)用list.size也是會有資源消耗的。

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

很多bug都是因為修改了對外老接口，但是卻不做兼容導(dǎo)致的。關(guān)鍵這個問題多數(shù)是比較嚴(yán)重的，可能直接導(dǎo)致系統(tǒng)發(fā)版失敗的。新手程序員很容易就犯這個錯誤了哦~

所以，如果你的需求是在原來接口上修改，，尤其這個接口是對外提供服務(wù)的話，一定要考慮接口兼容。舉個例子吧，比如dubbo接口，原本是只接收A，B參數(shù)，現(xiàn)在你加了一個參數(shù)C，就可以考慮這樣處理。

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

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

31 代碼采取措施避免運行時錯誤（如數(shù)組邊界溢出，被零除等）

日常開發(fā)中，我們需要采取措施規(guī)避數(shù)組邊界溢出，被零整除，空指針等運行時錯誤。

類似代碼比較常見:

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

所以，應(yīng)該采取措施，預(yù)防一下數(shù)組邊界溢出，「正例：」

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

32. 注意 ArrayList.toArray() 強轉(zhuǎn)的坑

public class ArrayListTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>(1);
        list.add("公眾號：撿田螺的小男孩");
        String[] array21 = (String[])list.toArray();//類型轉(zhuǎn)換異常
    }
}

因為返回的是Object類型，Object類型數(shù)組強轉(zhuǎn)String數(shù)組，會發(fā)生ClassCastException。解決方案是，使用toArray()重載方法toArray(T[] a)

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

33. 盡量不在循環(huán)里遠(yuǎn)程調(diào)用、或者數(shù)據(jù)庫操作，優(yōu)先考慮批量進行。

程操作或者數(shù)據(jù)庫操作都是比較耗網(wǎng)絡(luò)、IO資源的，所以盡量不在循環(huán)里遠(yuǎn)程調(diào)用、不在循環(huán)里操作數(shù)據(jù)庫，能批量一次性查回來盡量不要循環(huán)多次去查。（但是呢，也不要一次性查太多數(shù)據(jù)哈，要分批500一次醬紫）

「正例：」

remoteBatchQuery(param);

「反例：」

for(int i=0;i<n;i++){
  remoteSingleQuery(param)
}

34. 寫完代碼，腦洞一下多線程執(zhí)行會怎樣，注意并發(fā)一致性問題

我們經(jīng)常見的一些業(yè)務(wù)場景，就是先查下有沒有記錄，再進行對應(yīng)的操作（比如修改）。但是呢，(查詢+修改)合在一起不是原子操作哦，腦洞下多線程，就會發(fā)現(xiàn)有問題了，

「反例：」

if(isAvailable(ticketId){  //非原子操作 
    1、給現(xiàn)金增加操作 
    2、deleteTicketById(ticketId) 
}else{ 
    return "沒有可用現(xiàn)金券";
}

為了更容易理解它，看這個流程圖吧：

• 1.線程A加現(xiàn)金
• 2.線程B加現(xiàn)金
• 3.線程A刪除票標(biāo)志
• 4.線程B刪除票標(biāo)志

顯然這樣存在并發(fā)問題，正例應(yīng)該利用數(shù)據(jù)庫刪除操作的原子性，如下：

if(deleteAvailableTicketById(ticketId) == 1){ //原子操作
    1、給現(xiàn)金增加操作 
}else{ 
    return “沒有可用現(xiàn)金券” 
}

35 多線程異步優(yōu)先考慮恰當(dāng)?shù)木€程池，而不是new thread,同時考慮線程池是否隔離

為什么優(yōu)先使用線程池？使用線程池有這幾點好處呀

• 它幫我們管理線程，避免增加創(chuàng)建線程和銷毀線程的資源損耗。
• 提高響應(yīng)速度。
• 重復(fù)利用。

同時呢，盡量不要所有業(yè)務(wù)都共用一個線程池，需要考慮線程池隔離。就是不同的關(guān)鍵業(yè)務(wù)，分配不同的線程池，然后線程池參數(shù)也要考慮恰當(dāng)哈。之前寫過幾篇線程池的，覺得還不錯，有興趣的朋友可以看一下哈

36. 優(yōu)化程序結(jié)構(gòu)，盡量減少方法的重復(fù)調(diào)用

「反例：」

    public static void listDetail(List<UserInfo> userInfoList) {
        for (int i = 0; i < userInfoList.size(); i++) {
            //重復(fù)調(diào)用userList.size()方法了
        }
    }

「正例：」

 public static void listDetail(List<UserInfo> userInfoList) {
        int length = userInfoList.size();
        for (int i = 0; i < length; i++) {
            //減少調(diào)用userList.size()方法，只在length變量調(diào)了一次。
        }
    }

37，直接大文件或者一次性從數(shù)據(jù)庫讀取太多數(shù)據(jù)到內(nèi)存，可能導(dǎo)致OOM問題

如果一次性把大文件或者數(shù)據(jù)庫太多數(shù)據(jù)達到內(nèi)存，是會導(dǎo)致OOM的。所以，為什么查詢DB數(shù)據(jù)庫，一般都建議分批。

讀取文件的話，一般文件不會太大，才使用Files.readAllLines()。為什么呢？因為它是直接把文件都讀到內(nèi)存的，預(yù)估下不會OOM才使用這個吧，可以看下它的源碼：

public static List<String> readAllLines(Path path, Charset cs) throws IOException {
    try (BufferedReader reader = newBufferedReader(path, cs)) {
        List<String> result = new ArrayList<>();
        for (;;) {
            String line = reader.readLine();
            if (line == null)
                break;
            result.add(line);
        }
        return result;
    }
}

如果是太大的文件，可以使用Files.line()按需讀取，當(dāng)時讀取文件這些，一般是使用完需要關(guān)閉資源流的哈。

38. 調(diào)用第三方接口，需要考慮異常處理，安全性，超時重試這幾個點。

日常開發(fā)中，經(jīng)常需要調(diào)用第三方服務(wù)，或者分布式遠(yuǎn)程服務(wù)的的話，需要考慮：

• 異常處理（比如，你調(diào)別人的接口，如果異常了，怎么處理，是重試還是當(dāng)做失敗）
• 超時（沒法預(yù)估對方接口一般多久返回，一般設(shè)置個超時斷開時間，以保護你的接口）
• 重試次數(shù)（你的接口調(diào)失敗，需不需要重試，需要站在業(yè)務(wù)上角度思考這個問題）

?

簡單一個例子，你一個http請求調(diào)別人的服務(wù)，需要考慮設(shè)置connect-time，和retry次數(shù)。

?

39 不要使用循環(huán)拷貝集合，盡量使用JDK提供的方法拷貝集合

?

• JDK提供原生API方法，可以直接指定集合的容量，避免多次擴容損耗性能。
• 這些方法的底層調(diào)用System.arraycopy方法實現(xiàn)，進行數(shù)據(jù)的批量拷貝效率更高。

?

「反例：」

public List<UserInfo> copyMergeList(List<UserInfo> user1List, List<UserInfo> user2List) {
     List<UserInfo> 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<UserInfo> copyMergeList(List<UserInfo> user1List, List<UserInfo> user2List) {
     List<UserInfo> userList = new ArrayList<>(user1List.size() + user2List.size());
     userList.addAll(user1List);
     userList.addAll(user2List);
     return user1List;
 }

40. 對于復(fù)雜的代碼邏輯，添加清楚的注釋

寫代碼的時候，是沒有必要寫太多的注釋的，好的方法變量命名就是最好的注釋。但是，如果是業(yè)務(wù)邏輯很復(fù)雜的代碼，真的非常有必要寫清楚注釋。清楚的注釋，更有利于后面的維護。

41. 多線程情況下，考慮線性安全問題

在高并發(fā)情況下，HashMap可能會出現(xiàn)死循環(huán)。因為它是非線性安全的，可以考慮使用ConcurrentHashMap。所以這個也盡量養(yǎng)成習(xí)慣，不要上來反手就是一個new HashMap();

• Hashmap、Arraylist、LinkedList、TreeMap等都是線性不安全的；
• Vector、Hashtable、ConcurrentHashMap等都是線性安全的

42. 使用spring事務(wù)功能時，注意這幾個事務(wù)未生效的坑

日常業(yè)務(wù)開發(fā)中，我們經(jīng)常跟事務(wù)打交道，事務(wù)失效主要有以下幾個場景：

• 底層數(shù)據(jù)庫引擎不支持事務(wù)
• 在非public修飾的方法使用
• rollbackFor屬性設(shè)置錯誤
• 本類方法直接調(diào)用
• 異常被try...catch吃了，導(dǎo)致事務(wù)失效。

「反例：」

public class TransactionTest{
  public void A(){
    //插入一條數(shù)據(jù)
    //調(diào)用方法B (本地的類調(diào)用，事務(wù)失效了)
    B();
  }
  
  @Transactional
  public void B(){
    //插入數(shù)據(jù)
  }
}

「注解的事務(wù)方法給本類方法直接調(diào)用，事務(wù)失效」

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參數(shù)：-Xmx8m -Xms8m :

運行結(jié)果：

我們看下源碼，其實newFixedThreadPool使用的是無界隊列！

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

public class LinkedBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {
    ...
    /**
     * Creates a {@code LinkedBlockingQueue} with a capacity of
     * {@link Integer#MAX_VALUE}.
     */
    public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }
...
}

?

newFixedThreadPool線程池的核心線程數(shù)是固定的，它使用了近乎于無界的LinkedBlockingQueue阻塞隊列。當(dāng)核心線程用完后，任務(wù)會入隊到阻塞隊列，如果任務(wù)執(zhí)行的時間比較長，沒有釋放，會導(dǎo)致越來越多的任務(wù)堆積到阻塞隊列，最后導(dǎo)致機器的內(nèi)存使用不停的飆升，造成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. 接口需要考慮冪等性

接口是需要考慮冪等性的，尤其搶紅包、轉(zhuǎn)賬這些重要接口。最直觀的業(yè)務(wù)場景，就是用戶連著點兩次，你的接口有沒有hold住。

一般冪等技術(shù)方案有這幾種:

• 查詢操作
• 唯一索引
• token機制，防止重復(fù)提交
• 數(shù)據(jù)庫的delete/update操作
• 樂觀鎖
• 悲觀鎖
• Redis、zookeeper 分布式鎖（以前搶紅包需求，用了Redis分布式鎖）
• 狀態(tài)機冪等

46. 對于行數(shù)比較多的函數(shù)，建議劃分小函數(shù)，增強可讀性。

「反例：」

public class Test {
    private String name;
    private Vector<Order> orders = new Vector<Order>();

    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<Order> orders = new Vector<Order>();

    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);
    }
    
}

一個過于冗長的函數(shù)或者一段需要注釋才能讓人理解用途的代碼，可以考慮把它切分成一個功能明確的函數(shù)單元，并定義清晰簡短的函數(shù)名，這樣會讓代碼變得更加優(yōu)雅。

47. 你的關(guān)鍵業(yè)務(wù)代碼，一般建議搞點日志保駕護航。

關(guān)鍵業(yè)務(wù)代碼無論身處何地，都應(yīng)該有足夠的日志保駕護航。

?

比如：你實現(xiàn)轉(zhuǎn)賬業(yè)務(wù)，轉(zhuǎn)個幾百萬，然后轉(zhuǎn)失敗了，接著客戶投訴，然后你還沒有打印到日志，想想那種水深火熱的困境下，你卻毫無辦法。。。

?

那么，你的轉(zhuǎn)賬業(yè)務(wù)都需要那些日志信息呢？至少，方法調(diào)用前，入?yún)⑿枰蛴⌒枰桑涌谡{(diào)用后，需要捕獲一下異常吧，同時打印異常相關(guān)日志吧，如下：

public void transfer(TransferDTO transferDTO){
    log.info("invoke tranfer begin");
    //打印入?yún)?br>    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. 某些可變因素，如紅包皮膚等等，做成配置化是否會更好呢。

假如產(chǎn)品提了個紅包需求，圣誕節(jié)的時候，紅包皮膚為圣誕節(jié)相關(guān)的，春節(jié)的時候，紅包皮膚等。

反例:

if(duringChristmas){
   img = redPacketChristmasSkin;
}else if(duringSpringFestival){
   img =  redSpringFestivalSkin;
}

如果到了元宵節(jié)的時候，運營小姐姐突然又有想法，紅包皮膚換成燈籠相關(guān)的，這時候，是不是要去修改代碼了，重新發(fā)布了？從一開始，實現(xiàn)一張紅包皮膚的配置表，將紅包皮膚做成配置化呢？更換紅包皮膚，只需修改一下表數(shù)據(jù)就好了。

49，.直接迭代需要使用的集合,無須在額外操作

直接迭代需要使用的集合，無需通過其它操作獲取數(shù)據(jù)，比較典型就是Map的迭代遍歷：

「反例：」

Map<Long, UserDO> userMap = ...;
for (Long userId : userMap.keySet()) {
    UserDO user = userMap.get(userId);
    ...
}

「正例：」

Map<Long, UserDO> userMap = ...;
for (Map.Entry<Long, UserDO> userEntry : userMap.entrySet()) {
    Long userId = userEntry.getKey();
    UserDO user = userEntry.getValue();
    ...
}

50. 策略模式+工廠方法優(yōu)化冗余的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("展示守護勛章");
    }
    ...

首先，我們把每個條件邏輯代碼塊，抽象成一個公共的接口，我們根據(jù)每個邏輯條件，定義相對應(yīng)的策略實現(xiàn)類，可得以下代碼：

//勛章接口
public interface IMedalService {
    void showMedal();
}

//守護勛章策略實現(xiàn)類
public class GuardMedalServiceImpl implements IMedalService {
    @Override
    public void showMedal() {
        System.out.println("展示守護勛章");
    }
}
//嘉賓勛章策略實現(xiàn)類
public class GuestMedalServiceImpl implements IMedalService {
    @Override
    public void showMedal() {
        System.out.println("嘉賓勛章");
    }
}
//VIP勛章策略實現(xiàn)類
public class VipMedalServiceImpl implements IMedalService {
    @Override
    public void showMedal() {
        System.out.println("會員勛章");
    }
}

接下來，我們再定義策略工廠類，用來管理這些勛章實現(xiàn)策略類，如下：

//勛章服務(wù)工產(chǎn)類
public class MedalServicesFactory {

    private static final Map<String, IMedalService> 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);
    }
}

優(yōu)化后，正例如下：

ublic class Test {
    public static void main(String[] args) {
        String medalType = "guest";
        IMedalService medalService = MedalServicesFactory.getMedalService(medalType);
        medalService.showMedal();
    }
}

< END >

種一棵樹最好的時間是十年前，其次是現(xiàn)在

想學(xué)編程就不要猶豫，掃碼感受代碼的魅力

點亮“在看”

點擊閱讀原文，立即開啟編程之路