数据结构之可变长度数组-仿ArrayList实现

分析：

1. 实现一个能自动扩容的Array,基于数组实现
2. 有增删改查操作
3. 类似一个Arraylist结合，支持范型

1.构造函数

private E[] mDatas;
private int size;

public Array(int capacity){
    mDatas = (E[]) new Object[capacity];
    size = 0;
}

public Array(){
    this(10);
}   

2. 添加数据

/**
 * 指定位置添加数据 能自动扩容
 * @param index
 * @param e
 */
public void add(int index,E e){

    assertIndex(index);

    //如果size == 数组的容量大小了 ，就把数组大小扩容为原来的两倍
    if(size == mDatas.length){
        resize( 2 * size);
    }

    //往指定位置添加元素 就是把指定位置的元素都往右移 不过要从最后一个数开始移动 直到index
    for (int i = size - 1; i >= index; i--) {
        mDatas[i + 1] = mDatas[i];
    }
    mDatas[index] = e;
    size ++;
}

public void addFirst(E e){
    add(0,e);
}

public void addLast(E e){
    add(size,e);
}

3. 删除数据

/**
 * 移除某一个位置的元素
 * @param index
 * @return
 */
public E remove(int index){

    assertIndex(index);
    E temp = mDatas[index];
    //删除某一个位置的元素就是从右往左移 把这个位置的元素用后面的元素覆盖掉
    for (int i = index + 1; i < size; i++) {
        mDatas[i - 1] = mDatas[i];
    }
    size--;
   // mDatas[index] = null;
    return temp;
}

/**
 * 删除头部元素
 * @return
 */
public E removeFirst(){
    return remove(0);
}

/**
 * 删除尾部元素
 * @return
 */
public E removeLast(){
    return remove(size - 1);
}

 /**
 * 移除某一个元素 先查找这个元素 查找到元素了根据位置去删除
 * @param e
 * @return
 */
public E removeElement(E e){
    int index = findIndex(e);
    if(index != -1){
        return remove(index);
    }
    return null;
}

4. 修改数据

/**
 * 修改某一个位置的元素
 * @param index
 * @param e
 */
public void set(int index,E e){
    assertIndex(index);
    mDatas[index] = e;
}

5. 查询数据

/**
 * 获取索引处的元素
 * @param index
 * @return
 */
public E get(int index){
    assertIndex(index);
    return mDatas[index];
}

public E getLast(){
    return get(size - 1);
}

public E getFirst(){
    return get(0);
}

/**
 * 根据元素查找元素索引
 * @param e
 * @return
 */
public int findIndex(E e){
    for (int i = 0; i < mDatas.length; i++) {
        if(e.equals(mDatas[i])){
            return i;
        }
    }
    return -1;
}

/**
 * 根据索引查找元素
 * @param index
 * @return
 */
public E find(int index){

    assertIndex(index);
    for (int i = 0; i < mDatas.length; i++) {
        if(mDatas[index].equals(mDatas[i])){
            return mDatas[i];
        }
    }
    return null;
}

6. 数组扩容

/**
 * 扩容的函数
 * @param capacity
 */
private void resize(int capacity) {

    E[] newData = (E[]) new Object[capacity];
    for (int i = 0; i < size; i++) {
        newData[i] = mDatas[i];
    }
    //扩容后的数组赋值给原始数组
    mDatas = newData;
}

7. 小结

其实就是针对数组的操作

8.联系方式

QQ:1509815887