源码阅读计算,非泛型集合和泛型集合的一流详解

ArrayList ,List

ArrayList 和 List 都以不限量长度的集合类型 ,List比较ArrayList
就在那之中贯彻而言除了泛型本质没有太大分歧。可是为幸免装箱拆箱难点,尽恐怕选拔List

集合内部是由数组完毕,私下认可大小是4,但您使用无参构造函数构造实例时,内部数组大小是0,当你投入第二个成分时,才扩容为4,添欧成分时,若是发现内置数组大小不够,内置数组大小会扩大体积为原本的两倍,每2回扩大容积都会重新开发三个数组,拷贝旧数组的数额,假如您要给集合添加多量的要素却不为它早先化2个适当体积,频仍的内部存款和储蓄器开辟和剩下的数组拷贝会导致品质的损耗。

故而选拔时提议提供合适的体积。

C#非泛型集合和泛型集合的特等详解,

C# 泛型集合之非泛型集合类与泛型集合类的应和:

ArrayList对应List

HashTable对应Dictionary

Queue对应Queue

Stack对应Stack

SortedList对应SortedList

 

率先  : ArrayList(非泛型集合)  与List(泛型集合)

ArrayList 是数组的纷纷版本。ArrayList 类提供在大多数 Collections
类中提供但不在 Array 类中提供的有的效果:

1.Array 的体量是原则性的,而 ArrayList 的容积是基于必要活动扩大的。

2.ArrayList 提供丰盛、插入或移除某一限制成分的点子。在 Array
中,您不得不三遍得到或设置贰个要素的值。

3.采纳 Synchronized 方法可以很简单地创建 ArrayList 的同步版本。而 Array
将直接保持它直到用户完成协同停止。

4.ArrayList 提供将只读和一向大小包裹重回到聚集的点子。而 Array 不提供。

5.Array 提供 ArrayList 所不抱有的少数灵活性:

   a.能够安装 Array 的下限,但 ArrayList 的下限始终为零。

   b.Array 能够具备多少个维度,而 ArrayList 始终只是一维的。

   c.特定类型(不包蕴 Object)的 Array 的属性比 ArrayList 好,那是因为
ArrayList 的因素属于 Object
类型,所以在蕴藏或探寻值类型时平常发生装箱和废除装箱。

   d.须求二个数组的绝超过三分之一场地也能够代之以使用
ArrayList。它更易于使用,并且普通全部与 Object 类型的数组类似的习性。

6.Array 位居 System 命名空间中;ArrayList 位于 System.Collections
命名空间中。

ArrayList类对象方法:

1:Add()向数组中添加二个因素,
2:Remove()删除数组中的二个因素
3:(int i)删除数组中索引值为i的成分
4:Reverse()反转数组的要素
5:Sort()以从小到大的顺序排列数组的要素
6:Clone()复制二个数组

源码阅读计算,非泛型集合和泛型集合的一流详解。一:ArrayList:

ArrayList可以毫无钦命维数 可动态赋值  赋差别类型值

 

ArrayList arrayList1 = new ArrayList();
             arrayList1.
             arrayList1.Add("a");
             arrayList1.Add(1);
             arrayList1.Add("b");
             Response.Write(arrayList1[1]);

二:Array:

Array的容积是一定的 先钦点大小 在赋值

 

 Array arrayList2 = Array.CreateInstance(typeof(string), 6);
             arrayList2.SetValue("a", 0);
             arrayList2.SetValue("b", 1);
             Response.Write(arrayList2.GetValue(1));

List泛型集合:

泛型集合List<T>
  泛型最首要的使用便是集聚操作,使用泛型集合能够升高代码重用性,类型安全和更佳的属性。
  List<T>的用法和ArrayList相似,List<T>有更好的档次安全性,无须拆,装箱。
在泛型定义中,泛型类型参数“<T>”是必须钦点的,在那之中T是概念泛型类时的占位符,其并不是一系列型,仅表示某种只怕的花色。在概念时T会被选取的档次代替。泛型集合List<T>中只好有贰个参数类型,“<T>”中的T能够对聚集中的成分类型举办约束。

eg:
List<T>添加、删除、检索成分的形式和ArrayList相似,显然的特色是不必要像ArrayList那样装箱和拆箱。

List < Student > students = new List < Student > ();
   Student stu1 = new Student();
   stu1.Name = "陆小凤";
   stu1.Number = "0801";
   stu1.Score = 20;
   Student stu2 = new Student();
   stu2.Name = "西门吹雪";
   stu2.Number = "0802";
   stu2.Score = 23;
   students.Add(stu1);
   students.Add(stu2);
   Console.WriteLine("集合中的元素个数为{0}", students.Count);
   foreach (Student stu in students)
   {
    Console.WriteLine("/t{0}/t{1}/t{2}", stu.Name, stu.Number, stu.Score);
   }
   students.Remove(stu1);
   Console.WriteLine("集合中的元素个数为{0}", students.Count);
   Console.ReadLine();

List<T>和ArrayList的区别
     
List<T>和ArrayList的相同点:添欧成分、删除成分、通过索引访问元素方法同样。
  List<T>和ArrayList的区别点:
ArrayList能够添加任意档次成分;List<T>对拉长的因素具有类型约束;
ArratList添加时装箱,读取时拆箱;List<T>不要求装箱,拆箱操作;

//创建Person对象
   Person p1 = new Person("张三", 30);
   Person p2 = new Person("李四", 20);
   Person p3 = new Person("王五", 50);
   //创建类型为Person的对象集合
   List < Person > persons = new List < Person > ();
   //将Person对象放入集合
   persons.Add(p1);
   persons.Add(p2);
   persons.Add(p3);
   //输出第2个人的姓名
   Console.WriteLine(persons[1].Name);
   foreach (Person p in persons)
   {
    Console.WriteLine("/t{0}/t{1}", p.Name, p.Age);
   }

第② :HashTable(非泛型集合)对应Dictionary(泛型集合)

Hashtable 和 Dictionary <K, V> 类型

 1:单线程程序中推荐介绍应用 Dictionary, 有泛型优势, 且读取速度较快,
体积利用更丰盛.
 2:三十二线程程序中援引应用 Hashtable, 暗许的 Hashtable 允许单线程写入,
八线程读取, 对 Hashtable 进一步调用 Synchronized()
方法能够博得完全线程安全的类型. 而 Dictionary 非线程安全, 必须人为使用
lock 语句举行爱抚, 效用大减.
 3:Dictionary 有按插入顺序排列数据的天性 (注: 但当调用 Remove()
删除过节点后各样被打乱), 由此在急需反映顺序的境地中采用 Dictionary
能赢得肯定方便.

Hashtable 类和 Dictionary<(Of <(TKey, 电视机alue>)>) 泛型类达成IDictionary 接口

Dictionary<(Of <(TKey, 电视机alue>)>) 泛型类还达成IDictionary<(Of <(TKey, 电视alue>)>)
泛型接口。因而,这一个聚集中的每一种成分都是三个键/值对。

Dictionary<(Of <(TKey, 电视alue>)>) 类与 Hashtable
类的作用雷同
对于值类型,特定类型(不包含 Object)的 Dictionary<(Of <(TKey,
电视alue>)>) 的习性优越 Hashtable,那是因为 Hashtable 的要素属于
Object 类型,所以在仓储或探寻值类型时一般产生装箱和撤回装箱操作。

eg:

HashTable ht=new HashTable();//实现 IDictionary接口
ht.Add(1,"A");
 ht.Add(2,"B");
 ht.Add(3,"c");
 foreach(DictionaryEntry de in ht)//HashTable返回的是DictionaryEntry类型
 {
     de.Key;
     de.Value;
  }

Dictionary<int,string> myDictionary=new Dictionary<int,string>();//实现IDictionary接口,IDictionary<T key,T value>类
myDictionary.Add(1,"a");
 myDictionary.Add(2,"b");
 myDictionary.Add(3,"c");
 foreach(int i in myDictionary.Keys)
{
   Console.WriteLine("Key="+i+"Value="+myDictionary);
 }
 Or
 foreach(KeyValuePair<string, double> temp in myDictionary)//返回的是KeyValuePair<string, double>泛型数组
  {
        temp.Key;
        temp.Value;
   }

一:HashTable:

1.HashTable是一种散列表,他里面维护广大对Key-Value键值对,其还有叁个看似索引的值叫做散列值(HashCode),它是遵照GetHashCode方法对Key通过自然算法获取得到的,全数的搜寻操作定位操作都是根据散列值来落到实处找到呼应的Key和Value值的。

2.我们要求运用叁个算法让散列值对应HashTable的长空地址尽量不重复,那便是散列函数(GetHashCode)需求做的事。

3.当一个HashTable被挤占大多数的时候大家因此测算散列值取得的地方值恐怕会再也指向同一地址,那便是哈希冲突。

4.在.Net中键值对在HashTable中的地点Position= (HashCode& 0x7FFFFFFF) %
HashTable.Length,.net中是因此探测法消除哈希争辩的,当通过散列值取得的职位Postion以及被占用的时候,就会增多2个位移x值判断下多个地点Postion+x是还是不是被占用,就算仍旧被挤占就三番6遍往下位移x判断Position+2*x地方是不是被占用,要是没有被占据则将值放入当中。当HashTable中的可用空间特别小时,则获得得到可用空间的难度越来越大,消耗的时间就越多。

5..脚下HashTable中的被占用空间达到2个比例的时候就将该空间活动扩大体积,在.net中那些比例是72%,也叫.net中HashTable的填充因子为0.72。例如有1个HashTable的空间尺寸是100,当它须求加上第7十七个值的时候将会扩容此HashTable.

6.那一个自动扩大体积的分寸是稍微呢?答案是时下空间大小的两倍最相仿的素数,例如当前HashTable所占空间为素数71,借使扩容,则扩大体量大小为素数131.

美高梅开户网址 1

二:Dictionary

1.Dictionary是一种变种的HashTable,它接纳一种分离链接散列表的数据结构来缓解哈希抵触的难题。

2.分离链接散列表是当散列到同三个地点的值存为贰个链表中。

3.这些变种HashTable的填写因子是1

美高梅开户网址 2

eg:本文将以代码的款型探索HashTable和Dictionary的插入和二种读取格局的频率(for/foreach/GetEnumerator)

