Java中list详解

一、list

（1）List 是接口，继承至Collection接口（Collection接口下还有个Queue接口，有PriorityQueue类）；

（2）List下有ArrayList，Vector，LinkedList

注意：Queue接口与List同一级别，都是继承了Collection接口。LinkedList既可以实现Queue接口,也可以实现List接口.Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法）。

二、list详解

1）ArrayList

ArrayList的实现原理

/*
ArrayList继承AbstractList类，
实现了List和RandomAccess，Cloneable, Serializable接口，
底层是基于动态的数组。
底层使用数组实现,默认初始容量为10.
当超出后，会自动扩容为原来的1.5倍，即自动扩容机制。
List list = Collections.synchronizedList(new ArrayList(...))
//即可线程安全。

// 利用ArrayList类实例化List集合
List<String> list = new ArrayList<String>();
*/
import java.util.*;

public class ArrayListExamples {

	public static void main(String args[]) {
		// 创建一个空的数组链表对象list，list用来存放String类型的数据
		ArrayList<String> list = new ArrayList<String>();

		// 增加元素到list对象中
		list.add("Item1");
		list.add("Item2");
		list.add(2, "Item3"); // 此条语句将会把“Item3”字符串增加到list的第3个位置。
		list.add("Item4");

		// 显示数组链表中的内容
		System.out.println("The arraylist contains the following elements: " + list);

		// 检查元素的位置
		int pos = list.indexOf("Item2");
		System.out.println("The index of Item2 is: " + pos);

		// 检查数组链表是否为空
		boolean check = list.isEmpty();
		System.out.println("Checking if the arraylist is empty: " + check);

		// 获取链表的大小
		int size = list.size();
		System.out.println("The size of the list is: " + size);

		// 检查数组链表中是否包含某元素
		boolean element = list.contains("Item5");
		System.out.println("Checking if the arraylist contains the object Item5: " + element);

		// 获取指定位置上的元素
		String item = list.get(0);
		System.out.println("The item is the index 0 is: " + item);

		// 遍历arraylist中的元素

		// 第1种方法: 循环使用元素的索引和链表的大小
		System.out.println("Retrieving items with loop using index and size list");
		for (int i = 0; i < list.size(); i++) {
			System.out.println("Index: " + i + " - Item: " + list.get(i));
		}

		// 第2种方法:使用foreach循环
		System.out.println("Retrieving items using foreach loop");
		for (String str : list) {
			System.out.println("Item is: " + str);
		}

		// 第三种方法:使用迭代器
		// hasNext(): 返回true表示链表链表中还有元素
		// next(): 返回下一个元素
		System.out.println("Retrieving items using iterator");
		for (Iterator<String> it = list.iterator(); it.hasNext();) {
			System.out.println("Item is: " + it.next());
		}

		// 替换元素
		list.set(1, "NewItem");
		System.out.println("The arraylist after the replacement is: " + list);

		// 移除元素
		// 移除第0个位置上的元素
		list.remove(0);

		// 移除第一次找到的 "Item3"元素
		list.remove("Item3");

		System.out.println("The final contents of the arraylist are: " + list);

		// 转换 ArrayList 为 Array
		String[] simpleArray = list.toArray(new String[list.size()]);
		System.out
				.println("The array created after the conversion of our arraylist is: " + Arrays.toString(simpleArray));
	}
}

ArrayList的优缺点

优点：底层数据结构是数组，查询快，增删慢。

缺点： 线程不安全，效率高

2）LinkedList

LinkedList的实现原理

/*
LinkedList继承AbstractList类，
实现了List，Serializable，Queue接口，
LinkedList是通过双向链表去实现的，
既然是链表实现那么它的随机访问效率比ArrayList要低，
顺序访问的效率要比较的高。
每个节点都有一个前驱（之前前面节点的指针）
一个后继（指向后面节点的指针）。
// 利用LinkedList类实例化List集合
List<String> list = new LinkedList<String>();
*/
import java.util.List;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.NoSuchElementException;
 
