#数据结构--用Java实现一个顺序表

一个顺序表应该具有基本的增删改查功能，它最显著的特点是能够自动扩容，底层是基于数组实现的，下面我们来自己实现一个包含基本功能的顺序表。
定义MyList接口，该接口声明了顺序表功能的基本方法：

package com.yzh.maven.main;
public interface MyList<E> {
	/***
	 * @functionName:add
	 * @description:添加元素
	 * @param
	 * @author yzh
	 * @date 2018-12-31
	 * @return
	 */
	public boolean add(E element);
	
	/***
	 * @functionName:size
	 * @description:获得顺序表的大小
	 * @param
	 * @author yzh
	 * @date 2018-12-31
	 * @return
	 */
	public int size();
	
	/***
	 * @functionName:get
	 * @description:通过索引获得顺序表的元素
	 * @param index
	 * @author yzh
	 * @date 2018-12-31
	 * @return
	 */
	public E get(int index);
	
	/***
	 * @functionName:update
	 * @description:通过索引修改顺序表的元素
	 * @param newElement:目标元素
	 * @param fromIndex:被修改元素的索引
	 * @author yzh
	 * @date 2019-01-01
	 * @return
	 */
	public void update(E newElement,int fromIndex);
	
	/***
	 * @functionName:update
	 * @description:通过新元素修改顺序表的元素
	 * @param oldElement:旧元素
	 * @param newElement:目标元素
	 * @author yzh
	 * @date 2019-01-01
	 * @return
	 */
	public void update(E oldElement,E newElement);
	
	/***
	 * @functionName:myIndexOf
	 * @description:通过顺序表的元素获得第一个索引
	 * @param element:元素
	 * @author yzh
	 * @date 2019-01-01
	 * @return
	 */
	public int myIndexOf(E element);
	
	/***
	 * @functionName:delete
	 * @description:通过顺序表的索引删除元素
	 * @param index
	 * @author yzh
	 * @date 2019-01-01
	 * @return
	 */
	public void delete(int index);
	
	/***
	 * @functionName:delete
	 * @description:通过顺序表的元素删除元素
	 * @param element
	 * @author yzh
	 * @date 2019-01-01
	 * @return
	 */
	public void delete(E element);
	
	/***
	 * @functionName:clear
	 * @description:清空元素
	 * @author yzh
	 * @date 2019-01-01
	 * @return
	 */
	public void clear();
}

实现顺序表的代码如下所示。

package com.yzh.maven.main;
import java.util.AbstractList;
import java.util.Iterator;
/**
 * @className MyArrayList<E>
 * @description 创建一个顺序表
 * @author yzh
 * @date 2018-12-31
 * @param <E>
 */
public class MyArrayList<E> extends AbstractList<E> implements MyList<E>{
	//初始化空元素数组
	private static final Object[] MYDEFAULT_ELEMENTDATA = {}; 
	//顺序表list的大小
	private int size;
	//顺序表底层数组
	private transient Object[] myElementData;
	//默认的构造方法时的容量大小
	private static final int MYDEFULT_CAPACITY = 10;
	//设计默认构造方法
	public MyArrayList(){
		//初始化顺序表的数组
		myElementData = MYDEFAULT_ELEMENTDATA;
	}
	//传参构造方法
	public MyArrayList(int initCapacity){
		if(initCapacity < 0){
			//第一种方式,如果入参小于0,那么抛出参数异常
			//throw new IllegalArgumentException("illegal capacity"+initCapacity);
			//第二种处理方式:入参小于0就转换为元素为空的MYDEFAULT_ELEMENTDATA默认数组
			myElementData = MYDEFAULT_ELEMENTDATA;
		}else{
			//初始化顺序表的数组
			myElementData = new Object[initCapacity];
		}
	}
	
