05-集合框架区别以及性能测试

一、区别

这一块属于面试比较容易遇到的：

针对Collection下的集合的区别

Collection

|-List(接口)顺序是List最重要的特性他可以保证元素可以按照规定的顺序排列

|-ArrayList底层是有一个数组实现的允许对元素的快速访问，用来替换原来的Vector数组的缺点是元素之间不能有间隔，当数组大小不够时，就需要拓展其存储

能力，将现有的数组元素复制到新的存储空间因此在ArrayList中间位置插入数据或者删除数据的时候就涉及到了数组元素的复制、移动等相对消耗性

能的操作，因此通常情况下ArrayList用来对数据的遍历和查找，不适合插入和删除等操作。

|-LinkedList用链表结构存储数据，能快速的插入和删除但是不适合数据的遍历也提供了addFirst()，addLast()，getFirst()，getLast()，removeFirst()以及

removeLast()等方法也可以将LinkedList当作一个规格的队列或者双向队列使用提供push()pop()方法可当作堆栈使用

|-Vector底层是数组的实现不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的

　　　　　　　　　　花费，因此，访问它比访问ArrayList慢

--ListIterator专门为List结合提供的迭代器利用它可在一个列表里朝两个方向遍历，同时插入和删除位于列表中部的元素（同样地，只建议对LinkedList这样做）

|-Set(接口)添加到Set的每个元素都必须是独一无二的，否则Set就不会添加重复的元素

|-HashSet用于除非常小的以外的所有Set无序的集合

|-ArraySet由一个数组后推得到的Set。面向非常小的Set设计，特别是那些需要频繁创建和删除的。对于小Set，与HashSet相比，ArraySet创建和反复所需付

　　　　　　　　　　出的代价都要小得多。但随着Set的增大，它的性能也会大打折扣。

|-TreeSet由一个“红黑树”后推得到的顺序Set有序的集合

二、性能测试

工具类：

//:Collection1.java
//ThingsyoucandowithallCollections
packagec08.newcollections;

importjava.util.*;
publicclassCollection1{
//Fillwith'size'elements,start

//countingat'start':
publicstaticCollectionfill(Collectionc,intstart,intsize){
for(inti=start;i<start+size;i++)
c.add(Integer.toString(i));
returnc;
}

//Defaulttoa"start"of0:
publicstaticCollectionfill(Collectionc,intsize){
returnfill(c,0,size);
}

//Defaultto10elements:
publicstaticCollectionfill(Collectionc){
returnfill(c,0,10);
}

//Create&upcasttoCollection:
publicstaticCollectionnewCollection(){
returnfill(newArrayList());
//ArrayListisusedforsimplicity,butit's
//onlyseenasagenericCollection
//everywhereelseintheprogram.
}

//FillaCollectionwitharangeofvalues:
publicstaticCollectionnewCollection(intstart,intsize){
returnfill(newArrayList(),start,size);
}

//MovingthroughaListwithaniterator:
publicstaticvoidprint(Collectionc){
for(Iteratorx=c.iterator();x.hasNext();)
System.out.print(x.next()+"");
System.out.println();
}

}///:~

2.1List测试

//:ListPerformance.java
//DemonstratesperformancedifferencesinLists
packagec08.newcollections;

importjava.util.*;

publicclassListPerformance{
privatestaticfinalintREPS=100;

privateabstractstaticclassTester{
Stringname;
intsize;//Testquantity

Tester(Stringname,intsize){
this.name=name;
this.size=size;
}

abstractvoidtest(Lista);
}

privatestaticTester[]tests={newTester("get",300){
voidtest(Lista){
for(inti=0;i<REPS;i++){
for(intj=0;j<a.size();j++)
a.get(j);
}
}
},

newTester("iteration",300){
voidtest(Lista){
for(inti=0;i<REPS;i++){
Iteratorit=a.iterator();
while(it.hasNext())
it.next();
}
}
},newTester("insert",1000){
voidtest(Lista){
inthalf=a.size()/2;
Strings="test";
ListIteratorit=a.listIterator(half);
for(inti=0;i<size*10;i++)
it.add(s);
}
},newTester("remove",5000){
voidtest(Lista){
ListIteratorit=a.listIterator(3);
while(it.hasNext()){
it.next();
it.remove();
}
}
},};

publicstaticvoidtest(Lista){
//Atricktoprintouttheclassname:
System.out.println("Testing"+a.getClass().getName());
for(inti=0;i<tests.length;i++){
Collection1.fill(a,tests[i].size);
System.out.print(tests[i].name);
longt1=System.currentTimeMillis();
tests[i].test(a);
longt2=System.currentTimeMillis();
System.out.println(":"+(t2-t1));
}
}

publicstaticvoidmain(String[]args){
test(newArrayList());
test(newLinkedList());
}
}///:~

执行的结果：

Testingjava.util.ArrayList
get:4
iteration:5
insert:9
remove:91
Testingjava.util.LinkedList
get:13
iteration:5
insert:3
remove:6

2.2Set测试

//:SetPerformance.java
packagec08.newcollections;

importjava.util.*;

