Java-Verbesserungskapitel (29) -----Vector

Im Java-Verbesserungskapitel (Two One) – ArrayList, im Java-Verbesserungskapitel (Two Two) – LinkedList werden die Prinzipien und Implementierungsprozesse von ArrayList und LinkedIn ausführlich erläutert Listenschnittstelle hier Außerdem wird die Implementierungsklasse Vector vorgestellt. Die Vector-Klasse kann ein erweiterbares Objektarray implementieren.

1. Einführung in Vector

Vector kann ein erweiterbares Objektarray implementieren. Wie ein Array enthält es Komponenten, auf die über ganzzahlige Indizes zugegriffen werden kann. Die Größe des Vektors kann jedoch vergrößert oder verkleinert werden, um nach der Erstellung des Vektors Hinzufügungs- oder Löschvorgänge zu ermöglichen.

Vector implementiert die List-Schnittstelle und erbt die AbstractList-Klasse, sodass wir sie als Warteschlange betrachten können, die verwandte Funktionen wie Hinzufügen, Löschen, Ändern und Durchlaufen unterstützt , usw.

Vector implementiert die RandmoAccess-Schnittstelle, die Direktzugriff und Schnellzugriff ermöglicht. In Vector können wir direkt auf Elemente zugreifen.

      Vector implementiert die Cloneable-Schnittstelle, unterstützt die clone()-Methode und kann geklont werden.

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

 Vector bietet vier Konstruktoren:

/**
     * 构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。
     */
     public Vector() {
            this(10);
     }
    
    /**
     * 构造一个包含指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列。
     */
    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 Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }
    
    /**
     *  使用指定的初始容量和容量增量构造一个空的向量。
     */
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

 In Bezug auf Mitgliedsvariablen stellt Vector drei zur Verfügung Mitgliedsvariablen elementData, elementCount und CapacityIncrement. Darunter

                                   elementData: „Array vom Typ Object[]“, das die Elemente in Vector speichert. Gemäß dem Design von Vector ist elementData ein dynamisches Array, das mit zunehmenden Elementen dynamisch wachsen kann. Die spezifische Erhöhungsmethode wird später erwähnt (ensureCapacity-Methode). Wenn die Containergröße bei der Initialisierung des Vektors nicht angegeben wird, wird die Standardgröße von 10 verwendet.

    capacityIncrement: Wenn die Größe des Vektors größer als seine Kapazität ist, wird die Kapazität automatisch um den Betrag erhöht. Wenn die Größe von „capacityIncrement“ beim Erstellen von Vector angegeben wird, beträgt die erhöhte Größe jedes Mal, wenn die Kapazität des dynamischen Arrays in Vector zunimmt. Wenn die Kapazitätserhöhung kleiner oder gleich Null ist, wird die Kapazität des Vektors jedes Mal verdoppelt, wenn eine Kapazitätserhöhung erforderlich ist. Vector

   Gleichzeitig ist Vector threadsicher!

2. Quellcode-Analyse

entfernen) wird auf zwei Arten erklärt.

2.1 hinzugefügt: add(E e)

 

add(E e): Füge das angegebene Element dazu hinzu Das Ende des Vektors.

 

Diese Methode ist relativ einfach, die spezifische Der Prozess besteht darin, zunächst die Größe des Containers zu bestätigen, um zu sehen, ob eine Erweiterung erforderlich ist, und dann das E-Element am Ende dieses Vektors hinzuzufügen.

public synchronized boolean add(E e) {
        modCount++;     
        ensureCapacityHelper(elementCount + 1);    //确认容器大小，如果操作容量则扩容操作
        elementData[elementCount++] = e;   //将e元素添加至末尾
        return true;
    }

private void ensureCapacityHelper(int minCapacity) {
        //如果
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    /**
     * 进行扩容操作
     * 如果此向量的当前容量小于minCapacity，则通过将其内部数组替换为一个较大的数组俩增加其容量。
     * 新数据数组的大小姜维原来的大小 + capacityIncrement，
     * 除非 capacityIncrement 的值小于等于零，在后一种情况下，新的容量将为原来容量的两倍，不过，如果此大小仍然小于 minCapacity，则新容量将为 minCapacity。
     */
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;     //当前容器大小
        /*
         * 新容器大小
         * 若容量增量系数(capacityIncrement) > 0，则将容器大小增加到capacityIncrement
         * 否则将容量增加一倍
         */
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    
    /**
     * 判断是否超出最大范围
     * MAX_ARRAY_SIZE：private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
     */
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
    }

  
Für den gesamten Erweiterungsprozess von Vector wird die Erweiterungsgröße basierend auf CapacityInkrement bestimmt. Wenn Kapazitätsinkrement <= 0 ist, wird sie verdoppelt, andernfalls wird sie auf Kapazitätsinkrement erweitert. Der maximale Bereich dieser Kapazität ist natürlich Integer.MAX_VALUE, also 2 ^ 32 - 1, sodass Vector nicht unendlich erweitert werden kann.

2.2, entfernen(Objekt o)

因为Vector底层是使用数组实现的，所以它的操作都是对数组进行操作，只不过其是可以随着元素的增加而动态的改变容量大小，其实现方法是是使用Arrays.copyOf方法将旧数据拷贝到一个新的大容量数组中。Vector的整个内部实现都比较简单，这里就不在重述了。

三、Vector遍历

Vector支持4种遍历方式。

3.1、随机访问

因为Vector实现了RandmoAccess接口，可以通过下标来进行随机访问。

for(int i = 0 ; i < vec.size() ; i++){
        value = vec.get(i);
    }

3.2、迭代器

Iterator it = vec.iterator();
    while(it.hasNext()){
        value = it.next();
        //do something
    }

3.2、for循环

for(Integer value:vec){
        //do something
    }

3.4、Enumeration循环

Vector vec = new Vector<>();
    Enumeration enu = vec.elements();
    while (enu.hasMoreElements()) {
        value = (Integer)enu.nextElement();
    }

——————————————————————————————————————————————————————————————————————————

以上就是java提高篇（二九）-----Vector的内容，更多相关内容请关注PHP中文网（www.php.cn）！