	/***
	 * @functionName:add
	 * @description:添加元素（扩容）
	 * @param element:元素对象
	 * @author yzh
	 * @date 2018-12-31
	 * @return
	 */
	@Override
	public boolean add(E element){
		//1.先扩容
		//添加一个元素前需要进行扩容+1,避免存储空间溢出，也就是所需容量
		int initCapacity = size+1;
		int newCapacity = 0;
		//判断是否是无参构造器或者在有参构造器中输入了负数
		if(myElementData == MYDEFAULT_ELEMENTDATA){
			initCapacity = Math.max(initCapacity, MYDEFULT_CAPACITY);
		}
		/*顺序表的基础数组扩容的条件就是每次添加元素将原容量加1（即所需容量）与数组的容量比较大小，
		如果所需容量>myElementData.length，那么说明添加元素前需要对基础数组进行扩容，否则会溢出
		*/
		if(initCapacity > myElementData.length){
			//扩容规则
			//数组的原容量
			int oldCapacity = myElementData.length;
			//新容量是容量的2倍
			newCapacity = 2*oldCapacity;
			if((newCapacity - initCapacity) < 0){
				newCapacity = initCapacity;
			}
			//扩容的最大边界值,太大则抛异常(-20是为确保不发生)
			if(newCapacity - (Integer.MAX_VALUE - 20) > 0){
				throw new RuntimeException("myElementData capacity is too big!");
			}
			//扩容的中间数组：底层代码可以类比myElementData = Arrays.copyOf(myElementData, newCapacity);
			Object[] myElementDataTemp = new Object[newCapacity];
			System.arraycopy(myElementData, 0, myElementDataTemp, 0, myElementData.length);
			myElementData = myElementDataTemp;
		}
		//2.扩容后添加元素
		myElementData[size] = element;
		//数组引用指向下一个存储空间
		size++;
		return true;
	}
	
	/***
	 * @functionName:size
	 * @description:获得顺序表的大小
	 * @param
	 * @author yzh
	 * @date 2018-12-31
	 * @return
	 */
	@Override
	public int size(){
		return size;
	}
	
	/***
	 * @functionName:get
	 * @description:通过索引获得顺序表的元素
	 * @param index
	 * @author yzh
	 * @date 2018-12-31
	 * @return
	 */
	@Override
	@SuppressWarnings("unchecked")
	public E get(int index){
		//对太大或太小的索引使用异常抛出进行控制，对于顺序表而言，底层数组的有效索引区间为0-size
		if((myElementData == MYDEFAULT_ELEMENTDATA ) || ((size > 0) && index >= size) || index < 0){
			throw new RuntimeException("illegal element index of myElementData");
		}
		return (E) myElementData[index];
	}
	
	/***
	 * @functionName:update
	 * @description:通过索引修改顺序表的元素
	 * @param newElement:目标元素
	 * @param fromIndex:被修改元素的索引
	 * @author yzh
	 * @date 2019-01-01
	 * @return
	 */
	@Override
	public void update(E newElement,int fromIndex){
		//如果等于0，那么说明没有一个元素,或者元素索引过大
		if((myElementData == MYDEFAULT_ELEMENTDATA ) || ((size > 0) && (fromIndex >= size)) || fromIndex < 0){
			throw new RuntimeException("illegal element index of myElementData");
		}
		myElementData[fromIndex] = newElement;
	}
	
	/***
	 * @functionName:update
	 * @description:通过新元素修改顺序表的元素
	 * @param oldElement:旧元素
	 * @param newElement:目标元素
	 * @author yzh
	 * @date 2019-01-01
	 * @return
	 */
	@Override
	public void update(E oldElement,E newElement){
		//返回该元素在该数组中第一次出现时的索引
		int oldElementIndex = myIndexOf(oldElement);
		//如果oldElementIndex存在于myElementData数组中，那么返回值必然不小于0
		if(oldElementIndex >= 0){
			myElementData[oldElementIndex] = newElement;
		}
	}
	
