Java list接口用法详解

List 是 Collection 的常用子接口，可以存储一组有序、不唯一的对象，List 接口的定义如下：

public interface List<E> extends Collection<E>

List 接口在继承 Collection 接口的基础上进行了扩展，常用的扩展方法如下表所示。

方 法	描 述
E get(int index)	通过下标获取集合中指定位置的元素
E set(int index, E element)	替换集合中指定位置的元素。
void add(int index, E element)	向集合中的指定位置添加元素。
E remove(int index)	通过下标删除集合中指定位置的元素。
int indexOf(Object o)	查找某个对象在集合中的位置。
mt lastIndexOf(Object o)	从后向前查找某个对象在集合中的位置。
ListIterator<E> listlterator()	实例化 ListIterator 接口。
list<E> subList(int fromlndex, int toIndex)	获取集合中的子集合。

List接口的实现类

ArrayList 是开发中经常使用到的实现类，实现了长度可变的数组。

ArrayList 可以在内存中分配连续的空间，底层是基于索引的数据结构，所以访问元素效率较高。使用索引查询元素可快速访问到对应的元素，但缺点是若添加或者删除元素，需要移动兄弟元素的位置，效率较低，相关的定义为：

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

下面的程序演示了 ArrayList 的用法。

public class Test {
   public static void main(String[] args) {
      ArrayList list = new ArrayList();
      list.add("Hello");
      list.add("World");
      list.add("JavaSE");
      list.add("JavaME");
      list.add("JavaEE");
      System.out.println("list:"+list);
      System.out.println("list的长度："+list.size());
      System.out.println("list是否包含Java："+list.contains("Java"));
      Iterator iter = list.iterator();
      while(iter.hasNext()) {
         System.out.print(iter.next()+",");
      }
      for(int i = 0; i < list.size(); i++) {
         System.out.print(list.get(i)+",");
      }
      list.remove("Hello");
      list.remove(0);
      for(int i = 0; i < list.size(); i++) {
         System.out.print(list.get(i)+",");
      }
      list.add(1, "我爱学Java");
      for(int i = 0; i < list.size(); i++) {
         System.out.print(list.get(i)+",");
      }
      list.set(2, "ArrayList详解");
      for(int i = 0; i < list.size(); i++) {
         System.out.print(list.get(i)+",");
      }
      System.out.println("JavaEE在集合中的下标："+list.indexOf("JavaEE"));
      List list2 = list.subList(1, 3);
      System.out.println(list2);
   }
}

运行结果为：

list:[Hello, World, JavaSE, JavaME, JavaEE] 
list的长度：5 
list是否包含Java：false 
Hello,World,JavaSE,JavaME,JavaEE, 
Hello,World,JavaSE,JavaME,JavaEE, 
JavaSE,JavaME,JavaEE, 
JavaSE,我爱学Java,JavaME,JavaEE, 
JavaSE,我爱学Java,ArrayList详解,JavaEE, 
JavaEE在集合中的下标：3 
[我爱学Java, ArrayList详解]

Vector 是一个早期的 List 实现类，用法基本与 ArrayList 一致，定义如下：

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

下面的代码演示了 Vector 的使用：

public class Test {
   public static void main(String[] args) {
      Vector vector = new Vector();
      vector.addElement("Hello");
      vector.add("Java");
      for(int i = 0; i < vector.size(); i++) {
         System.out.println(vector.get(i));
      }
   }
}

运行结果为：

Hello
Java

Stack 是 Vector 的子类，实现了一个“后进先出”的栈，定义如下：

public Class Stack<E> extends Vector<E>

下面的代码演示了 Stack 的使用：

public class Test {
   public static void main(String[] args) {
      Stack stack = new Stack();
      stack.push("Hello");
      stack.push("JavaSE");
      stack.push("JavaME");
      stack.push("JavaEE");
      System.out.println(stack);
      for (int i = 0; i < stack.size(); i++) {
         System.out.print(stack.get(i)+",");
      }
      System.out.println("栈顶元素："+stack.peek());
      for (int i = 0; i < stack.size(); i++) {
         System.out.print(stack.get(i)+",");
      }
      System.out.println("栈顶元素："+stack.pop());
      for (int i = 0; i < stack.size(); i++) {
         System.out.print(stack.get(i)+",");
      }
   }
}

运行结果为：

[Hello, JavaSE, JavaME, JavaEE] 
Hello,JavaSE,JavaME,JavaEE 
栈顶元素：JavaEE
Hello,JavaSE,JavaME,JavaEE
栈顶元素：JavaEE
Hello,JavaSE,JavaME,

