Java基础知识：Java集合——List接口之Vector

Java集合框架结构图

通过以上集合框架图我们可以发现，Collection接口主要有List接口，set接口，Queue接口，而list（元素按进入先后有序保存，可重复）下面经常使用的有：

LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全
ArrayList 接口实现类， 数组， 随机访问， 没有同步， 线程不安全
Vector 接口实现类 数组， 同步， 线程安全
Stack 是Vector类的实现类
而set（不可重复，并做内部排序）接口下面有：

HashSet 使用hash表（数组）存储元素，底层数据结构采用哈希表实现，元素无序且元素不可重复，线程不安全，效率高，可以存储null元素，元素的唯一性是靠所存储元素类型是否重写hashCode()和equals()方法来保证的，如果没有重写这两个方法，则无法保证元素的唯一性。
 LinkedHashSet 链表维护元素的插入次序，底层数据结构采用链表和哈希表共同实现，链表保证了元素的顺序与存储顺序一致，哈希表保证了元素的唯一性。线程不安全，效率高。
TreeSet 底层实现为二叉树，元素排好序

Vector详解

Vector可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。

Vector 类实现了一个动态数组。和 ArrayList 很相似，但是两者是不同的：

• Vector 是同步访问的。
• Vector 包含了许多传统的方法，这些方法不属于集合框架。

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

从以上源码可以看出：

1. Vector 继承了AbstractList，实现了List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。
2. Vector 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在Vector中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。
3. Vector 实现了Cloneable接口，即实现clone()函数。它能被克隆。
4. 实现java.io.Serializable接口，这意味着Vector 支持序列化，能通过序列化去传输
5. 和ArrayList不同，Vector中的操作是线程安全的

Vector构造方法

//创建指定大小的向量，并且增量用 incr 指定。增量表示向量每次增加的元素数目 
public Vector(int initialCapacity, int capacityIncrement) {
	super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
	this.elementData = new Object[initialCapacity];
	this.capacityIncrement = capacityIncrement;
  }
  //创建指定大小的向量
  public Vector(int initialCapacity) {
	this(initialCapacity, 0);
   }
   //创建一个默认的向量，默认大小为 10
  public Vector() {
	this(10);
  }
  //创建一个包含集合 c 元素的向量
  public Vector(Collection<? extends E> c) {
	elementData = c.toArray();
	elementCount = elementData.length;
	if (elementData.getClass() != Object[].class)
	    elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
   }

当vector容量不够时，会自动扩容，如果在创建vector时定义了每次增长的容量大小，那么，每次会按照规定的大小进行扩容，如果没有规定，则每次扩容为原来的2倍，和arraylist一样，扩容时每次先创建一个新的数组，随后将原来的数组拷贝过去完成扩容。

Vector是线程安全的，原因是：vector中的方法都使用了synchronized关键字以确保所有的操作都是线程安全的。

Vector和ArrayList的区别

1. ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访，线程不安全。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。ArrayList每次扩容时会增加1.5倍，而Vector会增加2倍，
2. Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢，如果不考虑到线程的安全因素，一般用Arraylist效率比较高。
3. 如果查找一个指定位置的数据，vector和arraylist使用的时间是相同的，都是0(1),因为两者底层实现都是数组，都支持随机访问，这个时候使用vector和arraylist都可以，两者并没有明显的区别
4. 而如果移动一个指定位置的数据花费的时间为0(n-i)n为总长度，这个时候就应该考虑到使用Linkedlist,因为它移动一个指定位置的数据所花费的时间为0(1),而查询一个指定位置的数据时花费的时间为0(i)。
5. ArrayList 和Vector是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，都允许直接序号索引元素，但是插入数据要设计到数组元素移动 等内存操作，所以索引数据快插入数据慢，Vector由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差

Vector是常用的方法

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

 

Vector遍历

Vector支持4种遍历方式：

1. 通过迭代器遍历
2. 由于Vector实现了RandomAccess接口，它支持通过索引值去随机访问元素
3. for循环
4. Enumeration遍历

由于Vector底层实现为数组，所以采用随取访问的方式效率是最高的