数据结构之动态数组

Batac

联系方式:1763781716@qq.com

几种数据结构:集合,线性结构,树形结构,图形结构:

说明:

• 线性表的顺序存储结构:数组
• 数组:一次性申请一定量的内存空间;
• 动态数组:不断的扩容,重新申请更大的内存空间;
• 实现动态数组:

---

public class ArrayList<E> {



/**

* 元素个数

*/

private int size;



/**

* 数组

*/

private E[] elements;



/**

* 默认数组容量

*/

private static final int DEFAULT_CAPACITY = 10;



/**

* 未找到数据

*/

private static final int DEFAULT_NOT_FOUND = -1;



/**

* 传入对应大小容量

* @param capaticy

*/

public ArrayList(int capaticy) {

    if (capaticy < DEFAULT_CAPACITY) {

        elements = (E[]) new Object[DEFAULT_CAPACITY];

    }else{

        elements = (E[]) new Object[capaticy];

    }

}



/**

* 创建数组

*/

public ArrayList() {

    this(DEFAULT_CAPACITY);

}



/**

* 数组元素个数

* @return

*/

public int size() {

    return size;

}



/**

* 判断是数组否为空

* @return

*/

public boolean isEmpty() {

    if (size == 0) {

        return true;
    
    }else{

        return false;

    }

}



/**

* 判断是否包含element元素

* @param element

* @return

*/

public boolean contains(E element) {

    if (indexOf(element) == DEFAULT_NOT_FOUND) {

        return false;

    }else{

        return true;

    }

}



/**

* 添加元素

* @param element

*/

public void add(E element) {

    add(size, element);

}



/**

* 获取元素

* @param index

* @return

*/

public E get(int index) {

    rangeCheck(index);

    return elements[index];

}



/**

* 插入元素

* @param index

* @param element

*/

public void add(int index,E element) {

    enCapacity(index);///扩容

    rangeCheckForAdd(index);



    if (index == size){

        elements[size] = element;

    }else{

        for (int i = size; i > index; i--) {

            elements[i] = elements[i-1];

        }

        elements[index] = element;

    }

      size++;

}


/**
*
*打印数组内容
*/
@Override

public String toString() {

    String string = "ArrayList [size=" + size + ", elements=[";

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

        if (i== 0) {

            string = string+elements[i];

        }else{

            string = string+", "+elements[i];

        }

    }

    string = string+"]";

    return string;

}



/**

* 判断某元素位置

* @param element

* @return

*/

public int indexOf(E element) {//可以保存null,所以校验null需要做特殊处理

    if (element == null) {

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

            if (elements[i] == null)return i;

        }

    }else{

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

            if (element.equals(elements[i]))return i;

        }

    }

    return DEFAULT_NOT_FOUND;

}



/**

* 删除元素

* @param element

* @return

*/

public int remove(E element) {

    int index = indexOf(element);

    rangeCheck(index);

    if (index != size-1) {//最后一个元素,直接减去

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

            elements[i] = elements[i+1];

        }

    }

    elements[(size--)-1] = null;//删除最后一个对象的值

    return index;

}



/**

* 删除指定索引值

* @param index

* @return

*/

public E removeOfIndex(int index) {

    rangeCheck(index);

    E old = get(index);

    remove(old);

    return old;

}



/**

* 清空数组

*/

public void clear() {

    //清空内存地址

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

        elements[i] = null;

    }

    size = 0;

}



private void IndexOutOfBounds(int index) {

    throw new IndexOutOfBoundsException("Index:"+index + ","+"Size:"+size);

}

private void rangeCheck(int index) {

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

        IndexOutOfBounds(index);

    }

}



/**

* 边界校验

* @param index

*/

private void rangeCheckForAdd(int index) {

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

        IndexOutOfBounds(index);

    }

}



/**

* 扩容

* @param index

*/

private void enCapacity(int index) {

    int oldCap = elements.length;

    if (size == oldCap-1){

        oldCap = oldCap + (oldCap >> 1);

        E[] el = (E[]) new Object[oldCap];

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

            el[i] = elements[i];

        }

        System.out.println(elements.length + "扩容:"+el.length);

        elements = el;

    }

}

}

对外公开方法: