数据结构--Java实现动态数组

Java实现动态数组

//定义一个自己的数组---泛型
public class MyArray<T> {
    
    
    int size;//定义数组存放内容的实际个数
    T [] data;/*定义一个数组 构造方法--->定义数组长度*/

    public MyArray(int capacity) {
    
    
        size = 0;
        this.data = (T[]) new Object[capacity];
    }

        public MyArray() {
    
    
        this(10);
    }

    //判断数组是否为空
    public boolean isEmpty() {
    
    
        return size == 0;
    }

    //获取数组的容量
    public int getCapacity() {
    
    
        return data.length;
    }

    //向数组末尾添加数据
    public void addLast(T element) {
    
    
        /*if (size == data.length) {
            throw new ArrayIndexOutOfBoundsException("数组容量不足!");
        }
        data[size] = element;
        size ++;*/
        addPosition(size,element);
    }
    //向数组指定位置添加元素
    public void addPosition(int index,T element) {
    
    
        if (index < 0 || index > size){
    
    
            throw new ArrayIndexOutOfBoundsException("索引不在数组有效索引之内!");
        }
        if (size == data.length){
    
    
            //数组扩容
            reCapacity(getCapacity()<<1);
        }
        for (int i = size; i > index; i--) {
    
    
            data[i] = data[i-1];
        }
        data[index] = element;
        size ++;
    }

    //数组改变容量(增减)
    private void reCapacity(int newCapacity){
    
    
        T[] newData = (T[])new Object[newCapacity];
        System.arraycopy(data,0,newData,0,size);
        data = newData;
    }

    //向数组头部添加元素
    public void addHeader(T element) {
    
    
        addPosition(0,element);
    }

    //获取指定位置元素
    public T getElementByIndex(int index){
    
    
        if (index < 0 || index >= size){
    
    
            throw new ArrayIndexOutOfBoundsException("索引不在数组有效范围内!");
        }
        return data[index];
    }

    //修改指定位置元素
    public void setElementByIndex(int index,T element){
    
    
        if (index < 0 || index >= size){
    
    
            throw new ArrayIndexOutOfBoundsException("索引不在数组有效范围内!");
        }
        data[index] = element;
    }

    //判断数组中是否包含指定元素
    public boolean isInclude(T element){
    
    
        boolean flag = false;
        for (int i = 0; i < size; i++) {
    
    
            if (data[i].equals(element)){
    
    
                flag = true;
                break;
            }
        }
        return flag;
    }

    //搜索指定元素的位置
    public int searchIndexByElement(T element){
    
    
        int flag = -1;
        for (int i = 0; i < size; i++){
    
    
            if (data[i].equals(element)){
    
    
                flag = i;
                break;
            }
        }
        return flag;
    }

    //删除指定位置的元素
    public T deleteElementByIndex(int index){
    
    
        if (index < 0 || index >= size){
    
    
            throw new ArrayIndexOutOfBoundsException("索引位置不在数组有效范围内!");
        }
        //被删除的数据
        T number = data[index];
        for (int i = index; i < size-1; i++){
    
    
            data[i] = data[i+1];
        }
        data[size-1] = null;
        size--;
        if (size == getCapacity()/3 && (getCapacity()>>1) >10){
    
    
            //数组减容
            reCapacity(getCapacity()>>1);
        }
        return number;
    }

    //删除最后一个元素
    public T deleteLastElement(){
    
    
        return deleteElementByIndex(size-1);
    }

    //删除第一个元素
    public T deleteFirstElement() {
    
    
        return deleteElementByIndex(0);
    }

    //删除指定元素
    public void deleteElement(T element){
    
    
        deleteElementByIndex(searchIndexByElement(element));
    }

    @Override
    public String toString() {
    
    
        StringBuffer str = new StringBuffer();
        str.append("数组容量为"+getCapacity()+",数组内的有效元素有"+size+"个"+"\n");
        str.append("数组为[");
        for (int i = 0; i < size; i++) {
    
    
            if (i == size-1){
    
    
                str.append(getElementByIndex(i));
            }else{
    
    
                str.append(getElementByIndex(i)+",");
            }
        }
        str.append("]");
        return str.toString();
    }
}