Java中list详解

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.*;publicclassArrayListExamples{publicstaticvoidmain(String args[]){// 创建一个空的数组链表对象list，list用来存放String类型的数据
        ArrayList<String> list =newArrayList<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(newString[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  [email protected]
 */publicclassLinkedListTest{publicstaticvoidmain(String[] args){// 测试LinkedList的APItestLinkedListAPIs();// 将LinkedList当作 LIFO(后进先出)的堆栈useLinkedListAsLIFO();// 将LinkedList当作 FIFO(先进先出)的队列useLinkedListAsFIFO();}/*
     * 测试LinkedList中部分API
     */privatestaticvoidtestLinkedListAPIs(){
        String val = null;//LinkedList llist;//llist.offer("10");// 新建一个LinkedList
        LinkedList llist =newLinkedList();//---- 添加操作 ----// 依次添加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(newString[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(后进先出)的堆栈
     */privatestaticvoiduseLinkedListAsLIFO(){
        System.out.println("\nuseLinkedListAsLIFO");// 新建一个LinkedList
        LinkedList stack =newLinkedList();// 将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(先进先出)的队列
     */privatestaticvoiduseLinkedListAsFIFO(){
        System.out.println("\nuseLinkedListAsFIFO");// 新建一个LinkedList
        LinkedList queue =newLinkedList();// 将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;publicclassVectorApp{publicstaticvoidmain(String args[]){
Vector v1 =newVector();
Integer integer1=newInteger(1);//加入为字符串对象
v1.addElement("one");//加入的为integer的对象
v1.addElement(integer1);
v1.addElement(integer1);
v1.addElement("two");
v1.addElement(newInteger(2));
v1.addElement(integer1);
v1.addElement(integer1);//转为字符串并打印
System.out.println("The Vector v1 is:\n\t"+v1);//向指定位置插入新对象
v1.insertElementAt("three",2);
v1.insertElementAt(newFloat(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是基于链表的数据结构