不能小瞧的数组——数组用法的挖掘

来源：互联网发布：触摸精灵源码编辑：程序博客网时间：2024/05/21 02:36

在编码过程中，数组是我们最最常用的数据结构之一。但是数组又是我们最容易抛弃的数据结构，经常由于初始化和数组长度固定等原因，我们常常用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);

}