威尼斯人线上娱乐

【威尼斯人线上娱乐】源码阅读总计,非泛型集合和泛型集合的极品详解

1 4月 , 2019  

ArrayList ,List

ArrayList 和 List 都是不限量长度的集合类型 ,List比较ArrayList
就在那之中贯彻而言除了泛型本质没有太大分别。不过为幸免装箱拆箱难题,尽大概使用List

集聚内部是由数组完成,暗中同意大小是四,但你利用无参构造函数构造实例时,内部数组大小是0,当你投入第三个成分时,才扩大体量为肆,添新币素时,假使发现内置数组大小不够,内置数组大小会扩大体量为本来的两倍,每贰回扩大体积都会另行开发一个数组,拷贝旧数组的数目,假使你要给集合添加大批量的要素却不为它初叶化贰个适当体量,频仍的内部存储器开辟和剩余的数组拷贝会导致质量的花费。

之所以选拔时提出提供合适的容积。

C#非泛型集合和泛型集合的超级详解,

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

ArrayList对应List

HashTable对应Dictionary

Queue对应Queue

Stack对应Stack

SortedList对应SortedList

 

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

ArrayList 是数组的繁杂版本。ArrayList 类提供在大部分 Collections
类中提供但不在 Array 类中提供的1些意义:

1.Array 的体量是稳定的,而 ArrayList 的体量是依照供给活动扩张的。

2.ArrayList 提供丰盛、插入或移除某壹限制成分的艺术。在 Array
中,您不得不1遍得到或设置1个要素的值。

三.行使 Synchronized 方法能够很简单地创立 ArrayList 的共同版本。而 Array
将直接维系它直到用户完结联机截止。

肆.ArrayList 提供将只读和从来大小包裹再次来到到集结的方式。而 Array 不提供。

伍.Array 提供 ArrayList 所不拥有的一点灵活性:

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

   b.Array 能够有所七个维度,而 ArrayList 始终只是1维的。

   c.特定类型(不包涵 Object)的 Array 的质量比 ArrayList 好,这是因为
ArrayList 的要素属于 Object
类型,所以在仓库储存或探寻值类型时经常发生装箱和打消装箱。

   d.要求三个数组的超过一半景观也能够代之以使用
ArrayList。它更便于使用,并且普通具有与 Object 类型的数组类似的性质。

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

ArrayList类对象方法:

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

一: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是概念泛型类时的占位符,其并不是1种类型,仅代表某种大概的类型。在概念时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:二10拾2线程程序中推荐介绍使用 Hashtable, 暗中认可的 Hashtable 允许单线程写入,
二10拾二线程读取, 对 Hashtable 进一步调用 Synchronized()
方法能够获得完全线程安全的类型. 而 Dictionary 非线程安全, 必须人为使用
lock 语句举行维护, 功效大减.
 三:Dictionary 有按插入顺序排列数据的本性 (注: 但当调用 Remove()
删除过节点后相继被打乱), 因而在要求反映顺序的境地中央银行使 Dictionary
能获取肯定方便.

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

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

Dictionary<(Of <(TKey, TValue>)>) 类与 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:

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

二.我们供给使用2个算法让散列值对应HashTable的半空中地址尽量不另行,这正是散列函数(GetHashCode)需求做的事。

三.当二个HashTable被占用大多数的时候我们通过总括散列值取得的位置值恐怕会重复指向同1地点,那便是哈希争辨。

四.在.Net中键值对在HashTable中的地方Position= (HashCode& 0x七FFFFFFF) %
HashTable.Length,.net中是经过探测法解决哈希争执的,当通过散列值取得的岗位Postion以及被占用的时候,就会大增三个位移x值判断下二个职位Postion+x是不是被占用,倘若照旧被并吞就卫冕往下位移x判断Position+2*x位置是还是不是被占用,假若没有被占用则将值放入当中。当HashTable中的可用空间尤其小时,则获得得到可用空间的难度越来越大,消耗的小时就更多。

威尼斯人线上娱乐 ,伍..脚下HashTable中的被占用空间达到1个比例的时候就将该空间活动扩大容积,在.net中这一个比例是7二%,也叫.net中HashTable的填写因子为0.7二。例如有二个HashTable的空中尺寸是十0,当它要求加上第八拾三个值的时候将会扩大体量此HashTable.

