Java基礎學習筆記--常用API之List(ArrayList,Vector)

package com.common.api;
import java.util.*;
/*
 * 	Collection
 * 		|------List:元素是有序的，元素可以重複，因爲該集合體繫有索引
 * 				|------ArrayList:底層的數據結構使用的是數組結構，特點是查詢和修改速度很快，但是增刪稍慢，元素越多越明顯，線程不同步
 * 								ArrayList默認長度10，超過了按照50%新建新的數組
 * 				|------LinkedList：底層使用的鏈表數據結構，特點是增刪速度很快，查詢的速度稍慢
 * 				|------Vector：底層是數組數據結構，Vector出現的時候，集合框架尚未出現，線程同步，無論增刪改查都很慢，被ArrayList取代
 * 							Vector默認長度是10，超過了按照100%新建新的數組
 * 		|------Set:元數是無序的，元素不可以重複
 * 
 * 	List 常見方法：
 * 		特有方法：凡是可以操作下標的方法都是該體系特有的方法
 * 		增：
 * 			void add(String item, int index)  
 * 			boolean addAll(int index, Collection<? extends E> c)  
 * 		刪：
 * 			E remove(int index)  
 * 		改：
 * 			E set(int index, E element)  
 * 		查：
 * 			E get(int index)  
 * 			List<E> subList(int fromIndex, int toIndex)  
 * 			ListIterator<E> listIterator()  
 * 			int indexOf(Object o)  
 * 			int lastIndexOf(Object o)  
 * 
 * 	List集合特有的迭代器：ListIterator是iteratir的子接口
 * 		1）在迭代時不可以通過集合對象的方法操作集合中的元素，因爲會發生異常
 * 		所以在迭代器時，是能用迭代器的方法操作元素，可以使Iterator方法是有限的
 * 		如果想要其他的操作如增加，修改等，就需要使用使用子接口ListIterator
 * 		改接口只能通過List集合的ListIterator方法獲取
 * 
 * 	ListIterator常見方法：
 * 		void add(E e)  
 * 		boolean hasNext()  
 * 		boolean hasPrevious()  
 * 		E next()  
 * 		int nextIndex()  
 * 		E previous()  
 * 		int previousIndex()  
 * 		void remove()  
 * 		void set(E e)  
 * 
 * 	Vector比較特殊的方法：
 * 		枚舉就是Vector特有的取出方式，枚舉和迭代器很像，其實和Iterator功能是重複的
 * 		因爲枚舉的名稱以及方法的名稱都過長，所以被迭代器取代了，枚舉就鬱鬱而終了。
 * 		Enumeration<E> elements()  
 */

public class ListDemo {
	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	
	public static void method_base()
	{
		ArrayList a1=new ArrayList();
		//	添加元素
		a1.add("Java01");
		a1.add("java02");
		a1.add("java03");
		
		sop("原集合是："+a1);
		//在指定位置添加元素
		a1.add(1,"java09");
		sop("在下標1位置加java09後："+a1);
		
		//在指定位置刪除一個元素
		a1.remove(2);
		sop("將下標爲2的刪除後結果："+a1);
		
		// 修改指定位置的元素
		a1.set(2, "java07");
		sop("將下標爲2的修改爲 java07"+a1);
		
		//通過角標獲取元素
		sop("get(1):"+a1.get(1));
		
		//獲取所有元素
		for(int i=0;i<a1.size();i++)
		{
			System.out.printf("a1[%d] = %s\n", i,a1.get(i));
		}
		
		Iterator it=a1.iterator();
		while(it.hasNext()){
			sop("next:"+it.next());
		}
		
		//通過indexOf獲取對象的位置
		sop("index = "+ a1.indexOf("java09"));
		
		List sub=a1.subList(1, 3);
		sop("sub="+sub);
	}
	
	public static void mehtod_iterator()
	{
		ArrayList a1=new ArrayList();
		//	添加元素
		a1.add("Java01");
		a1.add("java02");
		a1.add("java03");
		sop("原有集合："+a1);
		//在迭代過程中增加或刪除元素
		//如下方式存在獲取和插入同時操作即併發，所以存在併發處理危險問題
		Iterator it=a1.iterator();
		while(it.hasNext())
		{
			Object obj=it.next();
			if(obj.equals("java02"))
			{
				//a1.add("java08");  //迭代器在獲取元素，集合又在插入元素，存在並非修改危險，這裏會報異常
				it.remove();
			}
			sop("obj:"+obj);
		}
		sop("修改之後集合："+a1);
		a1.add("java02");
		sop("原有集合："+a1);
		
		ListIterator li=a1.listIterator();
		while(li.hasNext())
		{
			Object obj=li.next();
			if(obj.equals("java02"))
			{
				li.add("java09");
			}
			if(obj.equals("java01"))
			{
				li.set("java06");
			}
		}
		sop("修改之後集合："+a1);
		
		sop("hasNext():"+li.hasNext());
		sop("hasPrevious()"+li.hasPrevious());
		
		while(li.hasPrevious())
		{
			Object obj=li.previous();
			if(obj.equals("java02"))
			{
				li.set("java10");
			}
		}
		sop("逆向遍歷修改之後集合："+a1);
	}
	
	public static void method_vector()
	{
		Vector v=new Vector();
		v.add("java01");
		v.add("java02");
		v.add("java03");
		v.add("java04");
		
		sop("原始Vector："+v);
		
		Enumeration en = v.elements();
		while(en.hasMoreElements())
		{
			sop(en.nextElement());
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		method_base();
		
		mehtod_iterator();
		
		method_vector();
	}
}

運行結果爲：

原集合是：[Java01, java02, java03]
在下標1位置加java09後：[Java01, java09, java02, java03]
將下標爲2的刪除後結果：[Java01, java09, java03]
將下標爲2的修改爲 java07[Java01, java09, java07]
get(1):java09
a1[0] = Java01
a1[1] = java09
a1[2] = java07
next:Java01
next:java09
next:java07
index = 1
sub=[java09, java07]
原有集合：[Java01, java02, java03]
obj:Java01
obj:java02
obj:java03
修改之後集合：[Java01, java03]
原有集合：[Java01, java03, java02]
修改之後集合：[Java01, java03, java02, java09]
hasNext():false
hasPrevious()true
逆向遍歷修改之後集合：[Java01, java03, java10, java09]
原始Vector：[java01, java02, java03, java04]
java01
java02
java03
java04