11、java.util.List集合

一、List接口

 

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

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

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

    |--：Vector：底层是数组数据结构，线程同步，被ArrayList替代了

 

/**
 *java.util.List
 *有序的 collection（也称为序列）。
 *此接口的用户可以对列表中每个元素的插入位置进行精确地控制。
 *用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
 *与 set 不同，列表通常允许重复的元素。
 *List集合因为角标所以可以通过角标遍历集合元素，比其他集合多了一种遍历方式
 */

public interface List<E> extends Collection<E>
{
	/**
	 * 除了从Collection继承的方法外，List有自己特有的方法
	 * 凡是可以操作角标的方法都是该体系特有的方法
	 */

	 //1,在列表的指定位置插入指定元素（可选操作）
	 void add(int index, E element);
     
	 //2,将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
	 boolean addAll(int index, Collection<? extends E> c); 
     
	 //3,返回列表中指定位置的元素。
	 E get(int index);
     
	 //4,用指定元素替换列表中指定位置的元素（可选操作）。
	 E set(int index, E element); 
     
	 //5,返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
	 int lastIndexOf(Object o);
		
	 //6,返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
	 int indexOf(Object o);
		
	 //7,返回此列表元素的列表迭代器（按适当顺序）。
	 ListIterator<E> listIterator();

	 //8,返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
	 ListIterator<E> listIterator(int index);
	 
	 //9,移除列表中指定位置的元素（可选操作）。
	 E remove(int index); 

	 //10,返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
	 List<E> subList(int fromIndex, int toIndex);
}

 二、ListIterator列表迭代器

 

/** 
 *java.util.ListIterator接口 
 *对 List 进行迭代的迭代器。 
 *系列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。
 *ListIterator 没有当前元素；
 *它的光标位置 始终位于调用 previous() 所返回的元素和调用 next() 所返回的元素之间。
 */  
public interface ListIterator<E>extends Iterator<E>
{  
	//从Iterator继承的方法********************

    //如果仍有元素可以迭代，则返回 true。  
    boolean hasNext();  
  
    //返回迭代的下一个元素。  
    E next();  
  
    //从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。  
    void remove();  

	//特有方法*******************************

	//1,如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
	boolean hasPrevious();

	//2,返回对 next 的后续调用所返回元素的索引。
	int nextIndex();

	//3,返回列表中的前一个元素
	E previous();

	//4,返回对 previous 的后续调用所返回元素的索引
	int previousIndex();

	//5,用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。
	void set(E e);
	//6,将指定的元素插入列表（可选操作）。
	void add(E e);
}

 三、Iterator和ListIterator的区别

 

1. Iterator是ListIterator的父接口。
2. terator是单列集合(Collection)公共取出容器中元素的方式。对于List，Set都通用。
3. ListIterator是List集合的特有取出元素方式。
4. Iterator中具备的功能只有hashNext(),next()，remove();
5. ListIterator中具备着对被遍历的元素进行增删改查的方法，可以对元素进行逆向遍历。
6. 之所以如此，是因为ListIterator遍历的元素所在的容器都有索引。
7. 示例

import java.util.ArrayList;
class ListDemo 
{
	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();
		al.add("dd");
		al.add("aa");
		al.add("cc");
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			Object obj = it.next();
			if(obj == "dd")
				al.add("kk");
		}
	}
}
/**
 *此示例会发生并发修改异常ConcurrentModificationException
 *不能同时用it和al对集合进行操作
 *在迭代时，不可以通过集合对象的方法操作集合中的元素。
 *在迭代器时，只能用迭代器的方法操作元素
 *如果想要其他的操作如添加，修改等
 *只能使用其子接口，ListIterator
 */

四、ArrayList集合

 

• ArrayList()构造一个初始容量为 10 的空列表。
• ArrayList是1.2版本出现的Vector是1.0出现的，
• ArrayList初始容量为10，当继续添加内容时，它再new一个长度为15的数组，
• 把原数组中的元素copy过去，再添加，并删除原数组，而Vector则是new一个20的，它们的初始容量都是10
• Vector特有的取出方式：枚举public Enumeration<E> elements()
• Enumeration，枚举和迭代器是一样的，因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。
• Iterator是jdk1.2出现的
• Enumeration是jdk1.0出现的

/**
 *java.util.ArrayList
 */
public class ArrayList<E>extends AbstractList<E>
		implements List<E>, RandomAccess, Cloneable, Serializable
{
	//构造方法*************

	//构造一个初始容量为 10 的空列表
	public ArrayList(){}

	//构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
	public ArrayList(Collection<? extends E> c){}

	//构造一个具有指定初始容量的空列表。
	public ArrayList(int initialCapacity){}

	//特殊方法****************

	//移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
	protected void removeRange(int fromIndex, int toIndex){}

	//将此 ArrayList 实例的容量调整为列表的当前大小。
	//应用程序可以使用此操作来最小化 ArrayList 实例的存储量。
	void trimToSize(){}

	//其余方法与List一致**********************************
}

 五、LinkedList集合

 

• List 接口的链接列表实现。
• 除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。
• 这些操作允许将链接列表用作堆栈、队列或双端队列。
• 注意，此实现不是同步的
• 如果多个线程同时访问一个链接列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步
• jdk1.2开始的

/**
 *java.util.LinkedList
 */
public class LinkedList<E>extends AbstractSequentialList<E>
		implements List<E>, Deque<E>, Cloneable, Serializable
{
	//构造方法*************

	//构造一个空列表。
	public LinkedList(){}

	//构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。
	public LinkedList(Collection<? extends E> c){}

	//特殊方法****************

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

	//将指定元素添加到此列表的结尾
	public void addLast(E e)(){}
	
	//返回此列表的第一个元素，不删除元素。如果集合为空，则会出现NoSuchElementException异常
	public E getFirst(){}

	//返回此列表的最后一个元素，不删除元素。如果集合为空，则会出现NoSuchElementException异常
	public E getLast(){}

	//移除并返回此列表的第一个元素，删除元素。如果集合为空，则会出现NoSuchElementException异常
	public E removeFirst(){}

	//移除并返回此列表的最后一个元素，删除元素。如果集合为空，则会出现NoSuchElementException异常
	public E removeLast(){}

	//以上方法在jdk1.6出现了替代方法

	//将指定元素添加到此列表的末尾（最后一个元素）。
	public boolean offer(E e){}

	//在此列表的开头插入指定的元素。
	public boolean offerFirst(E e){}

	//在此列表末尾插入指定的元素。
	public boolean offerLast(E e){}

	//获取但不移除此列表的第一个元素；如果此列表为空，则返回 null
	public E peekFirst(){}

	//获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null
	public E peekLast(){}

	//获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
	public E pollFirst(){}

	//获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
	public E pollLast(){}

	//其余方法与List一致**********************************
}

 

六、Vector集合

 

public class Vector<E>extends AbstractList<E>
		implements List<E>, RandomAccess, Cloneable, Serializable
{
	//特有方法*****************

	//返回指定索引处的组件。
	public E elementAt(int index){}

	//返回此向量的组件的枚举
	public Enumeration<E> elements(){}
}

 

java.util.Enumeration<E>

//实现 Enumeration 接口的对象，它生成一系列元素，一次生成一个。
//连续调用 nextElement 方法将返回一系列的连续元素。

public interface Enumeration<E>
{
	//测试此枚举是否包含更多的元素。
	boolean hasMoreElements();

	//如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。
	E nextElement();
}