关于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循环比较好。