public class HashTableTest

    {

        static Hashtable _Hashtable;

        static Dictionary<string, object> _Dictionary;

        static void Main()

        {

            Compare(10);

            Compare(10000);

            Compare(5000000);

            Console.ReadLine();

        }

        public static void Compare(int dataCount)

        {

            Console.WriteLine("-------------------------------------------------\n");

            _Hashtable = new Hashtable();

            _Dictionary = new Dictionary<string, object>();

            Stopwatch stopWatch = new Stopwatch();

            //HashTable插入dataCount条数据需要时间

            stopWatch.Start();

            for (int i = 0; i < dataCount; i++)

            {

                _Hashtable.Add("Str" + i.ToString(), "Value");

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable插入" + dataCount + "条数据需要时间:" + stopWatch.Elapsed);



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            stopWatch.Start();

            for (int i = 0; i < dataCount; i++)

            {

                _Dictionary.Add("Str" + i.ToString(), "Value");

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary插入" + dataCount + "条数据需要时间:" + stopWatch.Elapsed);



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            int si = 0;

            stopWatch.Start();

            for(int i=0;i<_Hashtable.Count;i++)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable遍历时间:" + stopWatch.Elapsed + " ,遍历采用for方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            foreach (var s in _Hashtable)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable遍历时间:" + stopWatch.Elapsed + " ,遍历采用foreach方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            IDictionaryEnumerator _hashEnum = _Hashtable.GetEnumerator();

            while (_hashEnum.MoveNext())

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable遍历时间:" + stopWatch.Elapsed + " ,遍历采用HashTable.GetEnumerator()方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            for(int i=0;i<_Dictionary.Count;i++)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary遍历时间:" + stopWatch.Elapsed + " ,遍历采用for方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            foreach (var s in _Dictionary)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary遍历时间:" + stopWatch.Elapsed + " ,遍历采用foreach方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            _hashEnum = _Dictionary.GetEnumerator();

            while (_hashEnum.MoveNext())

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary遍历时间:" + stopWatch.Elapsed + " ,遍历采用Dictionary.GetEnumerator()方式");





            Console.WriteLine("\n-------------------------------------------------");

        }

    }

 四:从地方的结果能够看来

1.HashTable大数据量插入数据时需求开支比Dictionary大的多的年华。

2.for措施遍历HashTable和Dictionary速度最快。

3.在foreach情势遍历时Dictionary遍历速度更快。

五:在单线程的时候使用Dictionary更好一些,多线程的时候利用HashTable更好。

因为HashTable能够通过Hashtable tab = Hashtable.Synchronized(new
Hashtable());得到线程安全的目的。

eg: hashtable

 public static Hashtable List()
        {
            Hashtable h = new Hashtable();
            h.Add(1,"asdasdsad");
            h.Add("dasda","dsadsa");
            return h;
        }


Hashtable list=List();
            foreach(Object item in list.Keys){
                Console.WriteLine(item);
                Console.WriteLine(list[item]);
            }

三:遍历方式:

Dictionary的两种遍历格局:

Dictionary<string, int> list = new Dictionary<string, int>();

           list.Add("d", 1);
//一:通过key值遍历:
foreach (string key in list.Keys) {
         Console.WriteLine(key + list[key]);
   }
//二:通过value值遍历:
foreach (int val in list.Values){
         Console.WriteLine(val);
   } 
//三:通过key和value遍历:
foreach (KeyValuePair<string, int> kv in list){
         Console.WriteLine(kv.Key + kv.Value);
   }
//四:3.0以上版本
foreach (var item in list){
         Console.WriteLine(item.Key + item.Value);
   }

HashTable的遍历格局:

static void Main(string[] args)
 2         {
 3             Person person1 = new Person();
 4             person1.Age = 34;
 5             person1.Name = "Jacky";
 6             person1.Email = "[email protected]";
 7 
 8             Person person2 = new Person();
 9             person2.Age = 23;
10             person2.Name = "Ajay";
11             person2.Email = "[email protected]";
12 
13             Person person3 = new Person();
14             person3.Age = 12;
15             person3.Name = "Bill";
16             person3.Email = "[email protected]";
17 
18             Person person4 = new Person();
19             person4.Age = 23;
20             person4.Name = "Gace";
21             person4.Email = "[email protected]";
22 
23             Person person5 = new Person();
24             person5.Age = 45;
25             person5.Name = "Jim";
26             person5.Email = "[email protected]";
27 
28             Hashtable ht = new Hashtable();
29             ht.Add("1", person1);
30             ht.Add("2", person2);
31             ht.Add("3", person3);
32             ht.Add("4", person4);
33             ht.Add("5", person5);
34             Console.WriteLine("请输入你的查询的用户名:");
35             string strName = Console.ReadLine();
36             //第一种方法 key值
37              foreach (string item in ht.Keys)
38             {
39                 Person p = (Person)ht[item];
40                 if (strName == p.Name)
41                 {
42                     Console.WriteLine("查询后的结果是:" + p.Name + "\t" + p.Email + "\t" + p.Age);
43                 }
44             }
45 
46 
47 
48             //第二种方法 value值
49              foreach (Person item in ht.Values)
50             {
51                 if (item.Name == strName)
52                 {
53                     Console.WriteLine("查询后的结果是:" + item.Name + "\t" + item.Email + "\t" + item.Age);
54                 }
55 
56             }
57             //第三种方法 key和value值
58              foreach (DictionaryEntry item in ht)
59             {
60                 if (strName == ((Person)item.Value).Name)
61                 {
62                     Console.WriteLine("查询后的结果是:" + ((Person)item.Value).Name + "\t" + ((Person)item.Value).Email + "\t" + ((Person)item.Value).Age);
63                 }
64             }
65 
66             //第四种方法
67              IDictionaryEnumerator id = ht.GetEnumerator();
68             while (id.MoveNext())
69             {
70              Person p =   (Person)ht[id.Key];
71              if (p.Name == strName)
72              {
73                  Console.WriteLine("查询后的结果是:" + p.Name + "\t" + p.Email + "\t" + p.Age);
74              }
75             }
76 
77         }

 第四:Queue集合和Stack

Queue:它是三个先进先出的联谊(它存款和储蓄于队列中),先进先出的情趣约等于首先放进集合的多寡,拿多少的时候从早期放进去的多寡开首拿。

Stack:它是2个后进先出的集聚(它存款和储蓄于栈中),后进先出的意趣顾名思义,也正是说取多少只好从最终放进去的百般数据伊始取。

 以下代码实例了个别采纳Stack和Queue打字与印刷数字0~9。

//写入数据到Queue中
2. Queue q = new Queue();
3. for (int i = 0; i < 10; i++)
4. {
5.     q.Enqueue(i);
6. }
7. 
8. 
9. //循环输出Queue所有数据
10. Console.WriteLine("开始输出Queue数据");
11. while (q.Count > 0)
12. {
13.     Console.WriteLine(q.Dequeue());
14. } 
15. 
16. //-------------------------------------分割线------------------------------------//
17. 
18. //写入数据到Stack中
19. Stack s = new Stack();
20. for (int i = 0; i < 10; i++)
21. {
22.     s.Push(i);
23. }
24. 
25. //循环输出所有Stack数据
26. Console.WriteLine("开始输出Stack数据");
27. while (s.Count > 0)
28. {
29.     Console.WriteLine(s.Pop());
30. }

出口结果:
美高梅开户网址 3

依据以下代码对Queue 与
Stack进行了质量测试,他们的属性都比数组要高差不多2~倍。

Stopwatch sw_queue = new Stopwatch();
2. sw_queue.Start();
3. 
4. //写入数据到Queue中
5. Queue q = new Queue();
6. for (int i = 0; i < 1000000; i++)
7. {
8.     q.Enqueue(i);
9. }
10. 
11. //循环输出Queue所有数据
12. while (q.Count > 0)
13. {
14.     q.Dequeue();
15. }
16. 
17. sw_queue.Stop(); // 停止监视
18. Console.WriteLine("Queue 100万数据写入读取消耗时间:{0}毫秒", sw_queue.Elapsed.TotalMilliseconds.ToString());
19. 
20. //---------------------------------分割线--------------------------------//
21. 
22. Stopwatch sw_stack = new Stopwatch();
23. sw_stack.Start();
24. 
25. 
26. //写入数据到Stack中
27. Stack s = new Stack();
28. for (int i = 0; i < 1000000; i++)
29. {
30.     s.Push(i);
31. }
32. 
33. //循环输出所有Stack数据
34. while (s.Count > 0)
35. {
36.     s.Pop();
37. }
38. 
39. sw_stack.Stop(); // 停止监视
40. Console.WriteLine("Stack 100万数据写入读取消耗时间:{0}毫秒", sw_stack.Elapsed.TotalMilliseconds.ToString());
41. 
42. 
43. Console.R
eadKey();

测试结果:
美高梅开户网址 4

Queue 的要害成员:

属性  

Count    //元素数     

方法 

Clear()   //清空 

Contains() //是不是包括 

Dequeue() //出列 

Enqueue() //入列 

Peek()   //获取将要出列的 

Stack 的最首要成员:

属性   Count       //     

方法 

Clear()      // 

Contains()    // 

Peek()       //获取将要出栈的 

Pop()       //出栈 

Push()       //压栈 

第五:SortedList

C#
泛型集合之非泛型集合类与泛型集合类的应和:

C#
泛型集合之非泛型集合类与泛型集合类的呼应:

hashtable,Dictionary

hashtable和Dictionary都以哈希表的落到实处,很三人说Dictionary内部是由hashtable达成的,那是不确切的。

hashtable的结构须要装载因子,装载因子是0.1 到 1.0 范围内的数字
,是里面存款和储蓄桶数(count)所占桶数组(buckets)桶数(hashsize)的最大比率
,当桶数大于装载数(loadsize)时,桶数组就会扩容

hashtable内部解除哈希顶牛的算法是再度散列法,是开放地点法中最棒的主意之一

而不一致的是,Dictionary内部解除哈希冲突的算法是链地址法,而且Dictionary的构造不必要装载因子,不受装载因子的范围
,要是Dictionary相当小,查找,插入,删除等操作拥有近乎O(1)的频率

和ArrayList
,List类似的是Dictionary和hashtable内部也是由数组完结的,所以组织时也急需提供适宜体积,幸免品质的开支。

但大家要求其它注意的是你提需要构造函数的容积不肯定会是从头时置放数组的长度,构造函数内部会挑选二个当先等于你所选取体积的素数作为忠实的起来体积。

1、SortedList定义

System.Collections.SortedList类表示键/值对的成团,这么些键值对按键排序并可依照键和目录访问。SortedList
在内部维护多个数组以存款和储蓄列表中的成分;即,三个数组用于键,另二个数组用于相关联的值。每一种成分都是3个可视作
DictionaryEntry 对象开始展览走访的键/值对。键无法为null,但值可以。

ArrayList对应List

ArrayList对应List

HashSet

HashSet是多个九冬的能够保险唯一性的成团。大家也能够把HashSet看作是Dictionary<TKey,TValue>,只然则TKey和TValue都对准同多个对象。内部贯彻和Dictionary十二分相似。
HashSet万分适合在大家必要有限协助集合内成分唯一性但又不要求按顺序排列的时候。

2.优点

壹 、SortedList
允许通过相关联键或通过索引对值进行走访,可提供更大的油滑。

贰 、可依据需求活动叠加体量。

HashTable对应Dictionary

HashTable对应Dictionary

SortedList

SortedList是支撑排序的关联性(键值对 )集合
,内部采取数组完结,所以和List相同的是,开首化时必要提供3个正好的体量,SortedList内部使用哈希算法达成,和Dictionary类似的是,SortedList内部解除哈希龃龉的算法是链地址法。

因为在搜索的时候使用了二分查找,所以寻找的质量会好一些,时间复杂度是O(log
n)

假诺你想要火速搜索,又想集合遵照key的顺序排列,末了那么些集合的操作(添加和移除)比较少的话,就是SortedList了

3.注意点:

一 、SortedList 的容积是 SortedList 能够保留的元素数。SortedList
的暗许伊始容积为 0。随着成分添加到 SortedList
中,在急需时得以由此重新分配自动扩大体积。可通过调用 TrimToSize方法
或透过显式设置 Capacity 属性缩小容积。

二 、SortedList 中不允许重复键。

三 、SortedList的目录顺序基于排序依次。当添新币素时,成分将按正确的排序依次插入
SortedList,同时索引会相应地展开调整。当移除成分时,索引也会相应地实行调整。因而,当在
SortedList 中丰硕或移除成分时,特定键/值对的目录只怕会变动。

4.当不向聚集中添加新因素,则调用TrimToSize措施可用于最小化集合的内部存款和储蓄器开销。

⑤ 、通过安装 SortedList
中不存在的键值(例如,myCollection[“myNonexistentKey”] =
myValue),仍可以够利用 Item 属性添加新成分。可是,若是钦赐的键已经存在于
SortedList 中,则设置 Item 属性将改写旧值。比较之下,Add
方法不改动现有成分。

键无法为 空引用(在 Visual Basic 中为
Nothing),但值能够。若要区分由于未找到钦点键而回到的 空引用(在 Visual
Basic 中为 Nothing) 和出于内定键的值为 空引用(在 Visual Basic 中为
Nothing) 而回到的 空引用(在 Visual Basic 中为 Nothing),请使用
Contains 方法或 ContainsKey 方法明显列表中是还是不是存在该键。

  1. SortedList的构造器

美高梅开户网址 5

5、SortedList的属性

美高梅开户网址 6

6.SortedList的方法

美高梅开户网址 7

美高梅开户网址 8

泛型集合SortedList<TKey,TValue>:

借使急需排好序的表,能够使用SortedList<TKey,TValue>。那么些类依照键给成分排序。

上边包车型客车例子创设二个里丑捧心表,当中键和值都以string类型。默许的构造函数创制了2个空表,再用Add()方法添加两本书。使用重载的构造函数,能够定义有序表的体量,传送执行了IComparer<TKey>接口的靶子,用于给有序表中得元素排序。

Add()方法的首先个参数是键(书名),第①个参数是值(ISBN号)。除了利用Add()方法之外,还是能够利用索引器将成分添加到平稳表中。索引器须求把键作为目录参数。如若键已存在,那么Add()方法就抛出3个ArgumentException类型的不行。如若索引器使用同一的键,就用新值替代旧值。

 

static void Main(string[] args)  
06.        {  
07.            // 创建一个SortedList对象          
08.            SortedList mySortedList = new SortedList();  
09.            mySortedList.Add("First", "Hello");  
10.            mySortedList.Add("Second", "World");  
11.            mySortedList.Add("Third", "!");  
12.            mySortedList.Add("Four", "{1}quot;);    
13.  
14.            //列举SortedList的属性、键、值  
15.            Console.WriteLine("MySortedList");  
16.            Console.WriteLine("  Count:    {0}", mySortedList.Count);  
17.            Console.WriteLine("  Capacity: {0}", mySortedList.Capacity);  
18.            Console.WriteLine("  Keys and Values:");  
19.            PrintIndexAndKeysAndValues(mySortedList);  
20. 
21.            #region SortedList获得键、值列表  
22.            SortedList mySortedList1 = new SortedList();  
23.            mySortedList1.Add(1.3, "fox");  
24.            mySortedList1.Add(1.4, "jumped");  
25.            mySortedList1.Add(1.5, "over");  
26.            mySortedList1.Add(1.2, "brown");  
27.            mySortedList1.Add(1.1, "quick");  
28.            mySortedList1.Add(1.0, "The");  
29.            mySortedList1.Add(1.6, "the");  
30.            mySortedList1.Add(1.8, "dog");  
31.            mySortedList1.Add(1.7, "lazy");   
32.  
33.            //获得指定索引处的键和值  
34.            int myIndex = 3;  
35.            //     获取 System.Collections.SortedList 对象的指定索引处的键  
36.            Console.WriteLine("The key  at index {0} is {1}.", myIndex, mySortedList1.GetKey(myIndex));  
37.            //     获取 System.Collections.SortedList 对象的指定索引处的值  
38.            Console.WriteLine("The value at index {0} is {1}.", myIndex, mySortedList1.GetByIndex(myIndex));     
39.  
40.            // 获得SortedList中的键列表和值列表         
41.            IList myKeyList = mySortedList1.GetKeyList();  
42.            IList myValueList = mySortedList1.GetValueList();  
43.            // Prints the keys in the first column and the values in the second column.             
44.            Console.WriteLine("\t-KEY-\t-VALUE-");  
45.            for (int i = 0; i < mySortedList1.Count; i++)   
46.                Console.WriteLine("\t{0}\t{1}", myKeyList[i], myValueList[i]);  
47. 
48.            #endregion   
49. 
50.            #region 为SortedList中的元素重新赋值   
51.            // Creates and initializes a new SortedList.     
52.            SortedList mySortedList2 = new SortedList();  
53.            mySortedList2.Add(2, "two");  
54.            mySortedList2.Add(3, "three");   
55.            mySortedList2.Add(1, "one");  
56.            mySortedList2.Add(0, "zero");  
57.            mySortedList2.Add(4, "four");             
58.            // 打印显示列表的键和值           
59.            Console.WriteLine("The SortedList contains the following values:");  
60.            PrintIndexAndKeysAndValues(mySortedList2);        
61.     
62.            // 获得指定键的索引          
63.            int myKey = 2;  
64.            Console.WriteLine("The key \"{0}\" is at index {1}.", myKey, mySortedList2.IndexOfKey(myKey));        
65.            // 获得指定值的索引       
66.            String myValue = "three";  
67.            Console.WriteLine("The value \"{0}\" is at index {1}.", myValue, mySortedList2.IndexOfValue(myValue));        
68.            // 重新设置指定索引处的值           
69.            mySortedList2.SetByIndex(3, "III");   // SetByIndex:替换 System.Collections.SortedList 对象中指定索引处的值  
70.            mySortedList2.SetByIndex(4, "IV");         
71.            //打印显示列表的键和值         
72.            Console.WriteLine("After replacing the value at index 3 and index 4,");  
73.            PrintIndexAndKeysAndValues(mySortedList2);        
74.            #endregion  
75.            Console.ReadKey();  
76.        }  
77.  
78.        //打印SortedList中的键和值   
79.        public static void PrintIndexAndKeysAndValues(SortedList myList)    
80.        {              
81.            Console.WriteLine("\t-INDEX-\t-KEY-\t-VALUE-");  
82.            for (int i = 0; i < myList.Count; i++)       
83.            {             
84.                Console.WriteLine("\t[{0}]:\t{1}\t{2}", i, myList.GetKey(i), myList.GetByIndex(i));       
85.            }         
86.            Console.WriteLine();       
87.        }  
88.    }  

出口结果:
美高梅开户网址 9

                                                             
 能够到软件里畅游的写———————-来自鬼世界的镰刀

 

 

 

 

 

 

 

 

 

C#
泛型集合之非泛型集合类与泛型集合类的附和: ArrayList对应List
HashTable对应Dictionary Queue对应Queue…

Queue对应Queue

Queue对应Queue

SortedSet,SortedDictioanry

SortedSet类似于HashSet,但略有不相同的是,SortedSet是稳步排列,SortedSet内部贯彻应有是具备集合中最复杂,是借助红黑树的原理达成。

SortedDictioanry和Dictionary的分别与HashSet和SortedSet的界别基本一致,因为SortedDictioanry内部本身就是凭借SortedSet达成的,并且SortDictionary内部顺序是以key的逐一为排列的

public SortedDictionary(IDictionary<TKey,TValue> dictionary, IComparer<TKey> comparer) {
          if( dictionary == null) {
              ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
          }

          _set = new TreeSet<KeyValuePair<TKey, TValue>>(new KeyValuePairComparer(comparer));

          foreach(KeyValuePair<TKey, TValue> pair in dictionary) {
              _set.Add(pair);
          }            
      }

Stack对应Stack

Stack对应Stack

LinkedList,Stack,Queue

这二个聚众笔者就不多做说明,完全按这多少个基础数据结构的法则来兑现。然而Stack,Queue内部采纳数组完结,所以也要小心起先化时提供1个确切的体积啊

SortedList对应SortedList

SortedList对应SortedList

 

 

先是  : ArrayList(非泛型集合)  与List(泛型集合)

率先  : ArrayList(非泛型集合)  与List(泛型集合)

ArrayList 是数组的错综复杂版本。ArrayList
类提供在超越四分一 Collections 类中提供但不在 Array
类中提供的一对功能:

ArrayList 是数组的纷纭版本。ArrayList
类提供在半数以上 Collections 类中提供但不在 Array
类中提供的局地效应:

1.Array 的体积是定点的,而 ArrayList
的体量是依照需求活动扩充的。

1.Array 的体量是一定的,而 ArrayList
的体积是依照要求活动扩展的。

2.ArrayList
提供丰盛、插入或移除某一范围成分的艺术。在 Array
中,您不得不一次得到或设置四个要素的值。

2.ArrayList
提供丰富、插入或移除某一范围成分的点子。在 Array
中,您不得不一次获得或设置1个因素的值。

3.使用 Synchronized 方法能够很简单地创建ArrayList 的联合版本。而 Array 将直接维系它直到用户完成同步截止。

3.行使 Synchronized 方法能够很不难地创制ArrayList 的同台版本。而 Array 将直接维系它直到用户达成同步结束。

4.ArrayList
提供将只读和稳定大小包裹重回到聚集的艺术。而 Array 不提供。

4.ArrayList
提供将只读和定位大小包裹重返到集结的法子。而 Array 不提供。

5.Array 提供 ArrayList
所不享有的有个别灵活性:

5.Array 提供 ArrayList
所不持有的一点灵活性:

   a.可以安装 Array 的下限,但 ArrayList
的下限始终为零。

   a.能够设置 Array 的下限,但 ArrayList
的下限始终为零。

   b.Array 能够有所多少个维度,而 ArrayList
始终只是一维的。

   b.Array 可以享有多少个维度,而 ArrayList
始终只是一维的。

   c.特定类型(不包涵 Object)的 Array
的习性比 ArrayList 好,那是因为 ArrayList 的成分属于 Object
类型,所以在蕴藏或探寻值类型时经常产生装箱和收回装箱。

   c.特定类型(不包括 Object)的 Array
的属性比 ArrayList 好,那是因为 ArrayList 的成分属于 Object
类型,所以在仓库储存或探寻值类型时通常产生装箱和撤消装箱。

  
d.须求一个数组的大部场合也足以代之以使用
ArrayList。它更便于使用,并且普通兼有与 Object
类型的数组类似的习性。

  
d.供给1个数组的大部景况也得以代之以使用
ArrayList。它更易于使用,并且普通拥有与 Object
类型的数组类似的习性。

6.Array 位居 System 命名空间中;ArrayList
位于 System.Collections 命名空间中。

6.Array 坐落 System 命名空间中;ArrayList
位于 System.Collections 命名空间中。

ArrayList类对象方法:

ArrayList类对象方法:

1:Add()向数组中添加贰个因素,
2:Remove()删除数组中的2个成分
3:(int i)删除数组中索引值为i的成分
4:Reverse()反转数组的要素
5:Sort()以从小到大的顺序排列数组的要素
6:Clone()复制3个数组

1:Add()向数组中添加二个成分,
2:Remove()删除数组中的2个元素
3:(int i)删除数组中索引值为i的要素
4:Reverse()反转数组的要素
5:Sort()以从小到大的顺序排列数组的因素
6:Clone()复制多少个数组

一:ArrayList:

一:ArrayList:

ArrayList能够毫不钦定维数 可动态赋值 
赋不一致类型值

ArrayList能够不要钦点维数 可动态赋值 
赋分歧类型值

 

 

ArrayList arrayList1 = new ArrayList();
             arrayList1.
             arrayList1.Add("a");
             arrayList1.Add(1);
             arrayList1.Add("b");
             Response.Write(arrayList1[1]);
ArrayList arrayList1 = new ArrayList();
             arrayList1.
             arrayList1.Add("a");
             arrayList1.Add(1);
             arrayList1.Add("b");
             Response.Write(arrayList1[1]);

二:Array:

二:Array:

Array的体量是定位的 先钦点大小
在赋值

Array的体量是一定的 先钦赐大小
在赋值

 

 

 Array arrayList2 = Array.CreateInstance(typeof(string), 6);
             arrayList2.SetValue("a", 0);
             arrayList2.SetValue("b", 1);
             Response.Write(arrayList2.GetValue(1));
 Array arrayList2 = Array.CreateInstance(typeof(string), 6);
             arrayList2.SetValue("a", 0);
             arrayList2.SetValue("b", 1);
             Response.Write(arrayList2.GetValue(1));

List泛型集合:

List泛型集合:

泛型集合List<T>
  泛型最要紧的应用正是汇集操作,使用泛型集合能够增长代码重用性,类型安全和更佳的品质。
  List<T>的用法和ArrayList相似,List<T>有更好的门类安全性,无须拆,装箱。
在泛型定义中,泛型类型参数“<T>”是必须钦点的,个中T是概念泛型类时的占位符,其并不是一种档次,仅代表某种只怕的类型。在概念时T会被运用的门类代替。泛型集合List<T>中不得不有贰个参数类型,“<T>”中的T能够对聚集中的成分类型进行封锁。

泛型集合List<T>
  泛型最要害的利用正是集结操作,使用泛型集合能够增长代码重用性,类型安全和更佳的性能。
  List<T>的用法和ArrayList相似,List<T>有更好的种类安全性,无须拆,装箱。
在泛型定义中,泛型类型参数“<T>”是必须钦赐的,个中T是概念泛型类时的占位符,其并不是一类别型,仅表示某种可能的体系。在概念时T会被选用的体系代替。泛型集合List<T>中只可以有一个参数类型,“<T>”中的T能够对聚集中的成分类型进行约束。

eg:
List<T>添加、删除、检索元素的办法和ArrayList相似,鲜明的特点是不要求像ArrayList那样装箱和拆箱。

eg:
List<T>添加、删除、检索元素的措施和ArrayList相似,分明的性状是不必要像ArrayList那样装箱和拆箱。

List < Student > students = new List < Student > ();
   Student stu1 = new Student();
   stu1.Name = "陆小凤";
   stu1.Number = "0801";
   stu1.Score = 20;
   Student stu2 = new Student();
   stu2.Name = "西门吹雪";
   stu2.Number = "0802";
   stu2.Score = 23;
   students.Add(stu1);
   students.Add(stu2);
   Console.WriteLine("集合中的元素个数为{0}", students.Count);
   foreach (Student stu in students)
   {
    Console.WriteLine("/t{0}/t{1}/t{2}", stu.Name, stu.Number, stu.Score);
   }
   students.Remove(stu1);
   Console.WriteLine("集合中的元素个数为{0}", students.Count);
   Console.ReadLine();
List < Student > students = new List < Student > ();
   Student stu1 = new Student();
   stu1.Name = "陆小凤";
   stu1.Number = "0801";
   stu1.Score = 20;
   Student stu2 = new Student();
   stu2.Name = "西门吹雪";
   stu2.Number = "0802";
   stu2.Score = 23;
   students.Add(stu1);
   students.Add(stu2);
   Console.WriteLine("集合中的元素个数为{0}", students.Count);
   foreach (Student stu in students)
   {
    Console.WriteLine("/t{0}/t{1}/t{2}", stu.Name, stu.Number, stu.Score);
   }
   students.Remove(stu1);
   Console.WriteLine("集合中的元素个数为{0}", students.Count);
   Console.ReadLine();

List<T>和ArrayList的区别
     
List<T>和ArrayList的相同点:添加元素、删除成分、通过索引访问成分方法一致。
  List<T>和ArrayList的不一致点:
ArrayList能够添加任意档次成分;List<T>对增进的因素具有类型约束;
ArratList添加衣服箱,读取时拆箱;List<T>不须要装箱,拆箱操作;

List<T>和ArrayList的区别
     
List<T>和ArrayList的相同点:添美金素、删除元素、通过索引访问成分方法同样。
  List<T>和ArrayList的不一样点:
ArrayList能够拉长任意档次成分;List<T>对增加的要素具有类型约束;
ArratList添加服装箱,读取时拆箱;List<T>不供给装箱,拆箱操作;

//创建Person对象
   Person p1 = new Person("张三", 30);
   Person p2 = new Person("李四", 20);
   Person p3 = new Person("王五", 50);
   //创建类型为Person的对象集合
   List < Person > persons = new List < Person > ();
   //将Person对象放入集合
   persons.Add(p1);
   persons.Add(p2);
   persons.Add(p3);
   //输出第2个人的姓名
   Console.WriteLine(persons[1].Name);
   foreach (Person p in persons)
   {
    Console.WriteLine("/t{0}/t{1}", p.Name, p.Age);
   }
//创建Person对象
   Person p1 = new Person("张三", 30);
   Person p2 = new Person("李四", 20);
   Person p3 = new Person("王五", 50);
   //创建类型为Person的对象集合
   List < Person > persons = new List < Person > ();
   //将Person对象放入集合
   persons.Add(p1);
   persons.Add(p2);
   persons.Add(p3);
   //输出第2个人的姓名
   Console.WriteLine(persons[1].Name);
   foreach (Person p in persons)
   {
    Console.WriteLine("/t{0}/t{1}", p.Name, p.Age);
   }

第2:HashTable(非泛型集合)对应Dictionary(泛型集合)

其次
:HashTable(非泛型集合)对应Dictionary(泛型集合)

Hashtable 和
Dictionary <K, V> 类型

Hashtable 和
Dictionary <K, V> 类型

 1:单线程程序中引进使用 Dictionary, 有泛型优势, 且读取速度较快,
体积利用更充裕.
 2:四线程程序中推荐介绍应用 Hashtable, 暗中同意的 Hashtable 允许单线程写入,
多线程读取, 对 Hashtable 进一步调用 Synchronized()
方法能够获得完全线程安全的类型. 而 Dictionary 非线程安全, 必须人为使用
lock 语句实行保证, 作用大减.
 3:Dictionary 有按插入顺序排列数据的特征 (注: 但当调用 Remove()
删除过节点后逐一被打乱), 由此在急需反映顺序的景况中利用 Dictionary
能获得肯定方便.

 1:单线程程序中引进使用 Dictionary, 有泛型优势, 且读取速度较快,
容积利用更丰硕.
 2:二十三十二线程程序中推荐介绍应用 Hashtable, 私下认可的 Hashtable 允许单线程写入,
多线程读取, 对 Hashtable 进一步调用 Synchronized()
方法能够获取完全线程安全的类型. 而 Dictionary 非线程安全, 必须人为使用
lock 语句实行爱护, 作用大减.
 3:Dictionary 有按插入顺序排列数据的性状 (注: 但当调用 Remove()
删除过节点后逐一被打乱), 因而在急需反映顺序的意况中动用 Dictionary
能博取肯定方便.

Hashtable 类和 Dictionary<(Of
<(TKey, 电视alue>)>) 泛型类完毕 IDictionary 接口

Hashtable 类和 Dictionary<(Of
<(TKey, TValue>)>) 泛型类达成 IDictionary 接口

Dictionary<(Of <(TKey,
TValue>)>) 泛型类还完成 IDictionary<(Of <(TKey,
TValue>)>)
泛型接口。因而,这几个聚集中的各样成分都是三个键/值对。

Dictionary<(Of <(TKey,
TValue>)>) 泛型类还落到实处 IDictionary<(Of <(TKey,
TValue>)>)
泛型接口。因而,这一个聚集中的每一种成分都是三个键/值对。

Dictionary<(Of <(TKey,
TValue>)>) 类与 Hashtable 类的机能雷同
对于值类型,特定项目(不包括 Object)的 Dictionary<(Of <(TKey,
TValue>)>) 的天性优越 Hashtable,那是因为 Hashtable 的成分属于
Object
类型,所以在仓库储存或探寻值类型时一般发生装箱和收回装箱操作。

Dictionary<(Of <(TKey,
TValue>)>) 类与 Hashtable 类的效应雷同
对于值类型,特定项目(不包蕴 Object)的 Dictionary<(Of <(TKey,
TValue>)>) 的品质优越 Hashtable,这是因为 Hashtable 的成分属于
Object
类型,所以在存款和储蓄或探寻值类型时一般发生装箱和注销装箱操作。

eg:

eg:

HashTable ht=new HashTable();//实现 IDictionary接口
ht.Add(1,"A");
 ht.Add(2,"B");
 ht.Add(3,"c");
 foreach(DictionaryEntry de in ht)//HashTable返回的是DictionaryEntry类型
 {
     de.Key;
     de.Value;
  }

Dictionary<int,string> myDictionary=new Dictionary<int,string>();//实现IDictionary接口,IDictionary<T key,T value>类
myDictionary.Add(1,"a");
 myDictionary.Add(2,"b");
 myDictionary.Add(3,"c");
 foreach(int i in myDictionary.Keys)
{
   Console.WriteLine("Key="+i+"Value="+myDictionary);
 }
 Or
 foreach(KeyValuePair<string, double> temp in myDictionary)//返回的是KeyValuePair<string, double>泛型数组
  {
        temp.Key;
        temp.Value;
   }
HashTable ht=new HashTable();//实现 IDictionary接口
ht.Add(1,"A");
 ht.Add(2,"B");
 ht.Add(3,"c");
 foreach(DictionaryEntry de in ht)//HashTable返回的是DictionaryEntry类型
 {
     de.Key;
     de.Value;
  }

Dictionary<int,string> myDictionary=new Dictionary<int,string>();//实现IDictionary接口,IDictionary<T key,T value>类
myDictionary.Add(1,"a");
 myDictionary.Add(2,"b");
 myDictionary.Add(3,"c");
 foreach(int i in myDictionary.Keys)
{
   Console.WriteLine("Key="+i+"Value="+myDictionary);
 }
 Or
 foreach(KeyValuePair<string, double> temp in myDictionary)//返回的是KeyValuePair<string, double>泛型数组
  {
        temp.Key;
        temp.Value;
   }

一:HashTable:

一:HashTable:

1.HashTable是一种散列表,他个中维护广大对Key-Value键值对,其还有贰个类似索引的值叫做散列值(HashCode),它是基于GetHashCode方法对Key通过自然算法获取获得的,全体的搜寻操作定位操作都以依据散列值来兑现找到呼应的Key和Value值的。

1.HashTable是一种散列表,他里头维护广大对Key-Value键值对,其还有贰个像样索引的值叫做散列值(HashCode),它是依据GetHashCode方法对Key通过自然算法获取得到的,全部的追寻操作定位操作都以基于散列值来兑现找到呼应的Key和Value值的。

2.大家须求利用四个算法让散列值对应HashTable的空间地址尽量不重复,那便是散列函数(GetHashCode)要求做的事。

2.我们必要使用一个算法让散列值对应HashTable的上空地址尽量不另行,那正是散列函数(GetHashCode)要求做的事。

3.当四个HashTable被挤占大多数的时候大家透过总计散列值取得的地址值大概会再一次指向同一地点,那正是哈希争论。

3.当二个HashTable被占据大部分的时候大家通过总计散列值取得的地址值大概会再一次指向同一地点,那正是哈希争持。

4.在.Net中键值对在HashTable中的地方Position=
(HashCode& 0x7FFFFFFF) %
HashTable.Length,.net中是通过探测法消除哈希争辩的,当通过散列值取得的地方Postion以及被占用的时候,就会追加三个位移x值判断下五个职务Postion+x是不是被占用,假如依旧被占用就继续往下位移x判断Position+2*x地方是否被占用,假设没有被侵夺则将值放入个中。当HashTable中的可用空间越来越小时,则赢得获得可用空间的难度进一步大,消耗的小时就更加多。

4.在.Net中键值对在HashTable中的地点Position=
(HashCode& 0x7FFFFFFF) %
HashTable.Length,.net中是透过探测法消除哈希争辩的,当通过散列值取得的职分Postion以及被占用的时候,就会增多八个位移x值判断下1个职位Postion+x是不是被占用,假如照旧被并吞就持续往下位移x判断Position+2*x地方是还是不是被占用,假设没有被挤占则将值放入个中。当HashTable中的可用空间越发时辰,则获得获得可用空间的难度进一步大,消耗的时光就越来越多。

5..当下HashTable中的被占用空间达到二个比重的时候就将该空间活动扩大容积,在.net中这些比重是72%,也叫.net中HashTable的填写因子为0.72。例如有二个HashTable的长台湾空中大学小是100,当它须求加上第拾6个值的时候将会扩大体积此HashTable.

5..脚下HashTable中的被占用空间达到二个比例的时候就将该空间活动扩大体量,在.net中这几个比例是72%,也叫.net中HashTable的填写因子为0.72。例如有七个HashTable的长台湾空中大学小是100,当它须求加上第⑦贰个值的时候将会扩大体量此HashTable.

6.这么些自动扩大容积的尺寸是稍稍呢?答案是最近空中尺寸的两倍最相仿的素数,例如当前HashTable所占空间为素数71,假如扩大体积,则扩大体积大小为素数131.

6.以此自动扩大容积的分寸是有点吗?答案是当前空间大小的两倍最相近的素数,例如当前HashTable所占空间为素数71,假如扩大体量,则扩大体积大小为素数131.

美高梅开户网址 10

美高梅开户网址 11

二:Dictionary

二:Dictionary

1.Dictionary是一种变种的HashTable,它采取一种分离链接散列表的数据结构来化解哈希争辨的标题。

1.Dictionary是一种变种的HashTable,它利用一种分离链接散列表的数据结构来缓解哈希争辩的难题。

2.分离链接散列表是当散列到同三个地方的值存为3个链表中。

2.分离链接散列表是当散列到同3个地方的值存为一个链表中。

3.以此变种HashTable的填充因子是1

3.以此变种HashTable的填写因子是1

美高梅开户网址 12

美高梅开户网址 13

eg:本文将以代码的花样探索HashTable和Dictionary的插入和三种读取格局的频率(for/foreach/GetEnumerator)

eg:本文将以代码的花样探索HashTable和Dictionary的插入和二种读取格局的频率(for/foreach/GetEnumerator)

public class HashTableTest

    {

        static Hashtable _Hashtable;

        static Dictionary<string, object> _Dictionary;

        static void Main()

        {

            Compare(10);

            Compare(10000);

            Compare(5000000);

            Console.ReadLine();

        }

        public static void Compare(int dataCount)

        {

            Console.WriteLine("-------------------------------------------------\n");

            _Hashtable = new Hashtable();

            _Dictionary = new Dictionary<string, object>();

            Stopwatch stopWatch = new Stopwatch();

            //HashTable插入dataCount条数据需要时间

            stopWatch.Start();

            for (int i = 0; i < dataCount; i++)

            {

                _Hashtable.Add("Str" + i.ToString(), "Value");

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable插入" + dataCount + "条数据需要时间:" + stopWatch.Elapsed);



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            stopWatch.Start();

            for (int i = 0; i < dataCount; i++)

            {

                _Dictionary.Add("Str" + i.ToString(), "Value");

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary插入" + dataCount + "条数据需要时间:" + stopWatch.Elapsed);



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            int si = 0;

            stopWatch.Start();

            for(int i=0;i<_Hashtable.Count;i++)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable遍历时间:" + stopWatch.Elapsed + " ,遍历采用for方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            foreach (var s in _Hashtable)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable遍历时间:" + stopWatch.Elapsed + " ,遍历采用foreach方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            IDictionaryEnumerator _hashEnum = _Hashtable.GetEnumerator();

            while (_hashEnum.MoveNext())

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable遍历时间:" + stopWatch.Elapsed + " ,遍历采用HashTable.GetEnumerator()方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            for(int i=0;i<_Dictionary.Count;i++)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary遍历时间:" + stopWatch.Elapsed + " ,遍历采用for方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            foreach (var s in _Dictionary)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary遍历时间:" + stopWatch.Elapsed + " ,遍历采用foreach方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            _hashEnum = _Dictionary.GetEnumerator();

            while (_hashEnum.MoveNext())

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary遍历时间:" + stopWatch.Elapsed + " ,遍历采用Dictionary.GetEnumerator()方式");





            Console.WriteLine("\n-------------------------------------------------");

        }

    }
public class HashTableTest

    {

        static Hashtable _Hashtable;

        static Dictionary<string, object> _Dictionary;

        static void Main()

        {

            Compare(10);

            Compare(10000);

            Compare(5000000);

            Console.ReadLine();

        }

        public static void Compare(int dataCount)

        {

            Console.WriteLine("-------------------------------------------------\n");

            _Hashtable = new Hashtable();

            _Dictionary = new Dictionary<string, object>();

            Stopwatch stopWatch = new Stopwatch();

            //HashTable插入dataCount条数据需要时间

            stopWatch.Start();

            for (int i = 0; i < dataCount; i++)

            {

                _Hashtable.Add("Str" + i.ToString(), "Value");

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable插入" + dataCount + "条数据需要时间:" + stopWatch.Elapsed);



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            stopWatch.Start();

            for (int i = 0; i < dataCount; i++)

            {

                _Dictionary.Add("Str" + i.ToString(), "Value");

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary插入" + dataCount + "条数据需要时间:" + stopWatch.Elapsed);



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            int si = 0;

            stopWatch.Start();

            for(int i=0;i<_Hashtable.Count;i++)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable遍历时间:" + stopWatch.Elapsed + " ,遍历采用for方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            foreach (var s in _Hashtable)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable遍历时间:" + stopWatch.Elapsed + " ,遍历采用foreach方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            IDictionaryEnumerator _hashEnum = _Hashtable.GetEnumerator();

            while (_hashEnum.MoveNext())

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable遍历时间:" + stopWatch.Elapsed + " ,遍历采用HashTable.GetEnumerator()方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            for(int i=0;i<_Dictionary.Count;i++)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary遍历时间:" + stopWatch.Elapsed + " ,遍历采用for方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            foreach (var s in _Dictionary)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary遍历时间:" + stopWatch.Elapsed + " ,遍历采用foreach方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            _hashEnum = _Dictionary.GetEnumerator();

            while (_hashEnum.MoveNext())

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary遍历时间:" + stopWatch.Elapsed + " ,遍历采用Dictionary.GetEnumerator()方式");





            Console.WriteLine("\n-------------------------------------------------");

        }

    }

 四:从上边的结果能够见到

 四:从地点的结果能够看到

1.HashTable大数据量插入数据时须要费用比Dictionary大的多的小时。

1.HashTable大数据量插入数据时索要开销比Dictionary大的多的时日。

2.for方式遍历HashTable和Dictionary速度最快。

2.for主意遍历HashTable和Dictionary速度最快。

3.在foreach方式遍历时Dictionary遍历速度更快。

3.在foreach格局遍历时Dictionary遍历速度更快。

五:在单线程的时候利用Dictionary更好有的,二十八线程的时候使用HashTable更好。

五:在单线程的时候利用Dictionary更好一些,四线程的时候使用HashTable更好。

因为HashTable可以由此Hashtable tab =
Hashtable.Synchronized(new Hashtable());获得线程安全的对象。

因为HashTable能够因此Hashtable tab =
Hashtable.Synchronized(new Hashtable());获得线程安全的目标。

eg: hashtable

eg: hashtable

 public static Hashtable List()
        {
            Hashtable h = new Hashtable();
            h.Add(1,"asdasdsad");
            h.Add("dasda","dsadsa");
            return h;
        }


Hashtable list=List();
            foreach(Object item in list.Keys){
                Console.WriteLine(item);
                Console.WriteLine(list[item]);
            }
 public static Hashtable List()
        {
            Hashtable h = new Hashtable();
            h.Add(1,"asdasdsad");
            h.Add("dasda","dsadsa");
            return h;
        }


Hashtable list=List();
            foreach(Object item in list.Keys){
                Console.WriteLine(item);
                Console.WriteLine(list[item]);
            }

三:遍历方式:

三:遍历情势:

Dictionary的三种遍历格局:

Dictionary的三种遍历格局:

Dictionary<string, int> list = new Dictionary<string, int>();

           list.Add("d", 1);
//一:通过key值遍历:
foreach (string key in list.Keys) {
         Console.WriteLine(key + list[key]);
   }
//二:通过value值遍历:
foreach (int val in list.Values){
         Console.WriteLine(val);
   } 
//三:通过key和value遍历:
foreach (KeyValuePair<string, int> kv in list){
         Console.WriteLine(kv.Key + kv.Value);
   }
//四:3.0以上版本
foreach (var item in list){
         Console.WriteLine(item.Key + item.Value);
   }
Dictionary<string, int> list = new Dictionary<string, int>();

           list.Add("d", 1);
//一:通过key值遍历:
foreach (string key in list.Keys) {
         Console.WriteLine(key + list[key]);
   }
//二:通过value值遍历:
foreach (int val in list.Values){
         Console.WriteLine(val);
   } 
//三:通过key和value遍历:
foreach (KeyValuePair<string, int> kv in list){
         Console.WriteLine(kv.Key + kv.Value);
   }
//四:3.0以上版本
foreach (var item in list){
         Console.WriteLine(item.Key + item.Value);
   }

HashTable的遍历情势:

HashTable的遍历格局:

static void Main(string[] args)
 2         {
 3             Person person1 = new Person();
 4             person1.Age = 34;
 5             person1.Name = "Jacky";
 6             person1.Email = "Jacky@gmail.com";
 7 
 8             Person person2 = new Person();
 9             person2.Age = 23;
10             person2.Name = "Ajay";
11             person2.Email = "Ajay@gmail.com";
12 
13             Person person3 = new Person();
14             person3.Age = 12;
15             person3.Name = "Bill";
16             person3.Email = "Bill@gmail.com";
17 
18             Person person4 = new Person();
19             person4.Age = 23;
20             person4.Name = "Gace";
21             person4.Email = "Gace@gmail.com";
22 
23             Person person5 = new Person();
24             person5.Age = 45;
25             person5.Name = "Jim";
26             person5.Email = "Jim@gmail.com";
27 
28             Hashtable ht = new Hashtable();
29             ht.Add("1", person1);
30             ht.Add("2", person2);
31             ht.Add("3", person3);
32             ht.Add("4", person4);
33             ht.Add("5", person5);
34             Console.WriteLine("请输入你的查询的用户名:");
35             string strName = Console.ReadLine();
36             //第一种方法 key值
37              foreach (string item in ht.Keys)
38             {
39                 Person p = (Person)ht[item];
40                 if (strName == p.Name)
41                 {
42                     Console.WriteLine("查询后的结果是:" + p.Name + "\t" + p.Email + "\t" + p.Age);
43                 }
44             }
45 
46 
47 
48             //第二种方法 value值
49              foreach (Person item in ht.Values)
50             {
51                 if (item.Name == strName)
52                 {
53                     Console.WriteLine("查询后的结果是:" + item.Name + "\t" + item.Email + "\t" + item.Age);
54                 }
55 
56             }
57             //第三种方法 key和value值
58              foreach (DictionaryEntry item in ht)
59             {
60                 if (strName == ((Person)item.Value).Name)
61                 {
62                     Console.WriteLine("查询后的结果是:" + ((Person)item.Value).Name + "\t" + ((Person)item.Value).Email + "\t" + ((Person)item.Value).Age);
63                 }
64             }
65 
66             //第四种方法
67              IDictionaryEnumerator id = ht.GetEnumerator();
68             while (id.MoveNext())
69             {
70              Person p =   (Person)ht[id.Key];
71              if (p.Name == strName)
72              {
73                  Console.WriteLine("查询后的结果是:" + p.Name + "\t" + p.Email + "\t" + p.Age);
74              }
75             }
76 
77         }
static void Main(string[] args)
 2         {
 3             Person person1 = new Person();
 4             person1.Age = 34;
 5             person1.Name = "Jacky";
 6             person1.Email = "Jacky@gmail.com";
 7 
 8             Person person2 = new Person();
 9             person2.Age = 23;
10             person2.Name = "Ajay";
11             person2.Email = "Ajay@gmail.com";
12 
13             Person person3 = new Person();
14             person3.Age = 12;
15             person3.Name = "Bill";
16             person3.Email = "Bill@gmail.com";
17 
18             Person person4 = new Person();
19             person4.Age = 23;
20             person4.Name = "Gace";
21             person4.Email = "Gace@gmail.com";
22 
23             Person person5 = new Person();
24             person5.Age = 45;
25             person5.Name = "Jim";
26             person5.Email = "Jim@gmail.com";
27 
28             Hashtable ht = new Hashtable();
29             ht.Add("1", person1);
30             ht.Add("2", person2);
31             ht.Add("3", person3);
32             ht.Add("4", person4);
33             ht.Add("5", person5);
34             Console.WriteLine("请输入你的查询的用户名:");
35             string strName = Console.ReadLine();
36             //第一种方法 key值
37              foreach (string item in ht.Keys)
38             {
39                 Person p = (Person)ht[item];
40                 if (strName == p.Name)
41                 {
42                     Console.WriteLine("查询后的结果是:" + p.Name + "\t" + p.Email + "\t" + p.Age);
43                 }
44             }
45 
46 
47 
48             //第二种方法 value值
49              foreach (Person item in ht.Values)
50             {
51                 if (item.Name == strName)
52                 {
53                     Console.WriteLine("查询后的结果是:" + item.Name + "\t" + item.Email + "\t" + item.Age);
54                 }
55 
56             }
57             //第三种方法 key和value值
58              foreach (DictionaryEntry item in ht)
59             {
60                 if (strName == ((Person)item.Value).Name)
61                 {
62                     Console.WriteLine("查询后的结果是:" + ((Person)item.Value).Name + "\t" + ((Person)item.Value).Email + "\t" + ((Person)item.Value).Age);
63                 }
64             }
65 
66             //第四种方法
67              IDictionaryEnumerator id = ht.GetEnumerator();
68             while (id.MoveNext())
69             {
70              Person p =   (Person)ht[id.Key];
71              if (p.Name == strName)
72              {
73                  Console.WriteLine("查询后的结果是:" + p.Name + "\t" + p.Email + "\t" + p.Age);
74              }
75             }
76 
77         }

 第四:Queue集合和Stack

 第四:Queue集合和Stack

Queue:它是二个先进先出的集合(它存款和储蓄于队列中),先进先出的意味也便是初阶放进集合的多少,拿多少的时候从最初放进去的多寡起头拿。

Queue:它是一个先进先出的成团(它存储于队列中),先进先出的情趣也正是初次放进集合的多寡,拿多少的时候从初期放进去的数据开头拿。

Stack:它是一个后进先出的集结(它存储于栈中),后进先出的意趣顾名思义,也便是说取多少只好从最后放进去的卓殊数据起始取。

Stack:它是三个后进先出的会面(它存款和储蓄于栈中),后进先出的意味顾名思义,也正是说取多少只可以从最后放进去的足够数据起始取。

 以下代码实例了各自使用Stack和Queue打印数字0~9。

 以下代码实例了个别采用Stack和Queue打字与印刷数字0~9。

//写入数据到Queue中
2. Queue q = new Queue();
3. for (int i = 0; i < 10; i++)
4. {
5.     q.Enqueue(i);
6. }
7. 
8. 
9. //循环输出Queue所有数据
10. Console.WriteLine("开始输出Queue数据");
11. while (q.Count > 0)
12. {
13.     Console.WriteLine(q.Dequeue());
14. } 
15. 
16. //-------------------------------------分割线------------------------------------//
17. 
18. //写入数据到Stack中
19. Stack s = new Stack();
20. for (int i = 0; i < 10; i++)
21. {
22.     s.Push(i);
23. }
24. 
25. //循环输出所有Stack数据
26. Console.WriteLine("开始输出Stack数据");
27. while (s.Count > 0)
28. {
29.     Console.WriteLine(s.Pop());
30. }
//写入数据到Queue中
2. Queue q = new Queue();
3. for (int i = 0; i < 10; i++)
4. {
5.     q.Enqueue(i);
6. }
7. 
8. 
9. //循环输出Queue所有数据
10. Console.WriteLine("开始输出Queue数据");
11. while (q.Count > 0)
12. {
13.     Console.WriteLine(q.Dequeue());
14. } 
15. 
16. //-------------------------------------分割线------------------------------------//
17. 
18. //写入数据到Stack中
19. Stack s = new Stack();
20. for (int i = 0; i < 10; i++)
21. {
22.     s.Push(i);
23. }
24. 
25. //循环输出所有Stack数据
26. Console.WriteLine("开始输出Stack数据");
27. while (s.Count > 0)
28. {
29.     Console.WriteLine(s.Pop());
30. }

出口结果:
美高梅开户网址 14

输出结果:
美高梅开户网址 15

基于以下代码对Queue 与
Stack实行了质量测试,他们的性质都比数组要伟差不离2~倍。

遗闻以下代码对Queue 与
Stack实行了质量测试,他们的质量都比数组要伟大约2~倍。

Stopwatch sw_queue = new Stopwatch();
2. sw_queue.Start();
3. 
4. //写入数据到Queue中
5. Queue q = new Queue();
6. for (int i = 0; i < 1000000; i++)
7. {
8.     q.Enqueue(i);
9. }
10. 
11. //循环输出Queue所有数据
12. while (q.Count > 0)
13. {
14.     q.Dequeue();
15. }
16. 
17. sw_queue.Stop(); // 停止监视
18. Console.WriteLine("Queue 100万数据写入读取消耗时间:{0}毫秒", sw_queue.Elapsed.TotalMilliseconds.ToString());
19. 
20. //---------------------------------分割线--------------------------------//
21. 
22. Stopwatch sw_stack = new Stopwatch();
23. sw_stack.Start();
24. 
25. 
26. //写入数据到Stack中
27. Stack s = new Stack();
28. for (int i = 0; i < 1000000; i++)
29. {
30.     s.Push(i);
31. }
32. 
33. //循环输出所有Stack数据
34. while (s.Count > 0)
35. {
36.     s.Pop();
37. }
38. 
39. sw_stack.Stop(); // 停止监视
40. Console.WriteLine("Stack 100万数据写入读取消耗时间:{0}毫秒", sw_stack.Elapsed.TotalMilliseconds.ToString());
41. 
42. 
43. Console.R
eadKey();
Stopwatch sw_queue = new Stopwatch();
2. sw_queue.Start();
3. 
4. //写入数据到Queue中
5. Queue q = new Queue();
6. for (int i = 0; i < 1000000; i++)
7. {
8.     q.Enqueue(i);
9. }
10. 
11. //循环输出Queue所有数据
12. while (q.Count > 0)
13. {
14.     q.Dequeue();
15. }
16. 
17. sw_queue.Stop(); // 停止监视
18. Console.WriteLine("Queue 100万数据写入读取消耗时间:{0}毫秒", sw_queue.Elapsed.TotalMilliseconds.ToString());
19. 
20. //---------------------------------分割线--------------------------------//
21. 
22. Stopwatch sw_stack = new Stopwatch();
23. sw_stack.Start();
24. 
25. 
26. //写入数据到Stack中
27. Stack s = new Stack();
28. for (int i = 0; i < 1000000; i++)
29. {
30.     s.Push(i);
31. }
32. 
33. //循环输出所有Stack数据
34. while (s.Count > 0)
35. {
36.     s.Pop();
37. }
38. 
39. sw_stack.Stop(); // 停止监视
40. Console.WriteLine("Stack 100万数据写入读取消耗时间:{0}毫秒", sw_stack.Elapsed.TotalMilliseconds.ToString());
41. 
42. 
43. Console.R
eadKey();

测试结果:
美高梅开户网址 16

测试结果:
美高梅开户网址 17

Queue 的重庆大学成员:

Queue 的根本成员:

属性  

属性  

Count    //元素数     

Count    //元素数     

方法 

方法 

Clear()   //清空 

Clear()   //清空 

Contains() //是或不是带有 

Contains() //是还是不是包罗 

Dequeue() //出列 

Dequeue() //出列 

Enqueue() //入列 

Enqueue() //入列 

Peek()   //获取将要出列的 

Peek()   //获取将要出列的 

Stack 的显要成员:

Stack 的第14.29%员:

属性   Count       //     

属性   Count       //     

方法 

方法 

Clear()      // 

Clear()      // 

Contains()    // 

Contains()    // 

Peek()       //获取将要出栈的 

Peek()       //获取将要出栈的 

Pop()       //出栈 

Pop()       //出栈 

Push()       //压栈 

Push()       //压栈 

第五:SortedList

第五:SortedList

1、SortedList定义

System.Collections.SortedList类表示键/值对的聚集,那几个键值对按键排序并可依据键和目录访问。SortedList
在里边维护八个数组以存款和储蓄列表中的成分;即,2个数组用于键,另3个数组用于相关联的值。各种元素都以叁个可作为
DictionaryEntry.aspx)
对象开始展览走访的键/值对。键无法为null,但值能够。

1、SortedList定义

System.Collections.SortedList类表示键/值对的集结,那么些键值对按键排序并可依据键和目录访问。SortedList
在其间维护三个数组以存款和储蓄列表中的成分;即,2个数组用于键,另3个数组用于相关联的值。各种成分都以一个可作为
DictionaryEntry.aspx)
对象开始展览走访的键/值对。键无法为null,但值能够。

2.优点

① 、SortedList
允许通过有关联键或透过索引对值举行访问,可提供更大的灵活性。

二 、可依照必要活动叠加体积。

2.优点

① 、SortedList
允许通过相关联键或通过索引对值实行走访,可提供更大的油滑。

② 、可依照须求活动叠加容积。

3.注意点:

① 、SortedList 的体量是 SortedList 能够保留的要素数。SortedList
的暗中认可开端容积为 0。随着成分添加到 SortedList
中,在急需时方可因而重新分配自动扩充容积。可通过调用
TrimToSize美高梅开户网址,.aspx)方法
或透过显式设置
Capacity.aspx)
属性减弱体积。

② 、SortedList 中不容许重复键。

三 、SortedList的目录顺序基于排序依次。当添英镑素时,成分将按正确的排序依次插入
SortedList,同时索引会相应地开展调整。当移除成分时,索引也会相应地拓展调整。由此,当在
SortedList 中添加或移除成分时,特定键/值对的目录大概会变动。

4.当不向聚集中添加新因素,则调用TrimToSize艺术可用来最小化集合的内部存款和储蓄器费用。

五 、通过设置 SortedList
中不设有的键值(例如,myCollection[“myNonexistentKey”] =
myValue),还足以应用 Item 属性添加新成分。可是,借使钦定的键已经存在于
SortedList 中,则设置 Item
属性将改写旧值。比较之下,Add.aspx)
方法不修改现有成分。

键无法为 空引用(在 Visual Basic 中为
Nothing),但值能够。若要区分由于未找到内定键而回到的 空引用(在 Visual
Basic 中为 Nothing) 和出于钦命键的值为 空引用(在 Visual Basic 中为
Nothing) 而回到的 空引用(在 Visual Basic 中为 Nothing),请使用
Contains.aspx)
方法或
ContainsKey.aspx)
方法明确列表中是不是留存该键。

  1. SortedList的构造器