	/***
	 * @functionName:myIndexOf
	 * @description:通过顺序表的元素获得第一个索引
	 * @param element:元素
	 * @author yzh
	 * @date 2019-01-01
	 * @return
	 */
	@Override
	public int myIndexOf(E element) {
		if (element == null) {
			throw new RuntimeException("param is not null!");
		}else{
			for (int i = 0; i < size; i++) {
				//比的是同一个对象
				if (element.equals(myElementData[i])) {
					return i;
				}else{
					continue;
				}
			}
			return -1;
		}
	}
	
	/***
	 * @functionName:delete
	 * @description:通过顺序表的索引删除元素
	 * @param index
	 * @author yzh
	 * @date 2019-01-01
	 * @return
	 */
	@Override
	public void delete(int index){
		//元素索引过大或过小
		if((myElementData == MYDEFAULT_ELEMENTDATA ) || ((size > 0) && index >= size) || index < 0){
			throw new RuntimeException("illegal element index of myElementData");
		//如果0<=index<size && size>0
		}else{
			//从index索引开始移动元素的个数
			int moveCapacityNum = size-index-1;
			//如果索引在0-size - 2之间
			if(index < (size - 1)){
				/*
				1,2,3,4,5  ==>删除第3个元素 ==>1,2,3,5
				 这个问题可以转换成:1,2,3,5,5删除最后一个元素，同理：1,2,3,4,5  ==>删除第2个元素 ==>1,3,4,5
				 这个问题可以转换成:1,3,4,5,5删除最后一个元素,也就是从i数组的第3个元素开始复制，一共复制3个元素给i数组，
				 并将复制得到的元素从i数组的第2个存储空间开始存储，然后将最后一个元素置空;
				 第一个参数表述原数组,第二个参数index+1表示从删除元素后的索引开始对原数组进行拷贝,第三个参数表示目标数组,
				 第四个参数表示将原数组拷贝的元素从目标数组的index位置开始进行放置,第五个参数moveCapacityNum表示从原数组拷贝元素的个数
				*/
				System.arraycopy(myElementData, index+1, myElementData, index, moveCapacityNum);
			}
			//通过上面的arraycopy拷贝之后，多出了一个元素，还有一种情况删除的是最后一个元素即index==size - 1
			myElementData[--size] = null;//相当于myElementData[size-1] = null;size--;
		}
	}
	
	/***
	 * @functionName:delete
	 * @description:通过顺序表的元素删除元素
	 * @param element
	 * @author yzh
	 * @date 2019-01-01
	 * @return
	 */
	@Override
	public void delete(E element){
		if (element == null) {
			throw new RuntimeException("param is not null!");
		}else{
			for (int i = 0; i < size; i++) {
				//比的是同一个对象
				if (element.equals(myElementData[i])) {
					delete(i);
				}
			}
		}
	}
	
	/***
	 * @functionName:clear
	 * @description:清空元素
	 * @author yzh
	 * @date 2019-01-01
	 * @return
	 */
	@Override
	public void clear(){
		//底层数组的元素置空
		myElementData = MYDEFAULT_ELEMENTDATA;
		//顺序表的大小置0
		size = 0;
	}
	
	/***
	 * @functionName:toString
	 * @description:重写toString
	 * @author yzh
	 * @date 2019-01-01
	 * @return
	 */
    @Override
    public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }
}

说明：需要注意的是，这里的MyArrayList继承了AbstractList，这是因为AbstractList抽象类实现了Iterator迭代器的全部方法，因此要想MyArrayList能具有迭代器的功能，就必须继承AbstractList，使用迭代器的几个主要方法是：iterator()用于获取迭代器对象，hasNext()用于判断是否还有元素，next()用于获取元素值。就像下面这样：

Iterator<String> it = list3.iterator();
while(it.hasNext()){
System.out.println(it.next());
}

实际上，在增强型for循环中，你使用反编译工具可以看到其底层地代码就是迭代器设计的，因此，你要想使用增强型for循环，那么对象必须是数组或者迭代器的持有者，这意味着MyArrayList需要继承AbstractList才能持有迭代器，这时就可以使用增强型for循环遍历MyArrayList对象了：

for(String s:list){
	System.out.println(s);
}