非泛型集合和泛型集合的超级详解,源码阅读总结

ArrayList ,List

ArrayList 和 List 都以不约束长度的集结类型 ,List相比较ArrayList
就此中贯彻来说除了泛型本质未有太大差异。然而为防止装箱拆箱难题,尽也许接纳List

聚拢内部是由数组完成,私下认可大小是4,但您利用无参构造函数构造实例时,内部数组大小是0,当你投入第叁个因素时,才扩大体量为4,添美元素时,假如开掘内置数组大小相当不足,内置数组大小会扩大体量为原来的两倍,每壹次扩大体积都会另行开采二个数组,拷贝旧数组的数额,假使您要给群集增添大批量的要素却不为它开首化一个适用容积,频仍的内部存款和储蓄器开拓和多余的数组拷贝会招致品质的开销。

由此利用时建议提供适宜的体积。

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卡塔 尔(英语:State of Qatar)的 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(泛型集结卡塔 尔(英语:State of Qatar)

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, TValue>)>)
泛型接口。由此,那个聚聚焦的每一种成分都以一个键/值对。

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以至被占用的时候,就能够追加一个位移x值剖断下二个职责Postion+x是或不是被占用,假如仍旧被攻克就继续往下位移x判别Position+2*x地点是不是被占用,若无被挤占则将值放入个中。当HashTable中的可用空间愈发小时,则收得到到可用空间的难度更加大,消耗的岁月就越来越多。

5..当下HashTable中的被占用空间到达多个比重的时候就将该空间活动扩大体量,在.net中那几个比重是72%,也叫.net中HashTable的填写因子为0.72。比如有二个HashTable的长台湾空中大学小是100,当它需求丰硕第柒20个值的时候将会扩大体积此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:它是三个后进先出的聚众(它存款和储蓄于栈中卡塔尔国,后进先出的野趣从名称想到所包含的意义,也正是说取多少只好从最后放进去的十三分数据起初取。

 以下代码实例了各自选取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

hashtable,Dictionary

hashtable和Dictionary都以哈希表的落到实处,相当多个人说Dictionary内部是由hashtable完成的,那是不适宜的。

hashtable的结构必要装载因子,装载因子是0.1 到 1.0 范围内的数字
,是里面存款和储蓄桶数(count卡塔 尔(阿拉伯语:قطر‎所占桶数组(buckets卡塔尔桶数(hashsize卡塔 尔(英语:State of Qatar)的最大比率
,当桶数大于装载数(loadsize卡塔 尔(英语:State of Qatar)时,桶数组就能够扩大体量

hashtable内部撤销哈希冲突的算法是双重散列法,是开放地点法中最棒的艺术之风流洒脱

而各异的是,Dictionary内部废除哈希冲突的算法是链地址法,何况Dictionary的布局无需装载因子,不受装载因子的约束,假诺Dictionary一点都一点都不大,查找,插入,删除等操作具有相近O(1卡塔尔的作用

和ArrayList
,List相似的是Dictionary和hashtable内部也是由数组实现的,所以组织时也急需提供方便体量,幸免品质的费用。

但大家供给此外注意的是您提供给构造函数的容积不分明会是初始时放置数组的长度,构造函数内部会采用三个过量等于你所采取体量的素数作为忠实的初阶体量。

1、SortedList定义

System.Collections.SortedList类表示键/值对的汇集,这几个键值对开关排序并可依据键和目录访谈。SortedList
在里面维护多个数组以存款和储蓄列表中的元素;即,二个数组用于键,另一个数组用于相关联的值。种种成分都以叁个可看成
DictionaryEntry 对象开展会见的键/值对。键不能够为null,但值能够。

HashSet

HashSet是二个冬辰的能够保证唯大器晚成性的集合。我们也能够把HashSet看作是Dictionary<TKey,电视alue>,只不过TKey和电视alue都照准同一个指标。内部贯彻和Dictionary特别相近。
HashSet极其相符在我们必要保持会集内元素唯生龙活虎性但又无需按顺序排列的时候。

2.优点

1、SortedList
允许通过相关联键或通过索引对值进行拜访,可提供更加大的八面见光。

2、可依照供给活动叠合体积。

SortedList

SortedList是援助排序的关联性(键值对 卡塔尔集合,内部使用数组达成,所以和List雷同的是,最早化时供给提供三个正巧的容积,SortedList内部接受哈希算法达成,和Dictionary肖似的是,SortedList内部消释哈希冲突的算法是链地址法。

因为在寻觅的时候利用了二分查找,所以寻觅的质量会好有的,时间复杂度是O(log
n)

就算你想要火速寻觅,又想集合根据key的顺序排列,最终这么些集结的操作(增多和移除卡塔 尔(阿拉伯语:قطر‎少之甚少的话,正是SortedList了

3.注意点:

1、SortedList 的体量是 SortedList 可以保留的因素数。SortedList
的私下认可早先体积为 0。随着成分增添到 SortedList
中,在急需时得以通过重新分配自动增添容积。可通过调用 TrimToSize方法
或透过显式设置 Capacity 属性减弱体量。

2、SortedList 中不容许重复键。

3、SortedList的目录顺序基于排序依次。当添美金素时,成分将按精确的排序依次插入
SortedList,同有时间索引会相应地进行调解。当移除成分时,索引也会相应地开展调度。因而,当在
SortedList 中加上或移除成分时,特定键/值没有错目录恐怕会转移。

4.当不向聚聚焦增多新因素,则调用TrimToSize方法可用于最小化群集的内部存款和储蓄器耗费。

5、通过设置 SortedList
中官样文章的键值(譬喻,myCollection[“myNonexistentKey”] =
myValue卡塔 尔(阿拉伯语:قطر‎,还是能利用 Item 属性增多新成分。但是,纵然内定的键已经存在于
SortedList 中,则设置 Item 属性将改写旧值。比较之下,Add
方法不更改现成成分。

键不能够为 空引用(在 Visual Basic 中为
Nothing卡塔 尔(英语:State of Qatar),但值能够。若要区分由于未找到钦命键而回到的 空引用(在 Visual
Basic 中为 Nothing卡塔 尔(英语:State of Qatar) 和出于钦赐键的值为 空引用(在 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类型。默许的构造函数成立了一个空表,再用Add()方法增添两本书。使用重载的构造函数,可以定义有序表的体量,传送施行了IComparer<TKey>接口的对象,用于给有序表中得成分排序。

Add()方法的率先个参数是键(书名卡塔尔国,第一个参数是值(ISBN号卡塔 尔(英语:State of Qatar)。除了运用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.    }  

出口结果:
图片 9

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

 

 

 

 

 

 

 

 

 

C#
泛型集结之非泛型集合类与泛型集结类的相应: ArrayList对应List
HashTable对应Dictionary 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);
          }            
      }

LinkedList,Stack,Queue

那3个聚众笔者就比较少做表达,完全按那多少个底子数据结构的原理来兑现。可是Stack,Queue内部接纳数组完结,所以也要留神初步化时提供叁个极其的体积啊