美高梅开户网址 18

5、SortedList的属性

美高梅开户网址 19

6.SortedList的方法

美高梅开户网址 20

美高梅开户网址 21

泛型集合SortedList<TKey,电视机alue>:

固然急需排好序的表,能够利用SortedList<TKey,TValue>。这一个类遵照键给成分排序。

上边包车型大巴例证创造多少个平稳表,当中键和值都以string类型。暗中认可的构造函数创造了二个空表,再用Add()方法添加两本书。使用重载的构造函数,能够定义有序表的体量,传送执行了IComparer<TKey>接口的目的,用于给有序表中得成分排序。

Add()方法的率先个参数是键(书名),第3个参数是值(ISBN号)。除了使用Add()方法之外,还足以行使索引器将成分添加到平稳表中。索引器需求把键作为目录参数。假如键已存在,那么Add()方法就抛出八个ArgumentException类型的不得了。如若索引器使用同样的键,就用新值替代旧值。

 

static void Main(string[] args)  
06.        {  
07.            // 创建一个SortedList对象          
08.            SortedList mySortedList = new SortedList();  
09.            mySortedList.Add("First", "Hello");  
10.            mySortedList.Add("Second", "World");  
11.            mySortedList.Add("Third", "!");  
12.            mySortedList.Add("Four", "{1}quot;);    
13.  
14.            //列举SortedList的属性、键、值  
15.            Console.WriteLine("MySortedList");  
16.            Console.WriteLine("  Count:    {0}", mySortedList.Count);  
17.            Console.WriteLine("  Capacity: {0}", mySortedList.Capacity);  
18.            Console.WriteLine("  Keys and Values:");  
19.            PrintIndexAndKeysAndValues(mySortedList);  
20. 
21.            #region SortedList获得键、值列表  
22.            SortedList mySortedList1 = new SortedList();  
23.            mySortedList1.Add(1.3, "fox");  
24.            mySortedList1.Add(1.4, "jumped");  
25.            mySortedList1.Add(1.5, "over");  
26.            mySortedList1.Add(1.2, "brown");  
27.            mySortedList1.Add(1.1, "quick");  
28.            mySortedList1.Add(1.0, "The");  
29.            mySortedList1.Add(1.6, "the");  
30.            mySortedList1.Add(1.8, "dog");  
31.            mySortedList1.Add(1.7, "lazy");   
32.  
33.            //获得指定索引处的键和值  
34.            int myIndex = 3;  
35.            //     获取 System.Collections.SortedList 对象的指定索引处的键  
36.            Console.WriteLine("The key  at index {0} is {1}.", myIndex, mySortedList1.GetKey(myIndex));  
37.            //     获取 System.Collections.SortedList 对象的指定索引处的值  
38.            Console.WriteLine("The value at index {0} is {1}.", myIndex, mySortedList1.GetByIndex(myIndex));     
39.  
40.            // 获得SortedList中的键列表和值列表         
41.            IList myKeyList = mySortedList1.GetKeyList();  
42.            IList myValueList = mySortedList1.GetValueList();  
43.            // Prints the keys in the first column and the values in the second column.             
44.            Console.WriteLine("\t-KEY-\t-VALUE-");  
45.            for (int i = 0; i < mySortedList1.Count; i++)   
46.                Console.WriteLine("\t{0}\t{1}", myKeyList[i], myValueList[i]);  
47. 
48.            #endregion   
49. 
50.            #region 为SortedList中的元素重新赋值   
51.            // Creates and initializes a new SortedList.     
52.            SortedList mySortedList2 = new SortedList();  
53.            mySortedList2.Add(2, "two");  
54.            mySortedList2.Add(3, "three");   
55.            mySortedList2.Add(1, "one");  
56.            mySortedList2.Add(0, "zero");  
57.            mySortedList2.Add(4, "four");             
58.            // 打印显示列表的键和值           
59.            Console.WriteLine("The SortedList contains the following values:");  
60.            PrintIndexAndKeysAndValues(mySortedList2);        
61.     
62.            // 获得指定键的索引          
63.            int myKey = 2;  
64.            Console.WriteLine("The key \"{0}\" is at index {1}.", myKey, mySortedList2.IndexOfKey(myKey));        
65.            // 获得指定值的索引       
66.            String myValue = "three";  
67.            Console.WriteLine("The value \"{0}\" is at index {1}.", myValue, mySortedList2.IndexOfValue(myValue));        
68.            // 重新设置指定索引处的值           
69.            mySortedList2.SetByIndex(3, "III");   // SetByIndex:替换 System.Collections.SortedList 对象中指定索引处的值  
70.            mySortedList2.SetByIndex(4, "IV");         
71.            //打印显示列表的键和值         
72.            Console.WriteLine("After replacing the value at index 3 and index 4,");  
73.            PrintIndexAndKeysAndValues(mySortedList2);        
74.            #endregion  
75.            Console.ReadKey();  
76.        }  
77.  
78.        //打印SortedList中的键和值   
79.        public static void PrintIndexAndKeysAndValues(SortedList myList)    
80.        {              
81.            Console.WriteLine("\t-INDEX-\t-KEY-\t-VALUE-");  
82.            for (int i = 0; i < myList.Count; i++)       
83.            {             
84.                Console.WriteLine("\t[{0}]:\t{1}\t{2}", i, myList.GetKey(i), myList.GetByIndex(i));       
85.            }         
86.            Console.WriteLine();       
87.        }  
88.    }  

