Collection-List-Vector集合

---

Collection

1.单列集合框架结构

|----Collection接口：单列集合，用来存储一个一个的对象

• |----List接口：存储有序的、可重复的数据。 -->“动态”数组

• |----ArrayList、LinkedList、Vector

• |----Set接口：存储无序的、不可重复的数据 -->高中讲的“集合”

• |----HashSet、LinkedHashSet、TreeSet

2.Collection接口常用方法：

1）添加
add(Object obj):添加元素
addAll(Collection c):添加集合元素
2）删除
clear():清空
remove(Object obj):删除元素
removeAll(Collection c):删除集合元素
3）判断
isEmpty():是否为空
contains(Object obj):是否包含某个元素
containsAll(Collection c):是否包含指定集合元素
4）获取
size():集合大小
Iterator iterator():获取迭代器对象
5）其它功能
Object[] toArray():集合转数组
retainAll(Collection c):两个集合交集操作

3.Collection集合与数组间的转换

//集合 —>数组：toArray()
Object[] arr = coll.toArray();
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}

//拓展：数组 —>集合:调用Arrays类的静态方法asList(T … t)
List list = Arrays.asList(new String[]{“AA”, “BB”, “CC”});
System.out.println(list);

List arr1 = Arrays.asList(new int[]{123, 456});
System.out.println(arr1.size());//1

List arr2 = Arrays.asList(new Integer[]{123, 456});
System.out.println(arr2.size());//2

4.使用Collection集合存储对象，要求对象所属的类满足：

向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals().

5.遍历Collection的两种方式：

① 使用迭代器Iterator ② foreach循环（或增强for循环）

2.java.utils包下定义的迭代器接口：Iterator
2.1说明：
Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。
GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。
2.2作用：遍历集合Collectiton元素
2.3如何获取实例：coll.iterator()返回一个迭代器实例
2.4图示说明：
2.5remove方法的使用

3.jdk5.0新特性–增强for循环：(foreach循环)
简化数组或者集合的遍历
格式：
for(元素的数据类型 变量名:数组名或集合名){
}

4、可变参数
定义方法的时候不知道参数的个数
格式
修饰符 返回值类型 方法名(数据类型… 变量名){
方法体;
}
说明：变量名是所参数构成的一个数组的名称
注意：如果既可变参数，又其它参数，需要将可变参数放在最后面

要求：

层次一：选择合适的集合类去实现数据的保存，调用其内部的相关方法。

层次二：不同的集合类底层的数据结构为何？如何实现数据的操作的：增删改查等。

List

1. 存储的数据特点：存储有序的、可重复的数据。

按顺序存放元素，元素可以重复(可以存放null值)
实现类:
ArrayList：数组实现，查询快，增删慢，轻量级；(线程不安全)
LinkedList：双向链表实现，增删快，查询慢 (线程不安全)
Vector：数组实现，重量级 (线程安全、使用少)

2. 常用方法：(记住)

