澳门至尊网站-首页

您的位置:澳门至尊网站 > 程序编程 > 非泛型集合和泛型集合的超级详解,源码阅读总

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

2019-10-19 19:37

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)的 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, TValue>)>) 泛型类还贯彻IDictionary<(Of <(TKey, 电视机alue>)>) 泛型接口。因而,这一个聚聚集的各个成分都以三个键/值对。

Dictionary<(Of <(TKey, TValue>)>) 类与 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,当它必要加上第73个值的时候将会扩大体量此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)的最大比率 ,当桶数大于装载数(loadsize)时,桶数组就能够扩大容积

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),但值能够。若要区分由于未找到钦点键而回到的 空援引(在 Visual Basic 中为 Nothing) 和出于钦定键的值为 空援用(在 Visual Basic 中为 Nothing) 而回到的 空援用(在 Visual Basic 中为 Nothing),请使用 Contains 方法或 ContainsKey 方法鲜明列表中是不是留存该键。

  1. SortedList的构造器

图片 5

5、SortedList的属性

图片 6

6.SortedList的方法

图片 7

图片 8

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

举例必要排好序的表,可以应用SortedList<TKey,TValue>。那些类根据键给成分排序。

上面包车型地铁事例创造叁个长久以来表,在那之中键和值都以string类型。暗中认可的构造函数创制了一个空表,再用Add()方法增多两本书。使用重载的构造函数,能够定义有序表的体积,传送施行了IComparer<TKey>接口的指标,用于给有序表中得成分排序。

Add()方法的第多少个参数是键(书名),第贰个参数是值(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.    }  

输出结果:
图片 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内部接纳数组实现,所以也要留心开首化时提供一个非常的体量啊

本文由澳门至尊网站发布于程序编程,转载请注明出处:非泛型集合和泛型集合的超级详解,源码阅读总

关键词: