深入集合类系列——ArrayList和Vector的区别

区别：

1）Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe)，而ArrayList的方法不是，由于线程的同步必然要影响性能，因此,ArrayList的性能比Vector好。 
2）当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,而ArrayList只增加50%的大小，这样,ArrayList就有利于节约内存空间。

3）对于Vector、是一个比较古老的类、相对于ArrayList而言、它通过将许多方法使用synchronized修饰来保证线程安全性、但是保证线程安全是要代价的、这也使得他的效率并没有ArrayList高

arraylist的特点：

1、ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。

2、ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。

3、ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。稍后，我们会比较List的“快速随机访问”和“通过Iterator迭代器访问”的效率。

4、ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。

5、ArrayList 实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。

vector的特点：

1、Vector是内部是以动态数组的形式来存储数据的。

2、Vector具有数组所具有的特性、通过索引支持随机访问、所以通过随机访问Vector中的元素效率非常高、但是执行插入、删除时效率比较地下、具体原因后面有分析。

3、Vector实现了AbstractList抽象类、List接口、所以其更具有了AbstractList和List的功能、前面我们知道AbstractList内部已经实现了获取Iterator和ListIterator的方法、所以Vector只需关心对数组操作的方法的实现、

4、Vector实现了RandomAccess接口、此接口只有声明、没有方法体、表示Vector支持随机访问。

5、Vector实现了Cloneable接口、此接口只有声明、没有方法体、表示Vector支持克隆。

