列表List

列表List

List:列表

  • 有序的Collection
  • 允许重复元素
  • {1,2,4,{5,2},1,3}

List主要实现

  • ArrayList(非同步的)
  • LinkedList(非同步)
  • Vector(同步)

ArrayList:

  • 以数组实现的列表,不支持同步
  • 利用索引位置可以快速定位访问
  • 不适合指定位置的插入,删除操作
  • 适合变动不大,主要用于查询的数据
  • 和Java数组相比,其容量是可动态调整的
  • ArrayList在元素填满容器时会自动扩充容器大小的50%
import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListTest {
	public static void main(String[] args) {
		ArrayList<Integer> al = new ArrayList<Integer>();
		
		al.add(3);
		al.add(2);
		al.add(1);
		al.add(4);
		al.add(5);
		al.add(6);
		al.add(new Integer(6));
		
		System.out.println("The third elements is " + al.get(3));
		al.remove(3);//删除第四个单元,后面元素往前挪动
		al.add(3,9);//将9插入第4个元素,后面元素往后挪动
		
		//遍历方法:
		ArrayList<Integer> as = new ArrayList<Integer>(100000);
		for (int i = 0; i < 100000; i++) {
			as.add(i);
		}
		traverseByIterator(as);
		traverseByIndex(as);
		traverseFor(as);
		
	}
	
	private static void traverseFor(ArrayList<Integer> al) {
		long startTime = System.nanoTime();
		System.out.println("for循环遍历:");
		for(Integer item : al) {
			;
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
	}

	private static void traverseByIndex(ArrayList<Integer> al) {
		long startTime = System.nanoTime();
		
		System.out.println("随机索引遍历:");
		for(int i = 0; i < al.size(); i++) {
			al.get(i);
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}

	public static void traverseByIterator(ArrayList<Integer> al) {
		long startTime = System.nanoTime();
		
		System.out.println("迭代器遍历:");
		Iterator<Integer> iter1 = al.iterator();
		while(iter1.hasNext()) {
			iter1.next();
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
	}
	
}
The third elements is 4
迭代器遍历:
27090200纳秒
随机索引遍历:
14441700纳秒
for循环遍历:
24612900纳秒

LinkedList:

  • 以双向链表实现的链表,不支持同步
  • 可被当作堆栈,队列和双端队列进行操作
  • 顺序访问高效,随机访问较差,中间插入和删除高效
  • 适用于经常变化的数据
import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListTest {

	public static void main(String[] args) {
		LinkedList<Integer> ll = new LinkedList<Integer>();
		ll.add(3);
		ll.add(2);
		ll.add(5);
		ll.add(6);
		ll.add(6);
		System.out.println(ll.size());
		ll.addFirst(9);//在头部添加9
		ll.add(3,10);//将10插入到第四个元素,4以及后续的元素往后挪动
		ll.remove(3);//将第4个元素删除
		
		LinkedList<Integer> list = new LinkedList<Integer>();
		for(int i = 0; i < 100000; i++) {
			list.add(i);
		}
		traverseByIterator(list);
		traverseByIndex(list);
		traverseFor(list);
	}

	private static void traverseFor(LinkedList<Integer> list) {
		long startTime = System.nanoTime();
		System.out.println("for循环遍历:");
		for(Integer item : list) {
			;
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}

	private static void traverseByIndex(LinkedList<Integer> list) {
		long startTime = System.nanoTime();
		
		System.out.println("随机索引遍历:");
		for(int i = 0; i < list.size(); i++) {
			list.get(i);
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}

	private static void traverseByIterator(LinkedList<Integer> list) {
		long startTime = System.nanoTime();
		
		System.out.println("迭代器遍历:");
		Iterator<Integer> iter1 = list.iterator();
		while(iter1.hasNext()) {
			iter1.next();
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}

}
长度:
5
迭代器遍历:
6611800纳秒
随机索引遍历:
5266442500纳秒
for循环遍历:
7116100纳秒

Vector(同步):

  • 和ArrayList类似,可变数组实现的列表
  • Vector同步,适合在多线程下使用
  • 原先不属于JCF框架,属于Java最早的数据结构,性能较差
  • 官方文档建议在非同步情况下,优先采用ArrayList
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;

public class VectorTest {

	public static void main(String[] args) {
		Vector<Integer> v = new Vector<Integer>();
		v.add(1);
		v.add(2);
		v.add(3);
		v.remove(2);
		v.add(1, 5);
		System.out.println("长度:" + v.size());
		
		System.out.println("遍历方法:");
		Vector<Integer> v2 = new Vector<Integer>(100000);
		for(int i = 0; i < 100000; i++) {
			v2.add(i);
		}
		traverseByIterator(v2);
		traverseByIndex(v2);
		traverseFor(v2);
		traverseBuEnumeration(v2);

	}

	private static void traverseBuEnumeration(Vector<Integer> v) {
		long startTime = System.nanoTime();
		System.out.println("Enumeration遍历:");
		for(Enumeration<Integer> enu = v.elements(); enu.hasMoreElements();) {
			enu.nextElement();
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}

	private static void traverseFor(Vector<Integer> v2) {
		long startTime = System.nanoTime();
		System.out.println("for循环遍历:");
		for(Integer item : v2) {
			;
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}

	private static void traverseByIndex(Vector<Integer> v2) {
		long startTime = System.nanoTime();
		
		System.out.println("随机索引遍历:");
		for(int i = 0; i < v2.size(); i++) {
			v2.get(i);
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}

	private static void traverseByIterator(Vector<Integer> v2) {
		long startTime = System.nanoTime();
		
		System.out.println("迭代器遍历:");
		Iterator<Integer> iter1 = v2.iterator();
		while(iter1.hasNext()) {
			iter1.next();
		}
		long endTime = System.nanoTime();
		long duration = endTime - startTime;
		System.out.println(duration + "纳秒");
		
	}

}
长度:3
遍历方法:
迭代器遍历:
20057900纳秒
随机索引遍历:
6838800纳秒
for循环遍历:
5963200纳秒
Enumeration遍历:
7932200纳秒

总结

  • ArrayList/LinkedList/Vector
  • 同步采用Vector
  • 非同步情况下,根据数据特点选取ArrayList/LinkedList
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值