分享50個讓你程式碼更好的小建議

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

我們經常遇到類似的業務場景，如，判斷某個使用者userId是否是會員。

（反例）：

一些小夥伴會這樣實現，先查從使用者資訊表查出使用者記錄，然後再去判斷是否是會員：

selct user_id ， vip_flag from user_info where user_id =#{userId}； boolean isVip （String userId）{ UserInfo userInfo = userInfoDAp。selectUserByUserId（userId）； return UserInfo！=null && “Y”。equals（userInfo。getVipFlag（））}複製程式碼

（正例）：

針對這種業務場景，其實更好的實現，是直接select count一下，如下：

selct count（1） from user_info where user_id =#{userId} and vip_flag =‘Y’； boolean isVip （String userId）{ int vipNum = userInfoDAp。countVipUserByUserId（userId）； return vipNum>0}複製程式碼

2。 複雜的if邏輯條件，可以調整順序，讓程式更高效

假設業務需求是這樣：如果使用者是會員，並且第一次登陸時，需要發一條通知的簡訊。假如沒有經過思考，程式碼很可能直接這樣寫了。

if（isUserVip && isFirstLogin）{ sendMsgNotify（）；}複製程式碼

假設總共有5個請求進來，isUserVip透過的有3個請求，isFirstLogin透過的有1個請求。 那麼以上程式碼，isUserVip執行的次數為5次，isFirstLogin執行的次數也是3次，如下：

如果調整一下isUserVip和isFirstLogin的順序呢？

if（isFirstLogin && isUserVip ）{ sendMsg（）；}複製程式碼

isFirstLogin執行的次數是5次，isUserVip執行的次數是1次，如下：

如果你的isFirstLogin，判斷邏輯只是select count 一下資料庫表，isUserVip也是select count 一下資料庫表的話，顯然，把isFirstLogin放在前面更高效。

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

反例：

select * from user_info where user_id =#{userId}；複製程式碼

正例：

selct user_id ， vip_flag from user_info where user_id =#{userId}；複製程式碼

理由：

節省資源、減少網路開銷。

可能用到覆蓋索引，減少回表，提高查詢效率。

4。 最佳化你的程式，拒絕建立不必要的物件

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

反例：

String s = new String （“歡迎關注公眾號：撿田螺的小男孩”）；複製程式碼

正例：

String s= “歡迎關注公眾號：撿田螺的小男孩 ”；複製程式碼

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

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

假設你的map要儲存的元素個數是15個左右，最優寫法如下

//initialCapacity = 15/0。75+1=21 Map map = new HashMap（21）； 又因為hashMap的容量跟2的冪有關，所以可以取32的容量 Map map = new HashMap（32）；複製程式碼

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

反例：