/*
 * @desc LinkedList测试程序。
 *
 * @author skywang
 * @email  kuiwu-wang@163.com
 */
public class LinkedListTest {
    public static void main(String[] args) {
        // 测试LinkedList的API
        testLinkedListAPIs() ;
 
        // 将LinkedList当作 LIFO(后进先出)的堆栈
        useLinkedListAsLIFO();
 
        // 将LinkedList当作 FIFO(先进先出)的队列
        useLinkedListAsFIFO();
    }
     
    /*
     * 测试LinkedList中部分API
     */
    private static void testLinkedListAPIs() {
        String val = null;
        //LinkedList llist;
        //llist.offer("10");
        // 新建一个LinkedList
        LinkedList llist = new LinkedList();
        //---- 添加操作 ----
        // 依次添加1,2,3
        llist.add("1");
        llist.add("2");
        llist.add("3");
 
        // 将“4”添加到第一个位置
        llist.add(1, "4");
         
 
        System.out.println("\nTest \"addFirst(), removeFirst(), getFirst()\"");
        // (01) 将“10”添加到第一个位置。  失败的话，抛出异常！
        llist.addFirst("10");
        System.out.println("llist:"+llist);
        // (02) 将第一个元素删除。        失败的话，抛出异常！
        System.out.println("llist.removeFirst():"+llist.removeFirst());
        System.out.println("llist:"+llist);
        // (03) 获取第一个元素。          失败的话，抛出异常！
        System.out.println("llist.getFirst():"+llist.getFirst());
 
 
        System.out.println("\nTest \"offerFirst(), pollFirst(), peekFirst()\"");
        // (01) 将“10”添加到第一个位置。  返回true。
        llist.offerFirst("10");
        System.out.println("llist:"+llist);
        // (02) 将第一个元素删除。        失败的话，返回null。
        System.out.println("llist.pollFirst():"+llist.pollFirst());
        System.out.println("llist:"+llist);
        // (03) 获取第一个元素。          失败的话，返回null。
        System.out.println("llist.peekFirst():"+llist.peekFirst());
     
 
        System.out.println("\nTest \"addLast(), removeLast(), getLast()\"");
        // (01) 将“20”添加到最后一个位置。  失败的话，抛出异常！
        llist.addLast("20");
        System.out.println("llist:"+llist);
        // (02) 将最后一个元素删除。        失败的话，抛出异常！
        System.out.println("llist.removeLast():"+llist.removeLast());
        System.out.println("llist:"+llist);
        // (03) 获取最后一个元素。          失败的话，抛出异常！
        System.out.println("llist.getLast():"+llist.getLast());
 
 
        System.out.println("\nTest \"offerLast(), pollLast(), peekLast()\"");
        // (01) 将“20”添加到第一个位置。  返回true。
        llist.offerLast("20");
        System.out.println("llist:"+llist);
        // (02) 将第一个元素删除。        失败的话，返回null。
        System.out.println("llist.pollLast():"+llist.pollLast());
        System.out.println("llist:"+llist);
        // (03) 获取第一个元素。          失败的话，返回null。
        System.out.println("llist.peekLast():"+llist.peekLast());
 
          
 
        // 将第3个元素设置300。不建议在LinkedList中使用此操作，因为效率低！
        llist.set(2, "300");
        // 获取第3个元素。不建议在LinkedList中使用此操作，因为效率低！
        System.out.println("\nget(3):"+llist.get(2));
 
 
        // ---- toArray(T[] a) ----
        // 将LinkedList转行为数组
        String[] arr = (String[])llist.toArray(new String[0]);
        for (String str:arr)
            System.out.println("str:"+str);
 
        // 输出大小
        System.out.println("size:"+llist.size());
        // 清空LinkedList
        llist.clear();
        // 判断LinkedList是否为空
        System.out.println("isEmpty():"+llist.isEmpty()+"\n");
 
    }
 
