浅谈Java集合中Array(数组)的应用

我们都知道，由于Array(数组)通常意义上讲只是一个单纯的线性序列，又基于Native，凭此它的效率历来便号称Java中最高。所以通常我们也都承认Java中效率最高的存储方式就是使用数组。但是，由于数组初始化后大小固定，索引不能超出下标，缺少灵活的扩展功能等原因，使得很多人放弃了数组的使用， 转而使用Collection,List,Map,Set等接口处理集合操作。

诚然在Java中使用集合类可以极大的简化我们的代码编写量。但是，有时明明只是缓存一些线性数据，还偏偏有人要使用HashMap保存，系统为此付出了不必要的内存损耗。如果是通常的程序还没有什么，当应用在高并发或者加载高内存消耗对象时（如Image图像）无意义的频繁使用集合类将极易引发OutOfMemoryException。

我们很清楚，以List接口实现的集合类中，ArrayList内部运算是基于Array的，所以他继承了Array的优势，非常适合索引取值和存储线性数据(Vector虽然也是基于Array的，但毁在大量的synchronized上……所以很多情况下等于废了……)。但它不适合插入数据和删除数据，因为每插入或删除一次就会产生一次大量数组内容Copy的操作。而LinkedList正好与ArrayList相反，它比较适合与插入删除操作，不适合于索引取值，因为它不可以像数组一样根据索引值直接就可以定位元素的地址，而需要从头至尾一个一个的来数位置。

其实这也是当然的，但凡接触过数据结构的都会知道，任何存储结构都是有其局限性的，没有也不可能有所有方面都完美的存储方式。我们所能做的，只是尽可能使用特定范围内最有效的解决方案，而对此什么解决方法最有效呢？

一般情况下，考虑到效率与类型检查等问题，应该尽可能使用数组，所以我个人比较推荐的方式就是根据需要基于数组定制集合类。

说到这里可能很多人以开发周期及稳定、通用性为借口而直接使用JDK或第三方集合类（或者COPY代码|||）。其实就我个人认为，这有些因噎废食了，确实有时存储对象比较复杂，自己的集合类性能无法保障。但在大多数项目中，这种情况并不存在，我们完全有能力根据需求构造集合以避免不必要的资源占用及进行相应优化。而某些人往往只是见Hibernate等框架返回个List便有样学样的自己也List和Map到底，干脆忘了Arrays.asList等方法是为什么而存在的。

本来JDK提供给我们Arrays.asList方法和Collection.toArray方法就是为了集合类和数组优势互补之用，以此成为数组和Collection等集合类间的桥梁，只要有这两种方法Array和Collection就可以相互转换。那么，我们有什么理由枉费可以利用的资源而不用呢？

事实上，我们只要基本掌握Arrays类和Reflect这两个有力的武器，操作数组处理持久对象根本就是张飞吃豆芽——小菜一碟。

下面，我抛砖引玉的写些代码举例：

TestBean.java(测试用实体类)

packageorg.loon.framework.db.test.util;

/***//**
*<p>
*Title:LoonFramework
*</p>
*<p>
*Description:
*</p>
*<p>
*Copyright:Copyright(c)2007
*</p>
*<p>
*Company:LoonFramework
*</p>
*
*@authorchenpeng
*@email：[e-mail]
*@version0.1
*/
publicclassTestBean...{

Stringname;

intid;

publicintgetId()...{
returnid;
}

publicvoidsetId(intid)...{
this.id=id;
}

publicStringgetName()...{
returnname;
}

publicvoidsetName(Stringname)...{
this.name=name;
}

}

ArrayUtil.java(用于Array的增、删、改、查等操作)

packageorg.loon.framework.db.test.util;

importjava.io.Serializable;
importjava.lang.reflect.Array;
importjava.util.Arrays;
importjava.util.Collection;
importjava.util.List;
importjava.util.Random;