LinkedList 实现了一个“先进先出”的队列，采用链表的形式存储分散的内存空间。元素和元素之间通过存储彼此的位置信息来形成连接关系，通过位置信息找到前后节点的关系。所以添加或删除元素的效率更高，因为只需要修改前后节点信息即可。

LinkedList 不但要保存每个节点的数据，还需要保存前后节点的位置信息，所以它需要更多的内存空间。正因为如此，在索引检索时会很慢，需要从第一个元素开始遍历，查询元素效率低是其缺点，定义如下：

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, Java.io.Serializable

下面的代码演示了 LinkedList 的使用：

public class Test {
   public static void main(String[] args) {
      LinkedList list = new LinkedList();
      list.add("Hello");
      list.add("World");
      list.add("Java");
      System.out.println(list);
      list.offer("JavaSE");
      list.addLast("JavaSE2");
      System.out.println(list);
      list.push("JavaME");
      list.addFirst("JavaME2");
      System.out.println(list);
      System.out.println("第一个元素："+list.peekFirst());
      System.out.println("访问第一个元素之后的集合："+list);
      System.out.println("最后一个元素："+list.peekLast());
      System.out.println("访问最后一个元素之后的集合："+list);
      System.out.println(list.pop());
      System.out.println("取出第一个元素之后的集合："+list);
      System.out.println(list.pollLast());
      System.out.println("取出最后一个元素之后的集合："+list);
   }
}

运行结果为：

[Hello, World, Java] 
[Hello, World, Java, JavaSE, JavaSE2] 
[JavaME2, JavaME, Hello, World, Java, JavaSE, JavaSE2] 
第一个元素：JavaME2 
访问第一个元素之后的集合：[JavaME2, JavaME, Hello, World, Java, JavaSE, JavaSE2] 
最后一个元素：JavaSE2 
访问最后一个元素之后的集合：[JavaME2, JavaME, Hello, World, Java, JavaSE, JavaSE2] 
JavaME2 
取出第一个元素之后的集合：[JavaME, Hello, World, Java, JavaSE, JavaSE2] 
JavaSE2 
取出最后一个元素之后的集合：[JavaME, Hello, World, Java, JavaSE]

LinkedList 和 Stack 都有 pop() 方法，都是取出集合的第一个元素，但是可以看到两者的顺序恰好是相反的。Stack 采用的是“后进先出”的方式，是栈的形式；LinkedList 采用的是“先进先出”的方式，是队列的形式。

因为 LinkedList 定义时实现了 Deque 接口，而 Deque 是 Queue 的子接口，Queue 又继承自 Collection，它在底层实现了队列的数据结构，定义如下：

public interface Queue<E> extends Collections<E>

在实际开发中，不能直接实例化 Queue 来完成操作，需要实例化其实现类。Queue 的实现类是 AbstractQueue，同时 AbstractQueue 又是一个抽象类，开发中需要对其子类 PriorityQueue 进行实例化，AbstractQueue 的定义如下：

public abstract class AbstractQueue<E> extends AbstractCollection<E>
    implements Queue<E>

PriorityQueue的定义如下：

public class PriorityQueue<E> extends AbstractQueue<E>
    implements Java.io.Serializable

PriorityQueue 在使用时需要注意，添加到该队列中的数据必须是有序的，即对象具备排序的功能，我们来演示一个错误例子：

public class Test {
   public static void main(String[] args) {
      PriorityQueue queue = new PriorityQueue();
      queue.add(new A(2));
      queue.add(new A(1));
      System.out.println(queue);
   }
}

class A {
   private int num;
   public A(int num) {
      this.num = num;
   }
}

运行结果如下图所示：


错误原因是 A 的实例化对象无法进行排序，解决方法是让 A 实现 Comparable 接口，并且重写 compareTo 方法，再来完成具体的比较逻辑，代码如下所示：

class A implements Comparable {
   //……
   @Override
   public int compareTo(Object o) {
      // TODO Auto-generated method stub
      /**
       * A.compareTo(B)
       * 返回值：
       * 1表示A大于B
       * 0表示A等于B
       * -1表示A小于B
       */
      A a = (A) o;
      if(this.num > a.num) {
         return 1;
      }else if(this.num == a.num) {
         return 0;
      }else {
         return -1;
      }
   }
   @Override
   public String toString() {
      return "A [num=" + num + "]";
   }
}

再次运行程序，结果为：

[A [num=1], A [num=2]]

可以看到 PriorityQueue 会对元素进行比较，并按照升序进行排列，即自然排序。同时，PriorityQueue 不允许添加 null 元素。