简单实现一个动态数组

首先动态数组应该具有的特性：可以动态扩容，本身属于链表 Java动态数组是一种可以任意伸缩数组长度的对象，在Java中比较常用的是ArrayList，ArrayList是javaAPI中自带的java.util.ArrayList。

动态数组应该具有的属性：

int size(); // 元素的数量
boolean isEmpty(); // 是否为空
boolean contains(E element); // 是否包含某个元素
void add(E element); // 添加元素到最后面
E get(int index); // 返回index位置对应的元素
E set(int index, E element); // 设置index位置的元素
void add(int index, E element); // 往index位置添加元素
E remove(int index); // 删除index位置对应的元素
int indexOf(E element); // 查看元素的位置
void clear(); // 清除所有元素

1.1、添加基本属性

基本属性包括：

1、存储数据的数组

2、元素的数量

3、构造函数（默认数组大小）

public class ArrrayList<E> {
    /**
     * ############################基本属性 ############################
     * */
    //存储数据的数组
    private E[] elements ;

    //元素的数量
    private int size ;

    //数组的默认容量
    private static final int DEAULT_CAPACITY = 10;

    /**
     * ############################构造函数 ############################
     * */
    public ArrrayList(int capacity) {
        elements = (E[]) new Object[capacity];
    }

    public ArrrayList() {
        this(DEAULT_CAPACITY);
    }

}

1.2、实现方法内容1

先实现比较简单的方法

/**
 * 获取元素的数量
 * */
public int size(){
    return size;
}
// 是否为空
public boolean isEmpty(){
    return size == 0;
}
// 是否包含某个元素
public boolean contains(E element){
    for (int i=0;i<size ; i++){
        if (elements[i].equals(element)) return true;
    }
    return false;
}
// 清除所有元素
public void clear(){
    for (int i=0;i<size;i++){
        elements[i] = null ;
    }
    size = 0 ;
}

1.3、编写根据下标获取元素的方法

// 返回index位置对应的元素
public E get(int index){
    rangeCheck(index);
    return elements[index];
}
//检查是否数组下标越界的问题
public void rangeCheck(int index){
    if(index < 0 || index >= size){
        throw new ArrayIndexOutOfBoundsException();
    }
}

1.4、编写移除元素的操作

移除元素需要达到的效果：

比如现在要删除位置3的值：112

那么删除后的效果应该是：

代码实现

// 删除index位置对应的元素,并返回删除的元素
public E remove(int index){
    rangeCheck(index);
    E oldElements = elements[index];
    for (int i=index+1 ;i<size;i++){
        elements[i-1] = elements[i];
    }
    elements[--size] = null;
    return oldElements;
}

1.5、实现set操作

大概实现的样子

 代码：

// 设置index位置的元素,返回原来index位置的值
public E set(int index, E element){
    rangeCheck(index);
    E oldElements = elements[index];
    elements[index] = element;
    return oldElements;
}

1.6、查看元素的位置

实现效果

 代码：

private static final int DEFAULT_NOT_FOUND = -1;
// 查看元素的位置
public int indexOf(E element){
    for (int i=0;i<size;i++){
        if (elements[i].equals(element)){
            return i;
        }
    }
    return DEFAULT_NOT_FOUND ;
}

1.7、在指定位置添加元素操作

步骤

 代码

// 在指定位置添加元素
public void add(int index, E element){
    rangeCheckAdd(index);
    for(int i=size;i>index;i--){
        elements[i] = elements[i-1];
    }
    elements[index] = element ;
    size ++ ;

}

1.8、数组扩容操作

原有数组长度是10，现在要添加11个元素，那么此时数组就面临着扩容的需求

先自定义一个扩容因子，比如1.5倍

那么当数组容量不够的时候，就扩容DEAULT_CAPACITY = DEAULT_CAPACITY + DEAULT_CAPACITY >> 1

步骤：

扩容代码：

public void ensureCapacity(int capacity){
    int oldCapacity = elements.length;
    if (oldCapacity >= capacity) return ;
    //新数组容量
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //创建新数组
    E[] newElements = (E[])new Object[newCapacity];
    //将老数组的内容顺序添加到新数组
    for (int i=0;i<size;i++){
        newElements[i] = elements[i];
    }
    //然后将数组指针，指向新数组
    elements = newElements ;
    
}

然后在原有的add方法中添加ensureCapacity(size+1);

最后，add方法代码：

 

// 添加元素到最后面
public void add(E element){
    add(size , element);
}

// 在指定位置添加元素
public void add(int index, E element){
    rangeCheckAdd(index);
    ensureCapacity(size+1);
    for(int i=size;i>index;i--){
        elements[i] = elements[i-1];
    }
    elements[index] = element ;
    size ++ ;

}

1.9、编写测试

