沒忍住！49 個代碼優(yōu)化小技巧

大家好，我是二哥呀！

工作了很多年，看過很多思考不夠深入的代碼，有些甚至?xí)屛颐壬@樣的想法，“咦，代碼怎么可以這樣寫啊！太糟糕了。”結(jié)果再往后看，發(fā)現(xiàn)原來是自己寫的，哈哈哈 ??。

剛好一個讀者田螺給我投稿了一篇文章，里面包含了 49 條建議，我看完后，深表佩服，所以就給大家分享一下啦，希望能給大家一些啟發(fā)和幫助~~~

以下是正文。

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} and vip_flag ='Y';
 </select>

boolean isVip (String userId){
  UserInfo userInfo = userInfoDAp.selectUserByUserId(userId);
  return UserInfo!=null ；
}

（正例）： 針對這種業(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 個請求進(jìn)來，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 ("好好學(xué)習(xí)，天天向上");

正例：

String s=  "好好學(xué)習(xí)，天天向上”;

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)是“類名@散列碼的無符號十六進(jì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ù)進(jìn)來，并且你的公有方法是類似 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é)或者字符時，先不輸出，而是等達(dá)到緩沖區(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 {

    VIP("1","會員"),
    NOT_VIP("0","非會員"),:;

    private String code;
    private String desc;

    UserVipEnum(String code, String desc) {
        this.code = code;
        this.desc = desc;
    }
}

寫代碼的時候，不要一時興起，就直接使用魔法值哈。使用魔法值，維護(hù)代碼起來很難受的。

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 表達(dá)式替換內(nèi)部匿名類，使代碼更優(yōu)雅

JDK8 出現(xiàn)了新特性——Lambda 表達(dá)式。Lambda 表達(dá)式不僅比匿名內(nèi)部類更加優(yōu)雅，并且在大多數(shù)虛擬機(jī)中，都是采用 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 編譯器會找機(jī)會內(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 初始化強(qiáng)制依賴 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ù)不要過度封裝，把意思表達(dá)清楚即可。并且，方法調(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

因為計算機(jī)是以二進(jìn)制存儲數(shù)值的，對于浮點數(shù)也是。對于計算機(jī)而言，0.1 無法精確表達(dá)，這就是為什么浮點數(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.asList 的時候，對原始數(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)閉的：

try (FileInputStream inputStream = new FileInputStream(new File("jay.txt")) {
    // use resources
} catch (FileNotFoundException e) {
    log.error(e);
} catch (IOException e) {
    log.error(e);
}

27. 盡量在方法內(nèi)定義基本類型的臨時變量

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

public class AccumulatorUtil {

    private double result = 0.0D;
    //反例
    public void addAllOne( double[] values) {
        for(double value : values) {
            result += value;
        }
    }
    //正例，先在方法內(nèi)聲明一個局部臨時變量，累加完后，再賦值給方法外的成員變量
    public void addAll1Two(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, int 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() 強(qiáng)轉(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ù)組強(qiáng)轉(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)先考慮批量進(jìn)行。

遠(yuǎn)程操作或者數(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ù)場景，就是先查下有沒有記錄，再進(jìn)行對應(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，直接大文件或者一次性從數(shù)據(jù)庫讀取太多數(shù)據(jù)到內(nèi)存，可能導(dǎo)致 OOM 問題

如果一次性把大文件或者數(shù)據(jù)庫太多數(shù)據(jù)達(dá)到內(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)閉資源流的哈。

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

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

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

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

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

• JDK 提供原生 API 方法，可以直接指定集合的容量，避免多次擴(kuò)容損耗性能。
• 這些方法的底層調(diào)用 System.arraycopy 方法實現(xiàn)，進(jì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;
 }

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

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

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

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

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

41. 使用 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ù)失效

42. 使用 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)致機(jī)器的內(nèi)存使用不停的飆升，造成 JVM OOM。

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

44. 接口需要考慮冪等性

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

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

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

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

反例：

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)雅。

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

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

比如：你實現(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 級別，告警半夜三更催你起來排查問題就不好了。

49. 某些可變因素，如紅包皮膚等等，做成配置化是否會更好呢。

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

反例:

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

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

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

直接迭代需要使用的集合，無需通過其它操作獲取數(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();
    ...
}

49. 策略模式+工廠方法優(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("展示守護(hù)勛章");
    }
    ...

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

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

//守護(hù)勛章策略實現(xiàn)類
public class GuardMedalServiceImpl implements IMedalService {
    @Override
    public void showMedal() {
        System.out.println("展示守護(hù)勛章");
    }
}
//嘉賓勛章策略實現(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();
    }
}

分享的最后，二哥多說兩句。

平常工作的時候，一定要注意，多寫優(yōu)雅的代碼，不要將就，哪怕開發(fā)進(jìn)度很緊張，也不要將就，因為一旦將就，可能就隱藏了 bug 在里面。修改 bug 的時間可能就遠(yuǎn)遠(yuǎn)超出了你寫代碼花費的時間，很不劃算的。

優(yōu)雅的姿勢久了，你也會發(fā)現(xiàn)自己越來越優(yōu)秀了。

尤其是當(dāng)你的代碼在 review 的時候，領(lǐng)導(dǎo)發(fā)現(xiàn)，“咦，小伙子寫的代碼竟然超出了我的預(yù)期，學(xué)到了~”那不得了了，領(lǐng)導(dǎo)對你的印象肯定好到爆，績效分多給點，那就爽歪歪了，對吧？

我是二哥，下期見~