陆.以此活动扩大体积的深浅是有点吧?答案是日前空间大小的两倍最接近的素数,例如当前HashTable所占空间为素数71,假使扩大体量,则扩大体积大小为素数13一.

威尼斯人线上娱乐 1

二:Dictionary

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

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

三.以此变种HashTable的填充因子是一

威尼斯人线上娱乐 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-------------------------------------------------");

        }

    }

 4:从地点的结果能够看看

壹.HashTable大数据量插入数据时须要开销比Dictionary大的多的光阴。

2.for艺术遍历HashTable和Dictionary速度最快。

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

5:在单线程的时候使用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]);
            }

3:遍历格局:

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:它是3个后进先出的联谊(它存款和储蓄于栈中),后进先出的趣味顾名思义,也正是说取多少只好从最终放进去的不行数据开端取。

 以下代码实例了分别选用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实行了质量测试,他们的品质都比数组要伟大概二~倍。

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 到 壹.0 范围内的数字
,是在那之中存款和储蓄桶数(count)所占桶数组(buckets)桶数(hashsize)的最大比率
,当桶数大于装载数(loadsize)时,桶数组就会扩容

hashtable内部解除哈希争论的算法是再一次散列法,是开放地点法中最佳的法子之1

而不相同的是,Dictionary内部解除哈希争辨的算法是链地址法,而且Dictionary的协会不必要装载因子,不受装载因子的界定
,假使Dictionary相当的小,查找,插入,删除等操作拥有类似O(一)的效用

和ArrayList
,List类似的是Dictionary和hashtable内部也是由数组完成的,所以协会时也须求提供适当容量,制止品质的消耗。

但大家需求其它注意的是你提须求构造函数的体积不自然会是初叶时置放数组的长短,构造函数内部会采取三个过量等于你所挑选体量的素数作为忠实的始发体积。

1、SortedList定义

System.Collections.SortedList类表示键/值对的聚合,这么些键值对按键排序并可依据键和目录访问。SortedList
在中间维护四个数组以存款和储蓄列表中的成分;即,二个数组用于键,另一个数组用于相关联的值。每种成分都是一个可看做
DictionaryEntry 对象实行访问的键/值对。键不可能为null,但值能够。

ArrayList对应List

ArrayList对应List

HashSet

HashSet是三个冬日的能够保持唯壹性的集聚。大家也得以把HashSet看作是Dictionary<TKey,电视机alue>,只可是TKey和TValue都指向同1个对象。内部贯彻和Dictionary10分相像。
HashSet10分适合在我们须要保持集合内成分唯一性但又不须要按顺序排列的时候。

2.优点

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

2、可依照需求活动叠加体积。

HashTable对应Dictionary

HashTable对应Dictionary

SortedList

SortedList是永葆排序的关联性(键值对 )集合
,内部选择数组达成,所以和List相同的是,初叶化时要求提供3个适度的容积,SortedList内部采纳哈希算法落成,和Dictionary类似的是,SortedList内部解除哈希争持的算法是链地址法。

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

假定您想要快捷搜索,又想集合遵照key的顺序排列,最终那一个集合的操作(添加和移除)相比较少的话,正是SortedList了

3.注意点:

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

2、SortedList 中不容许重复键。

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

四.当不向聚集中添加新因素,则调用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,TValue>:

假定急需排好序的表,能够利用SortedList<TKey,TValue>。那么些类遵照键给成分排序。

上面的例证创立3个里丑捧心表,在那之中键和值都以string类型。私下认可的构造函数创制了二个空表,再用Add()方法添加两本书。使用重载的构造函数,能够定义有序表的容积,传送执行了IComparer<TKey>接口的对象,用于给有序表中得成分排序。

Add()方法的第三个参数是键(书名),第一个参数是值(ISBN号)。除了运用Add()方法之外,仍可以够动用索引器将成分添加到平稳表中。索引器供给把键作为目录参数。假使键已存在,那么Add()方法就抛出1个ArgumentException类型的老大。倘使索引器使用同1的键,就用新值替代旧值。

 

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(泛型集合)

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

