有序数组的实现

package com.xu.adt;

public class NumberOrderArray {

    private Integer[] obj;

    /** *//**
     * 
     */
    private int size = 0; // 有效数据大小

    private int step = 50; // 数组增长大小

    private int count = 50;// 数组大小(包含空值元素)

    public NumberOrderArray(int step) {
        obj = new Integer[50]; // 初始化一个数组
        this.step = step;
    }

    public NumberOrderArray() {
        this(50); // 默认空数组大小
    }

    public NumberOrderArray(Integer[] a) {
        obj = a; // 初始化一个数组
        size = a.length;
        this.count = size;
    }

    /** *//**
     * @param musicId
     * @return
     */
    public boolean insert(int index) {
        int ind = this.findNext(index);

        if (ind < 0) {
            return true;
        }
        if (count == size) {
            // 如果数组满，则增长数组
            count += step;
            Integer[] tempArray = new Integer[count];
            for (int i = 0; i < size; ++i)
                tempArray[i] = obj[i];
            obj = tempArray;
        }
        ++size;
        for (int i = size - 1; i > ind; --i)
            obj[i] = obj[i - 1];
        obj[ind] = index;
        return true;
    }
    
    
    /** *//**
     * 批量添加
     * @param secondArray
     * @return
     */
    public boolean insert(Integer[] secondArray) {
        if(secondArray.length == 0)
            return false;
        for(int i = 0,c = secondArray.length;i<c;++i) {
            if(secondArray[i]== null)
                break;
            insert(secondArray[i]);
        }
        return true;
    }
    
    public boolean insert(int index,boolean bl) {
        if(bl) {
            if (count == size) {
                // 如果数组满，则增长数组
                count += step;
                Integer[] tempArray = new Integer[count];
                for (int i = 0; i < size; ++i)
                    tempArray[i] = obj[i];
                obj = tempArray;
            }
            ++size;
            obj[size-1] = index;
            return true;
        }else {
            return insert(index);
        }
    }

    /** *//**
     * 删除音乐索引所在数据，但不删除数据所代表的音乐信息
     * 
     * @param musicId
     *            音乐索引
     * @return true
     */
    public boolean remove(int index) {
        int ind = indexOf(index);
        if (ind == -1)
            return false;
        --size;
        for (int i = ind; i < size; ++i)
            obj[i] = obj[i + 1];
        return true;
    }

    /** *//**
     * 删除数组中全部数据，但不改变数组长度
     * 
     * @return 返回true
     */
    public boolean removeAll() {
        if (size == 0)
            return true;
        for (int i = 0; i < size; ++i)
            obj[i] = null;
        size = 0;
        return true;
    }

    /** *//**
     * @param index
     *            数据索引
     * @return 索引号代表的值，为信息位置的索引
     */
    public Integer get(int index) {
        return obj[index];
    }

    /** *//**
     * 二分法查找一个musicId，如果存在，直接返回该musicId的引索值. 如果不存在，则返回-1
     * 
     * @param musicId
     *            musicId
     * @return musicId的引索值或-1
     */
    public int indexOf(int index) {
        if (size == 0) {
            return -1;
        }
        int height = size;
        int low = 0;
        int curId = (height + low) / 2;
        while (height >= low && low < size) {
            curId = (height + low) / 2;
            if ((Integer) obj[curId] == index) {
                return curId;
            } else if ((Integer) obj[curId] > index) {
                height = curId - 1;
            } else {
                low = curId + 1;
            }
        }
        return -1;
    }

    /** *//**
     * 用于要插入一个数据之前，运行，查找要插入的部位
     * 
     * @param index
     *            index
     * @return 比index大且最近的一个数的引索,如果数据为空，则返回0，如果存在，返回-1
     */
    private int findNext(int index) {
        if (size == 0) {
            return 0;
        }
        int height = size;
        int low = 0;
        int curId = (height + low) / 2;
        while (height >= low && low < size) {
            curId = (height + low) / 2;
            try {
                if ((Integer) obj[curId] == index) {
                    return -1;
                } else if ((Integer) obj[curId] > index) {
                    height = curId - 1;
                } else {
                    low = curId + 1;
                }
            } catch (Exception ex) {
                return -1;
            }
        }
        return (Integer) obj[curId] > index ? curId : curId + 1;
    }

    /**//*
     * 返回数组内有效值组成的字符串
     * 
     * @see java.lang.Object#toString()
     */
    public String toString() {
        if (size == 0)
            return "null";
        StringBuffer str = new StringBuffer(this.count * 4);
        // System.out.println("Size:"+size);
        for (int i = 0; i < this.size; ++i) {
            str.append(obj[i] + ",");
        }
        return str.deleteCharAt(str.length() - 1).toString();
    }

    /** *//**
     * @param args
     */
    public static void main(String[] args) {
        NumberOrderArray adt = new NumberOrderArray(50);
        for (int i = 10; i > 0; --i) {// 最坏情况的插入1000项数据
        // for (int i = 0; i < 1000; ++i) {//最好情况地插入1000条数据
            adt.insert(i);
            System.out.println(adt.toString());
        }
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public Integer[] getObj() {
        return obj;
    }

    public int getSize() {
        return size;
    }

    public int getStep() {
        return step;
    }
}

    没什么好说的，写来玩玩。