不能小瞧的數組——數組用法的挖掘

在編碼過程中，數組是我們最最常用的資料結構之一。但是數組又是我們最容易拋棄的資料結構，經常由於初始化和數組長度固定等原因，我們常常用ArrayList等其他一些集合類來代替它。其實，數組作為最簡單的集合資料，與其他集合資料比較起來有操作簡單和查詢速度快等優點。對於其長度固定的弱點，也在很多時候可以得到相應的解決。此外，在編碼過程中，有些是直觀的就能讓我們使用數組，而很多時候卻不是那麼直觀，需要我們稍加分析才行。本文的總結，是對數組的使用的被忽略而又能顯示數組優點的一些方面的闡述，希望用來拋磚引玉，引起大家對數組的用法進行挖掘。
第一，   數組對if…else…和case語句的改進
在我們的編碼過程中，if語句可以說是隨處可見，我們將我們寫的代碼進行review的時候，經常能看到有一些很長的if…else if…這樣的語句很刺眼，但又好像無可奈何。
            boolean flag = true;
            switch(operatorId)
           {
                 case 1:
                       conditionSql += " > " + "'" + cond + "'";
                       break;
                 case 2:
                       conditionSql += " >= " + "'" + cond + "'";
                       break;
                 case 3:
                       conditionSql += " < " + "'" + cond + "'";
                       break;
                 case 4:
                       conditionSql += " <= " + "'" + cond + "'";
                       break;
                 case 5:
                       conditionSql += " = " + "'" + cond + "'";
                       break;
                 case 6:
                       conditionSql += " like " + "'%" + cond + "%'";
                       break;
                 default:
                       flag = false;
                       break;
           }
這是我擇抄的一段case語句的代碼，在代碼的review過程中，我還發現過比這長多的很多這樣的代碼，所以這樣的代碼還是有一定的代表性。
我們來看這條語句：conditionSql += " > " + "'" + cond + "'";很明顯是一條重複性的語句。每個這樣的語句的不同點在於前面的”>”，”>=”，”<”，”<=”，”=”等等，而他們對應的條件是1，2，3，4等等。我們一觀察就可以知道，如果結果是一個數組的項的話，那麼條件就是該數組的下標。看，多完美啊。
所以我們將上面的語句修改如下：
String[] conditionSqls = new String[]{">'",">='","<'","<='","='","like '%"};
       boolean flag = true;
       if(operatorId>=1&&operatorId<=6)
        {
               conditionSql += conditionSqls[operatorId-1]+cond+"'";
        }
        else flag = false;
這樣是不是簡潔得多？
 
第二，   數組對大量重複性語句的改進
在編碼過程中，我們經常會有這樣的重複性語句：
request.setAttribute("getUserList", list);
                                   request.setAttribute("itemList", list);               
                                   request.setAttribute("tag1", tag);
                                   request.setAttribute("regularTotal",regularTotal);
                                   request.setAttribute("probationTotal",probationTotal);
                                   request.setAttribute("empTotal",empTotal);
                             request.setAttribute("deptEmpList",deptEmpList);
我們也遇到過這樣的指派陳述式：
String contractID = request.getParameter("contractID");
            String categoryID = request.getParameter("categoryID");
            String employeeID = request.getParameter("employeeID");
            String contractNumber = request.getParameter("contractNumber");
            String content = request.getParameter("content");
            String validityDate = request.getParameter("validityDate");
            String contractTerm = request.getParameter("contractTerm");
            String probationTime = request.getParameter("probationTime");
            String pay = request.getParameter("pay");
            String probationPay = request.getParameter("probationPay");
  String createDate = request.getParameter("createDate");
很明顯，這樣的語句都可以用數組來加以簡化，我們先來看第一個，我們一看便知，request.setAttribute("getUserList", list);重複，而每一條語句的不同在於setAttribute的第一個參數和第二個參數不同。解決辦法很明顯，就是把一個參數和第二個參數都做數組：
String[] names = new String[]{“getUserList”,”itemList”,”tag1”,”regularTotal”,” probationTotal”,”empTotal”,”deptEmpList”};
Object[] values = new Object[]{list , list , tag , regularTotal , probationTotal , empTotal , deptEmpList };
For(int I=0;I<names.length;I++)
{
       request.setAttribute(name[i],values[i]);
}
對於第二個語句，我們何必定義那麼多的變數呢，不如用一個數組來代替他們？
 
