devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java集合框架04-Vector详解_java 的vector是什么结构

作者：小小林熬夜学编程 | 2024-03-15 19:11:28

赞

踩

java 的vector是什么结构

1、Vector介绍

Vector是矢量队列，它继承了AbstractList，实现了List、 RandomAccess, Cloneable, java.io.Serializable接口。

  • Vector继承了AbstractList，实现了List，它是一个队列，因此实现了相应的添加、删除、修改、遍历等功能。
  • Vector实现了RandomAccess接口，因此可以随机访问。
  • Vector实现了Cloneable，重载了clone()方法，因此可以进行克隆。
  • Vector实现了Serializable接口，因此可以进行序列化。
  • Vector的操作是线程安全的。

2、Vector和ArrayList的关系

Vector的数据结构和ArrayList差不多，包含了3个成员变量：elementData，elementCount，capacityIncrement。 
（1）elementData是Object[]的数组，初始大小为10，会不断的增长。 
（2）elementCount是元素的个数。 
（3）capacityIncrement是动态数组增长的系数。

3、继承结构

  1. java.lang.Object
  2.    ↳     java.util.AbstractCollection<E>
  3.          ↳     java.util.AbstractList<E>
  4.                ↳     java.util.Vector<E>
  5.  
  6. public class Vector<E>
  7.     extends AbstractList<E>
  8.     implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}

