23.List接口实现类：

 List接口继承了Collection接口，它是一个允许存在重复项的有序集合。

 1>实现类ArrayList：

  ArrayList类支持可随需要而增长的动态数组。数组列表以一个原大小被创建，当超过了它的大小，

  类集自动增大，当对象被删除后，数组就可以缩小。

  优点：ArrayList类对于使用索引取出元素用较高的效率，他可以用索引快速定位对象。

  缺点：ArrayList类对于元素的删除或插入速度较慢。

  构造方法：

  · ArrayList(): 构造一个初始容量为10的空列表。

  · ArrayList(Collection c): 构造一个包含指定Collection的元素列表，这些元素是按照该Collection的迭代器返回它们

    的顺序排列的。 

  · ArrayList(int capacity): 构造一个初始容量为capacity的空数组, 当元素被迫加到数组类表上时，容量会自动增加。

  ArrayList类的用法例子：

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

  public class TestTreeSet {
	 public static void main(String[] args) {
		// 声明一个ArrayList对象c1
		Collection<Integer> c1 = new ArrayList<Integer>();
		// 实例化具体的c1对象
		for (int i = 0; i < 5; i++) {
			c1.add(new Integer(i));
		}
		c1.add(6);//添加对象6到列表1
		// 显示c1列表                   
		System.out.println("c1: " + c1);
		System.out.println();
		// 声明一个ArrayList对象c2
		Collection<Object> c2 = new ArrayList<Object>();
		c2.add(c1);// 将c1作为一个列表添加到类表c2
		c1.remove(3);// 删除c2中c1中的3对象
		c2.add("hello");// 向列表c2中添加对象
		// 显示c2列表
		System.out.println("c2: " + c2);
		//生成一个迭代器
		Iterator<Object> it = c2.iterator();
		//遍历类表c2
		while (it.hasNext()) {
                //Object obj = it.next();
			System.out.println("Iterator 遍历 c2： " + it.next());
		}
		System.out.println();
        
		Collection<Object> c3 = new ArrayList<Object>();
		c3.addAll(c1);//将c1中的每个对象添加到c3
		c3.remove(3);//删除c3中的对象3
		c3.add("hello");
		System.out.println("c3: " + c3);
		Iterator<Object> it2 = c3.iterator();
		while (it2.hasNext()) {
			//将列表对象转换为Object对象输出
			Object obj1 = it2.next();
			System.out.println("Iterator 遍历 c2： " + obj1);
		}
	 }
  }

 输出结果：

  c1: [0, 1, 2, 3, 4, 6]

  c2: [[0, 1, 2, 4, 6], hello]

  Iterator 遍历 c2： [0, 1, 2, 4, 6]

  Iterator 遍历 c2： hello

  c3: [0, 1, 2, 4, 6, hello]

  Iterator 遍历 c2： 0

  Iterator 遍历 c2： 1

  Iterator 遍历 c2： 2

  Iterator 遍历 c2： 4

  Iterator 遍历 c2： 6

  Iterator 遍历 c2： hello

2>实现类LinkedList：

 LinkList容器类通过连接指针来关联前后两个元素。

 构造方法：

 · LinkList(): 建立一个空的连接列表。

 · LinkList(Collection c): 建立一个列表，该列表有集合c中的元素初始化。

 下面用例子演示LinkList的一些方法：

import java.util.LinkedList;
 public class TestTreeSet {
	 public static void main(String[] args) {
		//声明一个LinkedList列表对象ll
		LinkedList<String> ll = new LinkedList<String>();
		//向列表ll中添加对象
		ll.add("d");
		ll.add("e");
		ll.add("f");
		ll.add("g");
		System.out.println("显示初始化后ll的内容： " + ll);
		//调用方法向列表ll中添加对象
		ll.addLast("z");
		ll.addFirst("b");
		ll.add(1, "a");
		System.out.println("显示添加操作后的ll内容： " + ll);
		//调用方法删除列表ll中的对象
		ll.remove("g");
		ll.remove(2);
		ll.removeFirst();
		ll.removeLast();
		System.out.println("显示删除操作后ll的内容： " + ll);
		//取得列表ll中的元素
		Object val = ll.get(1);
		//调用方法设置列表ll中指定位置的对象
		ll.set(2, (String) val + "Changed");
		System.out.println("显示设置操作后ll的内容： " + ll);
	}
  }

 输出结果：

 显示初始化后ll的内容： [d, e, f, g]

 显示添加操作后的ll内容： [b, a, d, e, f, g, z]

 显示删除操作后ll的内容： [a, e, f]

 显示设置操作后ll的内容： [a, e, eChanged]

3>实现类Vector：

 Vector类提供了实现可增长和缩短的数组功能，其与ArrayList类的操作大多数相同，区别在于Vector类是线程同步的。

 Vector类的构造方法：

 · Vector(): 构造一个空向量，其内部数组的大小为10，标准增量为0。

 · Vector(Collection c): 构造一个包含指定集合中的元素的向量，这些元素按其集合的迭代器返回元素顺序排列。

 · Vector(int initialCapacity): 使用指定的初始容量和等于0的增量构造一个空向量。 

 · Vector(int initialCapacity, int capacityIncrement): 使用指定的初始容量和容量增量构造一个空向量。 

 Vector的方法：

 · addElement(Object obj): 把组件添加到向量的尾部，同时向量容

   量比以前大1。

 · insertElementAt(Object obj, int index): 把组件插入到指定索引 

   处，此后的所有内容向后移动一位。

 · setElementAt(Object obj, int index): 把组件添加到指定索引处此

   处原先的元素被替换。

 · removeElemnet(Object obj): 把向量中含有的本组件移除。

 · removeAllElements(): 把向量中所有的组件移除。

 下面使用例子演示Vector的方法：

 import java.util.Vector;

 public class TestTreeSet {
	 public static void main(String[] args) {
		//声明一个空向量
	    Vector<String> v = new Vector<String>();
	    //向向量v中添加对象
	    v.add("one");
	    v.add("two");
	    v.add("three");
	    System.out.println("显示Vector的初始值： "+ v.toString());
	    //向向量v中插入元素
	    v.insertElementAt("zero", 0);
	    v.insertElementAt("oop", 3);
	    System.out.println("显示插入元素后Vector的值： "+ 
                                                        v.toString());
	    //修改向量V中的元素
	    v.setElementAt("three", 3);
	    v.setElementAt("four", 4);
	    System.out.println("显示修改后Vector的值："+ v.toString());
	    //删除v中指定元素
	    v.remove(4);
	    v.removeElement("three");
	    System.out.println("显示删除指定元素后Vector的值： "+ 
                                                       v.toString());
	    //删除v中的所有元素
	    v.removeAllElements();
	   System.out.println("显示删除所有元素后Vector的值： " + 
                                                      v.toString());
	    
	 }
  }