6、Vector实现了Serializable接口、此接口只有声明、没有方法体、表示Vector支持序列化、即可以将Vector以流的形式通过ObjectOutputStream来写入到流中。

 //底层的arraylist实现了AbstractList类  和四个接口
 //list接口、随机访问接口、可克隆接口、序列化接口
 public class MyArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

     private static final long serialVersionUID = 1L;
     // 属性,元素数据
     // transient：反序列化的关键字，不可以被serialized的数组
     private transient Object[] elementData;
     // 数组的大小,即包含的元素的个数
     private int size;

     // 构造函数1：根据初始大小分配数组
     public MyArrayList(int initialCapacity) {
         super();
         if (initialCapacity < 0) {
             System.out.println("初始化失败" + initialCapacity);
         }
         // 否则按照initialCapacity分配大小
         this.elementData = new Object[initialCapacity];
     }

     // 构造函数2：以10为大小分配数组
     public MyArrayList() {
         this(10);
     }

     // 构造函数3：参数为集合collection,集合之间的拷贝
     // Collection<? extends E>代表Collection<E>的子类
     public MyArrayList(Collection<? extends E> c) {
         // 把集合中的元素赋值给属性集合
         elementData = c.toArray();
         // 得到集合的大小
         size = elementData.length;
         // c返回的如果不是object[]数组，则显式转换
         if (elementData.getClass() != Object[].class) {
             elementData = Arrays.copyOf(elementData, size, Object[].class);
         }
     }

     // 保证数组的容量，确保不会越界
     public void ensureCapacity(int minCapacity) {
         // 该变量来自AbstractList，表示被修改的次数
         modCount++;
         // 原来数组的容量
         int oldCapacity = elementData.length;
         // 如果新的容量更大，则需要重新分配
         if (minCapacity > oldCapacity) {
             // 赋值出新的数组
             Object oldData[] = elementData;
             // 构造出新的数组容量，增加原有容量的50%
             int newCapacity = (oldCapacity * 3) / 2 + 1;
             // 如果新构造出的容量比参数minCapacity要小，则赋值大小和数组本身
             if (newCapacity < minCapacity) {
                 newCapacity = minCapacity;
                 elementData = Arrays.copyOf(elementData, newCapacity);
             }
         } // end of if
             // 当然，如果新的容量比老的容量小，则上面的if判断不会执行。
     }

     // 在尾部添加一个元素
     public boolean add(E e) {
         // 保证容量
         ensureCapacity(size + 1);
         // 赋值新的元素
         elementData[size++] = e;
         return true;
     }

     // 在指定位置处插入元素
     public void add(int index, E element) {
         if (index > size || index < 0) {
             System.out.println("数组越界");
         }
         // 调整容量
         ensureCapacity(size + 1);
         // 元素拷贝
         /*
          * 将elementData从index开始的元素赋值到index+1,复制的大小为size-index.也即将index后的元素整体后移动
          */
         System.arraycopy(elementData, index, elementData, index + 1, size - index);
         // 将element指向到index处
         elementData[index] = element;
         size++;
     }

     // 将一个集合中的所有元素拷贝到elementData中
     public boolean addAll(Collection<? extends E> c) {
         // 将集合c转换成Object类型的数组
         Object[] a = c.toArray();
         // 得到数组的长度
         int numNew = a.length;
         // 调整容量
         ensureCapacity(size + numNew);
         // 数组拷贝
         System.arraycopy(a, 0, elementData, size, numNew);
         // 原有大小增加
         size += numNew;
         return numNew != 0;
     }

     // 在指定的位置，将一个集合中的元素拷贝到另外一个集合
     public boolean addAll(int index, Collection<? extends E> c) {
         if (index < 0 || index > size) {
             System.out.println("数组越界");
         }

         Object[] a = c.toArray();
         int newNum = a.length;
         ensureCapacity(size + newNum);

         // 原有数据向后移动多少呢？
         int movedNum = size - index;
         if (movedNum > 0) {
             System.arraycopy(elementData, index, elementData, index + newNum, movedNum);
         }
         System.arraycopy(a, 0, elementData, index, newNum);
         size += newNum;
         return newNum != 0;
     }

     // 清空数组的内容,元素置Null 大小清0
     public void clear() {
         modCount++;
         for (int i = 0; i < size; i++) {
             elementData[i] = null;
         }
         size = 0;
     }

     // 浅拷贝
     public Object clone() {
         try {
             MyArrayList<E> v = (MyArrayList<E>) super.clone();
             v.elementData = Arrays.copyOf(elementData, size);
             v.modCount = 0;
             return v;
         } catch (CloneNotSupportedException e) {
             // TODO Auto-generated catch block
             throw new InternalError();
         }
     }

     // 返回对象在arraylist中的索引
     public int indexOf(Object o) {
         // 如果对象为null
         if (o == null) {
             for (int i = 0; i < size; i++) {
                 if (elementData[i] == null) {
                     return i;
                 }
             }
         } else {
             for (int i = 0; i < size; i++) {
                 if (o.equals((elementData)[i])) {
                     return i;
                 }
             }
         }
         return -1;
     }

     // 是否包含一个对象
     public boolean contains(Object o) {
         return indexOf(o) >= 0;
     }

     // 返回出现对象的最后一次索引
     // 从后向前遍历arraylist
     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 E get(int index) {
         RangeCheck(index);
         return (E) elementData[index];
     }

     // 越界检查的方法
     public void RangeCheck(int index) {
         if (index >= size || index < 0) {
             System.out.println("取值非法！");
         }
     }

     // 删除指定位置处的元素，并返回该元素
     public E remove(int index) {
         // 边界检查
         RangeCheck(index);
         modCount++;
         // 取得旧的元素
         E oldelement = (E) elementData[index];
         int numMoved = size - index - 1;
         if (numMoved > 0) {
             System.arraycopy(elementData, index + 1, elementData, index, numMoved);
         }
         elementData[--size] = null;
         return oldelement;
     }

     // 判断移除是否成功
     public boolean remove(Object o) {
         if (o == null) {
             for (int index = 0; index < size; index++)
                 if (elementData[index] == null) {
                     fastRemove(index);
                     return true;
                 }
         } else {
             for (int index = 0; index < size; index++)
                 if (o.equals(elementData[index])) {
                     fastRemove(index);
                     return true;
                 }
         }
         return false;
     }

     //快速移除的方法
     private void fastRemove(int index) {
         modCount++;
         int numMoved = size - index - 1;
         if (numMoved > 0)
             System.arraycopy(elementData, index+1, elementData, index,
                              numMoved);
         elementData[--size] = null; // Let gc do its work
     } 

     //转换成对象数组
     public Object[] toArray(){
         return Arrays.copyOf(elementData,size);
     }

     //调整数组的大小
     public void trimToSize(){
         modCount++;
         int oldCapacity = elementData.length;
         if(size<oldCapacity){
             //按照size的大小拷贝出一个数组，较少空间的使用
             elementData=Arrays.copyOf(elementData,size);
         }
     }

     @Override
     public int size() {
         // TODO Auto-generated method stub
         return 0;
     }
 }