list（接口） 顺序是list最重要的特性；它可保证元素按照规定的顺序排列。list为collection添加了大量方法，以便我们在list中部插入和删除元素（只推荐对linkedlist这样做）。list也会生成一个listiterator（列表反复器），利用它可在一个列表里朝两个方向遍历，同时插入和删除位于列表中部的元素（同样地，只建议对linkedlist这样做）
　　arraylist＊ 由一个数组后推得到的list。作为一个常规用途的对象容器使用，用于替换原先的vector。允许我们快速访问元素，但在从列表中部插入和删除元素时，速度却嫌稍慢。一般只应该用listiterator对一个arraylist进行向前和向后遍历，不要用它删除和插入元素；与linkedlist相比，它的效率要低许多
　　linkedlist 提供优化的顺序访问性能，同时可以高效率地在列表中部进行插入和删除操作。但在进行随机访问时，速度却相当慢，此时应换用arraylist。也提供了addfirst()，addlast()，getfirst()，getlast()，removefirst()以及removelast()（未在任何接口或基础类中定义），以便将其作为一个规格、队列以及一个双向队列使用
　　
　　下面这个例子中的方法每个都覆盖了一组不同的行为：每个列表都能做的事情（basictest()），通过一个反复器遍历（itermotion()）、用一个反复器改变某些东西（itermanipulation()）、体验列表处理的效果（testvisual()）以及只有linkedlist才能做的事情等：
　　
　　//: list1.java
　　// things you can do with lists
　　package c08.newcollections;
　　import java.util.*;
　　
　　public class list1 {
　　　// wrap collection1.fill() for convenience:
　　　public static list fill(list a) {
　　return (list)collection1.fill(a);
　　　}
　　　// you can use an iterator, just as with a
　　　// collection, but you can also use random
　　　// access with get():
　　　public static void print(list a) {
　　for(int i = 0; i < a.size(); i++)
　　　system.out.print(a.get(i) + " ");
　　system.out.println();
　　　}
　　　static boolean b;
　　　static object o;
　　　static int i;
　　　static iterator it;
　　　static listiterator lit;
　　　public static void basictest(list a) {
　　a.add(1, "x"); // add at location 1
　　a.add("x"); // add at end
　　// add a collection:
　　a.addall(fill(new arraylist()));
　　// add a collection starting at location 3:
　　a.addall(3, fill(new arraylist()));
　　b = a.contains("1"); // is it in there?
　　// is the entire collection in there?
　　b = a.containsall(fill(new arraylist()));
　　// lists allow random access, which is cheap
　　// for arraylist, expensive for linkedlist:
　　o = a.get(1); // get object at location 1
　　i = a.indexof("1"); // tell index of object
　　// indexof, starting search at location 2:
　　i = a.indexof("1", 2);
　　b = a.isempty(); // any elements inside?
　　it = a.iterator(); // ordinary iterator
　　lit = a.listiterator(); // listiterator
　　lit = a.listiterator(3); // start at loc 3
　　i = a.lastindexof("1"); // last match
　　i = a.lastindexof("1", 2); // ...after loc 2
　　a.remove(1); // remove location 1
　　a.remove("3"); // remove this object
　　a.set(1, "y"); // set location 1 to "y"
　　// keep everything that's in the argument
　　// (the intersection of the two sets):
　　a.retainall(fill(new arraylist()));
　　// remove elements in this range:
　　a.removerange(0, 2);
　　// remove everything that's in the argument:
　　a.removeall(fill(new arraylist()));
　　i = a.size(); // how big is it?
　　a.clear(); // remove all elements
　　　}
　　　public static void itermotion(list a) {
　　listiterator it = a.listiterator();
　　b = it.hasnext();
　　b = it.hasprevious();
　　o = it.next();
　　i = it.nextindex();
　　o = it.previous();
　　i = it.previousindex();
　　　}
　　　public static void itermanipulation(list a) {
　　listiterator it = a.listiterator();
　　it.add("47");
　　// must move to an element after add():
　　it.next();
　　// remove the element that was just produced:
　　it.remove();
　　// must move to an element after remove():
　　it.next();
　　// change the element that was just produced:
　　it.set("47");
　　　}
　　　public static void testvisual(list a) {
　　print(a);
　　list b = new arraylist();
　　fill(b);
　　system.out.print("b = ");
　　print(b);
　　a.addall(b);
　　a.addall(fill(new arraylist()));
　　print(a);
　　// shrink the list by removing all the
　　// elements beyond the first 1/2 of the list
　　system.out.println(a.size());
　　system.out.println(a.size()/2);
　　a.removerange(a.size()/2, a.size()/2 + 2);
　　print(a);
　　// insert, remove, and replace elements
　　// using a listiterator:
　　listiterator x = a.listiterator(a.size()/2);
　　x.add("one");
　　print(a);
　　system.out.println(x.next());
　　x.remove();
　　system.out.println(x.next());
　　x.set("47");
　　print(a);
　　// traverse the list backwards:
　　x = a.listiterator(a.size());
　　while(x.hasprevious())
　　　system.out.print(x.previous() + " ");
　　system.out.println();
　　system.out.println("testvisual finished");
　　　}
　　　// there are some things that only
　　　// linkedlists can do:
　　　public static void testlinkedlist() {
　　linkedlist ll = new linkedlist();
　　collection1.fill(ll, 5);
　　print(ll);
　　// treat it like a stack, pushing:
　　ll.addfirst("one");
　　ll.addfirst("two");
　　print(ll);
　　// like "peeking" at the top of a stack:
　　system.out.println(ll.getfirst());
　　// like popping a stack:
　　system.out.println(ll.removefirst());
　　system.out.println(ll.removefirst());
　　// treat it like a queue, pulling elements
　　// off the tail end:
　　system.out.println(ll.removelast());
　　// with the above operations, it's a dequeue!
　　print(ll);
　　　}
　　　public static void main(string args[]) {
　　// make and fill a new list each time:
　　basictest(fill(new linkedlist()));
　　basictest(fill(new arraylist()));
　　itermotion(fill(new linkedlist()));
　　itermotion(fill(new arraylist()));
　　itermanipulation(fill(new linkedlist()));
　　itermanipulation(fill(new arraylist()));
　　testvisual(fill(new linkedlist()));
　　testlinkedlist();
　　　}
　　} ///:~
　　
　　在basictest()和itermotiion()中，只是简单地发出调用，以便揭示出正确的语法。而且尽管捕获了返回值，但是并未使用它。在某些情况下，之所以不捕获返回值，是由于它们没有什么特别的用处。在正式使用它们前，应仔细研究一下自己的联机文档，掌握这些方法完整、正确的用法。