Java中Vector和ArrayList的区别

我会带着你远行 2022-05-20 05:11 249阅读 0赞

### Java Vector 类 ###

Vector类实现了一个动态数组。和ArrayList和相似，但是两者是不同的：  
1. Vector是同步访问的。  
2. Vector包含了许多传统的方法，这些方法不属于集合框架。  
Vector主要用在事先不知道数组的大小，或者只是需要一个可以改变大小的数组的情况。  
Vector类支持4种构造方法。

第一种构造方法创建一个默认的向量，默认大小为10：  
Vector()

第二种构造方法创建指定大小的向量。  
Vector(int size)

第三种构造方法创建指定大小的向量，并且增量用incr指定. 增量表示向量每次增加的元素数目。  
Vector(int size,int incr)

第四种构造方法创建一个包含集合c元素的向量：  
Vector(Collection c)  
![这里写图片描述][70]  
![这里写图片描述][70 1]  
![这里写图片描述][70 2]  
![这里写图片描述][70 3]  
![这里写图片描述][70 4]

### 示例 ###

import java.util.*;
    
    public class VectorDemo {
    
       public static void main(String args[]) {
          // initial size is 3, increment is 2
          Vector v = new Vector(3, 2);
          System.out.println("Initial size: " + v.size());
          System.out.println("Initial capacity: " +
          v.capacity());
          v.addElement(new Integer(1));
          v.addElement(new Integer(2));
          v.addElement(new Integer(3));
          v.addElement(new Integer(4));
          System.out.println("Capacity after four additions: " +
              v.capacity());
    
          v.addElement(new Double(5.45));
          System.out.println("Current capacity: " +
          v.capacity());
          v.addElement(new Double(6.08));
          v.addElement(new Integer(7));
          System.out.println("Current capacity: " +
          v.capacity());
          v.addElement(new Float(9.4));
          v.addElement(new Integer(10));
          System.out.println("Current capacity: " +
          v.capacity());
          v.addElement(new Integer(11));
          v.addElement(new Integer(12));
          System.out.println("First element: " +
             (Integer)v.firstElement());
          System.out.println("Last element: " +
             (Integer)v.lastElement());
          if(v.contains(new Integer(3)))
             System.out.println("Vector contains 3.");
          // enumerate the elements in the vector.
          Enumeration vEnum = v.elements();
          System.out.println("\nElements in vector:");
          while(vEnum.hasMoreElements())
             System.out.print(vEnum.nextElement() + " ");
          System.out.println();
       }
    }

输出

Initial size: 0
    Initial capacity: 3
    Capacity after four additions: 5
    Current capacity: 5
    Current capacity: 7
    Current capacity: 9
    First element: 1
    Last element: 12
    Vector contains 3.
    
    Elements in vector:
    1 2 3 4 5.45 6.08 7 9.4 10 11 12

### Java ArrayList类 ###

*  ArrayList 是一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List,RandomAccess\[随机访问\],Cloneable\[可克隆\], java.io.Serializable\[序列化\]这些接口。
 *  ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
 *  ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。稍后，我们会比较List的“快速随机访问”和“通过Iterator迭代器访问”的效率。
 *  ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。
 *  ArrayList 实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。
 *  和Vector不同，ArrayList中的操作不是线程安全的。所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。

#### ArrayList类的API ####

<span style="font-family:Microsoft YaHei;">// Collection中定义的API
    boolean             add(E object)//添加一个数组对象
    boolean             addAll(Collection<? extends E> collection)//添加一个包含Collection的对象
    void              clear()//清空
    boolean             contains(Object object)//包含
    boolean             containsAll(Collection<?> collection)
    boolean             equals(Object object)//判等
    int               hashCode()
    boolean             isEmpty()//判空
    Iterator<E>             iterator()
    boolean             remove(Object object)//删除
    boolean             removeAll(Collection<?> collection)
    boolean             retainAll(Collection<?> collection)
    int               size()
    <T> T[]             toArray(T[] array)
    Object[]             toArray()
    // AbstractCollection中定义的API
    void              add(int location, E object)
    boolean             addAll(int location, Collection<? extends E> collection)
    E                get(int location)//获取某个元素值
    int               indexOf(Object object)
    int               lastIndexOf(Object object)
    ListIterator<E>             listIterator(int location)
    ListIterator<E>             listIterator()
    E                remove(int location)
    E                set(int location, E object)
    List<E>             subList(int start, int end)
    // ArrayList新增的API
    Object             clone()//
    void              ensureCapacity(int minimumCapacity)//保证容量不小于元素个数
    void              trimToSize()
    void              removeRange(int fromIndex, int toIndex)
    </span>

#### ArrayList类的源码解析 ####