4、源码分析

  1. package list;
  2.  
  3. import java.util.*;
  4. import java.util.function.Consumer;
  5. import java.util.function.Predicate;
  6. import java.util.function.UnaryOperator;
  7.  
  8. public class Vector<E>
  9.         extends AbstractList<E>
  10.         implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
  11.     //当前数组
  12.     protected Object[] elementData;
  13.  
  14.     //当前数组元素个数
  15.     protected int elementCount;
  16.  
  17.    // capacityIncrement，扩增容量：代表当列表元素满了之后增加的容量。
  18.     //如果不设置capacityIncrement，那么Vector容量扩展时默认将扩展两倍
  19.     protected int capacityIncrement;
  20.  
  21.     //序列化uid
  22.     private static final long serialVersionUID = -2767605614048989439L;
  23.  
  24.     /**
  25.      * 创建一个带有指定容量和扩增容量的Vector
  26.      * @param   initialCapacity     初始化容量
  27.      * @param   capacityIncrement   列表元素满了之后增加的容量
  28.      * @throws IllegalArgumentException 如果指定容量为负
  29.      */
  30.     public Vector(int initialCapacity, int capacityIncrement) {
  31.         super();
  32.         if (initialCapacity < 0)
  33.             throw new IllegalArgumentException("Illegal Capacity: "+
  34.                     initialCapacity);
  35.         this.elementData = new Object[initialCapacity];//创建一个指定容量的数组
  36.         this.capacityIncrement = capacityIncrement;
  37.     }
  38.  
  39.     /**
  40.      * 创建一个带有指定容量和扩增容量为空的Vector
  41.      */
  42.     public Vector(int initialCapacity) {
  43.         this(initialCapacity, 0);
  44.     }
  45.  
  46.     /**
  47.      * 创建一个带有指定容量和扩增容量为空的Vector
  48.      */
  49.     public Vector() {
  50.         this(10);
  51.     }
  52.  
  53.     /**
  54.      * 创建一个包含指定集合中元素的Vector,
  55.      *  - 顺序按照集合的iterator
  56.      *  - <? extends E>  协变: 当你传入的集合是 E 的子类时，那么就可以协变。
  57.      */
  58.     public Vector(Collection<? extends E> c) {
  59.         elementData = c.toArray();
  60.         elementCount = elementData.length;
  61.         // c.toArray might (incorrectly) not return Object[] (see 6260652)
  62.         if (elementData.getClass() != Object[].class)
  63.             elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
  64.     }
  65.  
  66.     /**
  67.      * 将Vector中的元素拷贝到指定数组中
  68.      */
  69.     public synchronized void copyInto(Object[] anArray) {
  70.         System.arraycopy(elementData, 0, anArray, 0, elementCount);
  71.     }
  72.  
  73.     /**
  74.      * 将底层数组的容量调整为当前vector实际元素的个数，来释放空间。
  75.      */
  76.     public synchronized void trimToSize() {
  77.         modCount++;
  78.         int oldCapacity = elementData.length;
  79.         if (elementCount < oldCapacity) {
  80.             elementData = Arrays.copyOf(elementData, elementCount);
  81.         }
  82.     }
  83.  
  84.     /**
  85.      * 确保最小容量至少是minCapacity，如果不够，增长Vector的容量
  86.      */
  87.     public synchronized void ensureCapacity(int minCapacity) {
  88.         if (minCapacity > 0) {
  89.             modCount++;
  90.             ensureCapacityHelper(minCapacity);
  91.         }
  92.     }
  93.  
  94.     /**
  95.      * 这里注释解释，这个方法是异步(也就是能被多个线程同时访问)的，
  96.      * 原因是为了让同步方法都能调用到这个检测容量的方法，
  97.      */
  98.     private void ensureCapacityHelper(int minCapacity) {
  99.         // overflow-conscious code
  100.         if (minCapacity - elementData.length > 0)
  101.             //容量不够，就扩增，核心方法
  102.             grow(minCapacity);
  103.     }
  104.  
  105.     /**
  106.      * 因为某些VM会在数组中保留一些头字，尝试分配这个最大存储容量，可能会导致array容量大于VM的limit，最终导致OutOfMemoryError。
  107.      */
  108.     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
  109.  
  110.     /**
  111.      * 容量核心方法，增加容量
  112.      */
  113.     private void grow(int minCapacity) {
  114.         // overflow-conscious code
  115.         //原来的数组容量
  116.         int oldCapacity = elementData.length;
  117.         //如果capacityIncrement>0，就加capacityIncrement，如果不是就增加一倍。
  118.         int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
  119.                 capacityIncrement : oldCapacity);
  120.         //如果扩容后的容量还是比指定的最小容量小
  121.         if (newCapacity - minCapacity < 0)
  122.             newCapacity = minCapacity;//新容量=最小容量
  123.         //如果扩容后的容量比最大数组容量还要大
  124.         if (newCapacity - MAX_ARRAY_SIZE > 0)
  125.             newCapacity = hugeCapacity(minCapacity);//新容量=最大容量
  126.         elementData = Arrays.copyOf(elementData, newCapacity);//新数组大小
  127.     }
  128.  
  129.     private static int hugeCapacity(int minCapacity) {
  130.         if (minCapacity < 0) // overflow
  131.             throw new OutOfMemoryError();
  132.         return (minCapacity > MAX_ARRAY_SIZE) ?
  133.                 Integer.MAX_VALUE :
  134.                 MAX_ARRAY_SIZE;
  135.     }
  136.  
  137.     /**
  138.      * 设置vector的容量大小，如果新容量大于当前的容量，则增加items到vector的末尾
  139.      *   如果新容量小于当前容量，将vector从新容量到末尾处丢弃
  140.      */
  141.     public synchronized void setSize(int newSize) {
  142.         modCount++;
  143.         if (newSize > elementCount) {
  144.             ensureCapacityHelper(newSize);
  145.         } else {
  146.             for (int i = newSize ; i < elementCount ; i++) {
  147.                 elementData[i] = null;
  148.             }
  149.         }
  150.         elementCount = newSize;
  151.     }
  152.  
  153.     /**
  154.      * 获取vector的容量
  155.      */
  156.     public synchronized int capacity() {
  157.         return elementData.length;
  158.     }
  159.  
  160.     /**
  161.      * 返回 vector 元素个数
  162.      */
  163.     public synchronized int size() {
  164.         return elementCount;
  165.     }
  166.  
  167.     /**
  168.      * 判断vector元素是否为空
  169.      */
  170.     public synchronized boolean isEmpty() {
  171.         return elementCount == 0;
  172.     }
  173.  
  174.     /**
  175.      * 返回一个包含vector所有元素的枚举
  176.      * while (elements.hasMoreElements()) {
  177.      *       String s = elements.nextElement();
  178.      *       }
  179.      */
  180.     public Enumeration<E> elements() {
  181.         // 通过匿名类实现Enumeration
  182.         return new Enumeration<E>() {
  183.             int count = 0;
  184.  
  185.             // 是否存在下一个元素
  186.             public boolean hasMoreElements() {
  187.                 return count < elementCount;
  188.             }
  189.  
  190.             // 获取下一个元素
  191.             public E nextElement() {
  192.                 synchronized (Vector.this) {
  193.                     if (count < elementCount) {
  194.                         return elementData(count++);
  195.                     }
  196.                 }
  197.                 throw new NoSuchElementException("Vector Enumeration");
  198.             }
  199.         };
  200.     }
  201.  
  202.     /**
  203.      * 返回这个vector是否包含指定元素
  204.      */
  205.     public boolean contains(Object o) {
  206.         return indexOf(o, 0) >= 0;
  207.     }
  208.  
  209.     /**
  210.      * 返回这个vector中第一次出现指定元素的下标，如果不包括这个元素返回-1
  211.      * 从0开始查找
  212.      */
  213.     public int indexOf(Object o) {
  214.         return indexOf(o, 0);
  215.     }
  216.  
  217.     /**
  218.      *从指定的位置向后开始查找vector中第一次出现这个元素的下标
  219.      * 如果没有返回-1
  220.      */
  221.     public synchronized int indexOf(Object o, int index) {
  222.         if (o == null) {
  223.             for (int i = index ; i < elementCount ; i++)
  224.                 if (elementData[i]==null)
  225.                     return i;
  226.         } else {
  227.             for (int i = index ; i < elementCount ; i++)
  228.                 if (o.equals(elementData[i]))
  229.                     return i;
  230.         }
  231.         return -1;
  232.     }
  233.  
  234.     /**
  235.      * 返回在vector中最后一次出现指定元素的角标
  236.      * 如果vector不包含这个元素则返回-1
  237.      */
  238.     public synchronized int lastIndexOf(Object o) {
  239.         return lastIndexOf(o, elementCount-1);
  240.     }
  241.  
  242.     /**
  243.      * 返回在vector中最后一次出现指定元素的角标
  244.      * - 就是从指定位置向前寻找第一次出现的指定元素的角标
  245.      * - 如果找不到返回-1
  246.      */
  247.     public synchronized int lastIndexOf(Object o, int index) {
  248.         if (index >= elementCount)
  249.             throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
  250.  
  251.         if (o == null) {
  252.             for (int i = index; i >= 0; i--)
  253.                 if (elementData[i]==null)
  254.                     return i;
  255.         } else {
  256.             for (int i = index; i >= 0; i--)
  257.                 if (o.equals(elementData[i]))
  258.                     return i;
  259.         }
  260.         return -1;
  261.     }
  262.  
  263.     /**
  264.      * 返回指定下标的元素
  265.      * -- 这个只判断了index>elcmentCount
  266.      */
  267.     public synchronized E elementAt(int index) {
  268.         if (index >= elementCount) {
  269.             throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
  270.         }
  271.  
  272.         return elementData(index);
  273.     }
  274.  
  275.     /**
  276.      *返回vector中的第一个元素
  277.      * -- 如果没有元素会报错NoSuchElementException
  278.      */
  279.     public synchronized E firstElement() {
  280.         if (elementCount == 0) {
  281.             throw new NoSuchElementException();
  282.         }
  283.         return elementData(0);
  284.     }
  285.  
  286.     /**
  287.      *返回vector中的最后一个元素，
  288.      * -- 如果没有会报错NoSuchElementException
  289.      */
  290.     public synchronized E lastElement() {
  291.         if (elementCount == 0) {
  292.             throw new NoSuchElementException();
  293.         }
  294.         return elementData(elementCount - 1);
  295.     }
  296.  
  297.     /**
  298.      * 在指定位置设置指定元素，原来位置的元素会被丢弃
  299.      */
  300.     public synchronized void setElementAt(E obj, int index) {
  301.         if (index >= elementCount) {
  302.             throw new ArrayIndexOutOfBoundsException(index + " >= " +
  303.                     elementCount);
  304.         }
  305.         elementData[index] = obj;
  306.     }
  307.  
  308.     /**
  309.      * 删除指定位置的元素
  310.      * -- 指定位置后面如果还有元素，将后面的元素都向下移动1
  311.      * -- 元素长度-1
  312.      */
  313.     public synchronized void removeElementAt(int index) {
  314.         modCount++;
  315.         if (index >= elementCount) {
  316.             throw new ArrayIndexOutOfBoundsException(index + " >= " +
  317.                     elementCount);
  318.         }
  319.         else if (index < 0) {
  320.             throw new ArrayIndexOutOfBoundsException(index);
  321.         }
  322.         int j = elementCount - index - 1;//指定位置后还有多少元素(不含指定元素)
  323.         if (j > 0) {//如果指定位置后面还有元素
  324.             //将指定位置后面的元素向前移动
  325.             System.arraycopy(elementData, index + 1, elementData, index, j);
  326.         }
  327.         elementCount--;
  328.         elementData[elementCount] = null;//将元素顶部置空，方便回收器回收
  329.     }
  330.  
  331.     /**
  332.      * 在指定位置插入元素
  333.      * -- 将指定位置后面的元素(包括指定位置)向上移动一位
  334.      */
  335.     public synchronized void insertElementAt(E obj, int index) {
  336.         modCount++;
  337.         if (index > elementCount) {
  338.             throw new ArrayIndexOutOfBoundsException(index
  339.                     + " > " + elementCount);
  340.         }
  341.         ensureCapacityHelper(elementCount + 1);//确保容量够用
  342.         //将指定位置及其后面的元素向上移动一位
  343.         System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
  344.         //在指定位置插入元素
  345.         elementData[index] = obj;
  346.         //元素长度+1
  347.         elementCount++;
  348.     }
  349.  
  350.     /**
  351.      * 在vector的元素末尾添加一个元素
  352.      */
  353.     public synchronized void addElement(E obj) {
  354.         modCount++;
  355.         ensureCapacityHelper(elementCount + 1);//确保容量够用
  356.         elementData[elementCount++] = obj;
  357.     }
  358.  
  359.     /**
  360.      * 移除在vector中第一次出现的指定元素
  361.      * -- 如果vector中真的包含这个元素，这个元素后面的都要向下移动一位
  362.      */
  363.     public synchronized boolean removeElement(Object obj) {
  364.         modCount++;
  365.         int i = indexOf(obj);//查找元素在vector中的位置，如果没有返回-1
  366.         if (i >= 0) {
  367.             //如果有这个元素，删除
  368.             removeElementAt(i);
  369.             return true;
  370.         }
  371.         return false;
  372.     }
  373.  
  374.     /**
  375.      * 移除vector中的所有元素，让它的元素大小为0
  376.      */
  377.     public synchronized void removeAllElements() {
  378.         modCount++;
  379.         // 让回收器回收
  380.         for (int i = 0; i < elementCount; i++)
  381.             elementData[i] = null;
  382.         elementCount = 0;
  383.     }
  384.  
  385.     /**
  386.      * 由于实现了Cloneable,这个是深度克隆
  387.      */
  388.     public synchronized Object clone() {
  389.         try {
  390.             @SuppressWarnings("unchecked")
  391.             Vector<E> v = (Vector<E>) super.clone();
  392.             v.elementData = Arrays.copyOf(elementData, elementCount);
  393.             v.modCount = 0;
  394.             return v;
  395.         } catch (CloneNotSupportedException e) {
  396.             // this shouldn't happen, since we are Cloneable
  397.             throw new InternalError(e);
  398.         }
  399.     }
  400.  
  401.     /**
  402.      * 返回一个数组，包含vector中的所有元素
  403.      */
  404.     public synchronized Object[] toArray() {
  405.         return Arrays.copyOf(elementData, elementCount);
  406.     }
  407.  
  408.     /**
  409.      * 返回指定类型的数组
  410.      * - 这里T[] 可以是vector中指定的类型的父类
  411.      */
  412.     @SuppressWarnings("unchecked")
  413.     public synchronized <T> T[] toArray(T[] a) {
  414.         if (a.length < elementCount)
  415.             return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
  416.  
  417.         System.arraycopy(elementData, 0, a, 0, elementCount);
  418.  
  419.         if (a.length > elementCount)
  420.             a[elementCount] = null;
  421.  
  422.         return a;
  423.     }
  424.  
  425.     // Positional Access Operations
  426.     //返回指定位置的元素
  427.     //-- 没有检查，这个方法被内部方法调用
  428.     @SuppressWarnings("unchecked")
  429.     E elementData(int index) {
  430.         return (E) elementData[index];
  431.     }
  432.  
  433.     /**
  434.      * 获取指定位置的元素
  435.      */
  436.     public synchronized E get(int index) {
  437.         if (index >= elementCount)
  438.             throw new ArrayIndexOutOfBoundsException(index);
  439.  
  440.         return elementData(index);
  441.     }
  442.  
  443.     /**
  444.      * 在vector的指定位置代替指定的元素
  445.      * -- 返回指定位置原来的元素
  446.      */
  447.     public synchronized E set(int index, E element) {
  448.         if (index >= elementCount)
  449.             throw new ArrayIndexOutOfBoundsException(index);
  450.  
  451.         E oldValue = elementData(index);
  452.         elementData[index] = element;
  453.         return oldValue;
  454.     }
  455.  
  456.     /**
  457.      * 增加指定的元素到vector
  458.      */
  459.     public synchronized boolean add(E e) {
  460.         modCount++;
  461.         ensureCapacityHelper(elementCount + 1);//确保vector的容量够用
  462.         elementData[elementCount++] = e;//填充元素
  463.         return true;
  464.     }
  465.  
  466.     /**
  467.      * 移除vector中第一次出现的指定元素
  468.      */
  469.     public boolean remove(Object o) {
  470.         return removeElement(o);
  471.     }
  472.  
  473.     /**
  474.      * 在指定位置插入指定元素
  475.      * --向上移动当前元素和后续元素
  476.      */
  477.     public void add(int index, E element) {
  478.         insertElementAt(element, index);
  479.     }
  480.  
  481.     /**
  482.      *移除指定位置的元素
  483.      * -- 返回指定位的原来元素
  484.      * -- 向下移动指定位置后续的元素
  485.      */
  486.     public synchronized E remove(int index) {
  487.         modCount++;
  488.         if (index >= elementCount)
  489.             throw new ArrayIndexOutOfBoundsException(index);
  490.         E oldValue = elementData(index);//获取指定位的元素
  491.  
  492.         int numMoved = elementCount - index - 1;//获取指定位置后面的元素个数
  493.         if (numMoved > 0)
  494.             //向下移动指定位置的后续元素
  495.             System.arraycopy(elementData, index+1, elementData, index,
  496.                     numMoved);
  497.         elementData[--elementCount] = null; // Let gc do its work
  498.  
  499.         return oldValue;
  500.     }
  501.  
  502.     /**
  503.      * 清除vector中的所有元素
  504.      */
  505.     public void clear() {
  506.         removeAllElements();
  507.     }
  508.  
  509.     // Bulk Operations
  510.  
  511.     /**这个方法是调用父类AbstractCollection的方法实现的
  512.      * vector是否包含指定集合中的所有元素
  513.      * -- 如果指定集合中有一个元素不包含则返回false
  514.      */
  515.     public synchronized boolean containsAll(Collection<?> c) {
  516.         return super.containsAll(c);
  517.     }
  518.  
  519.     /**
  520.      * 添加指定集合中的所有元素到vector的末尾，
  521.      * --按照指定集合iterator返回的顺序
  522.      */
  523.     public synchronized boolean addAll(Collection<? extends E> c) {
  524.         modCount++;
  525.         Object[] a = c.toArray();//将集合转化成数组
  526.         int numNew = a.length;//集合的长度
  527.         ensureCapacityHelper(elementCount + numNew);//确保容量
  528.         System.arraycopy(a, 0, elementData, elementCount, numNew);//拷贝
  529.         elementCount += numNew;
  530.         return numNew != 0;
  531.     }
  532.  
  533.     /**
  534.      * 这个方法是调用父类AbstractCollection的方法实现的
  535.      * 删除vector中指定集合的所有元素
  536.      * -- 如 vector[2,5,7,10,3,] c[5,3,15] 指行这个方法后,vector中[2,7,10,3]
  537.      */
  538.     public synchronized boolean removeAll(Collection<?> c) {
  539.         return super.removeAll(c);
  540.     }
  541.  
  542.     /**
  543.      * 这个是调用父类AbstractCollection方法实现的
  544.      * 保留vector中指定集合的所有元素
  545.      * -- 如 vector[2,5,7,10,3,] c[5,3,15] 指行这个方法后,vector中[5,3]
  546.      */
  547.     public synchronized boolean retainAll(Collection<?> c) {
  548.         return super.retainAll(c);
  549.     }
  550.  
  551.     /**
  552.      * 在vector的指定位置添加指定集合中的所有元素
  553.      * -- 向右移动指定位置及其后继的元素
  554.      */
  555.     public synchronized boolean addAll(int index, Collection<? extends E> c) {
  556.         modCount++;
  557.         if (index < 0 || index > elementCount)
  558.             throw new ArrayIndexOutOfBoundsException(index);
  559.  
  560.         Object[] a = c.toArray();
  561.         int numNew = a.length;
  562.         ensureCapacityHelper(elementCount + numNew);
  563.  
  564.         int numMoved = elementCount - index;//指定位置及其后继元素的个数
  565.         if (numMoved > 0)
  566.             //向后移动集合元素大小个距离
  567.             System.arraycopy(elementData, index, elementData, index + numNew,
  568.                     numMoved);
  569.         //将集合元素添加到vector中
  570.         System.arraycopy(a, 0, elementData, index, numNew);
  571.         elementCount += numNew;
  572.         return numNew != 0;
  573.     }
  574.  
  575.     /**
  576.      * 这个方法是调用父类AbstractList方法实现的
  577.      * 比较vector和指定的对象
  578.      * 如果 这个对象是List对象而且集合中元素和vector中的元素一致则返回true，否则返回false
  579.      */
  580.     public synchronized boolean equals(Object o) {
  581.         return super.equals(o);
  582.     }
  583.  
  584.     /**
  585.      * 返回vector的hashCode
  586.      */
  587.     public synchronized int hashCode() {
  588.         return super.hashCode();
  589.     }
  590.  
  591.     /**
  592.      * 调用了父类的AbstractCollection中的方法
  593.      * 返回了这个vector的表示string，包括每一个元素的表示
  594.      */
  595.     public synchronized String toString() {
  596.         return super.toString();
  597.     }
  598.  
  599.     /**
  600.      *
  601.      *返回list中的[fromIndex,toIndex]的子视图
  602.      * -- 如果fromIndex==toIndex则返回的是一个空视图
  603.      * --  这个子视图是这个List的反射
  604.      */
  605.     public synchronized List<E> subList(int fromIndex, int toIndex) {
  606.         return Collections.synchronizedList(super.subList(fromIndex, toIndex));
  607.     }
  608.  
  609.     /**
  610.      * 移除list中[fromIndex,toIndex)范围的元素
  611.      * toIndex及其后继元素向前移动toIndex-fromIndex位
  612.      */
  613.     protected synchronized void removeRange(int fromIndex, int toIndex) {
  614.         modCount++;
  615.         int numMoved = elementCount - toIndex;//获取要移动元素的个数
  616.         System.arraycopy(elementData, toIndex, elementData, fromIndex,
  617.                 numMoved);
  618.  
  619.         // 回收
  620.         int newElementCount = elementCount - (toIndex-fromIndex);
  621.         while (elementCount != newElementCount)
  622.             elementData[--elementCount] = null;
  623.     }
  624.  
  625.     /**
  626.      * 序列化
  627.      */
  628.     private void writeObject(java.io.ObjectOutputStream s)
  629.             throws java.io.IOException {
  630.         final java.io.ObjectOutputStream.PutField fields = s.putFields();
  631.         final Object[] data;
  632.         synchronized (this) {
  633.             fields.put("capacityIncrement", capacityIncrement);
  634.             fields.put("elementCount", elementCount);
  635.             data = elementData.clone();
  636.         }
  637.         fields.put("elementData", data);
  638.         s.writeFields();
  639.     }
  640.     //--------下面的视图iterator，可以参考ArrayList的
  641.     /**
  642.      * 迭代器
  643.      */
  644.     public synchronized ListIterator<E> listIterator(int index) {
  645.         if (index < 0 || index > elementCount)
  646.             throw new IndexOutOfBoundsException("Index: "+index);
  647.         return new ListItr(index);
  648.     }
  649.  
  650.     /**
  651.      * Returns a list iterator over the elements in this list (in proper
  652.      * sequence)
  653.      */
  654.     public synchronized ListIterator<E> listIterator() {
  655.         return new ListItr(0);
  656.     }
  657.  
  658.     /**
  659.      * Returns an iterator over the elements in this list in proper sequence.
  660.      *
  661.      * <p>The returned iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
  662.      *
  663.      * @return an iterator over the elements in this list in proper sequence
  664.      */
  665.     public synchronized Iterator<E> iterator() {
  666.         return new Itr();
  667.     }
  668.  
  669.     /**
  670.      * An optimized version of AbstractList.Itr
  671.      */
  672.     private class Itr implements Iterator<E> {
  673.         int cursor;       // index of next element to return
  674.         int lastRet = -1; // index of last element returned; -1 if no such
  675.         int expectedModCount = modCount;
  676.  
  677.         public boolean hasNext() {
  678.             // Racy but within spec, since modifications are checked
  679.             // within or after synchronization in next/previous
  680.             return cursor != elementCount;
  681.         }
  682.  
  683.         public E next() {
  684.             synchronized (Vector.this) {
  685.                 checkForComodification();
  686.                 int i = cursor;
  687.                 if (i >= elementCount)
  688.                     throw new NoSuchElementException();
  689.                 cursor = i + 1;
  690.                 return elementData(lastRet = i);
  691.             }
  692.         }
  693.  
  694.         public void remove() {
  695.             if (lastRet == -1)
  696.                 throw new IllegalStateException();
  697.             synchronized (Vector.this) {
  698.                 checkForComodification();
  699.                 Vector.this.remove(lastRet);
  700.                 expectedModCount = modCount;
  701.             }
  702.             cursor = lastRet;
  703.             lastRet = -1;
  704.         }
  705.  
  706.         @Override
  707.         public void forEachRemaining(Consumer<? super E> action) {
  708.             Objects.requireNonNull(action);
  709.             synchronized (Vector.this) {
  710.                 final int size = elementCount;
  711.                 int i = cursor;
  712.                 if (i >= size) {
  713.                     return;
  714.                 }
  715.                 @SuppressWarnings("unchecked")
  716.                 final E[] elementData = (E[]) Vector.this.elementData;
  717.                 if (i >= elementData.length) {
  718.                     throw new ConcurrentModificationException();
  719.                 }
  720.                 while (i != size && modCount == expectedModCount) {
  721.                     action.accept(elementData[i++]);
  722.                 }
  723.                 // update once at end of iteration to reduce heap write traffic
  724.                 cursor = i;
  725.                 lastRet = i - 1;
  726.                 checkForComodification();
  727.             }
  728.         }
  729.  
  730.         final void checkForComodification() {
  731.             if (modCount != expectedModCount)
  732.                 throw new ConcurrentModificationException();
  733.         }
  734.     }
  735.  
  736.     /**
  737.      * An optimized version of AbstractList.ListItr
  738.      */
  739.     final class ListItr extends Itr implements ListIterator<E> {
  740.         ListItr(int index) {
  741.             super();
  742.             cursor = index;
  743.         }
  744.  
  745.         public boolean hasPrevious() {
  746.             return cursor != 0;
  747.         }
  748.  
  749.         public int nextIndex() {
  750.             return cursor;
  751.         }
  752.  
  753.         public int previousIndex() {
  754.             return cursor - 1;
  755.         }
  756.  
  757.         public E previous() {
  758.             synchronized (Vector.this) {
  759.                 checkForComodification();
  760.                 int i = cursor - 1;
  761.                 if (i < 0)
  762.                     throw new NoSuchElementException();
  763.                 cursor = i;
  764.                 return elementData(lastRet = i);
  765.             }
  766.         }
  767.  
  768.         public void set(E e) {
  769.             if (lastRet == -1)
  770.                 throw new IllegalStateException();
  771.             synchronized (Vector.this) {
  772.                 checkForComodification();
  773.                 Vector.this.set(lastRet, e);
  774.             }
  775.         }
  776.  
  777.         public void add(E e) {
  778.             int i = cursor;
  779.             synchronized (Vector.this) {
  780.                 checkForComodification();
  781.                 Vector.this.add(i, e);
  782.                 expectedModCount = modCount;
  783.             }
  784.             cursor = i + 1;
  785.             lastRet = -1;
  786.         }
  787.     }
  788.  
  789.     @Override
  790.     public synchronized void forEach(Consumer<? super E> action) {
  791.         Objects.requireNonNull(action);
  792.         final int expectedModCount = modCount;
  793.         @SuppressWarnings("unchecked")
  794.         final E[] elementData = (E[]) this.elementData;
  795.         final int elementCount = this.elementCount;
  796.         for (int i=0; modCount == expectedModCount && i < elementCount; i++) {
  797.             action.accept(elementData[i]);
  798.         }
  799.         if (modCount != expectedModCount) {
  800.             throw new ConcurrentModificationException();
  801.         }
  802.     }
  803.  
  804.     @Override
  805.     @SuppressWarnings("unchecked")
  806.     public synchronized boolean removeIf(Predicate<? super E> filter) {
  807.         Objects.requireNonNull(filter);
  808.         // figure out which elements are to be removed
  809.         // any exception thrown from the filter predicate at this stage
  810.         // will leave the collection unmodified
  811.         int removeCount = 0;
  812.         final int size = elementCount;
  813.         final BitSet removeSet = new BitSet(size);
  814.         final int expectedModCount = modCount;
  815.         for (int i=0; modCount == expectedModCount && i < size; i++) {
  816.             @SuppressWarnings("unchecked")
  817.             final E element = (E) elementData[i];
  818.             if (filter.test(element)) {
  819.                 removeSet.set(i);
  820.                 removeCount++;
  821.             }
  822.         }
  823.         if (modCount != expectedModCount) {
  824.             throw new ConcurrentModificationException();
  825.         }
  826.  
  827.         // shift surviving elements left over the spaces left by removed elements
  828.         final boolean anyToRemove = removeCount > 0;
  829.         if (anyToRemove) {
  830.             final int newSize = size - removeCount;
  831.             for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
  832.                 i = removeSet.nextClearBit(i);
  833.                 elementData[j] = elementData[i];
  834.             }
  835.             for (int k=newSize; k < size; k++) {
  836.                 elementData[k] = null;  // Let gc do its work
  837.             }
  838.             elementCount = newSize;
  839.             if (modCount != expectedModCount) {
  840.                 throw new ConcurrentModificationException();
  841.             }
  842.             modCount++;
  843.         }
  844.  
  845.         return anyToRemove;
  846.     }
  847.  
  848.     @Override
  849.     @SuppressWarnings("unchecked")
  850.     public synchronized void replaceAll(UnaryOperator<E> operator) {
  851.         Objects.requireNonNull(operator);
  852.         final int expectedModCount = modCount;
  853.         final int size = elementCount;
  854.         for (int i=0; modCount == expectedModCount && i < size; i++) {
  855.             elementData[i] = operator.apply((E) elementData[i]);
  856.         }
  857.         if (modCount != expectedModCount) {
  858.             throw new ConcurrentModificationException();
  859.         }
  860.         modCount++;
  861.     }
  862.  
  863.     @SuppressWarnings("unchecked")
  864.     @Override
  865.     public synchronized void sort(Comparator<? super E> c) {
  866.         final int expectedModCount = modCount;
  867.         Arrays.sort((E[]) elementData, 0, elementCount, c);
  868.         if (modCount != expectedModCount) {
  869.             throw new ConcurrentModificationException();
  870.         }
  871.         modCount++;
  872.     }
  873.  
  874.     /**
  875.      * Creates a <em><a href="Spliterator.html#binding">late-binding</a></em>
  876.      * and <em>fail-fast</em> {@link Spliterator} over the elements in this
  877.      * list.
  878.      *
  879.      * <p>The {@code Spliterator} reports {@link Spliterator#SIZED},
  880.      * {@link Spliterator#SUBSIZED}, and {@link Spliterator#ORDERED}.
  881.      * Overriding implementations should document the reporting of additional
  882.      * characteristic values.
  883.      *
  884.      * @return a {@code Spliterator} over the elements in this list
  885.      * @since 1.8
  886.      */
  887.     @Override
  888.     public Spliterator<E> spliterator() {
  889.         return new VectorSpliterator<>(this, null, 0, -1, 0);
  890.     }
  891.  
  892.     /** Similar to ArrayList Spliterator */
  893.     static final class VectorSpliterator<E> implements Spliterator<E> {
  894.         private final Vector<E> list;
  895.         private Object[] array;
  896.         private int index; // current index, modified on advance/split
  897.         private int fence; // -1 until used; then one past last index
  898.         private int expectedModCount; // initialized when fence set
  899.  
  900.         /** Create new spliterator covering the given  range */
  901.         VectorSpliterator(Vector<E> list, Object[] array, int origin, int fence,
  902.                           int expectedModCount) {
  903.             this.list = list;
  904.             this.array = array;
  905.             this.index = origin;
  906.             this.fence = fence;
  907.             this.expectedModCount = expectedModCount;
  908.         }
  909.  
  910.         private int getFence() { // initialize on first use
  911.             int hi;
  912.             if ((hi = fence) < 0) {
  913.                 synchronized(list) {
  914.                     array = list.elementData;
  915.                     expectedModCount = list.modCount;
  916.                     hi = fence = list.elementCount;
  917.                 }
  918.             }
  919.             return hi;
  920.         }
  921.  
  922.         public Spliterator<E> trySplit() {
  923.             int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
  924.             return (lo >= mid) ? null :
  925.                     new VectorSpliterator<E>(list, array, lo, index = mid,
  926.                             expectedModCount);
  927.         }
  928.  
  929.         @SuppressWarnings("unchecked")
  930.         public boolean tryAdvance(Consumer<? super E> action) {
  931.             int i;
  932.             if (action == null)
  933.                 throw new NullPointerException();
  934.             if (getFence() > (i = index)) {
  935.                 index = i + 1;
  936.                 action.accept((E)array[i]);
  937.                 if (list.modCount != expectedModCount)
  938.                     throw new ConcurrentModificationException();
  939.                 return true;
  940.             }
  941.             return false;
  942.         }
  943.  
  944.         @SuppressWarnings("unchecked")
  945.         public void forEachRemaining(Consumer<? super E> action) {
  946.             int i, hi; // hoist accesses and checks from loop
  947.             Vector<E> lst; Object[] a;
  948.             if (action == null)
  949.                 throw new NullPointerException();
  950.             if ((lst = list) != null) {
  951.                 if ((hi = fence) < 0) {
  952.                     synchronized(lst) {
  953.                         expectedModCount = lst.modCount;
  954.                         a = array = lst.elementData;
  955.                         hi = fence = lst.elementCount;
  956.                     }
  957.                 }
  958.                 else
  959.                     a = array;
  960.                 if (a != null && (i = index) >= 0 && (index = hi) <= a.length) {
  961.                     while (i < hi)
  962.                         action.accept((E) a[i++]);
  963.                     if (lst.modCount == expectedModCount)
  964.                         return;
  965.                 }
  966.             }
  967.             throw new ConcurrentModificationException();
  968.         }
  969.  
  970.         public long estimateSize() {
  971.             return (long) (getFence() - index);
  972.         }
  973.  
  974.         public int characteristics() {
  975.             return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
  976.         }
  977.     }
  978. }

5、总结

  • Vector底层是数组。
  • 有序。Vector底层是数组，数组是有序的。
  • 可重复。数组是可重复的。
  • 随机访问效率高，增删效率低。通过索引可以很快的查找到对应元素，而增删元素许多元素的位置都要改变。
  • 线程安全。很多方法都是synchronized的。

 

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/243857
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号