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

ArrayList ,List

ArrayList 和 List 都以不限定长度的集合类型 ,List相比ArrayList
就个中贯彻而言除了泛型本质没有太大分别。可是为制止装箱拆箱难点,尽大概使用List

相会内部是由数组达成,私下认可大小是4,但你利用无参构造函数构造实例时,内部数组大小是0,当您加入第三个因素时,才扩大容积为4,添欧成分时,要是发现内置数组大小不够,内置数组大小会扩大体积为本来的两倍,每1遍扩容都会重复开发四个数组,拷贝旧数组的数码,借使你要给集合添加多量的元素却不为它发轫化多少个适合体积,频仍的内存开辟和剩余的数组拷贝会导致品质的消耗。

之所以选择时提议提供适当的体积。

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()复制1个数组

一: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>)>)
泛型接口。因而,这几个聚集中的各种元素都以1个键/值对。

Dictionary<(Of <(TKey, 电视alue>)>) 类与 Hashtable
类的效应雷同
对此值类型,特定项目(不包涵 Object)的 Dictionary<(Of <(TKey,
TValue>)>) 的性质优于 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.当1个HashTable被占用半数以上的时候我们通过计算散列值取得的地址值或然会再度指向同一地方,那就是哈希争辩。

4.在.Net中键值对在HashTable中的地点Position= (HashCode& 0x7FFFFFFF) %
HashTable.Length,.net中是经过探测法化解哈希争辩的,当通过散列值取得的岗位Postion以及被占用的时候,就会大增一个位移x值判断下3个职位Postion+x是不是被占用,倘使还是被占据就三番五次往下位移x判断Position+2*x地点是否被占用,即使没有被挤占则将值放入当中。当HashTable中的可用空间愈发小时,则获得获得可用空间的难度越来越大,消耗的时日就越来越多。

5..当下HashTable中的被占用空间达到三个百分比的时候就将该空间活动扩大体积,在.net中这一个比重是72%,也叫.net中HashTable的填写因子为0.72。例如有贰个HashTable的上台湾空中大学小是100,当它要求足够第十11个值的时候将会扩大体积此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:它是3个先进先出的集纳(它存储于队列中),先进先出的情趣也正是起首放进集合的数目,拿多少的时候从最初放进去的数码初叶拿。

Stack:它是二个后进先出的聚众(它存款和储蓄于栈中),后进先出的意味顾名思义,也等于说取多少只可以从最后放进去的11分数据初步取。

 以下代码实例了各自选用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
在内部维护七个数组以存款和储蓄列表中的成分;即,二个数组用于键,另三个数组用于相关联的值。各个成分都以三个可看做
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相同的是,初步化时索要提供多个适中的容积,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,电视机alue>。那几个类遵照键给成分排序。

下边包车型大巴事例创立一个不变表,当中键和值都以string类型。暗中同意的构造函数成立了2个空表,再用Add()方法添加两本书。使用重载的构造函数,能够定义有序表的体积,传送执行了IComparer<TKey>接口的目的,用于给有序表中得成分排序。

Add()方法的第贰个参数是键(书名),第四个参数是值(ISBN号)。除了使用Add()方法之外,还足以应用索引器将成分添加到有序表中。索引器须求把键作为目录参数。如若键已存在,那么Add()方法就抛出1个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内部选用数组落成,所以也要小心伊始化时提供三个适当的容积啊

SortedList对应SortedList

SortedList对应SortedList

 

 

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

第3  : ArrayList(非泛型集合)  与List(泛型集合)

ArrayList 是数组的错综复杂版本。ArrayList
类提供在半数以上 Collections 类中提供但不在 Array
类中提供的一些效应:

ArrayList 是数组的纷纭版本。ArrayList
类提供在大部 Collections 类中提供但不在 Array
类中提供的局部职能:

1.Array 的容积是定点的,而 ArrayList
的容积是依据须要活动扩充的。

1.Array 的体量是一定的,而 ArrayList
的体积是基于须求活动增添的。

2.ArrayList
提供丰盛、插入或移除某一限制成分的办法。在 Array
中,您不得不一遍得到或安装一个成分的值。

2.ArrayList
提供充分、插入或移除某一限制成分的艺术。在 Array
中,您不得不1次获得或安装2个成分的值。

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.供给四个数组的超越一全场地也足以代之以使用
ArrayList。它更易于使用,并且普通拥有与 Object
类型的数组类似的质量。

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

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

ArrayList类对象方法:

ArrayList类对象方法:

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

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>中只好有2个参数类型,“<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);
   }

其次
: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, TValue>)>) 泛型类完毕 IDictionary 接口

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

Dictionary<(Of <(TKey,
电视机alue>)>) 泛型类还落到实处 IDictionary<(Of <(TKey,
电视alue>)>)
泛型接口。因而,那么些聚集中的每一个元素都以贰个键/值对。

Dictionary<(Of <(TKey,
TValue>)>) 泛型类还完成 IDictionary<(Of <(TKey,
电视机alue>)>)
泛型接口。因此,这几个聚集中的每一种成分都以叁个键/值对。

