Vector底层原理

public interface Enumeration<E> {    ///判断是否有下一个可迭代元素    boolean hasMoreElements();    //获取下一个元素    E nextElement();}

这是Java接口Enumeration定义。该界面定义了迭代元素的两种方法：

1. boolean hasMoreElements(): 该方法用于判断是否有下一个可迭代元素。如果是这样，返回true；否则返回false。
2. E nextElement(): 该方法用于获取下一个元素，并将迭代器的位置移动到下一个元素。如果没有更多的元素可以迭代，它将被抛出NoSuchElementException异常。

该接口通常用于遍历集合中的元素。在实际使用中，您可以从定义迭代器中实现此接口，以便在您的集合类中使用。

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {    ///外部操作数    protected transient int modCount = 0;//3}public class Vector<E> extends AbstractList<E> implements List<E>{    ///数据容器    protected Object[] elementData;//new Object[100]{付张祥，张浩天，田海龙，null,null,...}    //元素的数量    protected int elementCount;//3    //容量增加    protected int capacityIncrement;//50        public Vector() {        this(10);///使用无参构造创建Vector对象，底部默认容量为10    }        //initialCapacity - 10    public Vector(int initialCapacity) {        this(initialCapacity, 0);    }        //initialCapacity - 100    //capacityIncrement - 50    public Vector(int initialCapacity, int capacityIncrement) {        super();        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal Capacity: "+                                               initialCapacity);        this.elementData = new Object[initialCapacity];        this.capacityIncrement = capacityIncrement;    }        //e - 田海龙    public synchronized boolean add(E e) {        modCount++;        ensureCapacityHelper(elementCount + 1);        elementData[elementCount++] = e;        return true;    }        //minCapacity - 101    private void ensureCapacityHelper(int minCapacity) {        //判断是否扩展        if (minCapacity - elementData.length > 0)            grow(minCapacity);    }        //minCapacity - 101    private void grow(int minCapacity) {        // oldCapacity - 100        int oldCapacity = elementData.length;        // newCapacity - 100 + 50        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);    }        @SuppressWarnings("unchecked")    E elementData(int index) {        return (E) elementData[index];    }        public Enumeration<E> elements() {        return new Enumeration<E>() {            int count = 0;            public boolean hasMoreElements() {                return count < elementCount;            }            public E nextElement() {                synchronized (Vector.this) {                    if (count < elementCount) {                        return elementData(count++);                    }                }                throw new NoSuchElementException("Vector Enumeration");            }        };    }    }

这个代码显示了Java中Vector类的简单实现。Vector是一个动态数组，可以根据需要自动增加容量。以下是代码解释和功能描述:

1. Vector类继承自AbstractList类，实现了List接口。它是抽象的，不能直接实例化。
2. Vector类有三个字段：

• elementData：存储元素的数组。最初，容量为10，可根据需要动态增长。
• elementCount：元素的数量。初始时为0，每次添加元素时自增。
• capacityIncrement：容量增加。当数组需要扩大容量时，增加的容量大小。初始时间为0，表示每次扩大容量时容量翻倍。

3. Vector类有多个结构函数：

• 无参构造函数：创建一个容量为10的Vector对象。
• 具有初始容量的构造函数：创建一个Vector对象，指定初始容量。
• 具有初始容量和容量增量的构造函数：创建指定初始容量和容量增量的Vector对象。

4. add(E e)方法:在Vector中添加元素。首先添加元素。modCount用于记录修改次数的字段值。然后调用ensureCapacityHelper确保容量足够，如果需要扩大容量，请调用grow扩展的方法。最终添加元素elementData并将在数组中elementCount字段自增。
5. ensureCapacityHelper(int minCapacity)方法：检查当前容量是否足够，如果不足，则调用grow扩容方法。
6. grow(int minCapacity)方法:扩容数组。首先获得当前数组的容量oldCapacity，然后计算新的容量newCapacity，如果容量增量大于0，则将其添加到旧容量上，否则将旧容量翻倍。如果新容量小于所需的最小容量minCapacity，以最小容量为新容量。若新容量超过MAX_ARRAY_SIZE调用限制hugeCapacity获得合法容量值的方法。最后，使用Arrays.copyOf该方法将旧数组的元素复制到新数组。
7. elementData(int index)方法：根据索引返回元素。
8. elements()方法：返回枚举器，用于遍历Vector中的元素。实现了枚举器hasMoreElements()方法和nextElement()方法，通过synchronized实现线程安全的关键字。

一般来说，这个Vector类实现了动态数组的功能，可以根据需要自动扩展容量，并提供了添加和遍历元素的方法。

//Vector<String> v = new Vector<>();Vector<String> v = new Vector<>(100,50);v.add(小白);v.add(“小王”);v.add(“小文”;Enumeration<String> elements = v.elements();while(elements.hasMoreElements()){String element = elements.nextElement();System.out.println(element);}

这个代码演示了如何使用它Vector类和Enumeration接口遍历一个向量元素。

第一，创建了一个Vector对象v，初始容量为100，增量为50，通过构造函数指定。然后，使用add方法向向量中添加了三个字符串元素。

接下来，通过调用elements获得一个方法Enumeration对象elements，它用于遍历向量中的元素。

最后，使用while循环和hasMoreElements判断是否有下一个可迭代元素的方法。如果是，请使用它nextElement获取下一个元素的方法，并将其打印出来。

这样，打印出向量中的所有元素都可以遍历。

请注意，Vector类别是线程安全的，但是在现代Java开发中，更推荐使用ArrayList类来代替Vector，因为ArrayList性能更好。

ArrayList和Vector在Java集合框架中，它们具有类似的功能，但在某些方面存在一些差异。

1. 线程安全：Vector是线程安全，而且ArrayList不是。这意味着在多线程环境中，Vector集中元素可以安全地访问和修改多个线程，ArrayList这种保证在多线程环境中没有提供。如果您的应用程序需要在多线程环境中使用集合，您可能更喜欢使用它们Vector。
2. 性能：由于Vector线程安全，在执行某些操作时会引入额外的费用，如同步和锁定。相比之下，ArrayList因此，在单线程环境下，不需要这些额外的费用，ArrayList性能通常比Vector更好。
3. 扩容方法：当集合需要扩容时，Vector它的容量会自动增加一倍，ArrayList会增加一定比例的容量(通常是当前容量的一半)。这就是为什么在大多数情况下，ArrayList性能更好，因为它可以更有效地管理内存。
4. ArrayList 这是JDK1.2之前的一个类别。这个集合不是线程安全。扩展机制是原始长度的1.5倍。Vector是JDK1.0。这个集合是线程安全（锁定）。扩展机制需要判断容量增量。容量增量为0。扩展机制是原始长度的两倍，容量增量大于0。扩展机制是原始长度+容量增量

综上所述，如果你的应用程序在单线程环境中运行，性能是关键因素，那么ArrayList这可能是一个更好的选择。如果您的应用程序需要在多线程环境中集合，线程安全是一个关键因素，那么Vector可能是更好的选择。但需要注意的是，在现代Java开发中，更推荐使用ArrayList或其他并发集合类，如CopyOnWriteArrayList，来替代Vector。