List的共性方法

Collection

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

                ArrayList：底层的数据结构使用的是数组结构。特点：查询速度快，但是增删较慢。线程不同步。初始长度为10，默认扩充为原来的1.5倍。

                ListedList：底层使用的链表结构。特点：增删速度很快，查询速度较慢。

                Vector：底层是数组数据结构。线程同步。被ArrayList替代了。初始长度为10，默认扩充为原来的2倍。

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

        Vector：

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

    增：

        add(int index, E element)

        addAll(int index, Collection<? extents E> c)

    删：

        remove(int index)

    改：

        set(int index,E element)

    查：

        get(int index)

        subList(int formindex,int toindex)

        listIterator()

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListDemo {

	public static void main(String[] args) {
		ArrayList arr=new ArrayList();
		
		//添加元素
		arr.add("1");
		arr.add("2");
		arr.add("3");
		
		sop("原集合是："+arr);
		
		//在指定位置添加元素
		arr.add(1, "4");
		
		//删除指定位置的元素
		//arr.remove(3);
		
		//修改元素
		arr.set(1, "5");
		
		//通过脚标获取元素
		sop("get(2):"+arr.get(2));
		
		sop("新集合是："+arr);
		
		//方法一获取所有元素
		for(int i=0;i<arr.size();i++){
			System.out.println("arr("+i+")="+arr.get(i));
		}
		//方法二
		Iterator iterator=arr.iterator();
		while(iterator.hasNext()){
			sop(iterator.next());
		}
		
		//通过indexof获取对象的位置
		sop("index="+arr.indexOf("3"));
		
		List sub=arr.subList(0, 2);
		sop("sub"+sub);
	}
	
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

运行结果为：

    原集合是：[1, 2, 3]
    get(2):2
    新集合是：[1, 5, 2, 3]
    arr(0)=1
    arr(1)=5
    arr(2)=2
    arr(3)=3
    1
    5
    2
    3
    index=3
    sub[1, 5]

List集合特有的迭代器，listIterator是Iterator的子接口。

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

    该接口只能通过List集合的listIterator方法获取。

        

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class ListDemo {

	public static void main(String[] args) {
		//演示列表迭代器
		ArrayList arrayList=new ArrayList();
		
		//添加元素
		arrayList.add("a");
		arrayList.add("b");
		arrayList.add("c");
		arrayList.add("d");
		
		sop(arrayList);
		
		ListIterator listIterator=arrayList.listIterator();
		
		sop("hasPrevious():"+listIterator.hasPrevious());
		
		//正向取元素
		while(listIterator.hasNext()){
			Object object=listIterator.next();
			if(object.equals("c")){
				//在迭代器中添加一个元素
				//listIterator.add("f");
				//在迭代器中修改一个元素
				listIterator.set("e");
			}
		}
		
		//sop("hasNext():"+listIterator.hasNext());
		//sop("hasPrevious():"+listIterator.hasPrevious());
		
		//逆向取元素
		while(listIterator.hasPrevious()){
			sop("pre:"+listIterator.previous());
		}
		
		
		sop(arrayList);
		
		/*
		//在迭代过程中，准备添加或删除元素
		Iterator iterator=arrayList.iterator();
		while(iterator.hasNext()){
			Object object=iterator.next();
			
			if(object.equals("c")){
				//arrayList.add("f");
				//arrayList.remove(object);
			}
			sop("obj="+object);
		}
		*/
		
	}
	
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

运行结果为：

    [a, b, c, d]
    hasPrevious():false
    pre:d
    pre:e
    pre:b
    pre:a

    [a, b, e, d]

枚举是Vector特有的取出方法

    其实枚举和迭代器是一样的。

    因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo {

	public static void main(String[] args) {
		Vector vector=new Vector();
		
		vector.add("a");
		vector.add("b");
		vector.add("c");
		vector.add("d");
		
		Enumeration enumeration=vector.elements();//返回此向量的组件的枚举
		
		while(enumeration.hasMoreElements()){//测试此枚举是否包含更多的元素。
			System.out.println(enumeration.nextElement());// 如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。
		}
	}
}

运行结果为：

    a
    b
    c
    d