第三，   互不相關的重複的判斷語句
我們還遇到過大量重複的單條件判斷語句，像下面這樣的例子：
            if(ObjectUtils.isNullOrEmpty(categoryID))
           {
                 errors.add(ActionErrors.GLOBAL_ERROR,
                                  new ActionError("ContractInfo.Add.categoryID"));
                 saveErrors(request, errors);
           }
            if(ObjectUtils.isNullOrEmpty(employeeID))
           {
                 errors.add(ActionErrors.GLOBAL_ERROR,
                                  new ActionError("ContractInfo.Add.employeeID"));
                 saveErrors(request, errors);
           }
            if(ObjectUtils.isNullOrEmpty(contractNumber))
           {
                 errors.add(ActionErrors.GLOBAL_ERROR,
                                  new ActionError("ContractInfo.Add.contractNumber"));
                 saveErrors(request, errors);
           }
            if(ObjectUtils.isNullOrEmpty(validityDate))
           {
                 errors.add(ActionErrors.GLOBAL_ERROR,
                                  new ActionError("ContractInfo.Add.validityDate"));
                 saveErrors(request, errors);
           }
            if(ObjectUtils.isNullOrEmpty(contractTerm))
           {
                 errors.add(ActionErrors.GLOBAL_ERROR,
                                  new ActionError("ContractInfo.Add.contractTerm"));
                 saveErrors(request, errors);
           }
            if(ObjectUtils.isNullOrEmpty(probationTime))
           {
                 errors.add(ActionErrors.GLOBAL_ERROR,
                                  new ActionError("ContractInfo.Add.probationTime"));
                 saveErrors(request, errors);
           }
            if(ObjectUtils.isNullOrEmpty(pay))
           {
                 errors.add(ActionErrors.GLOBAL_ERROR,
                                  new ActionError("ContractInfo.Add.pay"));
                 saveErrors(request, errors);
           }
            if(ObjectUtils.isNullOrEmpty(probationPay))
           {
                 errors.add(ActionErrors.GLOBAL_ERROR,
                                  new ActionError("ContractInfo.Add.probationPay"));
                 saveErrors(request, errors);
           }
 
            if(ObjectUtils.isNullOrEmpty(createDate))
           {
                 errors.add(ActionErrors.GLOBAL_ERROR,
                                  new ActionError("ContractInfo.Add.createDate"));
                 saveErrors(request, errors);
           }
  }
這種if語句沒有else，每一個都要判斷到，其實是一個迴圈語句。修改後的代碼如下：
String[] values = newString[]{categoryID,employeeID,contractNumber,validityDate,contractTerm,probationTime,pay,probationPay,createDate};
String[] InfoNames = new String[]{“categoryID”,”employeeID”,”contractNumber”,”validityDate”,”contractTerm”,”probationTime”,”pay”,”probationPay”,”createDate”};
For(int I=0;I<values.length;I++)
{
              if(ObjectUtils.isNullOrEmpty(values[i]))
           {
                 errors.add(ActionErrors.GLOBAL_ERROR,
                                  new ActionError("ContractInfo.Add."+InfoNames[i]));
                 saveErrors(request, errors);
           }
}
第四，   零長度數組的使用。
在數組的使用過程中，我們經常出現這樣的語句：
if(names!=null)
{
        for(int I=0;I<names.length;I++)
        {
               ……
}
}
明明names是一個數組，卻要判斷它非空的情況，這個if語句讓人感覺很多此一舉，但又無可奈何。
其實，我們仔細一想，出現names為空白的情況的原因就是在給names數組賦值的時候，出現了一種情況下沒有對names初始化，這在我們的編碼過程中其實是不允許的。
解決的辦法就是在沒有辦法對names初始化的時候將它初始化為零長度數組。如：
String[] names;
        String condition = "1";
       if(condition.equals("2"))
        {
               names = new String[]{"name1","name2"};
        }
        else
        {
               names = new String[]{};
        }
        for(int i=0;i<names.length;i++)
        {
               System.out.println(names[i]);
        }