ArrayList 是数组的复杂性版本。ArrayList
类提供在大多数 Collections 类中提供但不在 Array
类中提供的一对功用:

ArrayList 是数组的扑朔迷离版本。ArrayList
类提供在大部 Collections 类中提供但不在 Array
类中提供的片段职能:

壹.Array 的体量是定位的,而 ArrayList
的体量是依据要求活动扩展的。

一.Array 的容积是一直的,而 ArrayList
的容积是基于须求活动增添的。

2.ArrayList
提供丰盛、插入或移除某1限量元素的主意。在 Array
中,您不得不二遍拿走或设置3个因素的值。

二.ArrayList
提供丰硕、插入或移除某壹范围成分的方法。在 Array
中,您不得不叁次获得或设置三个要素的值。

三.利用 Synchronized 方法可以很不难地开创
ArrayList 的联手版本。而 Array 将直接维持它直到用户实现同台截至。

三.用到 Synchronized 方法能够很简单地开创
ArrayList 的一块儿版本。而 Array 将直接维持它直到用户完结联机甘休。

四.ArrayList
提供将只读和稳定大小包裹再次回到到聚集的不二等秘书籍。而 Array 不提供。

4.ArrayList
提供将只读和固定大小包裹再次回到到集结的点子。而 Array 不提供。

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

伍.Array 提供 ArrayList
所不拥有的少数灵活性:

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

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

   b.Array 能够具有七个维度,而 ArrayList
始终只是1维的。

   b.Array 能够拥有三维,而 ArrayList
始终只是一维的。

   c.特定类型(不包蕴 Object)的 Array
的性质比 ArrayList 好,这是因为 ArrayList 的成分属于 Object
类型,所以在储存或探寻值类型时1般发生装箱和注销装箱。

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

  
d.须要二个数组的大部气象也得以代之以使用
ArrayList。它更易于使用,并且普通兼有与 Object
类型的数组类似的习性。

  
d.供给一个数组的多数情景也足以代之以使用
ArrayList。它更易于使用,并且普通全部与 Object
类型的数组类似的属性。

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

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

ArrayList类对象方法:

ArrayList类对象方法:

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

一:Add()向数组中添加三个因素,
2:Remove()删除数组中的三个因素
3:(int i)删除数组中索引值为i的因素
四:Reverse()反转数组的成分
五:Sort()以从小到大的顺序排列数组的因素
陆: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是概念泛型类时的占位符,其并不是1连串型,仅表示某种只怕的类型。在概念时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的相同点:添美金素、删除成分、通过索引访问成分方法1致。
  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> 类型

 一:单线程程序中推荐使用 Dictionary, 有泛型优势, 且读取速度较快,
体量利用更丰富.
 二:多线程程序中引进使用 Hashtable, 默许的 Hashtable 允许单线程写入,
多线程读取, 对 Hashtable 进一步调用 Synchronized()
方法能够取得完全线程安全的类型. 而 Dictionary 非线程安全, 必须人为使用
lock 语句实行维护, 成效大减.
 三:Dictionary 有按插入顺序排列数据的特征 (注: 但当调用 Remove()
删除过节点后逐一被打乱), 因而在供给反映顺序的情境中选取 Dictionary
能博得一定方便.

 1:单线程程序中推荐使用 Dictionary, 有泛型优势, 且读取速度较快,
体积利用更丰硕.
 2:二10二十四线程程序中引进使用 Hashtable, 暗许的 Hashtable 允许单线程写入,
102线程读取, 对 Hashtable 进一步调用 Synchronized()
方法能够得到完全线程安全的类型. 而 Dictionary 非线程安全, 必须人为使用
lock 语句举办维护, 功能大减.
 叁:Dictionary 有按插入顺序排列数据的风味 (注: 但当调用 Remove()
删除过节点后各样被打乱), 由此在急需反映顺序的境地中运用 Dictionary
能赢得肯定方便.

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

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

Dictionary<(Of <(TKey,
电视alue>)>) 泛型类还落到实处 IDictionary<(Of <(TKey,
电视alue>)>)
泛型接口。因而,这几个聚集中的每种成分都以1个键/值对。

