改善Java代碼的八個建議

前言

JAVA是一門優秀的面向對象的編程語言，針對遇到同樣的一個問題會有很多中解法，但是哪種實現方法是最優的或近似最優的，就需要不斷的探究JDK的底層原理。本文針對提出了一些改善Java的小建議。希望可以為大家在平時的開發實踐中提供一些小幫助。

用整數處理貨幣

大家考慮以下代碼輸出的值是多少？

public static void main(String[] args) {
    System.out.println(10.00-9.60);
}

實際結果： 0.40000000000000036

原因:

計算機中浮點數有可能是不準確的，因為計算機中浮點數的存儲規則導致的。 0.4的二進制是：0.0110……
乘2取整，順序排列

解決方案：

使用BigDecimal
使用整型（把參與運算的值擴大100倍，并轉為整型，然后在展現時再縮小100倍，這樣處理的好處是計算簡單，準確，一般在非金融行業(如零售行業)應用較多）

根據國際標準IEEE（電氣和電子工程協會）規定，任何一個浮點數NUM的二進制數可以寫為：
NUM = (-1) ^ S * M * 2 ^ E;//(S表示符號，E表示階乘，M表示有效數字)
①當S為0時，表示一個正數；當S為1時，表示一個負數
②M表示有效數字，1<= M <2
③2^E表示指數
比如十進制的3.0，二進制就是0011.0 就可以寫成（-1）^ 0 * 1.1 * 2 ^ 1
在比如十進制的-3.0，二進制就是-0011.0 就可以寫成（-1）^ 1 * 1.1 * 2 ^ 1
而規定float類型有一個符號位（S），有8個指數位（E），和23個有效數字位（M）
double類型有一個符號位（S），有11個指數位（E），和52個有效數字位（M）

邊界值校驗

public class Demo {
   // 一個會員擁有產品的最多數量
   public final static int LIMIT = 2000;

   public static void main(String[] args) {
     // 會員當前用有的產品數量
     int cur = 1000;
     Scanner input = new Scanner(System.in);
     System.out.println("請輸入需要預定的數量：");
     while (input.hasNextInt()) {
       int order = input.nextInt();
       if (order > 0 && order + cur <= LIMIT) {
         System.out.println("你已經成功預定：" + order + " 個產品");
       } else {
         System.out.println("超過限額，預定失敗！");
       }
     }
   }
 }

原因：

數字越界使校驗條件失效，輸入2147483647的邊界值

建議：

如果一個方法接收的是int類型的參數，那么以下三個值是必須測試的：

0
正最大
負最小其中正最大、負最小是邊界值

提防包裝類型的null值

public static int testMethod(List<Integer> list) {
   int count = 0;
   for (int i : list) {
     count += i;
   }
   return count;
 }

 public static void main(String[] args) {
   List<Integer> list = new ArrayList<Integer>();
   list.add(1);
   list.add(2);
   list.add(null);
   System.out.println(testMethod(list));
 }

原因：

在程序for循環中，隱含了一個拆箱過程，在此過程中包裝類型轉換為了基本類型。我們知道拆箱過程是通過調用包裝對象的intValue方法來實現的，由于包裝類型為null，訪問其intValue方法報空指針異常就在所難免了。

方案：

加入Null的校驗。

用偶判斷，不用奇判斷

需要了解Java后者任意編程語言對于取余的算法實現。大家可以參考程序語言中的取余是如何實現的。

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("請輸入多個數字判斷奇數偶數：");

        while (input.hasNextLine()) {
            int i = input.nextInt();

            String str = i + "->" + (i % 2 == 0 ? "偶數" : "奇數");
//            String str = i + "->" + (i % 2 == 1 ? "奇數" : "偶數");

            System.out.println(str);
        }
    }

謹慎包裝類型的大小比較

public static void main(String[] args) {
   Integer i = new Integer(100);
   Integer j = new Integer(100);
   compare(i, j);
 }

 public static void compare(Integer i, Integer j) {
   System.out.println(i == j);
   System.out.println(i > j);
   System.out.println(i < j);
 }

運行結果：

問題：