    /**
     * 将LinkedList当作 LIFO(后进先出)的堆栈
     */
    private static void useLinkedListAsLIFO() {
        System.out.println("\nuseLinkedListAsLIFO");
        // 新建一个LinkedList
        LinkedList stack = new LinkedList();
 
        // 将1,2,3,4添加到堆栈中
        stack.push("1");
        stack.push("2");
        stack.push("3");
        stack.push("4");
        // 打印“栈”
        System.out.println("stack:"+stack);
 
        // 删除“栈顶元素”
        System.out.println("stack.pop():"+stack.pop());
         
        // 取出“栈顶元素”
        System.out.println("stack.peek():"+stack.peek());
 
        // 打印“栈”
        System.out.println("stack:"+stack);
    }
 
    /**
     * 将LinkedList当作 FIFO(先进先出)的队列
     */
    private static void useLinkedListAsFIFO() {
        System.out.println("\nuseLinkedListAsFIFO");
        // 新建一个LinkedList
        LinkedList queue = new LinkedList();
 
        // 将10,20,30,40添加到队列。每次都是插入到末尾
        queue.add("10");
        queue.add("20");
        queue.add("30");
        queue.add("40");
        // 打印“队列”
        System.out.println("queue:"+queue);
 
        // 删除(队列的第一个元素)
        System.out.println("queue.remove():"+queue.remove());
     
        // 读取(队列的第一个元素)
        System.out.println("queue.element():"+queue.element());
 
        // 打印“队列”
        System.out.println("queue:"+queue);
    }
}

LinkedList的优缺点

优点：底层数据结构是链表，查询慢，增删快。

缺点： 线程不安全，效率高

3）Vector

Vector的实现原理

在ArrayList中每个方法中添加了synchronized关键字来保证同步。

//例子：
import java.util.Vector;
import java.lang.*;
import java.util.Enumeration;
public class VectorApp
{
public static void main(String args[])
{
Vector v1 = new Vector();
Integer integer1= new Integer(1);
//加入为字符串对象
v1.addElement("one");
//加入的为integer的对象
v1.addElement(integer1);
v1.addElement(integer1);
v1.addElement("two");
v1.addElement(new Integer(2));
v1.addElement(integer1);
v1.addElement(integer1);
//转为字符串并打印
System.out.println("The Vector v1 is:\n\t"+v1);
//向指定位置插入新对象
v1.insertElementAt("three",2);
v1.insertElementAt(new Float(3.9),3);
System.out.println("The Vector v1(used method
insertElementAt()is:\n\t)"+v1);
//将指定位置的对象设置为新的对象
//指定位置后的对象依次往后顺延
v1.setElementAt("four",2);
System.out.println("The vector v1 cused method setElmentAt()is:\n\t"+v1);
v1.removeElement(integer1);
//从向量对象v1中删除对象integer1
//由于存在多个integer1,所以从头开始。
//找删除找到的第一个integer1.
Enumeration enum = v1.elements();
System.out.println("The vector v1 (used method removeElememt()is");
while(enum.hasMoreElements())
System.out.println(enum.nextElement()+"");
System.out.println();
//使用枚举类(Enumeration)的方法取得向量对象的每个元素。
System.out.println("The position of Object1(top-to-botton):"+v1.indexOf(integer1));
System.out.println("The position of Object1(tottom-to-top):"+v1.lastIndexOf(integer1));
//按不同的方向查找对象integer1所处的位置
v1.setSize(4);
System.out.println("The new Vector(resized the vector)is:"+v1);
//重新设置v1的大小，多余的元素被抛弃
}
}

Vector的优缺点

优点：底层数据结构是数组，查询快，增删慢。

缺点：线程安全，效率低

4）三种list的使用

对数组查询次数多：ArrayList

对数组修改次数多：LinkedList

数组需要更加安全：Vector

数组不需要更加安全：ArrayList或者LinkedList

当需要使用list时，对使用具体哪个list不确定：ArrayList

总结： ArrayList是基于动态的数组的数据结构 LinkedList是基于链表的数据结构