增：add(Object obj)
删：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()`
遍历：① Iterator迭代器方式
② 增强for循环
③ 普通的循环

  int size()//返回集合的长度
  boolean isEmpty();//集合是否为空
  boolean contains(Object o);//如果此列表包含指定的元素，则返回 true。
  boolean add(E e);//增加元素
  boolean remove(Object o);//删除元素
  E get(int index);//获得指定位置上的元素
  int indexOf(Object o);//返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回 -1
  Iterator<E> iterator()//返回一个迭代器  

3. 常用实现类：

|----Collection接口：单列集合，用来存储一个一个的对象
|----List接口：存储序的、可重复的数据。 -->“动态”数组,替换原的数组
|----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
|----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储 |----Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储

4. 源码分析(难点)

4.3 Vector

底层结构是数组，查询快,增删慢；底层安全，效率低
jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。
在扩容方面，默认扩容为原来的数组长度的2倍。
特有功能：
addElement(E obj):添加元素
E elementAt(int index):指定索引位置处对应的元素值
Enumeration elements():获取集合所元素构成的一个枚举对象
Enumeration里面方法
hasMoreElements():是否更多元素
nextElement():获取下个元素

Vector类实现了一个可增长的对象数组，像数组一样包含可以使用整数索引访问的组件，大小可以根据需要增加或缩小，以适应在创建 Vector 后添加和删除
每个向量都试图通过维护 capacity 和 capacityIncrement 增量来优化存储管理，capacity 总是至少与向量大小一样大；通常更大，因为随着组件被添加到向量中，向量的存储以 capacityIncrement 增量大小的块的形式增加
该类的 iterator 和 listIterator 方法返回的 iterator 是快速失败的：如果在创建迭代器后的任何时间对向量进行结构修改，除了通过迭代器自己的remove或add方法外，迭代器将抛出 ConcurrentModificationException。因此，面对并发修改，迭代器快速而干净地失败，而不是冒着在未来不确定的时间出现任意、非确定性行为的风险。elements方法返回的Enumerations 不是快速失败的
从 Java 2 平台 v1.2 开始，该类经过改造以实现List接口，使其成为Java Collections Framework的成员。与新的集合实现不同，Vector是同步的、线程安全的。如果不需要线程安全的实现，建议使用ArrayList代替Vector

成员变量

    // 存储向量组件的数组缓冲区
	protected Object[] elementData;
	// Vector对象中有效组件的数量
    protected int elementCount;
   	// 当向量的大小大于其容量时，向量的容量自动增加的量
    protected int capacityIncrement;

构造函数定义

方法	作用
Vector()	构造一个空向量，使其内部数据数组的大小为 10 ，标准容量增量为零
Vector(int initialCapacity)	构造具有指定初始容量并且其容量增量等于零的空向量
Vector(int initialCapacity, int capacityIncrement)	构造具有指定的初始容量和容量增量的空向量
Vector(Collection<? extends E> c)	构造一个包含指定集合元素的向量，按照集合的迭代器返回的顺序

详解

    /**
	 * 无参构造
	 */
	public Vector() {
        // 调用Vector(int initialCapacity)，初始容量 initialCapacity 默认为 10
        this(10);
    }
    
	/**
	 * 具有指定初始容量的构造器，增量等于零的空向量
	 */
	public Vector(int initialCapacity) {
        // 调用 Vector(int initialCapacity, int capacityIncrement)，初始容量为10，增量为0
        this(initialCapacity, 0);
    }
	
	/**
	 * 具有指定的初始容量和容量增量的空向量构造器
	 */
	public Vector(int initialCapacity, int capacityIncrement) {
        super();
        // 如果初始容量小于0，抛出IllegalArgumentException
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        // 向量数组缓冲区为 initialCapacity 长度的Object数组
        this.elementData = new Object[initialCapacity];
        // 增量为0
        this.capacityIncrement = capacityIncrement;
    }

	/**
	 * 构造一个包含指定集合元素的向量，按照集合的迭代器返回的顺序
	 */
	public Vector(Collection<? extends E> c) {
        // 向量数组缓冲区为指定对象转为数组
        elementData = c.toArray();
        // 有效元素数量为向量数组缓冲区的长度
        elementCount = elementData.length;
        // 如果向量数组缓冲区类对象不等于Object数组类对象
        if (elementData.getClass() != Object[].class)
        	// 调用本地函数拷贝数组
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }

方法定义

	方法	作用
添加	boolean add(E e)	将指定的元素追加到此Vector的末尾
	void add(int index, E element)	在此Vector中的指定位置插入指定的元素
	boolean addAll(Collection<? extends E> c)	将指定集合中的所有元素追加到该向量的末尾，按照它们由指定集合的迭代器返回的顺序
	boolean addAll(int index, Collection<? extends E> c)	将指定集合中的所有元素插入到此向量中的指定位置
	void addElement(E obj)	将指定的组件添加到此向量的末尾，将其大小增加1
	void insertElementAt(E obj, int index)	在指定的index插入指定对象作为该向量中的一个 index
修改	E set(int index, E element)	用指定的元素替换此Vector中指定位置的元素
	void setElementAt(E obj, int index)	设置在指定的组件 index此向量的要指定的对象
	void replaceAll(UnaryOperator operator)	将该列表的每个元素替换为将该运算符应用于该元素的结果
	void setSize(int newSize)	设置此向量的大小
	void trimToSize()	修改该向量的容量成为向量的当前大小
查询	int size()	返回此向量中的组件数
	int capacity()	返回此向量的当前容量
	boolean contains(Object o)	如果此向量包含指定的元素，则返回 true
	boolean containsAll(Collection<?> c)	如果此向量包含指定集合中的所有元素，则返回true
	boolean equals(Object o)	将指定的对象与此向量进行比较以获得相等性
	E elementAt(int index)	返回指定索引处的组件
	Enumeration elements()	返回此向量的组件的枚举
	E firstElement()	返回此向量的第一个组件（索引号为 0的项目）
	E get(int index)	返回此向量中指定位置的元素
	int hashCode()	返回此Vector的哈希码值
	int indexOf(Object o)	返回此向量中指定元素的第一次出现的索引，如果此向量不包含元素，则返回-1
	int indexOf(Object o, int index)	返回此向量中指定元素的第一次出现的索引，从 index向前 index ，如果未找到该元素，则返回-1
	int lastIndexOf(Object o)	返回此向量中指定元素的最后一次出现的索引，如果此向量不包含元素，则返回-1
	int lastIndexOf(Object o, int index)	返回此向量中指定元素的最后一次出现的索引，从 index ，如果未找到元素，则返回-1
	E lastElement()	返回向量的最后一个组件
	boolean isEmpty()	测试此矢量是否没有组件
	List subList(int fromIndex, int toIndex)	返回此列表之间的fromIndex（包括）和toIndex之间的独占视图
删除	void clear()	从此Vector中删除所有元素
	E remove(int index)	删除此向量中指定位置的元素
	boolean remove(Object o)	删除此向量中指定元素的第一个出现如果Vector不包含元素，则它不会更改
	boolean removeAll(Collection<?> c)	从此Vector中删除指定集合中包含的所有元素
	void removeAllElements()	从该向量中删除所有组件，并将其大小设置为零
	boolean removeElement(Object obj)	从此向量中删除参数的第一个出现次数
	void removeElementAt(int index)	删除指定索引处的组件
	boolean removeIf(Predicate<? super E> filter)	删除满足给定谓词的此集合的所有元素
	protected void removeRange(int fromIndex, int toIndex)	从此列表中删除所有索引为 fromIndex （含）和 toIndex之间的元素
	boolean retainAll(Collection<?> c)	仅保留此向量中包含在指定集合中的元素
扩容	void ensureCapacity(int minCapacity)	如果需要，增加此向量的容量，以确保它可以至少保存最小容量参数指定的组件数
克隆	Object clone()	返回此向量的克隆
迭代器	Iterator iterator()	以正确的顺序返回该列表中的元素的迭代器
	ListIterator listIterator()	返回列表中的列表迭代器
	ListIterator listIterator(int index)	从列表中的指定位置开始，返回列表中的元素的列表迭代器
	Spliterator spliterator()	在此列表中的元素上创建late-binding和故障切换 Spliterator
循环	void forEach(Consumer<? super E> action)	对 Iterable的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常
复制到数组	void copyInto(Object[] anArray)	将此向量的组件复制到指定的数组中
转数组	Object[] toArray()	以正确的顺序返回一个包含此Vector中所有元素的数组
	T[] toArray(T[] a)	以正确的顺序返回一个包含此Vector中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型
转string	String toString()	返回此Vector的字符串表示形式，其中包含每个元素的String表示形式
排序	void sort(Comparator<? super E> c)	使用提供的 Comparator对此列表进行排序以比较元素

ensureCapacity(int minCapacity) 扩容详解

	/**
	 * 扩容
	 * 增加此向量的容量，确保它可以至少保存最小容量参数指定的元素
	 */
	public synchronized void ensureCapacity(int minCapacity) {
        // 如果参数大于0
        if (minCapacity > 0) {
            modCount++;
            // 确保容量
            ensureCapacityHelper(minCapacity);
        }
    }
    
	/**
	 * 确保容量
	 */
    private void ensureCapacityHelper(int minCapacity) {
        // 如果参数减去向量数组缓冲区长度大于0
        if (minCapacity - elementData.length > 0)
        	// 增长容量
            grow(minCapacity);
    }
    
    /**
     * 扩容
     */
    private void grow(int minCapacity) {
        // 获取当前向量数组缓冲区长度（旧容量）
        int oldCapacity = elementData.length;
        // 如果增量大于0，新容量 为 旧容量 + 增量
        // 如果增量小于等于0，新容量 为 旧容量 + 旧容量
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        // 如果新容量 - minCapacity 小于0
        if (newCapacity - minCapacity < 0)
        	// 新容量为 minCapacity
            newCapacity = minCapacity;
        // 如果新容量 - 2147483639 大于0
        if (newCapacity - MAX_ARRAY_SIZE > 0)
        	// 获取大容量
            newCapacity = hugeCapacity(minCapacity);
        // 复制数组
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    
	/**
	 * 大容量
	 */
    private static int hugeCapacity(int minCapacity) {
        // 如果参数小于0，throw OutOfMemoryError
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        // 如果 minCapacity 大于 21474836339，返回 21474836347
        // 如果 minCapacity 小于 21474836339，返回 21474836339
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

copyInto(Object[] anArray)详解

	/**
	 * 将此向量的元素复制到指定的数组中
	 */
	public synchronized void copyInto(Object[] anArray) {
        // 调用本地函数copy数组
        System.arraycopy(elementData, 0, anArray, 0, elementCount);
    }

trimToSize() 详解

/**

  * 修改该向量的容量成为向量的当前大小
    */
    public synchronized void trimToSize() {
      modCount++;
      // 获取向量数组缓冲区当前长度
      int oldCapacity = elementData.length;
      // 如果有效元素数量 < 向量数组缓冲区当前长度
      if (elementCount < oldCapacity) {
      	// 复制数组
          elementData = Arrays.copyOf(elementData, elementCount);
      }
    }

setSize(int newSize) 详解

设置向量的大小
*/
public synchronized void setSize(int newSize) {
  modCount++;
  // 如果新大小 大于 有效元素数量
  if (newSize > elementCount) {
  	// 确认容量，判断是否调用 grow 方法
      ensureCapacityHelper(newSize);
  } else {
  	// 循环置空元素
      for (int i = newSize ; i < elementCount ; i++) {
          elementData[i] = null;
      }
  }
  // 设置有效元素数量为 newSize
  elementCount = newSize;
}

capacity()、size()、isEmpty() 详解

/**

  * 获取向量数组缓冲区当前长度
    */
    public synchronized int capacity() {
      return elementData.length;
    }

	/**
	 * 获取有效元素数量
	 */
	public synchronized int size() {
	    return elementCount;
	}
	
	/**
	 * 判断是否为null
	 */
	public synchronized boolean isEmpty() {
	    return elementCount == 0;
	}

elements() 详解

/**

  * 返回此向量的组件的枚举
    */
    public Enumeration<E> elements() {
      return new Enumeration<E>() {
          int count = 0;
          // 是否包含更多元素
          public boolean hasMoreElements() {
              // 返回 0是否小于有效元素数量
              return count < elementCount;
          }
          // 如果此枚举对象至少有一个要提供的元素，则返回此枚举的下一个元素
          public E nextElement() {
              synchronized (Vector.this) {
              	// 0小于有效元素数量
                  if (count < elementCount) {
                      // 返回下标为count的元素，之后count+1
                      return elementData(count++);
                  }
              }
              throw new NoSuchElementException("Vector Enumeration");
          }
      };
    }

get(int index)、elementData(int index)详解

/**

  * 根据下标获取元素
    */
    public synchronized E get(int index) {
      // 如果下标大于等于有效元素数量，throw ArrayIndexOutOfBoundsException
      if (index >= elementCount)
          throw new ArrayIndexOutOfBoundsException(index);
      // 调用elementData(int index)
      return elementData(index);
    }

	/**
	 * 根据下标获取元素
	 */
	E elementData(int index) {
	    // 返回index所在对象
	    return (E) elementData[index];
	}

set(int index, E element)、setElementAt(E obj, int index) 详解

/**

  * 用指定的元素替换此Vector中指定位置的元素，并返回旧值
    */
    public synchronized E set(int index, E element) {
      // 如果下标大于等于有效元素数量，throw ArrayIndexOutOfBoundsException
      if (index >= elementCount)
          throw new ArrayIndexOutOfBoundsException(index);
      // 获取index所在元素
      E oldValue = elementData(index);
      // 赋值新元素
      elementData[index] = element;
      // 返回旧元素
      return oldValue;
    }

	/**
	 * 用指定的元素替换此Vector中指定位置的元素
	 */
	public synchronized void setElementAt(E obj, int index) {
	    // 如果下标大于等于有效元素数量，throw ArrayIndexOutOfBoundsException
	    if (index >= elementCount) {
	        throw new ArrayIndexOutOfBoundsException(index + " >= " +
	                                                 elementCount);
	    }
	    // 赋值
	    elementData[index] = obj;
	}

add(E e)、add(int index, E element)、insertElementAt(E obj, int index)、addAll(Collection<? extends E> c)、addAll(int index, Collection<? extends E> c) 详解

/**

  * 将指定的元素追加到此Vector的末尾
    */
    public synchronized boolean add(E e) {
      modCount++;
      // 判断有效元素数量+1-向量数组缓冲区长度是否大于0，是否增长
      ensureCapacityHelper(elementCount + 1);
      // 根据下标赋值
      elementData[elementCount++] = e;
      return true;
    }

	/**
	 * 指定位置插入指定的元素
	 */
	public void add(int index, E element) {
	    // 调用 insertElementAt(E obj, int index)
	    insertElementAt(element, index);
	}
	
	/**
	 * 指定位置插入指定的元素
	 */
	public synchronized void insertElementAt(E obj, int index) {
	    modCount++;
	    // 如果下标大于有效元素数量，throw ArrayIndexOutOfBoundsException
	    if (index > elementCount) {
	        throw new ArrayIndexOutOfBoundsException(index
	                                                 + " > " + elementCount);
	    }
	    // 判断有效元素数量+1-向量数组缓冲区长度是否大于0，是否增长
	    ensureCapacityHelper(elementCount + 1);
	    // 拷贝数组
	    System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
	    // 赋值
	    elementData[index] = obj;
	    // 有效元素数量增长
	    elementCount++;
	}
	
	/**
	 * 将指定集合中的所有元素追加到该向量的末尾
	 */
	public synchronized boolean addAll(Collection<? extends E> c) {
	    modCount++;
	    // 将参数集合转数组
	    Object[] a = c.toArray();
	    // 获取数组长度
	    int numNew = a.length;
	    // 判断有效元素数量 + 数组长度 - 向量数组缓冲区长度是否大于0，是否增长
	    ensureCapacityHelper(elementCount + numNew);
	    // 拷贝数组
	    System.arraycopy(a, 0, elementData, elementCount, numNew);
	    // 有效元素数量增长 numNew 大小
	    elementCount += numNew;
	    return numNew != 0;
	}
	
	/**
	 * 将指定集合中的所有元素插入到此向量中的指定位置
	 */
	public synchronized boolean addAll(int index, Collection<? extends E> c) {
	    modCount++;
	    // 如果 index 小于 0 或者 大于 有效元素数量 
	    if (index < 0 || index > elementCount)
	        throw new ArrayIndexOutOfBoundsException(index);
	    // 将参数集合转数组
	    Object[] a = c.toArray();
	    // 获取数组长度
	    int numNew = a.length;
	    // 判断有效元素数量 + 数组长度 - 向量数组缓冲区长度是否大于0，是否增长
	    ensureCapacityHelper(elementCount + numNew);
	    // 偏移量 = 有效元素数量 - index
	    int numMoved = elementCount - index;
	    // 偏移量大于0
	    if (numMoved > 0)
	        System.arraycopy(elementData, index, elementData, index + numNew,
	                         numMoved);
	    // 偏移量小于或等于0
	    System.arraycopy(a, 0, elementData, index, numNew);
	    // 有效元素数量增长 numNew 大小
	    elementCount += numNew;
	    return numNew != 0;
	}

remove(Object o)、removeElement(Object obj)、removeElementAt(int index)、remove(int index)、removeAll(Collection<?> c) 详解

/**

  * 删除指定元素的第一个出现，如果Vector不包含元素
    */
    public boolean remove(Object o) {
      // 调用removeElement(Object obj)
      return removeElement(o);
    }

	/**
	 * 删除指定元素的第一个出现，如果Vector不包含元素
	 */
	public synchronized boolean removeElement(Object obj) {
	    modCount++;
	    // 获取指定元素第一次出现的索引
	    int i = indexOf(obj);
	    // 元素存在
	    if (i >= 0) {
	    	// 调用removeElementAt(int index)
	        removeElementAt(i);
	        return true;
	    }
	    // 元素不存在
	    return false;
	}
	
	/**
	 * 根据下标删除元素
	 */
	public synchronized void removeElementAt(int index) {
	    modCount++;
	    // 如果index 大于等于 有效元素数量，throw ArrayIndexOutOfBoundsException
	    if (index >= elementCount) {
	        throw new ArrayIndexOutOfBoundsException(index + " >= " +
	                                                 elementCount);
	    }
	    // 如果index 小于 0，throw ArrayIndexOutOfBoundsException
	    else if (index < 0) {
	        throw new ArrayIndexOutOfBoundsException(index);
	    }
	    // j 等于 有效元素数量减index减1
	    int j = elementCount - index - 1;
	    //j 大于0，复制数组
	    if (j > 0) {
	        System.arraycopy(elementData, index + 1, elementData, index, j);
	    }
	    // 有效元素数量-1
	    elementCount--;
	    // 末尾置空
	    elementData[elementCount] = null;
	}
	
	/**
	 * 删除指定位置的元素，并返回
	 */
	public synchronized E remove(int index) {
	    modCount++;
	    // 如果index 大于等于 有效元素数量，throw ArrayIndexOutOfBoundsException
	    if (index >= elementCount)
	        throw new ArrayIndexOutOfBoundsException(index);
	    // 获取下标指向元素
	    E oldValue = elementData(index);
	    // 偏移量 等于 有效元素数量减index减1
	    int numMoved = elementCount - index - 1;
	    // 偏移量大于0
	    if (numMoved > 0)
	        System.arraycopy(elementData, index+1, elementData, index,
	                         numMoved);
	    // 末尾置空
	    elementData[--elementCount] = null;
	    // 返回原值
	    return oldValue;
	}
	
	/**
	 * 删除指定集合中包含的所有元素
	 */
	public synchronized boolean removeAll(Collection<?> c) {
	    // 调用父类removeAll(Collection<?> c)
	    return super.removeAll(c);
	}
	
	/**
	 * 父类removeAll(Collection<?> c)
	 */
	public boolean removeAll(Collection<?> c) {
	    // 判断是否为null
	    Objects.requireNonNull(c);
	    boolean modified = false;
	    // 获取迭代器
	    Iterator<?> it = iterator();
	    // 循环删除
	    while (it.hasNext()) {
	    	// 指定集合包含下一个元素，删除
	        if (c.contains(it.next())) {
	            it.remove();
	            modified = true;
	        }
	    }
	    return modified;
	}

clear()、removeAllElements() 详解

/**

  * 删除所有元素
    */
    public void clear() {
      // 调用removeAllElements()
      removeAllElements();
    }

	/**
	 * 删除所有元素
	 */
	public synchronized void removeAllElements() {
	    modCount++;
	    // 循环置空
	    for (int i = 0; i < elementCount; i++)
	        elementData[i] = null;
	    // 有效元素数量置为0
	    elementCount = 0;
	}

indexOf(Object o)、indexOf(Object o, int index) 详解

/**

  * 返回指定元素第一次出现的索引，如果不包含此元素，则返回-1
    */
    public int indexOf(Object o) {
      // 调用indexOf(Object o, int index)
      return indexOf(o, 0);
    }

    /**
     * 返回指定元素第一次出现的索引，如果不包含此元素，则返回-1
     */
    public synchronized int indexOf(Object o, int index) {
        // 指定元素为null
        if (o == null) {
            // 循环
            for (int i = index ; i < elementCount ; i++)
                // 下标为i的元素等于null
                if (elementData[i]==null)
                	// 返回下标
                    return i;
        // 指定元素不为null
        } else {
            for (int i = index ; i < elementCount ; i++)
                // 指定元素等于下标为i的元素
                if (o.equals(elementData[i]))
                	// 返回下标
                    return i;
        }
        // 不包含此元素，则返回-1
        return -1;
    }

contains(Object o)、containsAll(Collection<?> c) 详解

/**

  * 是否包含指定元素
    */
    public boolean contains(Object o) {
      // 如果元素所在下标大于等于0，存在
      return indexOf(o, 0) >= 0;
    }

	/**
	 * 是否包含指定集合中的所有元素
	 */
	public synchronized boolean containsAll(Collection<?> c) {
	    return super.containsAll(c);
	}
	/**
	 * 父类 containsAll(Collection<?> c)
	 */
	public boolean containsAll(Collection<?> c) {
	    // 循环判断是否包含
	    for (Object e : c)
	        if (!contains(e))
	            return false;
	    return true;
	}

retainAll(Collection<?> c) 详解

/**

  * 保留包含在指定集合中的元素
    */
    public synchronized boolean retainAll(Collection<?> c) {
      return super.retainAll(c);
    }
    	/**
  * 父类retainAll(Collection<?> c)
    */
    public boolean retainAll(Collection<?> c) {
      // 判断是否为null
      Objects.requireNonNull(c);
      boolean modified = false;
      Iterator<E> it = iterator();
      while (it.hasNext()) {
          // 如果指定集合不包含
          if (!c.contains(it.next())) {
              // 移除
              it.remove();
              modified = true;
          }
      }
      return modified;
    }

equals(Object o) 详解

/**

  * 判断是否相等
    */
    public synchronized boolean equals(Object o) {
      return super.equals(o);
    }
    /**
  * 父类equals(Object obj)
    */
    public boolean equals(Object obj) {
        return (this == obj);
    }

hashCode() 详解

/**

  * 获取哈希码值
    */
    public synchronized int hashCode() {
      return super.hashCode();
    }
    /**
  * 父类hashCode()
    */
    public int hashCode() {
        int hashCode = 1;
        for (E e : this)
            hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
        return hashCode;
    }

subList(int fromIndex, int toIndex) 详解

/**

  * 返回此列表fromIndex（包括）和toIndex之间的元素集合
    */
    public synchronized List<E> subList(int fromIndex, int toIndex) {
      return Collections.synchronizedList(super.subList(fromIndex, toIndex),this);
    }

replaceAll(UnaryOperator operator) 详解

/**

  * 将该列表的每个元素替换为将该运算符应用于该元素的结果
    */
    public synchronized void replaceAll(UnaryOperator<E> operator) {
      Objects.requireNonNull(operator);
      final int expectedModCount = modCount;
      final int size = elementCount;
      for (int i=0; modCount == expectedModCount && i < size; i++) {
      	// operator.apply()传入一个T类型参数，返回一个R类型对象
          elementData[i] = operator.apply((E) elementData[i]);
      }
      if (modCount != expectedModCount) {
          throw new ConcurrentModificationException();
      }
      modCount++;
    }

sort(Comparator<? super E> c) 详解

/**

  * 使用提供的 Comparator对此列表进行排序以比较元素
    */
    @SuppressWarnings("unchecked")
    @Override
    public synchronized void sort(Comparator<? super E> c) {
        final int expectedModCount = modCount;
        // 调用数组工具类，以指定条件排序
        Arrays.sort((E[]) elementData, 0, elementCount, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

toArray()、toArray(T[] a) 详解

/**

  * 以正确的顺序返回一个包含此Vector中所有元素的数组
    */
    public synchronized Object[] toArray() {
      // 数组拷贝
      return Arrays.copyOf(elementData, elementCount);
    }

	/**
	 * 以正确的顺序返回一个包含此Vector中所有元素的数组; 
	 * 返回的数组的运行时类型是指定数组的运行时类型
	 */
	@SuppressWarnings("unchecked")
	public synchronized <T> T[] toArray(T[] a) {
	    // 如果a的长度 小于 有效元素数量
	    if (a.length < elementCount)
	        return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
	    // 数组拷贝
	    System.arraycopy(elementData, 0, a, 0, elementCount);
	    // 如果a的长度 大于 有效元素数量
	    if (a.length > elementCount)
	        // 末尾置空
	        a[elementCount] = null;
	    return a;
	}


        

可以发现 Vector 中所有方法都是由 synchronized 修饰