i==j：在java中"=="是用來判斷兩個操作數是否有相等關系的，如果是基本類型則判斷值是否相等，如果是對象則判斷是否是一個對象的兩個引用，也就是地址是否相等，這里很明顯是兩個對象，兩個地址不可能相等。
i>j 和 i<j：在Java中，">" 和 "<" 用來判斷兩個數字類型的大小關系，注意只能是數字類型的判斷，對于Integer包裝類型，是根據其intValue()方法的返回值(也就是其相應的基本類型)進行比較的(其它包裝類型是根據相應的value值比較的，如doubleValue,floatValue等)，那很顯然，兩者不肯能有大小關系的。

方案：

問題清楚了，修改總是比較容易的，直接使用Integer的實例compareTo方法即可，但是這類問題的產生更應該說是習慣問題，只要是兩個對象之間的比較就應該采用相應的方法，而不是通過Java的默認機制來處理，除非你確定對此非常了解。

優先使用整型池

public static void main(String[] args) {
   Scanner input = new Scanner(System.in);
   while (input.hasNextInt()) {
     int tempInt = input.nextInt();
     System.out.println("n=====" + tempInt + " 的相等判斷=====");
     // 兩個通過new產生的對象
     Integer i = new Integer(tempInt);
     Integer j = new Integer(tempInt);
     System.out.println(" new 產生的對象：" + (i == j));
     // 基本類型轉換為包裝類型后比較
     i = tempInt;
     j = tempInt;
     System.out.println(" 基本類型轉換的對象：" + (i == j));
     // 通過靜態方法生成一個實例
     i = Integer.valueOf(tempInt);
     j = Integer.valueOf(tempInt);
     System.out.println(" valueOf產生的對象：" + (i == j));
   }
 }

現象：

大于127的數字和128和555的比較過程中產生的卻不是同一個對象。

說明：

127的包裝對象是直接從整型池中獲得的，不管你輸入多少次127這個數字，獲得的對象都是同一個，那地址自然是相等的。而128、555超出了整型池范圍，是通過new產生一個新的對象，地址不同，當然也就不相等了。

整型池的好處：

提高了系統性能，同時也節約了內存空間

優先選擇基本類型

public class Demo7 {
   public static void main(String[] args) {
     Demo7 c = new Demo7();
     int i = 140;
     // 分別傳遞int類型和Integer類型
     c.testMethod(i);
     c.testMethod(new Integer(i));
   }

   public void testMethod(long a) {
     System.out.println("基本類型的方法被調用");
   }

   public void testMethod(Long a) {
     System.out.println("包裝類型的方法被調用");
   }
 }

原則：

使用包裝類型確實有方便的方法，但是也引起一些不必要的困惑，比如我們這個例子，如果testMethod()的兩個重載方法使用的是基本類型，而且實參也是基本類型，就不會產生以上問題，而且程序的可讀性更強。自動裝箱(拆箱)雖然很方便，但引起的問題也非常嚴重，我們甚至都不知道執行的是哪個方法。

其他建議：

如果需要使用高效的包裝類集合，推進使用fastutil。Maven坐標：

<dependency>
    <groupId>it.unimi.dsi</groupId>
    <artifactId>fastutil</artifactId>
    <version>8.5.8</version>
</dependency>

不要隨便設置隨機種子

原則：

因為產生的隨機數的種子被固定了，在Java中，隨機數的產生取決于種子，隨機數和種子之間的關系遵從以下兩個原則：

種子不同，產生不同的隨機數
種子相同，即使實例不同也產生相同的隨機數

看完上面兩個規則，我們再來看以下這個例子。

public static void main(String[] args) {
   //Random r = new Random();
   Random r = new Random(1000);//產生的隨機數的種子被固定了
   for(int i = 1; i <= 4; i++){
     System.out.println("第" + i + "次:" + r.nextInt());
   }
 }

會發現問題就出在有參構造上，Random類的默認種子(無參構造)是System.nonoTime()的返回值(JDK1.5版本以前默認種子是System.currentTimeMillis()的返回值)，注意這個值是距離某一個固定時間點的納秒數，不同的操作系統和硬件有不同的固定時間點，也就是說不同的操作系統其納秒值是不同的，而同一個操作系統納秒值也會不同，隨機數自然也就不同了.