zoukankan      html  css  js  c++  java
  • java.util.Vector

    public class Vector<E>
        extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

    实例变量

    //保存元素的容器
    protected Object[] elementData;
    
    //元素的数量
    protected int elementCount;
    
    //容器扩容时的增量
    protected int capacityIncrement;

    4个构造器

    //初始容量和容器扩容增量的构造器
    public Vector(int initialCapacity, int capacityIncrement) {
            super();
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            this.elementData = new Object[initialCapacity];
            this.capacityIncrement = capacityIncrement;
    }
    
    //只有初始容量的构造器,默认使用容器扩容增量为0,表示不指定,那么扩容时会变成原容量的2倍
    public Vector(int initialCapacity) {
            this(initialCapacity, 0);
    }
    
    不指定初始容量,那么默认初始容量为10
    public Vector() {
            this(10);
    }
    
    //使用c构造Vector
    public Vector(Collection<? extends E> c) {
            elementData = c.toArray();
            elementCount = elementData.length;
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }

    扩容方法

    public synchronized void ensureCapacity(int minCapacity) {
            if (minCapacity > 0) {
                modCount++;
                ensureCapacityHelper(minCapacity);
            }
    }
    
    private void ensureCapacityHelper(int minCapacity) {
            // overflow-conscious code
            if (minCapacity - elementData.length > 0)
                grow(minCapacity);
    }
    
    private void grow(int minCapacity) {
            // overflow-conscious code
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                             capacityIncrement : oldCapacity);//如果capacityIncrement为0,那么newCapacity为oldCapacity * 2
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            elementData = Arrays.copyOf(elementData, newCapacity);
    }

    设置容量

    public synchronized void setSize(int newSize) {
            modCount++;
            if (newSize > elementCount) {//如果新容量大于旧容量,扩容
                ensureCapacityHelper(newSize);
            } else {//否则,将超过新容量的部分都设置为null,注意容量没变,只是超出newSize的元素变成null
                for (int i = newSize ; i < elementCount ; i++) {
                    elementData[i] = null;
                }
            }
            elementCount = newSize;
    }

    2个迭代器,一个从头迭代到尾,一个从尾迭代到头

    private class Itr implements Iterator<E> {//正向迭代器,cursor为0
            int cursor;       // index of next element to return
            int lastRet = -1; // index of last element returned; -1 if no such
            int expectedModCount = modCount;
    
            public boolean hasNext() {
                // Racy but within spec, since modifications are checked
                // within or after synchronization in next/previous
                return cursor != elementCount;
            }
    
            public E next() {
                synchronized (Vector.this) {
                    checkForComodification();
                    int i = cursor;
                    if (i >= elementCount)
                        throw new NoSuchElementException();
                    cursor = i + 1;
                    return elementData(lastRet = i);
                }
            }
    
            public void remove() {
                if (lastRet == -1)
                    throw new IllegalStateException();
                synchronized (Vector.this) {
                    checkForComodification();
                    Vector.this.remove(lastRet);
                    expectedModCount = modCount;
                }
                cursor = lastRet;
                lastRet = -1;
            }
    
            @Override
            public void forEachRemaining(Consumer<? super E> action) {
                Objects.requireNonNull(action);
                synchronized (Vector.this) {
                    final int size = elementCount;
                    int i = cursor;
                    if (i >= size) {
                        return;
                    }
            @SuppressWarnings("unchecked")
                    final E[] elementData = (E[]) Vector.this.elementData;
                    if (i >= elementData.length) {
                        throw new ConcurrentModificationException();
                    }
                    while (i != size && modCount == expectedModCount) {
                        action.accept(elementData[i++]);
                    }
                    // update once at end of iteration to reduce heap write traffic
                    cursor = i;
                    lastRet = i - 1;
                    checkForComodification();
                }
            }
    
            final void checkForComodification() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }
    }
    final class ListItr extends Itr implements ListIterator<E> {//从index到头迭代
            ListItr(int index) {
                super();
                cursor = index;
            }
    
            public boolean hasPrevious() {
                return cursor != 0;
            }
    
            public int nextIndex() {
                return cursor;
            }
    
            public int previousIndex() {
                return cursor - 1;
            }
    
            public E previous() {
                synchronized (Vector.this) {
                    checkForComodification();
                    int i = cursor - 1;
                    if (i < 0)
                        throw new NoSuchElementException();
                    cursor = i;
                    return elementData(lastRet = i);
                }
            }
    
            public void set(E e) {
                if (lastRet == -1)
                    throw new IllegalStateException();
                synchronized (Vector.this) {
                    checkForComodification();
                    Vector.this.set(lastRet, e);
                }
            }
    
            public void add(E e) {
                int i = cursor;
                synchronized (Vector.this) {
                    checkForComodification();
                    Vector.this.add(i, e);
                    expectedModCount = modCount;
                }
                cursor = i + 1;
                lastRet = -1;
            }
        }
    
        @Override
        public synchronized void forEach(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            final int expectedModCount = modCount;
            @SuppressWarnings("unchecked")
            final E[] elementData = (E[]) this.elementData;
            final int elementCount = this.elementCount;
            for (int i=0; modCount == expectedModCount && i < elementCount; i++) {
                action.accept(elementData[i]);
            }
            if (modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
    }
    //index指定从哪个位置开始往前迭代
    public synchronized ListIterator<E> listIterator(int index) {
            if (index < 0 || index > elementCount)
                throw new IndexOutOfBoundsException("Index: "+index);
            return new ListItr(index);
    }

    Vector是线程安全的,它的方法使用synchronized修饰,如果不需要线程安全,推荐使用ArrayList代替。

  • 相关阅读:
    国庆七天乐——第二天
    国庆七天乐——第一天
    线段树+树状数组+分块+循环展开 的模板
    AOE网络——求关键路径
    最小生成树模板+并查集(隐藏)+结构体排序模板
    并查集模板
    最短路径模板总结
    newifi mini将led指示灯引出当gpio使用
    openwrt 无线中继
    笔记本硬盘盒改装台式机硬盘盒
  • 原文地址:https://www.cnblogs.com/13jhzeng/p/5828094.html
Copyright © 2011-2022 走看看