第五，   Arrays庫的數組的用法。
在Java API的Arrays庫裡，有一些很好的方法，現列在下面：
1．  數組的查詢：binarySearch
String[] strs1 = new String[]{"1","2","3","4"};
  int i = Arrays.binarySearch(strs1,"2");
  System.out.println(i);
2．  數組的覆蓋：fill
String[] strs1 = new String[]{"1","2","3","4"};
  Arrays.fill(strs1,2,3,"haha");
  for(int i=0;i<strs1.length;i++)
         {
         System.out.println(strs1[i]);
         }
注意：第一個參數為數組，最後一個參數是覆蓋後的新值，覆蓋的位置為，從第二個參數開始，覆蓋數組項的個數為，第三個參數減去第二個參數。
3．  數組的排序：sort
String[] strs1 = new String[]{"1","2","6","4"};
Arrays.sort(strs1);
for(int i=0;i<strs1.length;i++)
        {
        System.out.println(strs1[i]);
        }
第六，   資料和其他資料類型的轉化
我們經常需要將數組轉化為List、ArrayList等一些資料類型，然後我們又需要將他們轉化回來。
將數組轉化為List：
String[] strs1 = new String[]{"1","2","6","4"};
        List list = Arrays.asList(strs1);
將數組轉化為ArrayList：
String[] strs1 = new String[]{"1","2","6","4"};
        List list = Arrays.asList(strs1);
       ArrayList al = new ArrayList();
       al.addAll(list);
將List轉化為數組：
String[] strs1 = new String[]{"1","2","6","4"};
        List list = Arrays.asList(strs1);
       String[] strs2 = (String[])list.toArray(new String[0]);
        for(int i=0;i<strs2.length;i++)
        {
               System.out.println(strs1[i]);
        }
第七，   去掉數組中相同的項
我們知道，數組的項是可以重複的，有時候我們需要去掉數組中重複的項，怎麼辦？我們也知道，HashSet裡面是沒有重複的項的，我們可不可以將數組轉化為HashSet，然後再轉化回來呢？
String[] strs1 = new String[]{"1","2","6","4","2","4"};
       HashSet set = new HashSet();
       set.addAll(Arrays.asList(strs1));
       String[] strs2 = (String[])set.toArray(new String[0]);
        for(int i=0;i<strs2.length;i++)
        {
               System.out.println(strs1[i]);
        }
第八，   數組的複製
我們可以將一個數組的一些項複製到另外一個數組裡面去，如：
String[] strs1 = new String[]{"1","2","3","4","5","6"};
       String[] strs2 = new String[4];
System.arraycopy(strs1,2,strs2,0,2);
        for(int i=0;i<strs2.length;i++)
        {
        System.out.println(strs2[i]);
        }
上面的這段代碼是將數組strs1複製到數組strs2裡面去，從strs1的下標為2的項開始複製，複製到strs2下標為0的項開始，一直複製2項。
第九，   長度不定的數組
如果數組長度只有有限的幾個選擇，可以使用如下的方法：
String[] array;
if(length.equals(“4”))
{
        array = new String[4];
        ……
}
else if(length.equals(“9”))
{
        array = new String[9];
        ……
}
else if(length.equals(“10”))
{
        array = new String[10];
        ……
}
else array = new String[]{};
 
如果不是能有限確定的，則可以利用反射來產生數組，如：
try {
               int length = 10;
               Class cls = Class.forName(
               "java.lang.String");
               Object arr = Array.newInstance(cls, length);
               String[] strs = (String[])arr;
               for(int i=0;i<strs.length;i++)
               {
                      strs[i] = String.valueOf(i);
               }
               for(int i=0;i<strs.length;i++)
               {
                      System.out.println(strs[i]);
               }
               }
               catch (Throwable e) {
               System.err.println(e);
               }
數組的好處：
1. 可以不用轉型，因為數組中存在的都是同一類型。在某些時候很有用。尤其是在多維陣列的情況下。
2.對於數組不能是有限確定的，說明不應當在繼續時使用數組了，而是使用其他的資料結構，如List。不應當建議使用反射產生動態數組（明顯是C思維）。建議用Arrays.asList轉化為List。如果確實需要參數為數組的，可以先在List上操作，然後可以在用Arrays.toArray產生數組。

本文來自CSDN部落格，轉載請標明出處：http://blog.csdn.net/nomily/archive/2009/06/12/4263286.aspx