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 的內(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);
    }
}

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

26，及時關閉IO資源流

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

所以使用完IO流，記得關閉哈?？梢允褂胻ry-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. 盡量使用函數(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è)務允許的情況下限制頁數(shù)：

29. 盡量減少對變量的重復計算

一般我們寫代碼的時候，會以以下的方式實現(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都是因為修改了對外老接口，但是卻不做兼容導致的。關鍵這個問題多數(shù)是比較嚴重的，可能直接導致系統(tǒng)發(fā)版失敗的。新手程序員很容易就犯這個錯誤了哦~

所以，如果你的需求是在原來接口上修改，，尤其這個接口是對外提供服務的話，一定要考慮接口兼容。舉個例子吧，比如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個元素哈

所以，應該采取措施，預防一下數(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) {
        Listlist = new ArrayList(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)里遠程調(diào)用、或者數(shù)據(jù)庫操作，優(yōu)先考慮批量進行。

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

「正例：」

remoteBatchQuery(param);

「反例：」

for(int i=0;i
		

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

		

			我們經(jīng)常見的一些業(yè)務場景，就是先查下有沒有記錄，再進行對應的操作（比如修改）。但是呢，(查詢+修改)合在一起不是原子操作哦，腦洞下多線程，就會發(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刪除票標志
			
			

				4.線程B刪除票標志
			
		
		

			顯然這樣存在并發(fā)問題，正例應該利用數(shù)據(jù)庫刪除操作的原子性，如下：
		
if(deleteAvailableTicketById(ticketId) == 1){ //原子操作
    1、給現(xiàn)金增加操作 
}else{ return “沒有可用現(xiàn)金券” 
}
		

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

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

			

				它幫我們管理線程，避免增加創(chuàng)建線程和銷毀線程的資源損耗。
			
			

				提高響應速度。
			
			

				重復利用。
			
		
		

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

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

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

			「正例：」
		
public static void listDetail(ListuserInfoList) {
        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)存，可能導致OOM問題
		
		

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

			讀取文件的話，一般文件不會太大，才使用Files.readAllLines()。為什么呢？因為它是直接把文件都讀到內(nèi)存的，預估下不會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. 調(diào)用第三方接口，需要考慮異常處理，安全性，超時重試這幾個點。
		
		

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

			

				異常處理（比如，你調(diào)別人的接口，如果異常了，怎么處理，是重試還是當做失敗）
			
			

				超時（沒法預估對方接口一般多久返回，一般設置個超時斷開時間，以保護你的接口）
			
			

				重試次數(shù)（你的接口調(diào)失敗，需不需要重試，需要站在業(yè)務上角度思考這個問題）
			
		
		

			 
			

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

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

			 
			

				

					JDK提供原生API方法，可以直接指定集合的容量，避免多次擴容損耗性能。
				
				

					這些方法的底層調(diào)用System.arraycopy方法實現(xiàn)，進行數(shù)據(jù)的批量拷貝效率更高。
				
			
 
		
		

			「反例：」
		
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. 對于復雜的代碼邏輯，添加清楚的注釋
		
		

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

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

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

			

				Hashmap、Arraylist、LinkedList、TreeMap等都是線性不安全的；
			
			

				Vector、Hashtable、ConcurrentHashMap等都是線性安全的
			
		
		

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

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

			

				底層數(shù)據(jù)庫引擎不支持事務
			
			

				在非public修飾的方法使用
			
			

				rollbackFor屬性設置錯誤
			
			

				本類方法直接調(diào)用
			
			

				異常被try...catch吃了，導致事務失效。
			
		
		

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

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

			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
		
		

			運行結果：
		
 
		

			我們看下源碼，其實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線程池的核心線程數(shù)是固定的，它使用了近乎于無界的LinkedBlockingQueue阻塞隊列。當核心線程用完后，任務會入隊到阻塞隊列，如果任務執(zhí)行的時間比較長，沒有釋放，會導致越來越多的任務堆積到阻塞隊列，最后導致機器的內(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è)務場景，就是用戶連著點兩次，你的接口有沒有hold住。
		
		

			一般冪等技術方案有這幾種:
		
		

			

				查詢操作
			
			

				唯一索引
			
			

				token機制，防止重復提交
			
			

				數(shù)據(jù)庫的delete/update操作
			
			

				樂觀鎖
			
			

				悲觀鎖
			
			

				Redis、zookeeper 分布式鎖（以前搶紅包需求，用了Redis分布式鎖）
			
			

				狀態(tài)機冪等
			
		
		

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

			「反例：」
		
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);
    }
    
}
		

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

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

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

			 
			

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

			那么，你的轉(zhuǎn)賬業(yè)務都需要那些日志信息呢？至少，方法調(diào)用前，入?yún)⑿枰蛴⌒枰?，接口調(diào)用后，需要捕獲一下異常吧，同時打印異常相關日志吧，如下：
		
public void transfer(TransferDTO transferDTO){
    log.info("invoke tranfer begin");
    //打印入?yún)?
    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é)相關的，春節(jié)的時候，紅包皮膚等。
		
		

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

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

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

			直接迭代需要使用的集合，無需通過其它操作獲取數(shù)據(jù)，比較典型就是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. 策略模式+工廠方法優(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ù)每個邏輯條件，定義相對應的策略實現(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)策略類，如下：
		
//勛章服務工產(chǎn)類
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);
    }
}
		

			優(yōu)化后，正例如下：
		
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%非業(yè)務的bug: https://juejin.cn/post/6899077803665260557#heading-12
		
 [4]
		

			Java日常開發(fā)的21個坑，你踩過幾個？: https://juejin.cn/post/6910831193931923463#heading-31
		
 [5]
		

			if-else代碼優(yōu)化的八種方案: https://juejin.cn/post/6844904083665453063