Dictionary<(Of <(TKey,
TValue>)>) 类与 Hashtable 类的职能雷同
对于值类型,特定项目(不蕴涵 Object)的 Dictionary<(Of <(TKey,
TValue>)>) 的性质优越 Hashtable,那是因为 Hashtable 的要素属于
Object
类型,所以在储存或探寻值类型时一般产生装箱和撤回装箱操作。

Dictionary<(Of <(TKey,
电视alue>)>) 类与 Hashtable 类的功能雷同
对此值类型,特定项目(不包蕴 Object)的 Dictionary<(Of <(TKey,
电视机alue>)>) 的属性优于 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键值对,其还有3个看似索引的值叫做散列值(HashCode),它是遵照GetHashCode方法对Key通过一定算法获取得到的,全部的寻找操作定位操作都以依据散列值来完结找到相应的Key和Value值的。

1.HashTable是一种散列表,他中间维护广大对Key-Value键值对,其还有3个近乎索引的值叫做散列值(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以及被占用的时候,就会追加2个位移x值判断下2个职分Postion+x是或不是被占用,借使依然被占据就此起彼伏往下位移x判断Position+2*x地方是不是被占用,借使没有被挤占则将值放入个中。当HashTable中的可用空间愈发小时,则获得获得可用空间的难度越来越大,消耗的岁月就更加多。

4.在.Net中键值对在HashTable中的地方Position=
(HashCode& 0x7FFFFFFF) %
HashTable.Length,.net中是通过探测法消除哈希争辨的,当通过散列值取得的地点Postion以及被占用的时候,就会扩展3个位移x值判断下一个岗位Postion+x是或不是被占用,假使依然被占用就持续往下位移x判断Position+2*x地点是还是不是被占用,如若没有被并吞则将值放入个中。当HashTable中的可用空间越来越小时,则收得到到可用空间的难度进一步大,消耗的年华就越多。

5..脚下HashTable中的被占用空间达到3个百分比的时候就将该空间活动扩大体量,在.net中那些比例是72%,也叫.net中HashTable的填写因子为0.72。例如有一个HashTable的上台湾空中大学小是100,当它须求丰盛第10五个值的时候将会扩大体积此HashTable.

5..当下HashTable中的被占用空间达到3个比例的时候就将该空间活动扩大容积,在.net中那一个比重是72%,也叫.net中HashTable的填充因子为0.72。例如有2个HashTable的长空尺寸是100,当它须要添加第812个值的时候将会扩大体积此HashTable.

6.那一个自动扩大体量的大大小小是不怎么啊?答案是近期空间尺寸的两倍最相近的素数,例如当前HashTable所占空间为素数71,假诺扩大体积,则扩大体量大小为素数131.

6.那个自动扩大体量的大大小小是稍稍啊?答案是当下空中尺寸的两倍最相仿的素数,例如当前HashTable所占空间为素数71,假使扩大体量,则扩大体量大小为素数131.

亚洲必赢官网 10

亚洲必赢官网 11

二:Dictionary

二:Dictionary

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

1.Dictionary是一种变种的HashTable,它使用一种分离链接散列表的数据结构来消除哈希争辨的难题。

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

亚洲必赢官网 ,2.分离链接散列表是当散列到同一个地方的值存为一个链表中。

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:它是2个先进先出的聚集(它存款和储蓄于队列中),先进先出的趣味约等于首先放进集合的多少,拿多少的时候从早期放进去的多寡开始拿。

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

Stack:它是1个后进先出的集合(它存储于栈中),后进先出的情趣顾名思义,也正是说取多少只好从最后放进去的分外数据开端取。

 以下代码实例了个别选拔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 的根本成员:

属性   Count       //     

属性   Count       //     

方法 

方法 

Clear()      // 

Clear()      // 

Contains()    // 

Contains()    // 

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

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

Pop()       //出栈 

Pop()       //出栈 

Push()       //压栈 

Push()       //压栈 

第五:SortedList

第五:SortedList

1、SortedList定义

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

1、SortedList定义

System.Collections.SortedList类表示键/值对的联谊,那个键值对按键排序并可根据键和目录访问。SortedList
在里面维护三个数组以存款和储蓄列表中的成分;即,一个数组用于键,另2个数组用于相关联的值。各样成分都是三个可作为
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,TValue>:

若果急需排好序的表,能够采取SortedList<TKey,电视alue>。那一个类遵照键给成分排序。

下面包车型大巴事例创设三个稳步表,在那之中键和值都是string类型。默许的构造函数创造了三个空表,再用Add()方法添加两本书。使用重载的构造函数,可以定义有序表的体量,传送执行了IComparer<TKey>接口的靶子,用于给有序表中得成分排序。

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

出口结果:
亚洲必赢官网 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,电视机alue>:

假定急需排好序的表,可以应用SortedList<TKey,电视机alue>。那个类依据键给成分排序。

下边包车型客车例子创造多少个因循古板表,当中键和值皆以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.    }  

出口结果:
亚洲必赢官网 27

                                                             
 能够到软件里畅游的写———————-来自幽冥间的镰刀

 

 

 

 

 

 

 

 

 

网站地图xml地图