public static void main(String[] args) {
    ArrrayList arrrayList = new ArrrayList();
    arrrayList.add(11);
    arrrayList.add(12);
    arrrayList.add(13);
    arrrayList.add(14);
    arrrayList.add(15);
    System.out.println(arrrayList);
    System.out.println("=================华丽的分隔符======================");
    arrrayList.set(1 , 22);
    System.out.println(arrrayList);
    System.out.println("=================华丽的分隔符======================");
    final boolean contains = arrrayList.contains(13);
    System.out.println("是否存在这个元素 ："+contains);
    System.out.println("=================华丽的分隔符======================");
    arrrayList.add(2 , 33);
    System.out.println(arrrayList);
    System.out.println("=================华丽的分隔符======================");

    System.out.println("位置2的元素值 ："+arrrayList.get(2));

    System.out.println("=================华丽的分隔符======================");

    System.out.println("22的位置："+arrrayList.indexOf(22));
    System.out.println("=================华丽的分隔符======================");

    arrrayList.clear();
    System.out.println(arrrayList);

}

全部代码：

package dynamicArray;

import java.util.Arrays;

/**
 * Created by angel
 */
public class ArrrayList<E> {
    /**
     * ############################基本属性 ############################
     * */
    //存储数据的数组
    private E[] elements ;

    //元素的数量
    private int size ;

    //数组的默认容量
    private static final int DEAULT_CAPACITY = 10;

    /**
     * ############################构造函数 ############################
     * */
    public ArrrayList(int capacity) {
        elements = (E[]) new Object[capacity];
    }

    public ArrrayList() {
        this(DEAULT_CAPACITY);
    }
    /**
     * 获取元素的数量
     * */
    public int size(){
        return size;
    }
    // 是否为空
    public boolean isEmpty(){
        return size == 0;
    }
    // 是否包含某个元素
    public boolean contains(E element){
        for (int i=0;i<size ; i++){
            if (elements[i].equals(element)) return true;
        }
        return false;
    }
    // 清除所有元素
    public void clear(){
        for (int i=0;i<size;i++){
            elements[i] = null ;
        }
        size = 0 ;
    }

    // 返回index位置对应的元素
    public E get(int index){
        rangeCheck(index);
        return elements[index];
    }
    //检查是否数组下标越界的问题
    public void rangeCheck(int index){
        if(index < 0 || index >= size){
            throw new ArrayIndexOutOfBoundsException();
        }
    }
    // 删除index位置对应的元素,并返回删除的元素
    public E remove(int index){
        rangeCheck(index);
        E oldElements = elements[index];
        for (int i=index+1 ;i<size;i++){
            elements[i-1] = elements[i];
        }
        elements[--size] = null;
        return oldElements;
    }
    // 设置index位置的元素,返回原来index位置的值
    public E set(int index, E element){
        rangeCheck(index);
        E oldElements = elements[index];
        elements[index] = element;
        return oldElements;
    }

    private static final int DEFAULT_NOT_FOUND = -1;
    // 查看元素的位置
    public int indexOf(E element){
        for (int i=0;i<size;i++){
            if (elements[i].equals(element)){
                return i;
            }
        }
        return DEFAULT_NOT_FOUND ;
    }

    // 添加元素到最后面
    public void add(E element){
        add(size , element);
    }

    // 在指定位置添加元素
    public void add(int index, E element){
        rangeCheckAdd(index);
        ensureCapacity(size+1);
        for(int i=size;i>index;i--){
            elements[i] = elements[i-1];
        }
        elements[index] = element ;
        size ++ ;

    }

    public void rangeCheckAdd(int index){
        if(index < 0 || index > size){
            throw new ArrayIndexOutOfBoundsException();
        }
    }

    public void ensureCapacity(int capacity){
        int oldCapacity = elements.length;
        if (oldCapacity >= capacity) return ;
        //新数组容量
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //创建新数组
        E[] newElements = (E[])new Object[newCapacity];
        //将老数组的内容顺序添加到新数组
        for (int i=0;i<size;i++){
            newElements[i] = elements[i];
        }
        //然后将数组指针，指向新数组
        elements = newElements ;

    }

    @Override
    public String toString() {
        return "ArrrayList{" +
                "elements=" + Arrays.toString(elements) +
                ", size=" + size +
                '}';
    }

    public static void main(String[] args) {
        ArrrayList arrrayList = new ArrrayList();
        arrrayList.add(11);
        arrrayList.add(12);
        arrrayList.add(13);
        arrrayList.add(14);
        arrrayList.add(15);
        System.out.println(arrrayList);
        System.out.println("=================华丽的分隔符======================");
        arrrayList.set(1 , 22);
        System.out.println(arrrayList);
        System.out.println("=================华丽的分隔符======================");
        final boolean contains = arrrayList.contains(13);
        System.out.println("是否存在这个元素 ："+contains);
        System.out.println("=================华丽的分隔符======================");
        arrrayList.add(2 , 33);
        System.out.println(arrrayList);
        System.out.println("=================华丽的分隔符======================");

        System.out.println("位置2的元素值 ："+arrrayList.get(2));

        System.out.println("=================华丽的分隔符======================");

        System.out.println("22的位置："+arrrayList.indexOf(22));
        System.out.println("=================华丽的分隔符======================");

        arrrayList.clear();
        System.out.println(arrrayList);

    }


}