线性表顺序存储结构（ArrayList底层实现原理）

public class ArrayList
{
     private Object[] elementData;
     private size;

 //初始化空表
  public ArrayList(int initalCapacity){
      this.elementData = new Object[initalCapacity];

  }

 //添加
 public boolean add(Object obj){
     if(size>= elementData.length){
       System.out.println("表空间已满");
       return false;

     }else{
      this.elementData[size++]=obj;

     }
 }
 //返回表的长度
 public int size(){
  return size;
 }

 //判断表是否为空
 public boolean isEmpty(){

  return size==0;
 }

 //获得指定位置元素
 public Object get(int index)
 {
    if(index<0 || index >= size){
      System.out.println("索引越界");
      return;
    }
    return elementData[index];
 }
 //替换指定位置元素
 public void set(int index, Object obj){
   if(index<0 || index >= size){
      System.out.println("索引越界");
      return;
    }
    elementData[index]=obj;
 }
 //获得元素第一次出现的位置
 public int indexOf(Object obj){
   if(obj==null){
     for(int i=0;i<size;i++){
       if(elementData[i]==null)
           return i;
           }
       }else{

        for(int i=0;i<size;i++){
         if(obj.equals(elementData[i]))
           return i;
           }
       }
     return -1;
 }
 //获得元素最后一次出现的位置
    public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size - 1; i >= 0; i--)
                if (elementData[i] == null)
                    return i;
        } else {
            for (int i = size - 1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
 //难点：在指定位置前插入元素,先向后移动元素，再向索引位置插入元素
 public void add(int index,Object obj){
     if(index<0 || index >= size){
      System.out.println("索引越界");
      return;
    }
    if(size>= elementData.length){
       System.out.println("表空间已满");
       return;
    }
    //从最后一个元素开始移动，到索引处结束
    for(int i=size;i>index;i--){
        elementData[i]=elementData[i-1];
    }
   elementData[index]=obj;
   size++;

 }


 //难点：删除元素，从索引处向前移动，直到最后一个元素
 public void remove(int index){
      if(index<0 || index >= size){
      System.out.println("索引越界");
      return;
    }
    for(int i=index;i<size;i++){
      a[i]=a[i+1];  
    }
    size--;
 }

 //难点：构建迭代器
 private class Iterator 
 {
     int cursor;//游标，指向下一个元素的索引
     public boolean hasNext(){
      return cursor !=size;

     }

     public Object next(){
       int i= cursor;
       if (i >= ArrayList.this.size)
                return "NoSuchElementException";
       cursor=i+1;
       Object[] elementData = ArrayList.this.elementData ;
       return elementData[i];

     }
 }
 public static void main(String[] args) {
  ArrayList list =new ArrayList(10);
  list.add(1);
  list.add(2);
  list.add(3);
  for(Iterator i = list.new Iterator();i.hasNext() )
      System.out.println(i.next());

 }


}

 private static final int DEFAULT_CAPACITY = 10;
 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
  transient Object[] elementData;
  //无参构造
  public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
//添加元素
  public boolean add(E e) {
        ensureCapacityInternal(size + 1);  
        elementData[size++] = e;
        return true;
    }
//如果用的是无参的构造方法，会默认创建一个长度是10的数组
 private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

  private void ensureExplicitCapacity(int minCapacity) {
        modCount++;


        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);//默认增加一半的长度
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }