3722人阅读
java（27）
package com.
import java.util.ArrayL
import java.util.I
import java.util.L
public class ArrayListDemo {
&&& public static void main(String args[]){
&&&&&&& List&String& list = new ArrayList&String&();
&&&&&&& list.add(&luojiahui&);
&&&&&&& list.add(&luojiafeng&);
&&&&&&& //方法1
&&&&&&& Iterator it1 = list.iterator();
&&&&&&& while(it1.hasNext()){
&&&&&&&&&&& System.out.println(it1.next());
&&&&&&& //方法2
&&&&&&& for(Iterator it2 = list.iterator();it2.hasNext();){
&&&&&&&&&&&& System.out.println(it2.next());
&&&&&&& //方法3
&&&&&&& for(String tmp:list){
&&&&&&&&&&& System.out.println(tmp);
&&&&&&& //方法4
&&&&&&& for(int i = 0;i & list.size(); i ++){
&&&&&&&&&&& System.out.println(list.get(i));
1、什么是ArrayList&
ArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了如下一些好处：&
动态的增加和减少元素&
实现了ICollection和IList接口&
灵活的设置数组的大小
2、如何使用ArrayList&
最简单的例子：&
ArrayList List = new ArrayList();&
for( int i=0;i &10;i++ ) //给数组增加10个Int元素&
List.Add(i);&
//..程序做一些处理&
List.RemoveAt(5);//将第6个元素移除&
for( int i=0;i &3;i++ ) //再增加3个元素&
List.Add(i+20);&
Int32[] values = (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的数组
这是一个简单的例子，虽然没有包含ArrayList所有的方法，但是可以反映出ArrayList最常用的用法
3、ArrayList重要的方法和属性&
1）构造器&
ArrayList提供了三个构造器：&
public ArrayList();&
默认的构造器，将会以默认（16）的大小来初始化内部的数组&
public ArrayList(ICollection);&
用一个ICollection对象来构造，并将该集合的元素添加到ArrayList&
public ArrayList(int);&
用指定的大小来初始化内部的数组
2）IsSynchronized属性和ArrayList.Synchronized方法&
IsSynchronized属性指示当前的ArrayList实例是否支持线程同步，而ArrayList.Synchronized静态方法则会返回一个ArrayList的线程同步的封装。&
如果使用非线程同步的实例，那么在多线程访问的时候，需要自己手动调用lock来保持线程同步，例如：&
ArrayList list = new ArrayList();&
lock( list.SyncRoot ) //当ArrayList为非线程包装的时候，SyncRoot属性其实就是它自己，但是为了满足ICollection的SyncRoot定义，这里还是使用SyncRoot来保持源代码的规范性&
list.Add( “Add a Item” );&
如果使用ArrayList.Synchronized方法返回的实例，那么就不用考虑线程同步的问题，这个实例本身就是线程安全的，实际上 ArrayList内部实现了一个保证线程同步的内部类，ArrayList.Synchronized返回的就是这个类的实例，它里面的每个属性都是用 了lock关键字来保证线程同步。
3）Count属性和Capacity属性&
Count属性是目前ArrayList包含的元素的数量，这个属性是只读的。&
Capacity属性是目前ArrayList能够包含的最大数量，可以手动的设置这个属性，但是当设置为小于Count值的时候会引发一个异常。
4）Add、AddRange、Remove、RemoveAt、RemoveRange、Insert、InsertRange&
这几个方法比较类似&
Add方法用于添加一个元素到当前列表的末尾&
AddRange方法用于添加一批元素到当前列表的末尾&
Remove方法用于删除一个元素，通过元素本身的引用来删除&
RemoveAt方法用于删除一个元素，通过索引值来删除&
RemoveRange用于删除一批元素，通过指定开始的索引和删除的数量来删除&
Insert用于添加一个元素到指定位置，列表后面的元素依次往后移动&
InsertRange用于从指定位置开始添加一批元素，列表后面的元素依次往后移动
另外，还有几个类似的方法：&
Clear方法用于清除现有所有的元素&
Contains方法用来查找某个对象在不在列表之中
其他的我就不一一累赘了，大家可以查看MSDN，上面讲的更仔细&
5）TrimSize方法&
这个方法用于将ArrayList固定到实际元素的大小，当动态数组元素确定不在添加的时候，可以调用这个方法来释放空余的内存。&
6）ToArray方法&
这个方法把ArrayList的元素Copy到一个新的数组中。&
4、ArrayList与数组转换&
ArrayList List = new ArrayList();&
List.Add(1);&
List.Add(2);&
List.Add(3);
Int32[] values = (Int32[])List.ToArray(typeof(Int32));
ArrayList List = new ArrayList();&
List.Add(1);&
List.Add(2);&
List.Add(3);
Int32[] values = new Int32[List.Count];&
List.CopyTo(values);
上面介绍了两种从ArrayList转换到数组的方法
ArrayList List = new ArrayList();&
List.Add( “string” );&
List.Add( 1 );&
//往数组中添加不同类型的元素
object[] values = List.ToArray(typeof(object)); //正确&
string[] values = (string[])List.ToArray(typeof(string)); //错误
和数组不一样，因为可以转换为Object数组，所以往ArrayList里面添加不同类型的元素是不会出错的，但是当调用ArrayList方法的时候，要么传递所有元素都可以正确转型的类型或者Object类型，否则将会抛出无法转型的异常。
5、ArrayList最佳使用建议&
这一节我们来讨论ArrayList与数组的差别，以及ArrayList的效率问题&
1）ArrayList是Array的复杂版本&
ArrayList内部封装了一个Object类型的数组，从一般的意义来说，它和数组没有本质的差别，甚
定到实际元素的大小，当动态数组元素确定不在添加的时候，可以调用这个方法来释放空余的内存。&
6）ToArray方法&
这个方法把ArrayList的元素Copy到一个新的数组中。&
4、ArrayList与数组转换&
ArrayList List = new ArrayList();&
List.Add(1);&
List.Add(2);&
List.Add(3);
Int32[] values = (Int32[])List.ToArray(typeof(Int32));
ArrayList List = new ArrayList();&
List.Add(1);&
List.Add(2);&
List.Add(3);
Int32[] values = new Int32[List.Count];&
List.CopyTo(values);
上面介绍了两种从ArrayList转换到数组的方法
ArrayList List = new ArrayList();&
List.Add( “string” );&
List.Add( 1 );&
//往数组中添加不同类型的元素
object[] values = List.ToArray(typeof(object)); //正确&
string[] values = (string[])List.ToArray(typeof(string)); //错误
和数组不一样，因为可以转换为Object数组，所以往ArrayList里面添加不同类型的元素是不会出错的，但是当调用ArrayList方法的时候，要么传递所有元素都可以正确转型的类型或者Object类型，否则将会抛出无法转型的异常。
5、ArrayList最佳使用建议&
这一节我们来讨论ArrayList与数组的差别，以及ArrayList的效率问题&
1）ArrayList是Array的复杂版本&
ArrayList内部封装了一个Object类型的数组，从一般的意义来说，它和数组没有本质的差别，甚至于ArrayList的许多方法，如Index、IndexOf、Contains、Sort等都是在内部数组的基础上直接调用Array的对应方法。&
2）内部的Object类型的影响&
对于一般的引用类型来说，这部分的影响不是很大，但是对于值类型来说，往ArrayList里面添加和修改元素，都会引起装箱和拆箱的操作，频繁的操作可能会影响一部分效率。&
但是恰恰对于大多数人，多数的应用都是使用值类型的数组。&
消除这个影响是没有办法的，除非你不用它，否则就要承担一部分的效率损失，不过这部分的损失不会很大。&
3）数组扩容&
这是对ArrayList效率影响比较大的一个因素。&
每 当执行Add、AddRange、Insert、InsertRange等添加元素的方法，都会检查内部数组的容量是否不够了，如果是，它就会以当前容量 的两倍来重新构建一个数组，将旧元素Copy到新数组中，然后丢弃旧数组，在这个临界点的扩容操作，应该来说是比较影响效率的。&
例1：比如，一个可能有200个元素的数据动态添加到一个以默认16个元素大小创建的ArrayList中，将会经过：&
16*2*2*2*2 = 256&
四次的扩容才会满足最终的要求，那么如果一开始就以：&
ArrayList List = new ArrayList( 210 );&
的方式创建ArrayList，不仅会减少4次数组创建和Copy的操作，还会减少内存使用。
例2：预计有30个元素而创建了一个ArrayList：&
ArrayList List = new ArrayList(30);&
在执行过程中，加入了31个元素，那么数组会扩充到60个元素的大小，而这时候不会有新的元素再增加进来，而且有没有调用TrimSize方法，那么就有1次扩容的操作，并且浪费了29个元素大小的空间。如果这时候，用：&
ArrayList List = new ArrayList(40);&
那么一切都解决了。&
所以说，正确的预估可能的元素，并且在适当的时候调用TrimSize方法是提高ArrayList使用效率的重要途径。&
4）频繁的调用IndexOf、Contains等方法（Sort、BinarySearch等方
法经过优化，不在此列）引起的效率损失&
首先，我们要明确一点，ArrayList是动态数组，它不包括通过Key或者Value快速访问 的算法，所以实际上调用IndexOf、Contains等方法是执行的简单的循环来查找元素，所以频繁的调用此类方法并不比你自己写循环并且稍作优化来 的快，如果有这方面的要求，建议使用Hashtable或SortedList等键值对的集合。&
ArrayList al=new ArrayList();
al.Add(&How&);&
al.Add(&are&);&
al.Add(&you!&);
al.Add(100);&
al.Add(200);&
al.Add(300);
al.Add(1.2);&
al.Add(22.8);
Java&List遍历方法&及其效率对比
Java List遍历方法&及其效率对比
Java代码&&
1.&package&com.zbalpha.&&
2.&import&java.util.ArrayL&&
3.&import&java.util.I&&
4.&import&java.util.L&&
6.&public&class&ListTest&{&&
7.&&&&&public&static&void&main(String&args[]){&&
8.&&&&&&&&&List&lists&=&new&ArrayList();&&
10.&&&&&&&&for(Long&i=0l;i&1000000l;i++){&&
11.&&&&&&&&&&&&lists.add(i);&&
12.&&&&&&&&}&&&&
13.&&&&&&&&&&
14.&&&&&&&&Long&oneOk&=&oneMethod(lists);&&
15.&&&&&&&&Long&twoOk&=&twoMethod(lists);&&
16.&&&&&&&&Long&threeOk&=&threeMethod(lists);&&
17.&&&&&&&&Long&fourOk&=&fourMethod(lists);&&
18.&&&&&&&&&&
19.&&&&&&&&System.out.println(&One:&&+&oneOk);&&
20.&&&&&&&&System.out.println(&Two:&&+&twoOk);&&
21.&&&&&&&&System.out.println(&Three:&&+&threeOk);&&
22.&&&&&&&&System.out.println(&four:&&+&fourOk);&&
23.&&&&&&&&&&
24.&&&&}&&
25.&//&&第一种方式，遍历时，内部不锁定,&效率最高,&但是当写多线程时要考虑并发操作的问题。
26.&&&&public&static&Long&oneMethod(List&lists){&&
27.&&&&&&&&&&
28.&&&&&&&&Long&timeStart&=&System.currentTimeMillis();&&
29.&&&&&&&&for(int&i=0;i
30.&&&&&&&&&&&&System.out.println(lists.get(i));&&
31.&&&&&&&&}&&
32.&&&&&&&&Long&timeStop&=&System.currentTimeMillis();&&
34.&&&&&&&&return&timeStop&-timeStart&;&&
35.&&&&}&&
36.&&&&&&//第二种方式，内部调用第四种,&换汤不换药,&&因此比Iterator&慢,这种循环方式还有其他限制,&不建议使用它。
37.&&&&&&&&&public&static&Long&twoMethod(List&lists){&&
38.&&&&&&&&&&
39.&&&&&&&&Long&timeStart&=&System.currentTimeMillis();&&
40.&&&&&&&&for(Long&string&:&lists)&&&&{&&
41.&&&&&&&&&&&&System.out.println(string);&&
42.&&&&&&&&}&&
43.&&&&&&&&Long&timeStop&=&System.currentTimeMillis();&&
45.&&&&&&&&return&timeStop&-timeStart&;&&
46.&&&&}&&
47.&&&&public&static&Long&threeMethod(List&lists){&&
48.&&&&&&&&&&
49.&&&&&&&&Long&timeStart&=&System.currentTimeMillis();&&
50.&&&&&&&&Iterator&it&=&lists.iterator();&&
51.&&&&&&&&while&(it.hasNext())&&
52.&&&&&&&&{&&
53.&&&&&&&&&&&&&&&&System.out.println(it.next());&&
54.&&&&&&&&}&&
55.&&&&&&&&Long&timeStop&=&System.currentTimeMillis();&&
57.&&&&&&&&return&timeStop&-timeStart&;&&
58.&&&&}&&&&&&
60.&&&&&&&&&&
61.&&&//第四种方式在循环执行过程中会进行数据锁定,&性能稍差,&同时,如果你想在寻找过程中去掉某个元素,只能调用it.remove方法,&不能使用list.remove方法,&否则一定出现并发访问的错误.
63.&&&&public&static&Long&fourMethod(List&lists){&&
64.&&&&&&&&&&
65.&&&&&&&&Long&timeStart&=&System.currentTimeMillis();&&
66.&&&&&&&&for(Iterator&i&=&lists.iterator();&i.hasNext();)&&&&{&&
67.&&&&&&&&&&&&System.out.println(i.next());&&
68.&&&&&&&&}&&
69.&&&&&&&&Long&timeStop&=&System.currentTimeMillis();&&
71.&&&&&&&&return&timeStop&-timeStart&;&&
72.&&&&}&&&&&&
容器类可以大大提高编程效率和编程能力，在Java2中，所有的容器都由SUN公司的JoshuaBloch进行了重新设计，丰富了容器类库的功能。&Java2容器类类库的用途是“保存对象”，它分为两类：&Collection----一组独立的元素，通常这些元素都服从某种规则。List必须保持元素特定的顺序，而Set不能有重复元素。&Map----一组成对的“键值对”对象，即其元素是成对的对象，最典型的应用就是数据字典，并且还有其它广泛的应用。另外，Map可以返回其所有键组成的Set和其所有值组成的Collection，或其键值对组成的Set，并且还可以像数组一样扩展多维Map，只要让Map中键值对的每个“值”是一个Map即可。&1.迭代器&　　迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。&Java中的Iterator功能比较简单，并且只能单向移动：&(1)使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。&(2)使用next()获得序列中的下一个元素。&(3)使用hasNext()检查序列中是否还有元素。&(4)使用remove()将迭代器新返回的元素删除。&Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。&2.List的功能方法&List(interface):次序是List最重要的特点；它确保维护元素特定的顺序。List为Collection添加了许多方法，使得能够向List中间插入与移除元素(只推荐LinkedList使用)。一个List可以生成ListIterator，使用它可以从两个方向遍历List，也可以从List中间插入和删除元素。&ArrayList:由数组实现的List。它允许对元素进行快速随机访问，但是向List中间插入与移除元素的速度很慢。ListIterator只应该用来由后向前遍历ArrayList，而不是用来插入和删除元素，因为这比LinkedList开销要大很多。&LinkedList:对顺序访问进行了优化，向List中间插入与删除得开销不大，随机访问则相对较慢(可用ArrayList代替)。它具有方法addFirst()、addLast()、getFirst()、getLast()、removeFirst()、removeLast()，这些方法(没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。&3.Set的功能方法&Set(interface):存入Set的每个元素必须是唯一的，因为Set不保存重复元素。加入Set的Object必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。&HashSet:为快速查找而设计的Set。存入HashSet的对象必须定义hashCode()。&TreeSet:保持次序的Set，底层为树结构。使用它可以从Set中提取有序的序列。&LinkedHashSet:具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。&HashSet采用散列函数对元素进行排序，这是专门为快速查询而设计的；TreeSet采用红黑树的数据结构进行排序元素；LinkedHashSet内部使用散列以加快查询速度，同时使用链表维护元素的次序，使得看起来元素是以插入的顺序保存的。需要注意的是，生成自己的类时，Set需要维护元素的存储顺序，因此要实现Comparable接口并定义compareTo()方法。&
转自：/blog/542875
http://blog.csdn.net/QH_JAVA/article/details/
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：310088次
积分：3144
积分：3144
排名：第10109名
转载：91篇
评论：14条
(3)(11)(1)(3)(4)(2)(1)(1)(2)(1)(7)(1)(1)(1)(1)(1)(3)(15)(1)(3)(7)(23)(4)(1)(2)匿名用户不能发表回复！|
每天回帖即可获得10分可用分！小技巧：
你还可以输入10000个字符
(Ctrl+Enter)
请遵守CSDN，不得违反国家法律法规。
转载文章请注明出自“CSDN（www.csdn.net）”。如是商业用途请联系原作者。　　.Net 框架提供了两种List类型，一种是基于链表的LinkedList, 一种是基于数组的List。那么在实际应用中到底采用哪种List，如何取舍呢？本文对两种类型在队列，堆栈和简单插入三种简单算法中的效率进行了一个比较。　　首先先让我们来看一下List的初始容量Capacity对List的性能是否有影响。　　测试方法：分别设置初始容量为0，64，255，1024. List插入的最大长度为1000，循环1000次，得到如下结果，单位为ms，下同。算法/初始容量队列堆栈简单插入 　　从上面数据中我们可以看出List的初始容量对效率没有明显影响。　　队列算法比较　　测试方法：对LinkedList和List采用先进先出的队列算法，分别设置队列最大长度为10，30，50，100，，并循环1000次，得到如下结果。List类型/队列最大长度010000LinkedList0..691List0..16 　　从测试结果中我们可以看出LinkedList 随着最大队列长度的增加，所用时间基本成线性增长。而List则成指数增长。我分析主要原因应该是每次删除List的数组头时，List都要做一次整个数数组的拷贝，而链表类型则不存在这个问题。有趣的是当队列长度小于30时，List的效率要比LinkedList要高，这主要是因为链表在增删时需要额外创建链表指针，而数组不需要这个操作。在队列长度较小时，这种开销就会显得很明显。　　堆栈算法比较　　测试方法：对LinkedList和List采用先进后出的堆栈算法，分别设置队列最大长度为10，30，50，100，，并循环1000次，得到如下结果。List类型/堆栈最大长度010000LinkedList0..714List0..284　　从测试结果看两种类型都是线性增长，但List的性能更高一些。我分析这主要是因为List类型在增长到最大值后在从尾部删除元素，其并不重新分配内存，除非你强行让它压缩。所以List从尾部删除只是将Count改变了一下，因此效率很高。而链表类型的效率和队列方式基本相当，这也是在预料之中的，其效率比List低的原因主要还是在增删时创建和删除节点的额外开销。　　简单插入算法比较　　测试方法：对LinkedList和List采用向后追加若干元素的算法，分别设置插入最大长度为10，30，50，100，，并循环1000次，得到如下结果。List类型/插入最大长度010000LinkedList0..35List0..109 　　其测试结果和堆栈算法基本类似，且List的效率更高，这里不再重复论述。　　总结　　如果采用队列算法建议采用LinkedList类型，除非队列长度小于30.　　如果采用堆栈或简单插入算法，建议采用List类型。但有一点需要说明，如果应用对内存占用有限制，建议采用LinkedList类型。　　测试　　class Program
　　　　const int TEST_TIMES = 1000;
　　　　static private void TestQueue(int count)
　　　　　　TestQueue(count, 0);
　　　　static private void TestQueue(int count, int capacity)
　　　　　　Console.WriteLine(&Count:& + count.ToString());
　　　　　　LinkedList&int& linkList = new LinkedList&int&();
　　　　　　List&int& list = new List&int&(capacity);
　　　　　　Stopwatch watch = new Stopwatch();
　　　　　　watch.Start();
　　　　　　 (int i = 0; i & TEST_TIMES; i++)
　　　　　　{
　　　　　　　　 (int j = 0; j & j++)
　　　　　　　　{
　　　　　　　　　　linkList.AddLast(j);
　　　　　　　　}
　　　　　　　　for (int j = 0; j & j++)
　　　　　　　　{
　　　　　　　　　　int test = linkList.First.V
　　　　　　　　　　linkList.RemoveFirst();
　　　　　　　　}
　　　　　　}
　　　　　　watch.Stop();
　　　　　　S
　　　　　　if (watch.ElapsedMilliseconds & 10)
　　　　　　{
　　　　　　　　duration = (((double)watch.ElapsedTicks) / 10000).ToString() + &ms&;
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　duration = watch.ElapsedMilliseconds.ToString() + &ms&;
　　　　　　}
　　　　　　Console.WriteLine(&LinkedList:& + duration);
　　　　　　watch.Reset();
　　　　　　watch.Start();
　　　　　　for (int i = 0; i & TEST_TIMES; i++)
　　　　　　{
　　　　　　　　for (int j = 0; j & j++)
　　　　　　　　{
　　　　　　　　　　list.Add(j);
　　　　　　　　}
　　　　　　　　for (int j = 0; j & j++)
　　　　　　　　{
　　　　　　　　　　int test = list[0];
　　　　　　　　　　list.RemoveAt(0);
　　　　　　　　}
　　　　　　}
　　　　　　if (watch.ElapsedMilliseconds & 10)
　　　　　　{
　　　　　　　　duration = (((double)watch.ElapsedTicks) / 10000).ToString() + &ms&;
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　duration = watch.ElapsedMilliseconds.ToString() + &ms&;
　　　　　　}
　　　　　　Console.WriteLine(&List:& + duration);
　　　　static private void TestStack(int count)
　　　　　　TestStack(count, 0);
　　　　static private void TestStack(int count, int capacity)
　　　　　　Console.WriteLine(&Count:& + count.ToString());
　　　　　　LinkedList&int& linkList = new LinkedList&int&();
　　　　　　List&int& list = new List&int&(capacity);
　　　　　　Stopwatch watch = new Stopwatch();
　　　　　　watch.Start();
　　　　　　for (int i = 0; i & TEST_TIMES; i++)
　　　　　　{
　　　　　　　　for (int j = 0; j & j++)
　　　　　　　　{
　　　　　　　　　　linkList.AddLast(j);
　　　　　　　　}
　　　　　　　　for (int j = 0; j & j++)
　　　　　　　　{
　　　　　　　　　　int test = linkList.Last.V
　　　　　　　　　　linkList.RemoveLast();
　　　　　　　　}
　　　　　　}
　　　　　　watch.Stop();
　　　　　　S
　　　　　　if (watch.ElapsedMilliseconds & 10)
　　　　　　{
　　　　　　　　duration = (((double)watch.ElapsedTicks) / 10000).ToString() + &ms&;
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　duration = watch.ElapsedMilliseconds.ToString() + &ms&;
　　　　　　}
　　　　　　Console.WriteLine(&LinkedList:& + duration);
　　　　　　watch.Reset();
　　　　　　watch.Start();
　　　　　　for (int i = 0; i & TEST_TIMES; i++)
　　　　　　{
　　　　　　　　for (int j = 0; j & j++)
　　　　　　　　{
　　　　　　　　　　list.Add(j);
　　　　　　　　}
　　　　　　　　for (int j = 0; j & j++)
　　　　　　　　{
　　　　　　　　　　int test = list[list.Count-1];
　　　　　　　　　　list.RemoveAt(list.Count - 1);
　　　　　　　　}
　　　　　　}
　　　　　　if (watch.ElapsedMilliseconds & 10)
　　　　　　{
　　　　　　　　duration = (((double)watch.ElapsedTicks) / 10000).ToString() + &ms&;
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　duration = watch.ElapsedMilliseconds.ToString() + &ms&;
　　　　　　}
　　　　　　Console.WriteLine(&List:& + duration);
　　　　static private void TestInsert(int count)
　　　　　　TestInsert(count, 0);
　　　　static private void TestInsert(int count, int capacity)
　　　　　　Console.WriteLine(&Count:& + count.ToString());
　　　　　　LinkedList&int& linkList = new LinkedList&int&();
　　　　　　List&int& list = new List&int&(capacity);
　　　　　　Stopwatch watch = new Stopwatch();
　　　　　　watch.Start();
　　　　　　for (int i = 0; i & TEST_TIMES; i++)
　　　　　　{
　　　　　　　　for (int j = 0; j & j++)
　　　　　　　　{
　　　　　　　　　　linkList.AddLast(j);
　　　　　　　　}
　　　　　　　　linkList.Clear();
　　　　　　}
　　　　　　watch.Stop();
　　　　　　S
　　　　　　if (watch.ElapsedMilliseconds & 10)
　　　　　　{
　　　　　　　　duration = (((double)watch.ElapsedTicks) / 10000).ToString() + &ms&;
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　duration = watch.ElapsedMilliseconds.ToString() + &ms&;
　　　　　　}
　　　　　　Console.WriteLine(&LinkedList:& + duration);
　　　　　　watch.Reset();
　　　　　　watch.Start();
　　　　　　for (int i = 0; i & TEST_TIMES; i++)
　　　　　　{
　　　　　　　　for (int j = 0; j & j++)
　　　　　　　　{
　　　　　　　　　　list.Add(j);
　　　　　　　　}
　　　　　　　　list.Clear();
　　　　　　}
　　　　　　if (watch.ElapsedMilliseconds & 10)
　　　　　　{
　　　　　　　　duration = (((double)watch.ElapsedTicks) / 10000).ToString() + &ms&;
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　duration = watch.ElapsedMilliseconds.ToString() + &ms&;
　　　　　　}
　　　　　　Console.WriteLine(&List:& + duration);
　　　　static void Main(string[] args)
　　　　　　//capacity
　　　　　　TestQueue(10000, 0);
　　　　　　TestQueue(10000, 64);
　　　　　　TestQueue(1);
　　　　　　TestQueue(1);
　　　　　　TestStack(10000, 0);
　　　　　　TestStack(10000, 64);
　　　　　　TestStack(1);
　　　　　　TestStack(1);
　　　　　　TestInsert(10000, 0);
　　　　　　TestInsert(10000, 64);
　　　　　　TestInsert(1);
　　　　　　TestInsert(1);
　　　　　　//compare LinkedList and List
　　　　　　TestQueue(10);
　　　　　　TestQueue(30);
　　　　　　TestQueue(50);
　　　　　　TestQueue(100);
　　　　　　TestQueue(1000);
　　　　　　TestQueue(10000);
　　　　　　TestStack(10);
　　　　　　TestStack(30);
　　　　　　TestStack(50);
　　　　　　TestStack(100);
　　　　　　TestStack(1000);
　　　　　　TestStack(10000);
　　　　　　TestInsert(10);
　　　　　　TestInsert(30);
　　　　　　TestInsert(50);
　　　　　　TestInsert(100);
　　　　　　TestInsert(1000);
　　　　　　TestInsert(10000);
无相关信息