try{ // do something}catch（Exception e）{ log。info（”撿田螺的小男孩，你的程式有異常啦“）；}複製程式碼

正例：

try{ // do something}catch（Exception e）{ log。info（”撿田螺的小男孩，你的程式有異常啦：“，e）； //把exception打印出來}複製程式碼

理由：

反例中，並沒有把exception出來，到時候排查問題就不好查了啦，到底是SQl寫錯的異常還是IO異常，還是其他呢？所以應該把exception列印到日誌中哦~

7。 列印日誌的時候，物件沒有覆蓋Object的toString的方法，直接把類名打印出來了。

我們在列印日誌的時候，經常想看下一個請求引數物件request是什麼。於是很容易有類似以下這些程式碼：

publick Response dealWithRequest（Request request）{ log。info（”請求引數是：“。request。toString）}複製程式碼

列印結果如下：

請求引數是：local。Request@49476842複製程式碼

這是因為物件的toString方法，預設的實現是“類名@雜湊碼的無符號十六進位制”。所以你看吧，這樣子列印日誌就沒啥意思啦，你都不知道列印的是什麼內容。

所以一般物件（尤其作為傳參的物件），

都覆蓋重寫toString()方法

：

class Request { private String age； private String name； @Override public String toString（） { return ”Request{“ + ”age=‘“ + age + ’\‘’ + ”， name=‘“ + name + ’\‘’ + ‘}’； }}publick Response dealWithRequest（Request request）{ log。info（”請求引數是：“。request。toString）}複製程式碼

列印結果如下：

請求引數是：Request{age=‘26’， name=‘公眾號：撿田螺的小男孩’}複製程式碼

8。 一個方法，拒絕過長的引數列表。

假設有這麼一個公有方法，形參有四個。。。

public void getUserInfo（String name，String age，String sex，String mobile）{ // do something 。。。}複製程式碼

如果現在需要多傳一個version引數進來，並且你的公有方法是類似dubbo這種對外提供的介面的話，那麼你的介面是不是需要相容老版本啦？

public void getUserInfo（String name，String age，String sex，String mobile）{ // do something 。。。}/** * 新介面調這裡 */public void getNewUserInfo（String name，String age，String sex，String mobile，String version）{ // do something 。。。}複製程式碼

所以呢，一般一個方法的引數，一般不宜過長。過長的引數列表，不僅看起來不優雅，並且介面升級時，可能還要考慮新老版本相容。如果引數實在是多怎麼辦呢？可以用個DTO物件包裝一下這些引數呢~如下：

public void getUserInfo（UserInfoParamDTO userInfoParamDTO）{ // do something 。。。}class UserInfoParamDTO{ private String name； private String age； private String sex； private String mobile；}複製程式碼

用個DTO物件包裝一下，即使後面有引數變動，也可以不用動對外介面了，好處槓槓的。

9。 使用緩衝流，減少IO操作

反例：

/** * 公眾號：撿田螺的小男孩 * @desc： 複製一張圖片檔案 */public class MainTest { public static void main（String［］ args） throws FileNotFoundException { long begin = System。currentTimeMillis（）； try （FileInputStream input = new FileInputStream（”C：/456。png“）； FileOutputStream output = new FileOutputStream（”C：/789。png“）） { byte［］ bytes = new byte［1024］； int i； while （（i = input。read（bytes）） ！= -1） { output。write（bytes，0，i）； } } catch （IOException e） { log。error（”複製檔案發生異常“，e）； } log。info（”常規流讀寫，總共耗時ms：“+（System。currentTimeMillis（） - begin））； }}複製程式碼

執行結果：

常規流讀寫，總共耗時ms：52複製程式碼

使用FileInputStream、FileOutputStream實現檔案讀寫功能，是沒有什麼問題的。但是呢，可以使用緩衝流BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream等，減少IO次數，提高讀寫效率。

如果是不帶緩衝的流，讀取到一個位元組或者字元的，就會直接輸出資料了。而帶緩衝的流，讀取到一個位元組或者字元時，先不輸出，而是等達到緩衝區的最大容量，才一次性輸出。

正例：

/** * 公眾號：撿田螺的小男孩 * @desc： 複製一張圖片檔案 */public class MainTest { public static void main（String［］ args） throws FileNotFoundException { long begin = System。currentTimeMillis（）； try （BufferedInputStream bufferedInputStream = new BufferedInputStream（new FileInputStream（”C：/456。png“））； 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（”複製檔案發生異常“，e）； } log。info（”總共耗時ms“+（System。currentTimeMillis（） - begin））； }}複製程式碼

執行結果：

緩衝流讀寫，總共耗時ms：12複製程式碼

10。 最佳化你的程式邏輯，比如前面已經查到的資料，在後面的方法也用到的話，是可以把往下傳參的，減少方法呼叫/查表

反例：

public Response dealRequest（Request request）{ UserInfo userInfo = userInfoDao。selectUserByUserId（request。getUserId）； if（Objects。isNull（request））{ return ； } insertUserVip（request。getUserId）； }private int insertUserVip（String userId）{ //又查了一次 UserInfo userInfo = userInfoDao。selectUserByUserId（request。getUserId）； //插入使用者vip流水 insertUserVipFlow（userInfo）； 。。。。}複製程式碼

很顯然，以上程式程式碼，已經查到 userInfo，然後又把userId傳下去，又查多了一次。。。實際上，可以把userInfo傳下去的，這樣可以省去一次查表操作，程式更高效。

正例：

public Response dealRequest（Request request）{ UserInfo userInfo = userInfoDao。selectUserByUserId（request。getUserId）； if（Objects。isNull（request））{ return ； } insertUserVip（userInfo）；}private int insertUserVip（UserInfo userInfo）{ //插入使用者vip流水 insertUserVipFlow（userInfo）； 。。。。}複製程式碼

11。 不要為了方便，直接在程式碼中使用0，1等魔法值，應該要用enum列舉代替。

反例：

if（”0“。equals（userInfo。getVipFlag））{ //非會員，提示去開通會員 tipOpenVip（userInfo）；}else if（”1“。equals（userInfo。getVipFlag））{ //會員，加勳章返回 addMedal（userInfo）；}複製程式碼

正例：

if（UserVipEnum。NOT_VIP。getCode。equals（userInfo。getVipFlag））{ //非會員，提示去開通會員 tipOpenVip（userInfo）；}else if（UserVipEnum。VIP。getCode。equals（userInfo。getVipFlag））{ //會員，加勳章返回 addMedal（userInfo）；}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； }}複製程式碼

寫程式碼的時候，不要一時興起，就直接使用魔法值哈。使用魔法值，維護程式碼起來很難受的。

12。 當成員變數值不會改變時，優先定義為靜態常量

反例：

public class Task { private final long timeout = 10L； 。。。}複製程式碼

正例：

public class Task { private static final long TIMEOUT = 10L； 。。。}複製程式碼

因為如果定義為static，即類靜態常量，在每個例項物件中，它只有一份副本。如果是成員變數，每個例項物件中，都各有一份副本。顯然，如果這個變數不會變的話，定義為靜態常量更好一些。

13。 注意檢驗空指標，不要輕易相信業務，說正常邏輯某個引數不可能為空。

NullPointerException 在我們日常開發中非常常見，我們程式碼開發過程中，一定要對空指標保持靈敏的嗅覺。

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

包裝型別的空指標問題

級聯呼叫的空指標問題

Equals方法左邊的空指標問題

ConcurrentHashMap 類似容器不支援 k-v為 null。

集合，陣列直接獲取元素

物件直接獲取屬性

反例：

public class NullPointTest { public static void main（String［］ args） { String s = null； if （s。equals（”666“）） { //s可能為空，會導致空指標問題 System。out。println（”公眾號：撿田螺的小男孩，乾貨滿滿“）； } }}複製程式碼

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

反例：

public static void testIgnoreException（） throws Exception { try { // 搞事情 } catch （Exception e） { //捕獲了異常，啥事情不做，日誌也不打？？ }}複製程式碼

正例：

public static void testIgnoreException（） { try { // 搞事情 } catch （Exception e） { log。error（”異常了，聯絡開發小哥哥看看哈“，e）； }}複製程式碼

15。 採用Lambda表示式替換內部匿名類，使程式碼更優雅

JDK8出現了新特性-Lambda表示式。Lambda表示式不僅比匿名內部類更加優雅，並且在大多數虛擬機器中，都是採用invokeDynamic指令實現，相對於匿名內部類，效率也更高

反例：

public void sortUserInfoList（List userInfoList）{ userInfoList。sort（new Comparator（） { @Override public int compare（UserInfo user1， UserInfo user2） { Long userId1 = user1。getUserId（）； Long userId2 = user2。getUserId（）； return userId1。compareTo（userId2）； }}）； }複製程式碼

正例：

public void sortUserInfoList（List userInfoList）{ userInfoList。sort（（user1， user2） -> { Long userId1 = user1。getUserId（）； Long userId2 = user2。getUserId（）； return userId1。compareTo（userId2）； }）； }複製程式碼

16。 通知類（如發郵件，有簡訊）的程式碼，建議非同步處理。

假設業務流程這樣：需要在使用者登陸時，添加個簡訊通知它的粉絲。 很容易想到的實現流程如下：

假設提供sendMsgNotify服務的系統掛了，或者呼叫sendMsgNotify失敗了，那麼使用者登陸就失敗了。。。 一個通知功能導致了登陸主流程不可用，明顯的撿了芝麻丟西瓜。那麼有沒有魚魚熊掌兼得的方法呢？有的，給發簡訊介面捕獲異常處理，或者另開執行緒非同步處理，如下：

因此，新增通知類等不是非主要，可降級的介面時，應該靜下心來考慮是否會影響主要流程，思考怎麼處理最好。

17。 處理Java日期時，當心YYYY格式設定的問題。

日常開發中，我們經常需要處理日期。我們要當時日期格式化的時候，年份是大寫YYYY的坑。

Calendar calendar = Calendar。getInstance（）；calendar。set（2019， Calendar。DECEMBER， 31）；Date testDate = calendar。getTime（）；SimpleDateFormat dtf = new SimpleDateFormat（”YYYY-MM-dd“）；System。out。println（”2019-12-31 轉 YYYY-MM-dd 格式後 “ + dtf。format（testDate））；複製程式碼

執行結果：

2019-12-31 轉 YYYY-MM-dd 格式後 2020-12-31複製程式碼

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

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

正例：

public final class Tools { public static void testFinal（）{ System。out。println（”工具類方法“）； }}複製程式碼

一個類指定了final修飾符，它不會被繼承了，並且其所有方法都是final的了。Java編譯器會找機會內聯所有的final方法，提升了Java執行效率。

19。 static靜態變數不要依賴spring例項化變數，可能會導致初始化出錯

之前看到專案有類似的程式碼。靜態變數依賴於spring容器的bean。

private static SmsService smsService = SpringContextUtils。getBean（SmsService。class）；複製程式碼

這個靜態的smsService有可能獲取不到的，因為類載入順序不是確定的，而以上的程式碼，靜態的smsService初始化強制依賴spring容器的例項了。正確的寫法可以這樣，如下：

private static SmsService smsService =null； //使用到的時候採取獲取 public static SmsService getSmsService（）{ if（smsService==null）{ smsService = SpringContextUtils。getBean（SmsService。class）； } return smsService； }複製程式碼

20。 與類成員變數無關的方法，應當宣告成靜態方法

有些方法，與例項成員變數無關，就可以宣告為靜態方法。這一點，工具類用得很多。

反例如下

：

/** * 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一下啦，那不就耗資源去

反覆建立物件

了嘛！！

BigDecimalUtils bigDecimalUtils = new BigDecimalUtils（）；bigDecimalUtils。sum（a，b）；複製程式碼

所以可以宣告成靜態變數，使用的時候，直接類名。方法呼叫即可，正例如下：

/** * 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。 如果變數的初值一定會被覆蓋，就沒有必要給變數賦初值。

反例:

List userList = new ArrayList<>（）；if （isAll） { userList = userInfoDAO。queryAll（）；} else { userList = userInfoDAO。queryActive（）；}複製程式碼

正例：

List userList ；if （isAll） { userList = userInfoDAO。queryAll（）；} else { userList = userInfoDAO。queryActive（）；}複製程式碼

24。金額數值計算要使用BigDecimal

看下這個浮點數計算的例子吧：

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。300000000000000040。19999999999999996401。499999999999941。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 addAll1Two（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， int 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） { List list = 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（List userInfoList） { for （int i = 0； i < userInfoList。size（）； i++） { //重複呼叫userList。size（）方法了 } }複製程式碼

正例：

public static void listDetail（List userInfoList） { int length = userInfoList。size（）； for （int i = 0； i < length； i++） { //減少呼叫userList。size（）方法，只在length變數調了一次。 } }複製程式碼

37，直接大檔案或者一次性從資料庫讀取太多資料到記憶體，可能導致OOM問題

如果一次性把大檔案或者資料庫太多資料達到記憶體，是會導致OOM的。所以，為什麼查詢DB資料庫，一般都建議分批。

讀取檔案的話，一般檔案不會太大，才使用Files。readAllLines（）。為什麼呢？因為它是直接把檔案都讀到記憶體的，預估下不會OOM才使用這個吧，可以看下它的原始碼：

public static List readAllLines（Path path， Charset cs） throws IOException { try （BufferedReader reader = newBufferedReader（path， cs）） { List result = new ArrayList<>（）； for （；；） { String line = reader。readLine（）； if （line == null） break； result。add（line）； } return result； }}複製程式碼

如果是太大的檔案，可以使用Files。line（）按需讀取，當時讀取檔案這些，一般是使用完需要關閉資源流的哈。

38。 呼叫第三方介面，需要考慮異常處理，安全性，超時重試這幾個點。

日常開發中，經常需要呼叫第三方服務，或者分散式遠端服務的的話，需要考慮：

異常處理（比如，你調別人的介面，如果異常了，怎麼處理，是重試還是當做失敗）

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

重試次數（你的介面調失敗，需不需要重試，需要站在業務上角度思考這個問題）

簡單一個例子，你一個http請求調別人的服務，需要考慮設定connect-time，和retry次數。

39 不要使用迴圈複製集合，儘量使用JDK提供的方法複製集合

JDK提供原生API方法，可以直接指定集合的容量，避免多次擴容損耗效能。 這些方法的底層呼叫System。arraycopy方法實現，進行資料的批次複製效率更高。

反例：

public List copyMergeList（List user1List， List user2List） { List userList = new ArrayList<>（user1List。size（） + user2List。size（））； for （UserInfo user ： user1List） { userList。add（user）； } for （UserInfo user ： user2List） { userList。add（user）； } return user1List； }複製程式碼

正例：

public List copyMergeList（List user1List， List user2List） { List userList = new ArrayList<>（user1List。size（） + user2List。size（））； userList。addAll（user1List）； userList。addAll（user2List）； return user1List； }複製程式碼

40。 對於複雜的程式碼邏輯，新增清楚的註釋

寫程式碼的時候，是沒有必要寫太多的註釋的，好的方法變數命名就是最好的註釋。但是，如果是業務邏輯很複雜的程式碼，真的非常有必要寫清楚註釋。清楚的註釋，更有利於後面的維護。

41。 多執行緒情況下，考慮線性安全問題

在高併發情況下，HashMap可能會出現死迴圈。因為它是非線性安全的，可以考慮使用ConcurrentHashMap。 所以這個也儘量養成習慣，不要上來反手就是一個new HashMap（）；

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

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

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 LinkedBlockingQueue extends AbstractQueue implements 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 Vector orders = new Vector（）； public void printOwing（） { //print banner System。out。println（”****************“）； System。out。println（”*****customer Owes *****“）； System。out。println（”****************“）； //calculate totalAmount Enumeration env = orders。elements（）； double totalAmount = 0。0； while （env。hasMoreElements（）） { Order order = （Order） env。nextElement（）； totalAmount += order。getAmout（）； } //print details System。out。println（”name：“ + name）； System。out。println（”amount：“ + totalAmount）； }}複製程式碼

正例：

public class Test { private String name； private Vector orders = new Vector（）； public void printOwing（） { //print banner printBanner（）； //calculate totalAmount double totalAmount = getTotalAmount（）； //print details printDetail（totalAmount）； } void printBanner（）{ System。out。println（”****************“）； System。out。println（”*****customer Owes *****“）； System。out。println（”****************“）； } double getTotalAmount（）{ Enumeration env = orders。elements（）； double totalAmount = 0。0； while （env。hasMoreElements（）） { Order order = （Order） env。nextElement（）； totalAmount += order。getAmout（）； } return totalAmount； } void printDetail（double totalAmount）{ System。out。println（”name：“ + name）； System。out。println（”amount：“ + totalAmount）； } }複製程式碼

一個過於冗長的函式或者一段需要註釋才能讓人理解用途的程式碼，可以考慮把它切分成一個功能明確的函式單元，並定義清晰簡短的函式名，這樣會讓程式碼變得更加優雅。

47。 你的關鍵業務程式碼，一般建議搞點日誌保駕護航。

關鍵業務程式碼無論身處何地，都應該有足夠的日誌保駕護航。

比如：你實現轉賬業務，轉個幾百萬，然後轉失敗了，接著客戶投訴，然後你還沒有列印到日誌，想想那種水深火熱的困境下，你卻毫無辦法。。。

那麼，你的轉賬業務都需要那些日誌資訊呢？至少，方法呼叫前，入參需要列印需要吧，介面呼叫後，需要捕獲一下異常吧，同時列印異常相關日誌吧，如下：

public void transfer（TransferDTO transferDTO）{ log。info（”invoke tranfer begin“）； //列印入參 log。info（”invoke tranfer，paramters：{}“，transferDTO）； try { res= transferService。transfer（transferDTO）； }catch（Exception e）{ log。error（”transfer fail，cifno：{}，account：{}“，transferDTO。getCifno（）， transferDTO。getaccount（）） log。error（”transfer fail，exception：{}“，e）； } log。info（”invoke tranfer end“）； }複製程式碼

除了列印足夠的日誌，我們還需要注意一點是，日誌級別別混淆使用，別本該列印info的日誌，你卻列印成error級別，告警半夜三更催你起來排查問題就不好了。

48。 某些可變因素，如紅包面板等等，做成配置化是否會更好呢。

假如產品提了個紅包需求，聖誕節的時候，紅包面板為聖誕節相關的，春節的時候，紅包面板等。

反例：

if（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（）； }}

作者：撿田螺的小男孩

連結：https：//juejin。cn/post/6944642153662398500

著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。