ArrayList，LinkedList，Vector

   

      一：概念介绍 

       List接口的实现类有3个：ArrayList（常用） ，LinkedList，Vector。

      ArrayList：它是最常用的List实现类，内部是通过数组实现的，数组的缺点是它需要一块连续的内存空间，数组内的元素必须是连续的，所以每当数组大小不能满足时需要增加存储能力，就需要将已经有数据的数据复制到新的存储空间中。所以ArrayList它的优点是能对元素进行快速随机的访问，缺点是对ArrayList进行元素的插入或者删除时，需要对数组进行复制、移动，代价比较高。因此，ArrayList适合随机查找或者遍历元素，不适合插入和删除。

      LinkedList：它也是List实现类，内部是用链表结构存储数据的，故避免了数组需要一块连续存储空间的缺点。LinkedList优点：很适合元素的动态插入和删除；缺点：对于元素的随机访问和遍历速度比较慢。另外LinkedList还提供了List接口中没有定义的方法，专门用于操作表头和表尾元素，可以当做堆栈、队列和双向队列使用。

      Vector：和ArrayList类似，内部也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但是同步需要很高的花费，因此，Vector访问元素的速度要比ArrayList慢。

     二：性能比较

       ArrayList和LinkedList的区别：

      1： ArrayList实现了基于动态数组的数据结构，LinkedList实现了基于链表的数据结构。

      2： 对于随机访问set和get，ArrayList性能要优于LinkedList，因为LinkedList是链表，而ArrayList是动态数组。时间复杂度LinkedList要远远大于ArrayList。特殊情况：对于访问开头元素，ArrayList和LinkedList性能一样。

      3： 对于增加add和删除remove，LinkedList性能要优于ArrayList，因为ArrayList是动态数组，删除和增加元素要移动数组内相关的元素，而LinkedList则不需要。LinkedList删除和增加任意位置的元素，性能都一样，而ArrayList对于删除和增加元素的位置在开头花销最大。时间复杂度ArrayList要远远大于LinkedList。特殊情况：对于增加和删除末尾元素，LinkedList和ArrayList性能一样。

      4：ArrayList和LinkedList是两个集合类，都可以用于存储一系列的对象(String, Integer)引用（references）。但是性能上差别好大。随机访问ArrayList性能要优于LinkedList；而对于增加、删除、反转，LinkedList性能要优于ArrayList。

      ArrayList和Vector的区别：

      1：ArrayList在内存不够时默认的扩展是：新内存容量=（旧内存容量*3）/ 2 + 1；即每次容量扩展为50%+1个，而Vector默认的扩展是增加一倍。

      2：Vector提供了indexOf( obj, start )接口，ArrayList没有。

      3：Vector属于线程级别安全的，但是大多数情况下不提倡使用，因为保证线程安装会使系统的开销加大。

    Set和List的区别

   1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。

     2. Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。

     3. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

      三：代码例子

       java代码：

package com.panli.list;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.LinkedList;
import java.util.Vector;

public class ListTest {

	public static void testArrayList() {
		ArrayList<Object> al = new ArrayList<Object>();
		al.add("abc");
		al.add(1);
		al.add('A');
		al.add(true);
		System.out.println("al顺序添加元素:" + al);

		// 如果没有两个数据，则会报出异常java.lang.IndexOutOfBoundsException
		al.add(2, false);
		System.out.println("al在1后面添加元素:" + al);

		ArrayList<Object> al2 = new ArrayList<Object>();
		al2.addAll(al);
		System.out.println("al2添加al全部元素:" + al2);

		ArrayList<Object> al3 = new ArrayList<Object>();
		al3.add(12);
		al3.add("abd");
		al3.add("abe");
		al3.addAll(0, al);
		System.out.println("al3添加在指定位置的al全部元素:" + al3);

		al3.remove("abd");
		System.out.println("al3中删除指定元素:" + al3);

		al3.remove(6);
		System.out.println("al3中删除索引为6的元素:" + al3);

		al3.removeAll(al);
		System.out.println("al3中删除包含al的全部元素:" + al3);

		al3.set(0, "abc");
		System.out.println("al3修改第一个元素值:" + al3);

		Object ob1 = al3.get(0);
		System.out.println("得到al3中索引为0的元素值:" + ob1);

		al3.clear();
		System.out.println("al3中元素清空:" + al3);

		for (Object obj : al) {
			System.out.println(obj);
		}
	}

	public static void testLinkedList() {
		LinkedList<Object> ll = new LinkedList<Object>();

		// 添加操作
		ll.add("abc");
		ll.add('d');
		ll.add(1, true);

		// 链表添加首元素
		ll.addFirst("start");

		// 链表添加尾元素
		ll.addLast("last");
		System.out.println("ll链表的元素:" + ll);

		// 移去链表首元素
		ll.removeFirst();
		// 移去链表尾元素
		ll.removeLast();

		System.out.println("ll链表的元素:" + ll);

		// 移去链表第索引为1的元素
		ll.remove(1);
		System.out.println("ll链表的元素:" + ll);

		// remove()默认删除第一个元素
		ll.remove();
		System.out.println("ll链表的元素:" + ll);

		LinkedList<Object> ll2 = new LinkedList<Object>();
		// 添加操作
		ll2.add(1);
		ll2.add(2);
		ll2.add(2, 3);

		// 在ll2末尾处添加ll元素
		ll2.addAll(ll);
		// 在ll2开头处添加ll元素
		ll2.addAll(0, ll);

		System.out.println("ll2链表的元素:" + ll2);

		// 修改索引为1的元素
		ll2.set(0, 0);

		// 修改索引为4的元素
		ll2.set(4, 4);
		System.out.println("ll2链表的元素:" + ll2);

		System.out.println("得到首元素:" + ll2.get(0));

		System.out.println("得到首元素:" + ll2.getFirst());
		System.out.println("得到尾元素:" + ll2.getLast());

		// 生成索引为2到4的子链表
		System.out.println("ll2的子链表:" + ll2.subList(2, 4));

	}

	public static void testVector() {
		Vector v = new Vector(3, 2);
		System.out.println("Initial size: " + v.size());
		System.out.println("Initial capacity: " + v.capacity());
		v.addElement(new Integer(1));
		v.addElement(new Integer(2));
		v.addElement(new Integer(3));
		v.addElement(new Integer(4));
		System.out.println("Capacity after four additions: " + v.capacity());

		v.addElement(new Double(5.45));
		System.out.println("Current capacity: " + v.capacity());
		v.addElement(new Double(6.08));
		v.addElement(new Integer(7));
		System.out.println("Current capacity: " + v.capacity());
		v.addElement(new Float(9.4));
		v.addElement(new Integer(10));
		System.out.println("Current capacity: " + v.capacity());
		v.addElement(new Integer(11));
		v.addElement(new Integer(12));
		System.out.println("First element: " + (Integer) v.firstElement());
		System.out.println("Last element: " + (Integer) v.lastElement());
		if (v.contains(new Integer(3)))
			System.out.println("Vector contains 3.");
		// enumerate the elements in the vector.
		Enumeration vEnum = v.elements();
		System.out.println("\nElements in vector:");
		while (vEnum.hasMoreElements())
			System.out.print(vEnum.nextElement() + " ");
		System.out.println();

	}

	public static void main(String[] args) {

		// ListTest.testArrayList();

		// ListTest.testLinkedList();

		ListTest.testVector();

	}
}