数组工具类 (集合，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;
/** */
/**
 * <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
 */
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());
         */
    }
}
用户注册

用户登录

发表随想

该用户最新代码

编程随想

[java]代码库

网友评论 (发表评论)

回复评论

发表评论：

评论须知：

扫码下载

输入口令后可复制整站源码
