集合（二）：List接口。

時間  2019-11-07
標籤 集合 list 接口 欄目 快樂工作 简体版
原文   原文鏈接

 一：List接口： 繼承自Collection，以下：java

public interface List extends Collection {}

    

1.ArrayList（ 實現類）：數組

  ArrayList 是一個數組隊列，至關於 動態數組。與Java中的數組相比，它的容量能動態增加。它繼承於AbstractList，實現了List, RandomAccess, Cloneable, java.io.Serializable這些接口。
ArrayList 繼承了AbstractList，實現了List。它是一個數組隊列，提供了相關的添加、刪除、修改、遍歷等功能。
  ArrayList 實現了RandmoAccess接口，即提供了隨機訪問功能。RandmoAccess是java中用來被List實現，爲List提供快速訪問功能的。在ArrayList中，咱們便可以經過元素的序號快速獲取元素對象；這就是快速隨機訪問。稍後，咱們會比較List的「快速隨機訪問」和「經過Iterator迭代器訪問」的效率。
  ArrayList 實現了Cloneable接口，即覆蓋了函數clone()，能被克隆。
  ArrayList 實現java.io.Serializable接口，這意味着ArrayList支持序列化，能經過序列化去傳輸，和Vector不一樣，ArrayList中的操做不是線程安全的。因此，建議在單線程中才使用ArrayList，而在多線程中能夠選擇Vector或者CopyOnWriteArrayList。安全

public class ArrayList extends AbstractList
        implements List, RandomAccess, Cloneable, java.io.Serializable
{}

1.1ArrayList中的一些基本簡單方法使用：數據結構

public class Test01List {

	@Test
	public void testArrayList(){
		//使用ArrayList()來存放數據。
		List<Person> list = new ArrayList<Person>();  // 父類引用指向子類對象。
		list.add( new Person("Berg",22));
		list.add( new Person("BergBerg", 21 ));

		System.out.println(" 總共有" + list.size() +" 個元素 。 ");
		for( int i=0; i<list.size();i++){
			//list可經過索引來訪問， 因此使用get（索引） 來取值。
			System.out.println(  list.get( i ));
		}
		
		// 迭代list
		Iterator<Person> iterator = list.iterator();
		while( iterator.hasNext() ){
			Person p = iterator.next();
			System.out.println( "iterator： " + p );
		}
		// 移除元素，按索引移除
		list.remove( 0 );
		System.out.println(" 移除第一個元素後：  ");
		System.out.println(" 總共有" + list.size() +" 個元素 。 ");

		for(int i =0 ; i<list.size(); i++){
			System.out.println(  list.get( i ));
		}
		list.add( new Person("Cccc" , 19) );
		System.out.println(" 總共有" + list.size() +" 個元素 。 ");
		
		Object[] obj = list.toArray();
		System.out.println( "\n******將list集合轉化爲數組*****:");
		for(int i=0;i<obj.length;i++){
			System.out.println(  obj[i]);
		}
		
		// 所有清空 。
		list.clear();
		System.out.println(" 總共有" + list.size() +" 個元素 。 ");
	}
}

1.2 List的「快速隨機訪問」和「經過Iterator迭代器訪問」的效率。( 三種遍歷方式)多線程

public class Test02ArrayList {

	public static void main(String[] args) {
		List list = new ArrayList();
		for (int i=0; i<100000; i++)
			list.add(i);
		//經過索引值遍歷
		iteratorByRandomAccess(list) ;
		//經過迭代器遍歷
		iteratorByIterator(list) ;
		//經過for循環遍歷
		iteratorByForEach(list) ;

	}