出口结果:
美高梅开户网址 22

                                                             
 能够到软件里畅游的写———————-来自地狱的镰刀

 

 

 

 

 

 

 

 

 

3.注意点:

一 、SortedList 的体积是 SortedList 能够保存的要素数。SortedList
的暗许初阶容积为 0。随着成分添加到 SortedList
中,在需求时能够透过重新分配自动增添体积。可由此调用
TrimToSize.aspx)方法
或通过显式设置
Capacity.aspx)
属性收缩容积。

二 、SortedList 中差别意重复键。

③ 、SortedList的目录顺序基于排序依次。当添欧元素时,成分将按正确的排序依次插入
SortedList,同时索引会相应地举办调整。当移除成分时,索引也会相应地开始展览调整。因而,当在
SortedList 中加上或移除成分时,特定键/值对的目录或者会转移。

4.当不向聚集中添加新因素,则调用TrimToSize艺术可用以最小化集合的内部存款和储蓄器开销。

五 、通过设置 SortedList
中不存在的键值(例如,myCollection[“myNonexistentKey”] =
myValue),还足以运用 Item 属性添加新成分。但是,假如钦命的键已经存在于
SortedList 中,则设置 Item
属性将改写旧值。相比较之下,Add.aspx)
方法不改动现有成分。