<span style="font-family:Microsoft YaHei;">package java.util;
    public class ArrayList<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    {
        
        // 序列版本号
        private static final long serialVersionUID = 8683452581122892189L;
        // 保存ArrayList中数据的数组
        private transient Object[] elementData;
        // ArrayList中实际数据的数量
        private int size;
        // ArrayList带容量大小的构造函数。
        public ArrayList(int initialCapacity) {
            super();
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            // 新建一个数组
            this.elementData = new Object[initialCapacity];
        }
        // ArrayList构造函数。默认容量是10。
        public ArrayList() {
            this(10);
        }
        // 创建一个包含collection的ArrayList
        public ArrayList(Collection<? extends E> c) {
            elementData = c.toArray();
            size = elementData.length;
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        }
        // 将当前容量值设为 =实际元素个数
        public void trimToSize() {
            modCount++;
            int oldCapacity = elementData.length;
            if (size < oldCapacity) {
                elementData = Arrays.copyOf(elementData, size);
            }
        }
        // 确定ArrarList的容量。
        // 若ArrayList的容量不足以容纳当前的全部元素，设置 新的容量=“(原始容量x3)/2 + 1”
        public void ensureCapacity(int minCapacity) {
            // 将“修改统计数”+1
            modCount++;
            int oldCapacity = elementData.length;
            // 若当前容量不足以容纳当前的元素个数，设置 新的容量=“(原始容量x3)/2 + 1”
            if (minCapacity > oldCapacity) {
                Object oldData[] = elementData;
                int newCapacity = (oldCapacity * 3)/2 + 1;
                if (newCapacity < minCapacity)
                    newCapacity = minCapacity;
                elementData = Arrays.copyOf(elementData, newCapacity);
            }
        }
        // 添加元素e
        public boolean add(E e) {
            // 确定ArrayList的容量大小
            ensureCapacity(size + 1);  // Increments modCount!!
            // 添加e到ArrayList中
            elementData[size++] = e;
            return true;
        }
        // 返回ArrayList的实际大小
        public int size() {
            return size;
        }
        // 返回ArrayList是否包含Object(o)
        public boolean contains(Object o) {
            return indexOf(o) >= 0;
        }
        // 返回ArrayList是否为空
        public boolean isEmpty() {
            return size == 0;
        }
        // 正向查找，返回元素的索引值
        public int indexOf(Object o) {
            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 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;
        }
        // 反向查找(从数组末尾向开始查找)，返回元素(o)的索引值
        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;
        }
    
        // 返回ArrayList的Object数组
        public Object[] toArray() {
            return Arrays.copyOf(elementData, size);
        }
        // 返回ArrayList的模板数组。所谓模板数组，即可以将T设为任意的数据类型
        public <T> T[] toArray(T[] a) {
            // 若数组a的大小 < ArrayList的元素个数；
            // 则新建一个T[]数组，数组大小是“ArrayList的元素个数”，并将“ArrayList”全部拷贝到新数组中
            if (a.length < size)
                return (T[]) Arrays.copyOf(elementData, size, a.getClass());
            // 若数组a的大小 >= ArrayList的元素个数；
            // 则将ArrayList的全部元素都拷贝到数组a中。
            System.arraycopy(elementData, 0, a, 0, size);
            if (a.length > size)
                a[size] = null;
            return a;
        }
        // 获取index位置的元素值
        public E get(int index) {
            RangeCheck(index);
            return (E) elementData[index];
        }
        // 设置index位置的值为element
        public E set(int index, E element) {
            RangeCheck(index);
            E oldValue = (E) elementData[index];
            elementData[index] = element;
            return oldValue;
        }
        // 将e添加到ArrayList中
        public boolean add(E e) {
            ensureCapacity(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
        }
        // 将e添加到ArrayList的指定位置
        public void add(int index, E element) {
            if (index > size || index < 0)
                throw new IndexOutOfBoundsException(
                "Index: "+index+", Size: "+size);
            ensureCapacity(size+1);  // Increments modCount!!
            System.arraycopy(elementData, index, elementData, index + 1,
                 size - index);
            elementData[index] = element;
            size++;
        }
        // 删除ArrayList指定位置的元素
        public E remove(int index) {
            RangeCheck(index);
            modCount++;
            E oldValue = (E) elementData[index];
            int numMoved = size - index - 1;
            if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index,
                     numMoved);
            elementData[--size] = null; // Let gc do its work
            return oldValue;
        }
        // 删除ArrayList的指定元素
        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;
        }
        // 快速删除第index个元素
        private void fastRemove(int index) {
            modCount++;
            int numMoved = size - index - 1;
            // 从"index+1"开始，用后面的元素替换前面的元素。
            if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index,
                                 numMoved);
            // 将最后一个元素设为null
            elementData[--size] = null; // Let gc do its work
        }
        // 删除元素
        public boolean remove(Object o) {
            if (o == null) {
                for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                return true;
                }
            } else {
                // 便利ArrayList，找到“元素o”，则删除，并返回true。
                for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                return true;
                }
            }
            return false;
        }
        // 清空ArrayList，将全部的元素设为null
        public void clear() {
            modCount++;
            for (int i = 0; i < size; i++)
                elementData[i] = null;
            size = 0;
        }
        // 将集合c追加到ArrayList中
        public boolean addAll(Collection<? extends E> c) {
            Object[] a = c.toArray();
            int numNew = a.length;
            ensureCapacity(size + numNew);  // Increments modCount
            System.arraycopy(a, 0, elementData, size, numNew);
            size += numNew;
            return numNew != 0;
        }
        // 从index位置开始，将集合c添加到ArrayList
        public boolean addAll(int index, Collection<? extends E> c) {
            if (index > size || index < 0)
                throw new IndexOutOfBoundsException(
                "Index: " + index + ", Size: " + size);
            Object[] a = c.toArray();
            int numNew = a.length;
            ensureCapacity(size + numNew);  // Increments modCount
            int numMoved = size - index;
            if (numMoved > 0)
                System.arraycopy(elementData, index, elementData, index + numNew,
                     numMoved);
            System.arraycopy(a, 0, elementData, index, numNew);
            size += numNew;
            return numNew != 0;
        }
        // 删除fromIndex到toIndex之间的全部元素。
        protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;
            System.arraycopy(elementData, toIndex, elementData, fromIndex,
                             numMoved);
        // Let gc do its work
        int newSize = size - (toIndex-fromIndex);
        while (size != newSize)
            elementData[--size] = null;
        }
        private void RangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(
            "Index: "+index+", Size: "+size);
        }
        // 克隆函数
        public Object clone() {
            try {
                ArrayList<E> v = (ArrayList<E>) super.clone();
                // 将当前ArrayList的全部元素拷贝到v中
                v.elementData = Arrays.copyOf(elementData, size);
                v.modCount = 0;
                return v;
            } catch (CloneNotSupportedException e) {
                // this shouldn't happen, since we are Cloneable
                throw new InternalError();
            }
        }
        // java.io.Serializable的写入函数
        // 将ArrayList的“容量，所有的元素值”都写入到输出流中
        private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();
            // 写入“数组的容量”
            s.writeInt(elementData.length);
        // 写入“数组的每一个元素”
        for (int i=0; i<size; i++)
                s.writeObject(elementData[i]);
        if (modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
        }
        // java.io.Serializable的读取函数：根据写入方式读出
        // 先将ArrayList的“容量”读出，然后将“所有的元素值”读出
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            // Read in size, and any hidden stuff
            s.defaultReadObject();
            // 从输入流中读取ArrayList的“容量”
            int arrayLength = s.readInt();
            Object[] a = elementData = new Object[arrayLength];
            // 从输入流中将“所有的元素值”读出
            for (int i=0; i<size; i++)
                a[i] = s.readObject();
        }
    }
    </span>

