类库-集合-List

java.util.List 接口继承自 Collection 接口，是单列集合的一个重要分支，习惯性地会将实现了 List 接口的对象称为List集合。

在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。

List接口特点：

　　1. 它是一个元素存取有序的集合，即元素的存入顺序和取出顺序一致。

　　例如，存元素的顺序是11、22、33。那么集合中，元素的存储就 是按照11、22、33的顺序完成的）

　　2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道 理）

　　3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

 

常用方法

List作为Collection集合的子接口，不但继承了Collection接口中的全部方法，而且还增加了一些根据元素索引来操作集合的特有方法，如下：

　　public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。

　　public E get(int index) :返回集合中指定位置的元素。此方法只有 List 接口才有定义，其他的任何接口都没有任何的定义。

　　public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。

　　public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新 前的元素。

　　public int indexOf(Object o):根据对象查找指定的位置，找不到返回-1。

 

使用

常用的实现类有如下几个： · ArrayList（95%）、Vector（4%）、LinkedList（1%）

ArrayList集合

java.util.ArrayList 集合数据存储的结构是数组结构。

元素增删慢，查找快，由于日常开发中使用 最多的功能为查询数据、遍历数据，所以 ArrayList 是最常用的集合。

许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。

此类的定义如下：

　　public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, Serializable

此类继承了 AbstractList 类。AbstractList 是 List 接口的子类。AbstractList 是个抽象类，适配器设计模式。

增加及取得元素，例：

public class ArrayListTest1 { 
    public static void main(String[] args) { 
        List all = new ArrayList(); // 实例化List对象，并指定泛型类型
        all.add("hello "); // 增加内容，此方法从Collection接口继承而来
        all.add(0, "LAMP ");// 增加内容，此方法是List接口单独定义的 
        all.add("world"); // 增加内容，此方法从Collection接口继承而来
        System.out.println(all); // 打印all对象调用toString()方法 
    }
}                 

此时的对象数组并没有长度的限制，长度可以任意长，只要是内存够大就行。

使用 remove()方法删除元素，并循环输出，例：

public class ArrayListTest2 { 
    public static void main(String[] args) { 
        List all = new ArrayList(); // 实例化List对象，并指定泛型类型
        all.add("hello "); // 增加内容，此方法从Collection接口继承而来
        all.add(0, "LAMP ");// 增加内容，此方法是List接口单独定义的 
        all.add("world"); // 增加内容，此方法从Collection接口继承而来
        all.remove(1); // 根据索引删除内容，此方法是List接口单独定义的
        all.remove("world");// 删除指定的对象 
        System.out.print("集合中的内容是：");
        for (int x = 0; x < all.size(); x++) { 
            // size()方法从Collection接口继承而来
            System.out.print(all.get(x) + "、"); // 此方法是List接口单独定义的 
        } 
    }        
}                             

Vector

与 ArrayList 一样，Vector 本身也属于 List 接口的子类，此类的定义如下：

　　public class Vector extends AbstractList implements List, RandomAccess, Cloneable, Serializable

Vector 属于 Java 元老级的操作类，是最早的提供了动态对象数组的操作类，在 JDK 1.0 的时候就已经推出了此 类的使用，只是后来在 JDK 1.2 之后引入了 Java 类集合框架。

但是为了照顾很多已经习惯于使用 Vector 的用户，所以在 JDK 1.2 之后将 Vector 类进行了升级了，让其多实现了一个 List 接口，这样才将这个类继续保留了下来。

Vector 类和 ArrayList 类的区别

区别点	ArrayList	Vector
时间	是新的类，是在 JDK 1.2 之后推出的	是旧的类，是在 JDK 1.0 的时候就定义的
性能	性能较高，是采用了异步处理	性能较低，是采用了同步处理
输出	支持 Iterator、ListIterator 输出	除了支持 Iterator、ListIterator 输出，还支持 Enumeration 输出

 

LinkedList集合：日常开发中此类的使用几率是非常低的。

java.util.LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。

定义如下：

　　public class LinkedList extends AbstractSequentialList implements List, Deque, Cloneable, Serializable

LinkedList是一个双向链表，实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。如下：

　　public void addFirst(E e) :将指定元素插入此列表的开头。

　　public void addLast(E e) :将指定元素添加到此列表的结尾。

　　public E getFirst() :返回此列表的第一个元素。

　　public E getLast() :返回此列表的最后一个元素。

　　public E removeFirst() :移除并返回此列表的第一个元素。

　　public E removeLast() :移除并返回此列表的最后一个元素。 　　

　　public E pop() :从此列表所表示的堆栈处弹出一个元素。

　　public void push(E e) :将元素推入此列表所表示的堆栈。

　　public boolean isEmpty() ：如果列表不包含元素，则返回true。

LinkedList是List的子类，List中的方法LinkedList都是可以使用。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。

此类继承了 AbstractList，所以是 List 的子类。但是此类也是 Queue 接口的子类，Queue 接口定义了如下的方法：

方法名称	描述
public boolean add(E e)	增加元素，如果有容量限制，并且已满，则抛出异常
public E element()	取得，但是不删除当前元素，如果对列为空则抛出异常
boolean offer(E e)	添加，如果有容量限制，并且已满，只是无法添加，但不抛出异常，返回 false 4 E peek() 普通取得头元素，但是不删除，如果队列为空，则返回null
E poll()	取得头元素，但是删除, 如果队列为空，则返回 null
E remove()	删除当前元素, 如果对列为空则抛出异常

例：验证 LinkedList 子类

import java.util.LinkedList;
import java.util.Queue;

public class Test {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<String>();
        queue.add("A");
        queue.add("B");
        queue.add("C");
        int len=queue.size();//把queue的大小先取出来，否则每循环一次，移除一个元素，就少一个元素，那么queue.size()在变小，就不能循环queue.size()次了。
        for (int x = 0; x <len; x++) {
            System.out.println(queue.poll());
        }
        System.out.println(queue);
    }    
}