键无法为 空引用(在 Visual Basic 中为
Nothing),但值能够。若要区分由于未找到钦命键而回到的 空引用(在 Visual
Basic 中为 Nothing) 和出于钦点键的值为 空引用(在 Visual Basic 中为
Nothing) 而回到的 空引用(在 Visual Basic 中为 Nothing),请使用
Contains.aspx)
方法或
ContainsKey.aspx)
方法鲜明列表中是或不是留存该键。

  1. SortedList的构造器

美高梅开户网址 23

5、SortedList的属性

美高梅开户网址 24

6.SortedList的方法

美高梅开户网址 25

美高梅开户网址 26

泛型集合SortedList<TKey,TValue>:

如果急需排好序的表,能够运用SortedList<TKey,电视alue>。那些类依照键给成分排序。

上边包车型地铁例证成立3个平稳表,在那之中键和值都以string类型。暗中同意的构造函数创设了1个空表,再用Add()方法添加两本书。使用重载的构造函数,能够定义有序表的容积,传送执行了IComparer<TKey>接口的对象,用于给有序表中得成分排序。

Add()方法的率先个参数是键(书名),第1个参数是值(ISBN号)。除了接纳Add()方法之外,仍是能够动用索引器将成分添加到有序表中。索引器须求把键作为目录参数。若是键已存在,那么Add()方法就抛出2个ArgumentException类型的不胜。假设索引器使用相同的键,就用新值替代旧值。

 