#### ArrayList总结 ####

*  ArrayList 实际上是通过一个数组去保存数据的。当我们构造ArrayList时；若使用默认构造函数，则ArrayList的默认容量大小是10。
 *  当ArrayList容量不足以容纳全部元素时，ArrayList会重新设置容量：新的容量=“(原始容量x3)/2 + 1”。
 *  ArrayList的克隆函数，即是将全部元素克隆到一个数组中。
 *  ArrayList实现java.io.Serializable的方式。当写入到输出流时，先写入“容量”，再依次写入“每一个元素”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。

#### 首先看这两类都实现List接口，而List接口一共有三个实现类，分别是ArrayList、Vector和LinkedList。List用于存放多个元素，能够维护元素的次序，并且允许元素的重复。3个具体实现类的相关区别如下： ####

1.  ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。
2.  Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。
3.  LinkedList是用链表结构存储数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，他还提供了List接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。
4.  vector是线程（Thread）同步（Synchronized）的，所以它也是线程安全的，而Arraylist是线程异步（ASynchronized）的，是不安全的。如果不考虑到线程的安全因素，一般用Arraylist效率比较高。
5.  如果集合中的元素的数目大于目前集合数组的长度时，vector增长率为目前数组长度的100%,而arraylist增长率为目前数组长度  
    的50%.如过在集合中使用数据量比较大的数据，用vector有一定的优势。
6.  如果查找一个指定位置的数据，vector和arraylist使用的时间是相同的，都是0(1),这个时候使用vector和arraylist都可以。而如果移动一个指定位置的数据花费的时间为0(n-i)n为总长度，这个时候就应该考虑到使用Linkedlist,因为它移动一个指定位置的数据所花费的时间为0(1),而查询一个指定位置的数据时花费的时间为0(i)。ArrayList 和Vector是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，都允许直接序号索引元素，但是插入数据要设计到数组元素移动 等内存操作，所以索引数据快插入数据慢，Vector由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差  
    ，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项的前后项即可，所以插入数度较快！
7.  笼统来说：LinkedList：增删改快

[70]: /images/20220520/18929c1311cf415fb34137992452f0bc.png
[70 1]: /images/20220520/6fd6ba2a9daa4785969659f6c8cb27a7.png
[70 2]: /images/20220520/4e2e56b8d34c4dd38f6f9fe82afbd7ed.png
[70 3]: /images/20220520/a4ac737ea7b9477c83332581b9b6bca9.png
[70 4]: /images/20220520/e82555ec60294ccd91f67b7fad20d2f0.png