Java数据结构源码分析-Vector

不念不忘少年蓝@ 2022-08-23 03:44 213阅读 0赞

## 1.Vector ##

Vector和ArrayList都是通过数组来构建顺序列表的数据结构，其关系同HashMap与HashTable一样，Vector是一个线程安全的数据结构，而ArrayList是非线程安全的，因此在不考虑多线程的情况下，ArrayList比Vector速度更加的快，在考虑线程安全的情况下，ArrayList提供了SynchronizedList类来保证线程安全，其访问速度同Vector没有太大差别，只不过Vector是synchronized(this)来保证线程安全，而SynchronizedList是通过synchronized(mutex)对象来保证。因此也Vector也可以被废弃（这个并不是因为性能原因）

public class Collections { 
        // Suppresses default constructor, ensuring non-instantiability.
        private Collections() {
        }
        public static <T> List<T> synchronizedList(List<T> list) {
            return (list instanceof RandomAccess ?
                    new SynchronizedRandomAccessList<>(list) :
                    new SynchronizedList<>(list));
        }
        static class SynchronizedList<E>
            extends SynchronizedCollection<E>
            implements List<E> {
            private static final long serialVersionUID = -7754090372962971524L;
    
            final List<E> list;
    
            SynchronizedList(List<E> list) {
                super(list);
                this.list = list;
            }
            SynchronizedList(List<E> list, Object mutex) {
                super(list, mutex);
                this.list = list;
            }
    
            public boolean equals(Object o) {
                if (this == o)
                    return true;
                synchronized (mutex) {
       return list.equals(o);}
            }
            public int hashCode() {
                synchronized (mutex) {
       return list.hashCode();}
            }
    
            public E get(int index) {
                synchronized (mutex) {
       return list.get(index);}
            }
            public E set(int index, E element) {
                synchronized (mutex) {
       return list.set(index, element);}
            }
            public void add(int index, E element) {
                synchronized (mutex) {list.add(index, element);}
            }
            public E remove(int index) {
                synchronized (mutex) {
       return list.remove(index);}
            }
    
            public int indexOf(Object o) {
                synchronized (mutex) {
       return list.indexOf(o);}
            }
            public int lastIndexOf(Object o) {
                synchronized (mutex) {
       return list.lastIndexOf(o);}
            }
    
            public boolean addAll(int index, Collection<? extends E> c) {
                synchronized (mutex) {
       return list.addAll(index, c);}
            }
    
            public ListIterator<E> listIterator() {
                return list.listIterator(); // Must be manually synched by user
            }
    
            public ListIterator<E> listIterator(int index) {
                return list.listIterator(index); // Must be manually synched by user
            }
    
            public List<E> subList(int fromIndex, int toIndex) {
                synchronized (mutex) {
                    return new SynchronizedList<>(list.subList(fromIndex, toIndex),
                                                mutex);
                }
            }
            private Object readResolve() {
                return (list instanceof RandomAccess
                        ? new SynchronizedRandomAccessList<>(list)
                        : this);
            }
        }
    }

## 2.Vector与ArrayList的差异性 ##

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