關於List接口中ArrayList，LinkedList和Vector的取值方法的一些性能測試

對於List接口下的ArrayList,LinkedList和Vector的取值的方式的測試：

對於ArrayList的取值方式的測試：

package com.test.collections.list;

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

/**
 * 
 * ArrayList測試類
 * @author work
 *
 */
public class TestArraryList{
	
	private static ArrayList<String> strs = new ArrayList<String>();
	/**
	 * 賦值操做
	 * @param arrays 數組
	 */
	private static void setValue(String[] arrays){
		strs.toArray(arrays);
	}
	
	/**
	 * 賦值操做
	 */
	private static void setValue(){
		for(int i=0; i<10000000; i++){
			strs.add("strs"+i);
		}
	}
	
	private static void iterValue(){
		long start = System.currentTimeMillis();
		for (Iterator<String> iterator = strs.iterator(); iterator.hasNext();) {
			String str = (String) iterator.next();
			//System.out.println(" iterator value "+ str);
		}
		long end = System.currentTimeMillis();
		System.out.println(" ArrayList iterValue 耗時 ：" + (end-start));
	}
	
	private static void forValue(){
		long start = System.currentTimeMillis();
		for (int i = 0; i < strs.size(); i++) {
			strs.get(i);
		}
		long end = System.currentTimeMillis();
		System.out.println(" ArrayList forValue 耗時 ：" + (end-start));
	}

	public static void main(String[] args){
		setValue();
		iterValue();
		forValue();
		
	}
	

}

運行結果以下：

 ArrayList iterValue 耗時 ：50

 ArrayList forValue 耗時 ：3

在使用iterator的方式獲取值時明顯比原始的for循環要慢，是應爲ArrayList是List基於數組的實現，而數組經過下標來獲取數據是最快的方式。

再看LinkedList的例子：

package com.test.collections.list;

import java.util.Iterator;
import java.util.LinkedList;

public class TestLinkedList {
	
	private static LinkedList<String> strings = new LinkedList<String>();
	
	/**
	 * 賦值
	 */
	private static void setValue(){
		for(int i=0; i<100000; i++){
			strings.add("str"+i);
		}
	}
	
	/**
	 * 經過數組賦值
	 * @param strs
	 */
	private static void setArrayValue(String[] strs){
		strings.toArray(strs);
	}
	
	private static void iterValue(){
		long start = System.currentTimeMillis();
		for (Iterator<String> iterator = strings.iterator(); iterator.hasNext();) {
			String str = (String) iterator.next();
			//System.out.println(" iterator value "+ str);
		}
		long end = System.currentTimeMillis();
		System.out.println(" linkedList iterValue 耗時 ：" + (end-start));
	}
	
	private static void forValue(){
		long start = System.currentTimeMillis();
		for (int i = 0; i < strings.size(); i++) {
			strings.get(i);
		}
		long end = System.currentTimeMillis();
		System.out.println(" linkedList forValue 耗時 ：" + (end-start));
	}

	public static void main(String[] args) {
		//String[] val = new String[]{"dddd","dddss","ssss","ggg","eee"};
		//setArrayValue(val);
		setValue();
		iterValue();
		forValue();
	}

}

注：在使用LinkedList的時候集合元素個數剛開始也是設置的10000000，可是運行過程當中，使用原始for循環的時候，直接內存溢出了，所以元素個數修改成100000；

運行結果以下：

 linkedList iterValue 耗時 ：6

 linkedList forValue 耗時 ：11982

在使用iterator是很是的快，而使用原始for循環的時候，性能太差了，究其緣由：LinkedList是基於雙向鏈表的實現，在鏈表中使用指針比使用下標獲取數據要快不少；

再看Vector的測試：

package com.test.collections.list;

import java.util.Iterator;
import java.util.Vector;

public class TestVector {
	
	private static Vector<String> strings = new Vector<String>();
	
	/**
	 * 賦值
	 * @param arrays
	 */
	private static void setValue(String[] arrays){
		strings.toArray(arrays);
	}
	
	/**
	 * 賦值
	 */
	private static void setValue(){
		for(int i=0; i<10000000; i++){
			strings.add("str"+i);
		}
	}
	
	private static void iterValue(){
		long start = System.currentTimeMillis();
		for (Iterator<String> iterator = strings.iterator(); iterator.hasNext();) {
			String str = (String) iterator.next();
			//System.out.println(" iterator value "+ str);
		}
		long end = System.currentTimeMillis();
		System.out.println(" Vector iterValue 耗時 ：" + (end-start));
	}
	
	private static void forValue(){
		long start = System.currentTimeMillis();
		for (int i = 0; i < strings.size(); i++) {
			strings.get(i);
		}
		long end = System.currentTimeMillis();
		System.out.println(" Vector forValue 耗時 ：" + (end-start));
	}

	
	
	public static void main(String[] args) {
		setValue();
		iterValue();
		forValue();
	}

}

運行結果以下：

元素個數設置爲10000000的結果：

 Vector iterValue 耗時 ：226

 Vector forValue 耗時 ：438

元素個數設置爲100000的結果：

 Vector iterValue 耗時 ：7

 Vector forValue 耗時 ：5

首先Vector也是List基於數組的實現，和ArrayList不一樣的是，Vector是一個線程安全的可變數組；

結果代表：在獲取Vector的元素的時候，在結果1中，iterator的方式比原始for循環的方式要快不少，在結果2中則原始for循環比iterator的方式快，在線程安全的環境中，若是數據量過大的時候，使用iterator的方式要比使用原始for循環的方式效果好不少；

ArrayList和Vector的結果比較，在數據量相同的狀況下，無論是何種方式，線程安全的要比線程不安全的慢不少，

所以：若是不是多線程環境，不要去使用Vector，使用ArrayList或者LinkedList比較合適，若是是基於鏈表的實現則使用iterator的方式比較好，若是是基於數組的實現則使用原始的for循環比較好。