ArrayList、LinkedList、Vector的创建，使用，遍历

列表List

-有序的Collection
-允许重复元素
-{1, 2, 4, {5, 2}, 1, 3}

List主要实现

-ArrayList(非同步的)
-LinkedList(非同步)
-Vector(同步)

ArrayList

-以数组实现的列表,不支持同步
-利用索引位置可以快速定位访问
-不适合指定位置的插入、删除操作
-适合变动不大,主要用于查询的数据
-和Java数组相比,其容量是可动态调整的
-ArrayList在元素填满容器时会自动扩充容器大小的50%
ArrayList只能装对象

创建

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListTest {
	public static void main(String[] a) {  
	    ArrayList<Integer> al = new ArrayList<Integer>();  //<Integer>表示泛型，说明al这个ArrayList里只能存放Integer这个类型的数据
	    al.add(3);  
	    //自动将普通的int变量3自动装箱为Integer(3)的对象，然后放入al里
	    al.add(2);          
	    al.add(1);  
	    al.add(4);  
	    al.add(5);  
	    al.add(6);  
	    al.add(new Integer(6));  
	  
	    System.out.print("The third element is  ");
	    System.out.println(al.get(3));//获得第四个元素
	    al.remove(3);  //删除第四个元素，后面元素往前挪动
	    al.add(3, 9);  //将9插入到第4个元素，后面元素往后挪动

输出

The third element is  4

遍历方法

创建ArrayList

		ArrayList<Integer> as = new ArrayList<Integer>(100000);//创建了包含100000个数据的ArrayList
		for (int i=0; i<100000; i++)
		{
			as.add(i);
		}
		traverseByIterator(as);  //iteration遍历，如下
		traverseByIndex(as);  //索引位置遍历，如下
		traverseByFor(as);    //for-each遍历，如下 
	}

iteration遍历

	public static void traverseByIterator(ArrayList<Integer> al)
	{
	 	Iterator<Integer> iter1 = al.iterator();  
	 	while(iter1.hasNext())
	 	{  
	     	iter1.next();  
	 	}
	}

索引位置遍历

	public static void traverseByIndex(ArrayList<Integer> al)
	{
	 	for(int i=0;i<al.size();i++)
	 	{
	    	al.get(i);
	 	}
	}

for循环遍历

	public static void traverseByFor(ArrayList<Integer> al)
	{
	    for(Integer item : al)
	    {
	    	;  //任意语句
	    }
	}

迭代器的速度最慢，索引方法和for方法速度接近

---

LinkedList

-以双向链表实现的列表,不支持同步
-可被当作堆栈、队列和双端队列进行操作
-顺序访问高效,随机访问较差,中间插入和删除高效
-适用于经常变化的数据

创建

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListTest {
	public static void main(String[] args) {
		LinkedList<Integer> ll = new LinkedList<Integer>();  
	    ll.add(3);  
	    ll.add(2);  
	    ll.add(5);  
	    ll.add(6);  
	    ll.add(6);  
	    System.out.println(ll.size()); //输出5
	    ll.addFirst(9);  //在头部增加9
	    ll.add(3, 10);   //将10插入到第四个元素，四以及后续的元素往后挪动
	    ll.remove(3);    //将第四个元素删除

遍历方法

创建LinkedList

		LinkedList<Integer> list = new LinkedList<Integer>();
		for (int i=0; i<100000; i++)
		{
	    	list.add(i);
		}
		traverseByIterator(list);   //iteration遍历，如下
		traverseByIndex(list);   //索引位置遍历，如下
		traverseByFor(list);     //for-each遍历，如下
	}

iteration遍历

	public static void traverseByIterator(LinkedList<Integer> list)
	{
		Iterator<Integer> iter1 = list.iterator();  
		while(iter1.hasNext())
		{  
	    	iter1.next();  
		}
	}

索引位置遍历

	public static void traverseByIndex(LinkedList<Integer> list)
	{
		for(int i=0;i<list.size();i++)
		{
	   		list.get(i);
		}
	}

for循环遍历

	public static void traverseByFor(LinkedList<Integer> list)
	{
		for(Integer item : list)
		{
	    	;  //任何语句
	 	}
	}

for循环遍历比迭代器快一点点，索引遍历最慢
ArrayList适用于较多查询的静态数据，而LinkedList适用于频繁增删的数据

---

Vector

-和ArrayList类似，可变数组实现的列表
-Vectora,适合在多线程下使用
-官方文档建议在非同步情况下,优先采用ArrayList

创建

import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;

public class VectorTest {
	public static void main(String[] args) {
		Vector<Integer> v = new Vector<Integer>();
		v.add(1);
		v.add(2);
		v.add(3);
		v.remove(2);
		v.add(1, 5);
		System.out.println(v.size());

遍历方法

创建一个Vector

		Vector<Integer> v2 = new Vector<Integer>(100000);
		for (int i = 0; i < 100000; i++) {
			v2.add(i);
		}
		traverseByIterator(v2);//itertor遍历
		traverseByIndex(v2);//索引位置遍历
		traverseByFor(v2);//for-each遍历
		traverseByEnumeration(v2);//Enumeration遍历
	}

iterator遍历

	public static void traverseByIterator(Vector<Integer> v) {
		Iterator<Integer> iter1 = v.iterator();
		while (iter1.hasNext()) 
		{
			iter1.next();
		}
	}

索引位置遍历

	public static void traverseByIndex(Vector<Integer> v) {
		for (int i = 0; i < v.size(); i++) 
		{
			v.get(i);
		}
	}

for循环遍历

	public static void traverseByFor(Vector<Integer> v) {
		for (Integer item : v) 
		{
			;  //任意语句
		}
	}

Enumeration遍历（老方法）

public static void traverseByEnumeration(Vector<Integer> v) {
	for (Enumeration<Integer> enu = v.elements();enu.hasMoreElements();){  
			enu.nextElement();
		}
	}

for循环最快，其次是位置索引