Dictionary<(Of <(TKey,
电视alue>)>) 泛型类还落到实处 IDictionary<(Of <(TKey,
电视alue>)>)
泛型接口。因而,那个聚集中的每一种成分都以2个键/值对。

Dictionary<(Of <(TKey,
TValue>)>) 类与 Hashtable 类的成效雷同
对于值类型,特定类型(不包罗 Object)的 Dictionary<(Of <(TKey,
TValue>)>) 的质量优越 Hashtable,那是因为 Hashtable 的因素属于
Object
类型,所以在储存或探寻值类型时一般产生装箱和注销装箱操作。

Dictionary<(Of <(TKey,
TValue>)>) 类与 Hashtable 类的功效雷同
对于值类型,特定类型(不包罗 Object)的 Dictionary<(Of <(TKey,
电视机alue>)>) 的性质优越 Hashtable,那是因为 Hashtable 的要素属于
Object
类型,所以在蕴藏或探寻值类型时1般产生装箱和注销装箱操作。

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:

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

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

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

二.大家需求采用3个算法让散列值对应HashTable的半空中地址尽量不另行,那就是散列函数(GetHashCode)要求做的事。

3.当三个HashTable被占用半数以上的时候大家因而估测计算散列值取得的地址值或者会再也指向同1人置,那正是哈希抵触。

叁.当3个HashTable被挤占大部分的时候大家由此测算散列值取得的地方值恐怕会再次指向同壹地方,那就是哈希冲突。

四.在.Net中键值对在HashTable中的地方Position=
(HashCode& 0x七FFFFFFF) %
HashTable.Length,.net中是通过探测法化解哈希顶牛的,当通过散列值取得的地方Postion以及被占用的时候,就会追加2个位移x值判断下1个任务Postion+x是不是被占用,假设照旧被占据就继续往下位移x判断Position+2*x位置是还是不是被占用,倘若没有被挤占则将值放入当中。当HashTable中的可用空间特别时辰,则得到获得可用空间的难度进一步大,消耗的日子就越来越多。

4.在.Net中键值对在HashTable中的地点Position=
(HashCode& 0x7FFFFFFF) %
HashTable.Length,.net中是经过探测法化解哈希争论的,当通过散列值取得的岗位Postion以及被占用的时候,就会大增3个位移x值判断下3个职位Postion+x是或不是被占用,借使如故被侵夺就连任往下位移x判断Position+二*x地点是不是被占用,假若没有被占据则将值放入个中。当HashTable中的可用空间尤其小时,则获得得到可用空间的难度越来越大,消耗的时日就更多。

5..当下HashTable中的被占用空间达到二个比例的时候就将该空间活动扩大容积,在.net中那几个比重是72%,也叫.net中HashTable的填充因子为0.7二。例如有八个HashTable的空间尺寸是100,当它必要添加第7拾个值的时候将会扩容此HashTable.

伍..脚下HashTable中的被占用空间达到三个比重的时候就将该空间活动扩大体积,在.net中这一个比重是7二%,也叫.net中HashTable的填充因子为0.7二。例如有多个HashTable的上空尺寸是100,当它供给加上第八十三个值的时候将会扩大容积此HashTable.

6.以此活动扩容的大大小小是稍微吗?答案是时下空中尺寸的两倍最接近的素数,例如当前HashTable所占空间为素数7一,要是扩大体量,则扩容大小为素数13一.

陆.那几个自动扩大体量的分寸是有点吗?答案是如今空间大小的两倍最接近的素数,例如当前HashTable所占空间为素数71,若是扩大体量,则扩大体量大小为素数13一.

威尼斯人线上娱乐 10

威尼斯人线上娱乐 11

二:Dictionary

二:Dictionary

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

壹.Dictionary是1种变种的HashTable,它利用壹种分离链接散列表的数据结构来消除哈希争论的标题。

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

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

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

三.这几个变种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大的多的大运。

一.HashTable大数据量插入数据时索要花费比Dictionary大的多的小时。

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

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

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

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

伍:在单线程的时候利用Dictionary更好有的,四线程的时候使用HashTable更好。

5:在单线程的时候利用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]);
            }

叁:遍历格局:

3:遍历格局:

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:它是1个先进先出的联谊(它存款和储蓄于队列中),先进先出的情趣也正是起首放进集合的多寡,拿多少的时候从最初放进去的数据开端拿。