static void Main(string[] args)  
06.        {  
07.            // 创建一个SortedList对象          
08.            SortedList mySortedList = new SortedList();  
09.            mySortedList.Add("First", "Hello");  
10.            mySortedList.Add("Second", "World");  
11.            mySortedList.Add("Third", "!");  
12.            mySortedList.Add("Four", "{1}quot;);    
13.  
14.            //列举SortedList的属性、键、值  
15.            Console.WriteLine("MySortedList");  
16.            Console.WriteLine("  Count:    {0}", mySortedList.Count);  
17.            Console.WriteLine("  Capacity: {0}", mySortedList.Capacity);  
18.            Console.WriteLine("  Keys and Values:");  
19.            PrintIndexAndKeysAndValues(mySortedList);  
20. 
21.            #region SortedList获得键、值列表  
22.            SortedList mySortedList1 = new SortedList();  
23.            mySortedList1.Add(1.3, "fox");  
24.            mySortedList1.Add(1.4, "jumped");  
25.            mySortedList1.Add(1.5, "over");  
26.            mySortedList1.Add(1.2, "brown");  
27.            mySortedList1.Add(1.1, "quick");  
28.            mySortedList1.Add(1.0, "The");  
29.            mySortedList1.Add(1.6, "the");  
30.            mySortedList1.Add(1.8, "dog");  
31.            mySortedList1.Add(1.7, "lazy");   
32.  
33.            //获得指定索引处的键和值  
34.            int myIndex = 3;  
35.            //     获取 System.Collections.SortedList 对象的指定索引处的键  
36.            Console.WriteLine("The key  at index {0} is {1}.", myIndex, mySortedList1.GetKey(myIndex));  
37.            //     获取 System.Collections.SortedList 对象的指定索引处的值  
38.            Console.WriteLine("The value at index {0} is {1}.", myIndex, mySortedList1.GetByIndex(myIndex));     
39.  
40.            // 获得SortedList中的键列表和值列表         
41.            IList myKeyList = mySortedList1.GetKeyList();  
42.            IList myValueList = mySortedList1.GetValueList();  
43.            // Prints the keys in the first column and the values in the second column.             
44.            Console.WriteLine("\t-KEY-\t-VALUE-");  
45.            for (int i = 0; i < mySortedList1.Count; i++)   
46.                Console.WriteLine("\t{0}\t{1}", myKeyList[i], myValueList[i]);  
47. 
48.            #endregion   
49. 
50.            #region 为SortedList中的元素重新赋值   
51.            // Creates and initializes a new SortedList.     
52.            SortedList mySortedList2 = new SortedList();  
53.            mySortedList2.Add(2, "two");  
54.            mySortedList2.Add(3, "three");   
55.            mySortedList2.Add(1, "one");  
56.            mySortedList2.Add(0, "zero");  
57.            mySortedList2.Add(4, "four");             
58.            // 打印显示列表的键和值           
59.            Console.WriteLine("The SortedList contains the following values:");  
60.            PrintIndexAndKeysAndValues(mySortedList2);        
61.     
62.            // 获得指定键的索引          
63.            int myKey = 2;  
64.            Console.WriteLine("The key \"{0}\" is at index {1}.", myKey, mySortedList2.IndexOfKey(myKey));        
65.            // 获得指定值的索引       
66.            String myValue = "three";  
67.            Console.WriteLine("The value \"{0}\" is at index {1}.", myValue, mySortedList2.IndexOfValue(myValue));        
68.            // 重新设置指定索引处的值           
69.            mySortedList2.SetByIndex(3, "III");   // SetByIndex:替换 System.Collections.SortedList 对象中指定索引处的值  
70.            mySortedList2.SetByIndex(4, "IV");         
71.            //打印显示列表的键和值         
72.            Console.WriteLine("After replacing the value at index 3 and index 4,");  
73.            PrintIndexAndKeysAndValues(mySortedList2);        
74.            #endregion  
75.            Console.ReadKey();  
76.        }  
77.  
78.        //打印SortedList中的键和值   
79.        public static void PrintIndexAndKeysAndValues(SortedList myList)    
80.        {              
81.            Console.WriteLine("\t-INDEX-\t-KEY-\t-VALUE-");  
82.            for (int i = 0; i < myList.Count; i++)       
83.            {             
84.                Console.WriteLine("\t[{0}]:\t{1}\t{2}", i, myList.GetKey(i), myList.GetByIndex(i));       
85.            }         
86.            Console.WriteLine();       
87.        }  
88.    }  

输出结果:
美高梅开户网址 27

                                                             
 能够到软件里畅游的写———————-来自鬼世界的镰刀

 

 

 

 

 

 

 

 

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图