/***//**
*<p>
*Title:LoonFramework
*</p>
*<p>
*Description:ArrayUtil，数组操作工具类
*</p>
*<p>
*Copyright:Copyright(c)2007
*</p>
*<p>
*Company:LoonFramework
*</p>
*
*@authorchenpeng
*@email：[e-mail]
*@version0.1
*/
publicclassArrayUtilimplementsSerializable...{
/***//**
*
*/
privatestaticfinallongserialVersionUID=8057374625909011982L;

//缓存数组对象
privateObjectobjArray;

//数组长度
privateintsize=0;

//缓存数组对象实体类型
privateStringobjType;

finalstaticprivateRandomrand=newRandom();

privatestaticArrayUtilinstance=null;

/***//**
*直接注入Collection
*
*@paramcollection
*@return
*/
publicstaticArrayUtilgetInstance(Collectioncollection)...{
returngetInstance(collection.toArray());
}
/***//**
*直接注入对象数组
*
*@paramarray
*/
publicstaticArrayUtilgetInstance(Objectarray)...{
if(instance==null)...{
instance=newArrayUtil(array);
}
returninstance;
}
/***//**
*注入类产生指定大小对象数组
*
*@paramclazz
*@parammaxSize
*/
publicstaticArrayUtilgetInstance(Classclazz,intmaxSize)...{
if(instance==null)...{
instance=newArrayUtil(clazz,maxSize);
}
returninstance;
}

privateArrayUtil()...{

}

/***//**
*注入对象数组产生指定大小对象数组
*
*@paramclazz
*@parammaxSize
*/
privateArrayUtil(Classclazz,intmaxSize)...{
//转为指定大小对象数组
Objectarray=(Object[])Array.newInstance(clazz,
maxSize);
//初始化
init(array);
}

/***//**
*直接注入对象数组
*
*@paramarray
*/
privateArrayUtil(Objectarray)...{
init(array);
}

privatevoidinit(Objectarray)...{
//检查是否数组对象
if(!(arrayinstanceofObject[]))...{
thrownewIndexOutOfBoundsException("Notobjectarrays！");
}
//缓存数组对象
objArray=array;
//缓存实体类型
objType=array.getClass().getComponentType().getSimpleName();
//缓存数组长度
size=Array.getLength(objArray);
}

/***//**
*返回指定对象索引位置
*
*@paramobj
*@return
*/
publicintget(Objectobj)...{
//检查是否合法对象
checkObject(obj);
Object[]object=(Object[])objArray;
for(inti=0;i<size;i++)
if(object[i]==obj)...{
returni;
}
return-1;
}

/***//**
*返回指定索引位置对象
*
*@paramindex
*@return
*/
publicObjectget(intindex)...{
checkIndex(index);
returngetObjectArray()[index];
}

/***//**
*加载对象在指定位置
*
*@paramobj
*@paramindex
*/
publicvoidadd(Objectobj,intindex)...{
//检查索引是否越界
checkIndex(index);
//检查是否合法对象
checkObject(obj);
Object[]objTemp=(Object[])objArray;
objTemp[index]=obj;
//copy临时数组到objArray
System.arraycopy(objTemp,0,objArray,0,objTemp.length);
}

/***//**
*加载对象
*
*@paramobj
*/
publicvoidadd(Objectobj)...{
//类型检查
checkObject(obj);
//累加
next();
//临时缓存旧数组数组
Object[]objTemp=newObject[size];
//加载对象
objTemp[size-1]=obj;
//copy
System.arraycopy(objArray,0,objTemp,0,Array.getLength(objArray));
//转换
objArray=objTemp;
}

/***//**
*删除指定索引位置数组数据
*
*@paramindex
*@return
*/
publicObjectremove(intindex)...{
//检查索引是否越界
checkIndex(index);
Object[]objTemp=(Object[])objArray;

//重新构建objArray
intj;
if((j=size-index-1)>0)...{
System.arraycopy(objTemp,index+1,objTemp,index,j);
}
//减少size
back();

returnobjTemp[index];
}

publicbooleancontains(Objectobj)...{
Object[]objTemp=(Object[])objArray;
for(inti=0;i<size;i++)...{
if(hash(objTemp[i])==hash(obj))...{
returntrue;
}
}
returnfalse;
}

publicObject[]sub(intstartIndex,intendIndex)...{
//验证索引范围
checkIndex(startIndex);
checkIndex(endIndex);
intover=endIndex-startIndex;
if(over<0)...{
thrownewIndexOutOfBoundsException("Indexbeyondtheendoftheborder!");
}
Object[]objTemp=(Object[])objArray;
Object[]objs=(Object[])Array.newInstance(objArray.getClass().getComponentType(),
over);
for(inti=startIndex;i<endIndex;i++)...{
objs[i-1]=objTemp[i-1];
}
returnobjs;
}

publicvoidclear()...{
Object[]objTemp=(Object[])objArray;
//清空数据
for(inti=0;i<size;i++)...{
objTemp[i]=null;
size=0;
}
}

/***//**
*删除指定的对象实体
*
*@paramobj
*@return
*/
publicbooleanremove(Objectobj)...{
//检查是否合法对象
checkObject(obj);
Object[]object=(Object[])objArray;
for(inti=0;i<size;i++)
if(object[i]==obj)...{
remove(i);
returntrue;
}
returnfalse;
}

/***//**
*混淆数组元素
*
*@return
*/
publicvoidmixElements()...{
mixElements(objArray);
}

/***//**
*检查数组内元素是否为空
*
*@return
*/
publicbooleanisEmpty()...{
return(size==0);
}

/***//**
*转为list
*
*@return
*/
publicListgetList()...{
returnArrays.asList((Object[])objArray);
}

/***//**
*减少size
*
*/
privatevoidback()...{
size--;
}

/***//**
*增加size
*
*/
privatevoidnext()...{
size++;
}

/***//**
*检查索引是否溢出
*
*@paramindex
*/
privatevoidcheckIndex(intindex)...{

if(index>=size||index<0)...{
thrownewIndexOutOfBoundsException("Index"+index
+"outofbounds！");
}
}

/***//**
*检查对象类型
*
*@paramobj
*/
privatevoidcheckObject(Objectobj)...{
if(objinstanceofObject[])...{
thrownewIndexOutOfBoundsException("Notloadingarrays！");
}
Stringtype;
if(!objType.equals(type=obj.getClass().getSimpleName()))...{
thrownewIndexOutOfBoundsException("Notthis"+type
+"typeofloading！");
}
}

/***//**
*扩充数组对象
*
*@paramobj
*@parami
*@paramflag
*@return
*/
staticpublicObjectexpand(Objectobj,inti,booleanflag)...{
intj=Array.getLength(obj);
Objectobj1=Array.newInstance(obj.getClass().getComponentType(),j
+i);
System.arraycopy(obj,0,obj1,flag?0:i,j);
returnobj1;
}

/***//**
*扩充数组对象
*
*@paramobj
*@parami
*@paramflag
*@return
*/
staticpublicObjectexpand(Objectobj,inti)...{
returnexpand(obj,i,true);
}

/***//**
*随机返回数组内容
*
*@paramobj
*/
staticpublicvoidmixElements(Objectobj)...{
inti=Array.getLength(obj);
for(intk=0;k<i;k++)...{
intj=getRandom(k,i-1);
Objectobj1=Array.get(obj,j);
Array.set(obj,j,Array.get(obj,k));
Array.set(obj,k,obj1);
}

}

staticpublicRandomgetRandomObject()...{
returnrand;
}

staticpublicintgetRandom(inti,intj)...{
returni+rand.nextInt((j-i)+1);
}

privateinthash(Objectobj)...{
inth=obj.hashCode();
h+=~(h<<9);
h^=(h>>>14);
h+=(h<<4);
h^=(h>>>10);
returnh;
}

publicinthashCode()...{
returnhash(objArray.getClass());
}

publicintsize()...{
returnsize;
}

/***//**
*反回当前数组对象
*
*@return
*/
publicObject[]getObjectArray()...{
return(Object[])objArray;
}

publicstaticvoidmain(String[]args)...{

/**//*TestBean[]tb=newTestBean[3];
for(inti=0;i<tb.length;i++){
tb[i]=newTestBean();
tb[i].setName("name"+i);
tb[i].setId(i);
}
//直接载入已有数组对象
ArrayUtilarrayUtil=ArrayUtil.getInstance(tb);
TestBeantb1=newTestBean();
//arrayUtil.add(tb[0]);
arrayUtil.remove(tb[0]);
//arrayUtil.remove(tb[2]);
System.out.println(arrayUtil.contains(tb1));
System.out.println(((TestBean)arrayUtil.get(0)).getName());
System.out.println(arrayUtil.size());
//打乱数组
arrayUtil.mixElements();
for(inti=0;i<arrayUtil.size();i++){
System.out.println(((TestBean)arrayUtil.get(i)).getName());
}*/
//生成TestBean的数组实例，初始容量为5
ArrayUtilarrayUtil=ArrayUtil.getInstance(TestBean.class,5);
TestBeant=newTestBean();
t.setName("test");
//在数组载入t的实例
arrayUtil.add(t,0);
TestBeant1=newTestBean();
t1.setName("test1");
arrayUtil.add(t1,1);
arrayUtil.add(t,2);
arrayUtil.add(t,3);
arrayUtil.add(t,4);
//会自动增加数组容量
arrayUtil.add(t);
//显示索引5数据
System.out.println(((TestBean)arrayUtil.get(5)).getName());
//截取索引1-3，显示1数据
System.out.println(((TestBean)arrayUtil.sub(1,3)[1]).getName());

}

}

通过例子我们可以发现，只是简单的几行代码，就令Array发挥出我们需要借助他人集合类才能完成的功能。而这些，却本来是我们也可以轻易做到的。

所以本人在此呼吁，坚持尽量使用数组，从我做起，从每个项目做起~~~