JAVA——集合（List延伸）

Collection

List:

元素是有序的，元素可以重复。因为该集合体系又索引。

ArrayList(jdk1.2以后)

底层的数据结构使用的是数组结构。特点：查询速度很快，但是增删稍慢。线程不同步。

LinkedList

底层使用的是链表的数据结构。特点：增删速度很快，查询稍慢。

Vector（jdk1.0以后）

底层是数组数据结构。线程同步，被ArrayList替代了。

Set:

元素是无序的，元素不可以重复。

List:
特有方法。凡是可以操作角标的方法都是该体系特有的方法。

增
add(index,element);
addAll(index,Collection);

删
remove(index);

改
set(index,element);

查
get(index);
subList(from,to);
listIterator();

List集合特有的迭代器,ListIterator是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。
所以在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的。只能对元素进行判断，取出，删除的操作。如果想要其他的操作如添加、修改等，就需要使用其子接口，ListIterator.
该接口只能通过List集合的listIterator方法获取。

import java.util.*;
class ListDemo
{
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
        sop(al);    
        ListIterator li = al.listIterator();
        while(li.hasNext())
        {
            Object obj  = li.next();
            if(obj.equals("java02"))
            {
                //li.add("java09");
                li.set("java10");
            }
        }
        sop(al);
        while(li.hasPrevious())     //倒着取数
        {
            sop("pre::"+li.previous());
        }   
    }
    public static void method_1()
    {
        //演示列表迭代器
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
        sop(al);            //[java01, java02, java03]

        //在迭代过程中，准备增加或者删除元素
        Iterator it = al.iterator();
        while(it.hasNext())
        {
            Object obj = it.next();
            if(obj.equals("java02"))
            {
                //al.add("java08"); //java.util.ConcurrentModificationException
                it.remove();            //将java02的引用从集合中删除了
                sop("obj="+obj);
            }
        }
        sop(al);                    //[java01, java03]
    }

    public static void method()
    {
        ArrayList al = new ArrayList();
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        sop("原集合为:"+al);
        //在制定位置添加元素
        al.add(1,"java09");
        sop(al);//[java01, java09, java02, java03, java04]
        //删除指定位置的元素
        al.remove(1);
        sop(al);        //[java01, java02, java03, java04]
        //修改元素
        al.set(2,"java08");
        sop(al);        //[java01, java02, java08, java04]

        //通过角标获取元素
        sop("get(1):"+al.get(1));   //get(1):java02
        //获取所有元素
        for(int x=0;x<al.size();x++)
        {
            System.out.println("al("+x+"):"+al.get(x));
            /* al(0):java01 al(1):java02 al(2):java08 al(3):java04 */
        }
        Iterator it = al.iterator();
        while(it.hasNext())
        {
            sop("next:"+it.next());
        }

        /* next:java01 next:java02 next:java08 next:java04 */
            //通过indexOf获取对象的位置
        sop("index="+al.indexOf("java02"));
                List sub = al.subList(1,3);
                     //index=1
                    //sub=[java02, java08]
        sop("sub="+sub);

    }

    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

}

枚举就是Vector特有的取出方式，发现枚举和迭代器很像，其实枚举和迭代器是一样的。因为枚举的名称及方法的名称都过长。所以被迭代器取代了。枚举就郁郁而终了。

class  VectorDemo
{
    public static void main(String[] args)
    {
        Vector v = new Vector();
        v.add("java01");
        v.add("java02");
        v.add("java03");
        v.add("java04");
        sop("原集合为:"+v);
        Enumeration en = v.elements();
        while(en.hasMoreElements())
        {
            System.out.println(en.nextElement());
        }
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

原集合为:[java01, java02, java03, java04]
java01
java02
java03
java04

LinkedList: //LinkedList的特有方法： addFirst();
addLast();

getFirst();
getLast();
//获取元素，但不删除元素，如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
//获取元素，但是元素被删除，如果集合中没有元素，会出现NoSuchElementException

//在jdk1.6以后出现了替代方法
offerFirst();
offerLast();

peekFirst();
peekLast();
//获取元素但不删除元素，如果集合中没有元素，会返回null

pollFirst();
pollLast();
//获取元素，但是元素被删除，如果集合中没有元素，会返回null；

class LinkedListDemo
{
    public static void main(String[] args)
    {
        LinkedList link = new LinkedList();
        LinkedList link1 = new LinkedList();
        LinkedList link2 = new LinkedList();

        sop(link2.peekFirst());
        sop(link.pollFirst());

        link.addFirst("one");
        link.addFirst("two");
        link.addFirst("three");
        link.addFirst("four");
        sop(link); //[four, three, two, one]

        while(!link1.isEmpty())
        {
            sop(link1.removeLast());
        }

        link1.addLast("one");
        link1.addLast("two");
        link1.addLast("three");
        link1.addLast("four");
        sop(link1); //[one, two, three, four]

        sop(link1.getFirst());
        sop(link1.getLast());
        sop(link1.size());

        sop(link1.removeFirst());
        sop(link1.removeLast());
        sop(link1.size());

        link2.offerFirst("five");
        link2.offerFirst("six");
        sop(link2); 
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}