publicclassSetPerformance{
privatestaticfinalintREPS=200;

privateabstractstaticclassTester{
Stringname;

Tester(Stringname){
this.name=name;
}

abstractvoidtest(Sets,intsize);
}

privatestaticTester[]tests={newTester("add"){
voidtest(Sets,intsize){
for(inti=0;i<REPS;i++){
s.clear();
Collection1.fill(s,size);
}
}
},newTester("contains"){
voidtest(Sets,intsize){
for(inti=0;i<REPS;i++)
for(intj=0;j<size;j++)
s.contains(Integer.toString(j));
}
},newTester("iteration"){
voidtest(Sets,intsize){
for(inti=0;i<REPS*10;i++){
Iteratorit=s.iterator();
while(it.hasNext())
it.next();
}

}
},};

publicstaticvoidtest(Sets,intsize){
//Atricktoprintouttheclassname:
System.out.println("Testing"+s.getClass().getName()+"size"
+size);
Collection1.fill(s,size);
for(inti=0;i<tests.length;i++){
System.out.print(tests[i].name);
longt1=System.currentTimeMillis();
tests[i].test(s,size);
longt2=System.currentTimeMillis();
System.out.println(":"+((double)(t2-t1)/(double)size));
}
}

publicstaticvoidmain(String[]args){
//Small:
test(newTreeSet(),10);
test(newHashSet(),10);
//Medium:
test(newTreeSet(),100);
test(newHashSet(),100);
//Large:
test(newHashSet(),1000);
test(newTreeSet(),1000);
}
}///:~

执行的结果：

Testingjava.util.TreeSetsize10
add:0.8
contains:0.2
iteration:0.8
Testingjava.util.HashSetsize10
add:0.3
contains:0.1
iteration:0.7
Testingjava.util.TreeSetsize100
add:0.12
contains:0.06
iteration:0.07
Testingjava.util.HashSetsize100
add:0.06
contains:0.02
iteration:0.09
Testingjava.util.HashSetsize1000
add:0.031
contains:0.026
iteration:0.082
Testingjava.util.TreeSetsize1000
add:0.127
contains:0.077
iteration:0.083

contains随机访问add添加数据方面TreeSet不如HashSet数据量大的时候优先使用HashSet

2.3Map测试

//:MapPerformance.java
//DemonstratesperformancedifferencesinMaps
packagec08.newcollections;

importjava.util.*;

publicclassMapPerformance{
privatestaticfinalintREPS=200;

publicstaticMapfill(Mapm,intsize){
for(inti=0;i<size;i++){
Stringx=Integer.toString(i);
m.put(x,x);
}
returnm;
}

privateabstractstaticclassTester{
Stringname;

Tester(Stringname){
this.name=name;
}

abstractvoidtest(Mapm,intsize);
}

privatestaticTester[]tests={newTester("put"){
voidtest(Mapm,intsize){
for(inti=0;i<REPS;i++){
m.clear();
fill(m,size);
}
}
},newTester("get"){
voidtest(Mapm,intsize){
for(inti=0;i<REPS;i++)
for(intj=0;j<size;j++)
m.get(Integer.toString(j));
}
},newTester("iteration"){
voidtest(Mapm,intsize){
for(inti=0;i<REPS*10;i++){
Iteratorit=m.keySet().iterator();
while(it.hasNext())
it.next();
}
}
},};

publicstaticvoidtest(Mapm,intsize){
//Atricktoprintouttheclassname:
System.out.println("Testing"+m.getClass().getName()+"size"
+size);

fill(m,size);
for(inti=0;i<tests.length;i++){
System.out.print(tests[i].name);
longt1=System.currentTimeMillis();
tests[i].test(m,size);
longt2=System.currentTimeMillis();
System.out.println(":"+((double)(t2-t1)/(double)size));
}
}

publicstaticvoidmain(String[]args){
//Small:
test(newHashtable(),10);
test(newHashMap(),10);
test(newTreeMap(),10);
//Medium:
test(newHashtable(),100);
test(newHashMap(),100);
test(newTreeMap(),100);
//Large:
test(newHashMap(),1000);
test(newHashtable(),1000);
test(newTreeMap(),1000);
}
}///:~

执行结果：

Testingjava.util.Hashtablesize10
put:0.5
get:0.1
iteration:0.7
Testingjava.util.HashMapsize10
put:0.3
get:0.1
iteration:0.8
Testingjava.util.TreeMapsize10
put:0.6
get:0.1
iteration:0.5
Testingjava.util.Hashtablesize100
put:0.03
get:0.02
iteration:0.09
Testingjava.util.HashMapsize100
put:0.06
get:0.02
iteration:0.09
Testingjava.util.TreeMapsize100
put:0.08
get:0.05
iteration:0.07
Testingjava.util.HashMapsize1000
put:0.029
get:0.027
iteration:0.079
Testingjava.util.Hashtablesize1000
put:0.031
get:0.029
iteration:0.08
Testingjava.util.TreeMapsize1000
put:0.16
get:0.086
iteration:0.091

当我们使用Map时，首要的选择应该是HashMap。只有在极少数情况下才需要考虑其他方法

TreeMap提供了出色的put()以及遍历时间，但get()的性能并不佳