	public static void iteratorByRandomAccess(List list) {
		long startTime;
		long endTime;
		startTime = System.currentTimeMillis();
		for (int i=0; i<list.size(); i++) {
			list.get(i);
		}
		endTime = System.currentTimeMillis();
		long interval = endTime - startTime;
		System.out.println("iteratorByRandomAccess：" + interval+" ms");
	}
	public static void iteratorByIterator(List list) {
		long startTime;
		long endTime;
		startTime = System.currentTimeMillis();
		for(Iterator iter = list.iterator(); iter.hasNext(); ) {
			iter.next();
		}
		endTime = System.currentTimeMillis();
		long interval = endTime - startTime;
		System.out.println("iteratorByIterator：" + interval+" ms");
	}
	public static void iteratorByForEach(List list) {
		long startTime;
		long endTime = 0; 
		startTime = System.currentTimeMillis();
		for(Object obj:list)
			endTime = System.currentTimeMillis();
		long interval = endTime - startTime;
		System.out.println("iteratorByForEach：" + interval+" ms");
	}

}
更多學習之ArrayList詳細介紹(示例)： http://www.jb51.net/article/42764.htm更多學習之ArrayList詳細介紹(示例)： http://www.jb51.net/article/42764.htm

2.LinkedList（ 實現類）：dom

    LinkedList也和ArrayList同樣實現了List接口，可是它執行插入和刪除操做時比ArrayList更加高效，由於它是基於鏈表的。基於鏈表也決定了它在隨機訪問方面要比ArrayList遜色一點。函數

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{}

    LinkedList是一個繼承於AbstractSequentialList的雙向鏈表。它也能夠被當作堆棧、隊列或雙端隊列進行操做。源碼分析

 LinkedList實現List接口，能對它進行隊列操做。性能

 LinkedList實現Deque接口，即能將LinkedList當作雙端隊列使用。學習

 LinkedList實現了Cloneable接口，即覆蓋了函數clone()，能克隆。

 LinkedList實現Serializable接口，這意味着LinkedList支持序列化，能經過序列化去傳輸。

 LinkedList是非同步的。

參照API，對LinkedList一些基本方法學習：

public class Test03LinkedList {

	public static void main(String[] args) {

		//使用LinkedList()來存放數據。
		List<String> list = new LinkedList<String>();  // 父類引用指向子類對象。
		list.add("Berg");
		list.add("Smith");
		list.add("Xujun");
		list.add("RedSun");
		System.out.println(" 總共有" + list.size() +" 個元素 。 ");

		//1.首先先迭代遍歷這個集合,並打印輸出當前元素的下標位置。
		Iterator<String> iterator = list.iterator();
		printResult(list);

		//2.在此列表中指定的位置插入指定的元素, 而後在迭代輸出。
		list.add(2, "China");
		printResult(list);

		//3.分別將某個元素添加到列表的頭部和尾部：
		((LinkedList)list).addFirst("firstElement");
		((LinkedList)list).addLast("lastElement");
		printResult(list);

		System.out.println("\n---------------------");
		//4.返回此列表中的元素的列表迭代器:list.listIterator()
		ListIterator<String> listIterator = list.listIterator();
		while( listIterator.hasNext() ){ //正向遍歷列表
			String string = listIterator.next();
			System.out.println( "當前元素爲：  " + string  );
		}
		while( listIterator.hasPrevious() ){ // 反向遍歷列表
			String str = listIterator.previous();
			System.out.println( "當前一個對象元素： " + str  );
		}

		//5.在當前位置前添加一個元素: 
//		listIterator.add("addNewElement");
//		printResult(list);
////		
		//6.用新元素取代next或previous上次訪問的元素。 若是在next或previous上次調用以後列表結構被修改了，將拋出一個IllegalStateException異常。
		listIterator.set( "setNewElement");
		printResult(list);
	}

	private static void printResult(List list){
		Iterator<String> iterator = list.iterator();
		System.out.println( "\n------------------------");
		while( iterator.hasNext() ){
			String str = iterator.next();
			System.out.println( "當前迭代的元素是： " + str + ", 及當前元素位置即下標值爲：  " + list.indexOf(str) );
		}
		System.out.println( "------------------------\n");
	}
}

 更多學習之LinkedList的實現原理：http://tan4836128.iteye.com/blog/1717809。

 Java源碼分析之LinkedList：http://blog.csdn.net/jzhf2012/article/details/8540543

 LinkedList和ArrayList的使用及性能分析：http://www.jb51.net/article/42767.htm

