java 创建数组工具类_数组工具类 (集合，Array的增、删、改、查等操作)

[java]代码库package org.loon.framework.db.test.util;

import java.io.Serializable;

import java.lang.reflect.Array;

import java.util.Arrays;

import java.util.Collection;

import java.util.List;

import java.util.Random;

/** */

/**

*

* Title: LoonFramework

*

*

* Description:ArrayUtil，数组操作工具类 (实现集合类部分功能，用于Array的增、删、改、查等操作)

*

*

* Copyright: Copyright (c) 2007

*

*

* Company: LoonFramework

*

*

* @author chenpeng

* @email：ceponline@yahoo.com.cn

* @version 0.1

*/

public class ArrayUtil implements Serializable {

/** */

/**

*

*/

private static final long serialVersionUID = 8057374625909011982L;

// 缓存数组对象

private Object objArray;

// 数组长度

private int size = 0;

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

private String objType;

final static private Random rand = new Random();

private static ArrayUtil instance = null;

/** */

/**

* 直接注入Collection

*

* @param collection

* @return

*/

public static ArrayUtil getInstance(Collection collection) {

return getInstance(collection.toArray());

}

/** */

/**

* 直接注入对象数组

*

* @param array

*/

public static ArrayUtil getInstance(Object array) {

if (instance == null) {

instance = new ArrayUtil(array);

}

return instance;

}

/** */

/**

* 注入类产生指定大小对象数组

*

* @param clazz

* @param maxSize

*/

public static ArrayUtil getInstance(Class clazz, int maxSize) {

if (instance == null) {

instance = new ArrayUtil(clazz, maxSize);

}

return instance;

}

private ArrayUtil() {

}

/** */

/**

* 注入对象数组产生指定大小对象数组

*

* @param clazz

* @param maxSize

*/

private ArrayUtil(Class clazz, int maxSize) {

// 转为指定大小对象数组

Object array = (Object[]) Array.newInstance(clazz, maxSize);

// 初始化

init(array);

}

/** */

/**

* 直接注入对象数组

*

* @param array

*/

private ArrayUtil(Object array) {

init(array);

}

private void init(Object array) {

// 检查是否数组对象

if (!(array instanceof Object[])) {

throw new IndexOutOfBoundsException("Not object arrays！");

}

// 缓存数组对象

objArray = array;

// 缓存实体类型

objType = array.getClass().getComponentType().getSimpleName();

// 缓存数组长度

size = Array.getLength(objArray);

}

/** */

/**

* 返回指定对象索引位置

*

* @param obj

* @return

*/

public int get(Object obj) {

// 检查是否合法对象

checkObject(obj);

Object[] object = (Object[]) objArray;

for (int i = 0; i < size; i++)

if (object[i] == obj) {

return i;

}

return -1;

}

/** */

/**

* 返回指定索引位置对象

*

* @param index

* @return

*/

public Object get(int index) {

checkIndex(index);

return getObjectArray()[index];

}

/** */

/**

* 加载对象在指定位置

*

* @param obj

* @param index

*/

public void add(Object obj, int index) {

// 检查索引是否越界

checkIndex(index);

// 检查是否合法对象

checkObject(obj);

Object[] objTemp = (Object[]) objArray;

objTemp[index] = obj;

// copy临时数组到objArray

System.arraycopy(objTemp, 0, objArray, 0, objTemp.length);

}

/** */

/**

* 加载对象

*

* @param obj

*/

public void add(Object obj) {

// 类型检查

checkObject(obj);

// 累加

next();

// 临时缓存旧数组数组

Object[] objTemp = new Object[size];

// 加载对象

objTemp[size - 1] = obj;

// copy

System.arraycopy(objArray, 0, objTemp, 0, Array.getLength(objArray));

// 转换

objArray = objTemp;

}

/** */

/**

* 删除指定索引位置数组数据

*

* @param index

* @return

*/

public Object remove(int index) {

// 检查索引是否越界

checkIndex(index);

Object[] objTemp = (Object[]) objArray;

// 重新构建objArray

int j;

if ((j = size - index - 1) > 0) {

System.arraycopy(objTemp, index + 1, objTemp, index, j);

}

// 减少size

back();

return objTemp[index];

}

public boolean contains(Object obj) {

Object[] objTemp = (Object[]) objArray;

for (int i = 0; i < size; i++) {

if (hash(objTemp[i]) == hash(obj)) {

return true;

}

}

return false;

}

public Object[] sub(int startIndex, int endIndex) {

// 验证索引范围

checkIndex(startIndex);

checkIndex(endIndex);

int over = endIndex - startIndex;

if (over < 0) {

throw new IndexOutOfBoundsException(

"Index beyond the end of the border!");

}

Object[] objTemp = (Object[]) objArray;

Object[] objs = (Object[]) Array.newInstance(objArray.getClass()

.getComponentType(), over);

for (int i = startIndex; i < endIndex; i++) {

objs[i - 1] = objTemp[i - 1];

}

return objs;

}

public void clear() {

Object[] objTemp = (Object[]) objArray;

// 清空数据

for (int i = 0; i < size; i++) {

objTemp[i] = null;

size = 0;

}

}

/** */

/**

* 删除指定的对象实体

*

* @param obj

* @return

*/

public boolean remove(Object obj) {

// 检查是否合法对象

checkObject(obj);

Object[] object = (Object[]) objArray;

for (int i = 0; i < size; i++)

if (object[i] == obj) {

remove(i);

return true;

}

return false;

}

/** */

/**

* 混淆数组元素

*

* @return

*/

public void mixElements() {

mixElements(objArray);

}

/** */

/**

* 检查数组内元素是否为空

*

* @return

*/

public boolean isEmpty() {

return (size == 0);

}

/** */

/**

* 转为list

*

* @return

*/

public List getList() {

return Arrays.asList((Object[]) objArray);

}

/** */

/**

* 减少size

*

*/

private void back() {

size--;

}

/** */

/**

* 增加size

*

*/

private void next() {

size++;

}

/** */

/**

* 检查索引是否溢出

*

* @param index

*/

private void checkIndex(int index) {

if (index >= size || index < 0) {

throw new IndexOutOfBoundsException("Index " + index

+ " out of bounds！");

}

}

/** */

/**

* 检查对象类型

*

* @param obj

*/

private void checkObject(Object obj) {

if (obj instanceof Object[]) {

throw new IndexOutOfBoundsException("Not loading arrays！");

}

String type;

if (!objType.equals(type = obj.getClass().getSimpleName())) {

throw new IndexOutOfBoundsException("Not this " + type

+ " type of loading！");

}

}

/** */

/**

* 扩充数组对象

*

* @param obj

* @param i

* @param flag

* @return

*/

static public Object expand(Object obj, int i, boolean flag) {

int j = Array.getLength(obj);

Object obj1 = Array.newInstance(obj.getClass().getComponentType(), j

+ i);

System.arraycopy(obj, 0, obj1, flag ? 0 : i, j);

return obj1;

}

/** */

/**

* 扩充数组对象

*

* @param obj

* @param i

* @param flag

* @return

*/

static public Object expand(Object obj, int i) {

return expand(obj, i, true);

}

/** */

/**

* 随机返回数组内容

*

* @param obj

*/

static public void mixElements(Object obj) {

int i = Array.getLength(obj);

for (int k = 0; k < i; k++) {

int j = getRandom(k, i - 1);

Object obj1 = Array.get(obj, j);

Array.set(obj, j, Array.get(obj, k));

Array.set(obj, k, obj1);

}

}

static public Random getRandomObject() {

return rand;

}

static public int getRandom(int i, int j) {

return i + rand.nextInt((j - i) + 1);

}

private int hash(Object obj) {

int h = obj.hashCode();

h += ~(h << 9);

h ^= (h >>> 14);

h += (h << 4);

h ^= (h >>> 10);

return h;

}

public int hashCode() {

return hash(objArray.getClass());

}

public int size() {

return size;

}

/** */

/**

* 反回当前数组对象

*

* @return

*/

public Object[] getObjectArray() {

return (Object[]) objArray;

}

public static void main(String[] args) {

/*

* package org.loon.framework.db.test.util;

*

*

* //测试实体类

*

* public class TestBean {

*

* String name;

*

* int id;

*

* public int getId() { return id; }

*

* public void setId(int id) { this.id = id; }

*

* public String getName() { return name; }

*

* public void setName(String name) { this.name = name; }

*

* }

*/

/**//*

* TestBean[] tb = new TestBean[3]; for (int i = 0; i < tb.length;

* i++) { tb[i] = new TestBean(); tb[i].setName("name" + i);

* tb[i].setId(i); } //直接载入已有数组对象 ArrayUtil arrayUtil =

* ArrayUtil.getInstance(tb); TestBean tb1 = new TestBean(); //

* 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 (int i = 0; i < arrayUtil.size();

* i++) { System.out.println(((TestBean)

* arrayUtil.get(i)).getName()); }

*/

/**

* // 生成TestBean的数组实例，初始容量为5 ArrayUtil arrayUtil =

* ArrayUtil.getInstance(TestBean.class, 5); TestBean t = new

* TestBean(); t.setName("test"); // 在数组载入t的实例 arrayUtil.add(t, 0);

* TestBean t1 = new TestBean(); 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());

*/

}

}