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;
/** */
/**
* <p>
* Title: LoonFramework
* </p>
* <p>
* Description:ArrayUtil，数组操作工具类 (实现集合类部分功能，用于Array的增、删、改、查等操作)
* </p>
* <p>
* Copyright: Copyright (c) 2007
* </p>
* <p>
* Company: LoonFramework
* </p>
*
* @author chenpeng
* @email：ceponline@yahoo.com.cn
* @version 0.1
*/
/** */
/**
*
*/
private static final long serialVersionUID = 8057374625909011982L;
// 缓存数组对象
// 数组长度
private int size = 0;
// 缓存数组对象实体类型
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) {
// 转为指定大小对象数组
// 初始化
init(array);
}
/** */
/**
* 直接注入对象数组
*
* @param array
*/
private ArrayUtil
(Object array
) { init(array);
}
private void init
(Object array
) { // 检查是否数组对象
if (!(array
instanceof Object[])) { }
// 缓存数组对象
objArray = array;
// 缓存实体类型
objType = array.getClass().getComponentType().getSimpleName();
// 缓存数组长度
size
= Array.
getLength(objArray
); }
/** */
/**
* 返回指定对象索引位置
*
* @param obj
* @return
*/
// 检查是否合法对象
checkObject(obj);
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);
objTemp[index] = obj;
// copy临时数组到objArray
System.
arraycopy(objTemp,
0, objArray,
0, objTemp.
length); }
/** */
/**
* 加载对象
*
* @param obj
*/
// 类型检查
checkObject(obj);
// 累加
next();
// 临时缓存旧数组数组
// 加载对象
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);
// 重新构建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
) { 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) {
"Index beyond the end of the border!");
}
.getComponentType(), over);
for (int i = startIndex; i < endIndex; i++) {
objs[i - 1] = objTemp[i - 1];
}
return objs;
}
public void clear() {
// 清空数据
for (int i = 0; i < size; i++) {
objTemp[i] = null;
size = 0;
}
}
/** */
/**
* 删除指定的对象实体
*
* @param obj
* @return
*/
public boolean remove
(Object obj
) { // 检查是否合法对象
checkObject(obj);
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
*/
}
/** */
/**
* 减少size
*
*/
private void back() {
size--;
}
/** */
/**
* 增加size
*
*/
private void next() {
size++;
}
/** */
/**
* 检查索引是否溢出
*
* @param index
*/
private void checkIndex(int index) {
if (index >= size || index < 0) {
+ " out of bounds！");
}
}
/** */
/**
* 检查对象类型
*
* @param obj
*/
private void checkObject
(Object obj
) { if (obj
instanceof Object[]) { }
if (!objType.equals(type = obj.getClass().getSimpleName())) {
+ " 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
*/
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);
}
}
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
() { }
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());
*/
}
}