3.Vector（ 實現類）:

    Vector 是矢量隊列，它是JDK1.0版本添加的類。繼承於AbstractList，實現了List, RandomAccess, Cloneable這些接口。
Vector 繼承了AbstractList，實現了List；因此，它是一個隊列，支持相關的添加、刪除、修改、遍歷等功能。
    Vector 實現了RandmoAccess接口，即提供了隨機訪問功能。RandmoAccess是java中用來被List實現，爲List提供快速訪問功能的。在Vector中，咱們便可以經過元素的序號快速獲取元素對象；這就是快速隨機訪問。
    Vector 實現了Cloneable接口，即實現clone()函數。它能被克隆。
和ArrayList不一樣，Vector中的操做是線程安全的；可是，Vector不支持序列化，即沒有實現java.io.Serializable接口。即：

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable{}

對Vector的一些基本方法的使用，參照API：

public class Test04Vector {

	public static void main(String[] args) {
		// 默認初始容量大小爲10 ， 這個可參考源碼。
		List<String> list = new Vector(1);
		
		list.add("Berg");
		list.add("china");
		
		// 1. 返回指定索引處的組件。 跟 get(intindex)功能徹底相同
		String str = (String) ((Vector)list).elementAt(1);
		System.out.println("返回的對象值： "+   str );
		
		((Vector)list).addElement("TheVector");
		//2.  返回此向量的組件的枚舉。
		Enumeration<String> enumeration = ((Vector)list).elements();
		//2.1測試此枚舉是否包含更多的元素。
		while( enumeration.hasMoreElements() ){
			//2.2 若是此枚舉對象至少還有一個可提供的元素，則返回此枚舉的下一個元素。
			String string = enumeration.nextElement();
			System.out.println( "枚舉對象值： " + string );
		}
		
		//3. 返回此向量的當前容量
		int size = ((Vector)list).capacity();
		System.out.println( "當前容量爲：  " + size );
		
		//4.將指定對象做爲此向量中的組件插入到指定的 index 處。
		((Vector)list).insertElementAt("insertNewElement", 2);
		
		//5.返回此 List 的部分視圖，元素範圍爲從 fromIndex（包括）到 toIndex（不包括）。
		List<String> list1 = ((Vector)list).subList(0, 2);
		printResult(list1);

		printResult(list);
	}
	
	private static void printResult(List<String> list ){
		Iterator<String> iterator = list.iterator();
		System.out.println( "\n------------------------");
		System.out.println(  "size: " + list.size() );
		while( iterator.hasNext() ){
			String str = iterator.next();
			System.out.println( "當前迭代的元素是： " + str + ", 及當前元素位置即下標值爲：  " + list.indexOf(str) );
		}
		System.out.println( "------------------------\n");
	}
}

Vector源碼解析和實例代碼：http://www.jb51.net/article/42765.htm （t挺好的。。。）

 

4. 總結：ArrayList， LinkedList，Vector的區別：

4.1 線程安全方面：

        Vector是線程安全，ArrayList與LinkedList線程不安全。

 4.2 底層數據結構的實現：

        LinkedList是雙向鏈表，而ArrayList 與 Vector 是數組。

 4.3 存儲性能和特性來說：

        ArrayList與Vector都是使用數組方式存儲數據，此數組元素數大於實際存儲的數據以便增長和插入元素，他們都容許直接按序號索引元素，可是插入元素要涉及數據元素移動等內存操做，因此索引數據快而插入數據慢。Vector因爲使用了synchronized方法，性能上較ArrayList差，而LinkedList使用雙向鏈表存儲，按序號索引數據須要進行前向或後向遍歷，可是插入數據時值須要記錄本項的先後項便可，因此插入速度較快。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程