Queue:它是二个先进先出的集结(它存款和储蓄于队列中),先进先出的意思也正是初次放进集合的数量,拿多少的时候从初期放进去的数目初步拿。

Stack:它是1个后进先出的汇集(它存款和储蓄于栈中),后进先出的情趣顾名思义,也正是说取多少只可以从最终放进去的尤其数据开端取。

Stack:它是贰个后进先出的聚合(它存储于栈中),后进先出的意味顾名思义,也正是说取多少只可以从最后放进去的不行数据早先取。

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

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

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

输出结果:
威尼斯人线上娱乐 14

出口结果:
威尼斯人线上娱乐 15

依照以下代码对Queue 与
Stack进行了质量测试,他们的性质都比数组要高大致2~倍。

基于以下代码对Queue 与
Stack实行了品质测试,他们的质量都比数组要高大概二~倍。

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
在里头维护三个数组以存款和储蓄列表中的成分;即,3个数组用于键,另贰个数组用于相关联的值。每一种成分都以二个可看成
DictionaryEntry.aspx)
对象开展走访的键/值对。键不能为null,但值能够。

1、SortedList定义

System.Collections.SortedList类表示键/值对的联谊,那一个键值对按键排序并可遵照键和目录访问。SortedList
在中间维护多个数组以存款和储蓄列表中的成分;即,一个数组用于键,另二个数组用于相关联的值。各样成分都以四个可看作
DictionaryEntry.aspx)
对象进行访问的键/值对。键不能够为null,但值能够。

2.优点

一、SortedList
允许通过相关联键或通过索引对值进行走访,可提供更大的灵活性。

2、可依照需求活动叠加体量。

2.优点

1、SortedList
允许通过有关联键或通过索引对值进行访问,可提供更大的左右逢源。

二、可依照供给活动叠加体积。

3.注意点:

一、SortedList 的体积是 SortedList 能够保存的元素数。SortedList
的私下认可起先体积为 0。随着成分添加到 SortedList
中,在急需时得以透过重新分配自动扩展体积。可透过调用
TrimToSize.aspx)方法
或通过显式设置
Capacity.aspx)
属性裁减容积。

二、SortedList 中不允许重复键。

三、SortedList的目录顺序基于排序依次。当添日币素时,成分将按正确的排序依次插入
SortedList,同时索引会相应地进行调整。当移除成分时,索引也会相应地展开调整。因而,当在
SortedList 中加上或移除成分时,特定键/值对的目录大概会改变。

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

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

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

  1. SortedList的构造器

威尼斯人线上娱乐 18

5、SortedList的属性

威尼斯人线上娱乐 19

6.SortedList的方法

威尼斯人线上娱乐 20

威尼斯人线上娱乐 21

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

假设急需排好序的表,能够动用SortedList<TKey,TValue>。那个类根据键给成分排序。

上面包车型地铁例证成立2个平稳表,在那之中键和值都以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.    }  

输出结果:
威尼斯人线上娱乐 22

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

 

 

 

 

 

 

 

 

 

3.注意点:

壹、SortedList 的体积是 SortedList 可以保留的成分数。SortedList
的私下认可初步体量为 0。随着元素添加到 SortedList
中,在急需时得以由此重新分配自动增添体量。可通过调用
TrimToSize.aspx)方法
或透过显式设置
Capacity.aspx)
属性缩短体积。

二、SortedList 中不容许重复键。

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

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

5、通过安装 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>。那个类依据键给成分排序。

上边包车型客车事例创造1个稳步表,个中键和值都是string类型。暗中同意的构造函数创造了二个空表,再用Add()方法添加两本书。使用重载的构造函数,能够定义有序表的容量,传送执行了IComparer<TKey>接口的靶子,用于给有序表中得成分排序。

Add()方法的首先个参数是键(书名),第四个参数是值(ISBN号)。除了行使Add()方法之外,还足以选用索引器将成分添加到有序表中。索引器需求把键作为目录参数。假使键已存在,那么Add()方法就抛出叁个ArgumentException类型的百般。借使索引器使用同1的键,就用新值替代旧值。

 

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地图