ArrayList ,List

ArrayList 和 List 都是不限量长度的集合类型 ,List相比较ArrayList
就当中贯彻而言除了泛型本质未有太大差异。可是为幸免装箱拆箱难点,尽恐怕接纳List

聚拢内部是由数组达成,暗中认可大小是四,但您利用无参构造函数构造实例时,内部数组大小是0,当您投入第三个成分时,才扩大体量为4,添日元素时,如若发现内置数组大小不够,内置数组大小会扩大体量为本来的两倍,每一次扩大体积都会重复开发二个数组,拷贝旧数组的数目,假如你要给集合添加多量的要素却不为它发轫化三个合适体量,频仍的内存开辟和剩余的数组拷贝会导致品质的消耗。

故此采纳时建议提供方便的容积。

C#非泛型集合和泛型集合的极品详解,

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

ArrayList对应List

HashTable对应Dictionary

Queue对应Queue

Stack对应Stack

SortedList对应SortedList

 

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

ArrayList 是数组的复杂性版本。ArrayList 类提供在超越2/4 Collections
类中提供但不在 Array 类中提供的局地功力:

壹.Array 的体积是定点的,而 ArrayList 的体积是基于供给活动扩张的。

二.ArrayList 提供丰硕、插入或移除某一范围成分的办法。在 Array
中,您不得不一遍获得或安装1个要素的值。

三.用到 Synchronized 方法能够很不难地开创 ArrayList 的同步版本。而 Array
将间接维持它直到用户完毕协同结束。

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

伍.Array 提供 ArrayList 所不富有的某个灵活性:

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

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

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

   d.须求三个数组的超过2/四情形也可以代之以使用
ArrayList。它更便于使用,并且普通具有与 Object 类型的数组类似的属性。

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

ArrayList类对象方法:

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

一:ArrayList:

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

 

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

二:Array:

Array的体积是固定的 先内定大小 在赋值

 

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

List泛型集合:

泛型集合List<T>
  泛型最珍视的选择正是汇集操作,使用泛型集合可以提高代码重用性,类型安全和更佳的属性。
  List<T>的用法和ArrayList相似,List<T>有更好的项目安全性,无须拆,装箱。
在泛型定义中,泛型类型参数“<T>”是必须钦定的,当中T是概念泛型类时的占位符,其并不是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> 类型

 一:单线程程序中引进使用 Dictionary, 有泛型优势, 且读取速度较快,
容积利用更充裕.
 二:拾二线程程序中推荐使用 Hashtable, 默许的 Hashtable 允许单线程写入,
10二线程读取, 对 Hashtable 进一步调用 Synchronized()
方法能够收获完全线程安全的类型. 而 Dictionary 非线程安全, 必须人为使用
lock 语句举行维护, 成效大减.
源码阅读总括,非泛型集合和泛型集合的一级详解。 3:Dictionary 有按插入顺序排列数据的特征 (注: 但当调用 Remove()
删除过节点后挨家挨户被打乱), 由此在急需反映顺序的情境中使用 Dictionary
能取得肯定方便.

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

Dictionary<(Of <(TKey, TValue>)>) 泛型类还达成IDictionary<(Of <(TKey, TValue>)>)
泛型接口。由此,那些聚集中的每一种成分都以3个键/值对。

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值的。

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

三.当3个HashTable被占据一大半的时候大家通过计算散列值取得的地址值或然会再一次指向同1地点,那正是哈希争持。

肆.在.Net中键值对在HashTable中的地方Position= (HashCode& 0x7FFFFFFF) %
HashTable.Length,.net中是经过探测法化解哈希争持的,当通过散列值取得的岗位Postion以及被占用的时候,就会大增多少个位移x值判断下贰个职务Postion+x是不是被占用,若是依旧被占据就接二连三往下位移x判断Position+二*x地方是否被占用,借使未有被挤占则将值放入其中。当HashTable中的可用空间越发小时,则获得获得可用空间的难度进一步大,消耗的大运就越来越多。

5..当下HashTable中的被占用空间达到一个比重的时候就将该空间活动扩容,在.net中这几个比重是7二%,也叫.net中HashTable的填充因子为0.7二。例如有一个HashTable的半空中尺寸是十0,当它必要丰盛第7公斤个值的时候将会扩容此HashTable.

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

金沙注册送58 1

二:Dictionary

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

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

三.这几个变种HashTable的填写因子是1

金沙注册送58 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-------------------------------------------------");

        }

    }

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

一.HashTable大数据量插入数据时要求费用比Dictionary大的多的光阴。

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

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

5:在单线程的时候使用Dictionary更好有的,10二线程的时候利用HashTable更好。

因为HashTable能够经过Hashtable tab = Hashtable.Synchronized(new
Hashtable());获得线程安全的靶子。

eg: hashtable

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


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

叁:遍历方式:

Dictionary的二种遍历方式:

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

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

HashTable的遍历格局:

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

 第四:Queue集合和Stack

Queue:它是三个先进先出的聚集(它存款和储蓄于队列中),先进先出的趣味也正是初阶放进集合的多寡,拿多少的时候从初期放进去的数据开头拿。

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

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

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

出口结果:
金沙注册送58 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();

测试结果:
金沙注册送58 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内部解除哈希争执的算法是双重散列法,是开放地点法中最棒的法门之1

而分裂的是,Dictionary内部解除哈希争辩的算法是链地址法,而且Dictionary的组织不须求装载因子,不受装载因子的限定
,若是Dictionary非常的小,查找,插入,删除等操作拥有近乎O(一)的效能

和ArrayList
,List类似的是Dictionary和hashtable内部也是由数组完成的,所以协会时也急需提供方便体积,防止品质的开销。

但我们要求其它注意的是您提要求构造函数的体量不必然会是起先时放置数组的尺寸,构造函数内部会采取3个压倒等于你所选择容积的素数作为忠实的起首体积。

1、SortedList定义

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

ArrayList对应List

ArrayList对应List

HashSet

HashSet是3个冬辰的能够保证唯壹性的联谊。大家也能够把HashSet看作是Dictionary<TKey,电视alue>,只但是TKey和电视alue都指向同3个对象。内部贯彻和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 中丰盛或移除成分时,特定键/值对的目录大概会改变。

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

金沙注册送58 5

5、SortedList的属性

金沙注册送58 6

6.SortedList的方法

金沙注册送58 7

金沙注册送58 8

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

要是急需排好序的表,能够运用SortedList<TKey,电视alue>。那几个类根据键给成分排序。

上面包车型地铁例子创造一个邯郸学步表,当中键和值都是string类型。私下认可的构造函数创造了1个空表,再用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.    }  

出口结果:
金沙注册送58 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
的容积是依照需求活动扩张的。

二.ArrayList
提供丰硕、插入或移除某一限制成分的措施。在 Array
中,您不得不二遍拿走或安装多个成分的值。

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

叁.利用 Synchronized 方法能够很不难地开创
ArrayList 的同台版本。而 Array 将一向维持它直到用户达成协同截至。

3.用到 Synchronized 方法能够很简单地开创
ArrayList 的一路版本。而 Array 将一向维持它直到用户达成协同截至。

四.ArrayList
提供将只读和一定大小包裹再次来到到集结的措施。而 Array 不提供。

四.ArrayList
提供将只读和定点大小包裹重临到集结的方法。而 Array 不提供。

5.Array 提供 ArrayList
所不享有的1些灵活性:

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

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

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

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

   b.Array 能够具备三个维度,而 ArrayList
始终只是壹维的。

   c.特定类型(不包涵 Object)的 Array
的特性比 ArrayList 好,那是因为 ArrayList 的因素属于 Object
类型,所以在储存或探寻值类型时1般产生装箱和打消装箱。

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

  
d.供给三个数组的抢先六一%情状也得以代之以使用
ArrayList。它更便于使用,并且普通全体与 Object
类型的数组类似的属性。

  
d.供给3个数组的大多数气象也得以代之以使用
ArrayList。它更便于使用,并且普通兼有与 Object
类型的数组类似的品质。

陆.Array 放在 System 命名空间中;ArrayList
位于 System.Collections 命名空间中。

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

ArrayList类对象方法:

ArrayList类对象方法:

一:Add()向数组中添加一个要素,
二:Remove()删除数组中的四个因素
三:(int i)删除数组中索引值为i的因素
4:Reverse()反转数组的成分
伍:Sort()以从小到大的顺序排列数组的元素
金沙注册送58,6:Clone()复制一个数组

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

一: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是概念泛型类时的占位符,其并不是1系列型,仅代表某种可能的项目。在概念时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> 类型

 壹:单线程程序中引进使用 Dictionary, 有泛型优势, 且读取速度较快,
容积利用更足够.
 二:拾贰线程程序中推荐使用 Hashtable, 暗中同意的 Hashtable 允许单线程写入,
八线程读取, 对 Hashtable 进一步调用 Synchronized()
方法能够收获完全线程安全的类型. 而 Dictionary 非线程安全, 必须人为使用
lock 语句进行保险, 功效大减.
 三:Dictionary 有按插入顺序排列数据的特点 (注: 但当调用 Remove()
删除过节点后挨家挨户被打乱), 由此在急需反映顺序的田地中使用 Dictionary
能取得一定方便.

 1:单线程程序中推荐应用 Dictionary, 有泛型优势, 且读取速度较快,
体量利用更丰硕.
 二:拾二线程程序中引进使用 Hashtable, 暗许的 Hashtable 允许单线程写入,
十二线程读取, 对 Hashtable 进一步调用 Synchronized()
方法能够赢得完全线程安全的类型. 而 Dictionary 非线程安全, 必须人为使用
lock 语句举办维护, 功用大减.
 三:Dictionary 有按插入顺序排列数据的本性 (注: 但当调用 Remove()
删除过节点后逐1被打乱), 因而在须要反映顺序的情境中动用 Dictionary
能收获一定方便.

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

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

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

Dictionary<(Of <(TKey,
电视alue>)>) 泛型类还落实 IDictionary<(Of <(TKey,
电视机alue>)>)
泛型接口。由此,那个聚集中的各类成分都以三个键/值对。

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
类型,所以在仓库储存或探寻值类型时经常产生装箱和撤回装箱操作。

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是1种散列表,他当中维护广大对Key-Value键值对,其还有一个近似索引的值叫做散列值(HashCode),它是依照GetHashCode方法对Key通过一定算法获取获得的,全体的搜寻操作定位操作都以根据散列值来促成找到呼应的Key和Value值的。

1.HashTable是一种散列表,他在那之中维护广大对Key-Value键值对,其还有一个看似索引的值叫做散列值(HashCode),它是依据GetHashCode方法对Key通过一定算法获取获得的,全数的查找操作定位操作都以依据散列值来兑现找到相应的Key和Value值的。

贰.大家要求利用1个算法让散列值对应HashTable的上空地址尽量不重复,这正是散列函数(GetHashCode)须求做的事。

二.我们须要利用二个算法让散列值对应HashTable的半空中地址尽量不重复,这正是散列函数(GetHashCode)须求做的事。

三.当1个HashTable被占据超过半数的时候大家通过总计散列值取得的地方值只怕会重复指向同1地址,那正是哈希争辩。

三.当一个HashTable被占用半数以上的时候大家由此计算散列值取得的地址值只怕会另行指向同壹地点,这就是哈希争辨。

4.在.Net中键值对在HashTable中的地点Position=
(HashCode& 0x7FFFFFFF) %
HashTable.Length,.net中是经过探测法消除哈希争辩的,当通过散列值取得的岗位Postion以及被占用的时候,就会追加二个位移x值判断下1个职分Postion+x是还是不是被占用,倘诺仍旧被占据就此起彼伏往下位移x判断Position+2*x地点是还是不是被占用,要是未有被挤占则将值放入当中。当HashTable中的可用空间特别小时,则得到获得可用空间的难度进一步大,消耗的小运就越来越多。

四.在.Net中键值对在HashTable中的地点Position=
(HashCode& 0x柒FFFFFFF) %
HashTable.Length,.net中是通过探测法消除哈希争执的,当通过散列值取得的岗位Postion以及被占用的时候,就会大增一个位移x值判断下2个职位Postion+x是不是被占用,如若依旧被私吞就接二连三往下位移x判断Position+二*x地方是还是不是被占用,假诺未有被占据则将值放入在那之中。当HashTable中的可用空间尤其小时,则赢得获得可用空间的难度越来越大,消耗的大运就越来越多。

5..当下HashTable中的被占用空间达到二个百分比的时候就将该空间活动扩大体量,在.net中这么些比重是7贰%,也叫.net中HashTable的填充因子为0.7二。例如有3个HashTable的空中山大学小是拾0,当它供给丰裕第1012个值的时候将会扩大体量此HashTable.

5..当下HashTable中的被占用空间达到叁个比例的时候就将该空间活动扩大容积,在.net中那一个比重是7二%,也叫.net中HashTable的填写因子为0.7贰。例如有3个HashTable的空间大小是100,当它须求添加第玖一个值的时候将会扩大体量此HashTable.

陆.以此自动扩大体量的高低是多少吗?答案是当下空间大小的两倍最周围的素数,例如当前HashTable所占空间为素数7一,如若扩大容积,则扩容大小为素数13一.

陆.以此自动扩大容积的轻重缓急是有点啊?答案是最近空间大小的两倍最接近的素数,例如当前HashTable所占空间为素数71,若是扩大体量,则扩大容积大小为素数13一.

金沙注册送58 10

金沙注册送58 11

二:Dictionary

二:Dictionary

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

1.Dictionary是壹种变种的HashTable,它选用壹种分离链接散列表的数据结构来缓解哈希争执的题材。

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

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

三.以此变种HashTable的填写因子是壹

叁.这几个变种HashTable的填充因子是壹

金沙注册送58 12

金沙注册送58 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-------------------------------------------------");

        }

    }

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

 四:从上边的结果能够看来

1.HashTable大数据量插入数据时索要开支比Dictionary大的多的年月。

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

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

贰.for办法遍历HashTable和Dictionary速度最快。

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

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

伍:在单线程的时候利用Dictionary更好一些,十二线程的时候利用HashTable更好。

五:在单线程的时候使用Dictionary更好1些,四线程的时候利用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:它是三个先进先出的集合(它存款和储蓄于队列中),先进先出的意味也便是第2放进集合的数量,拿多少的时候从中期放进去的数目开头拿。

Queue:它是三个先进先出的成团(它存储于队列中),先进先出的情趣也正是起首放进集合的数码,拿多少的时候从最初放进去的数额起首拿。

Stack:它是二个后进先出的聚众(它存款和储蓄于栈中),后进先出的意味顾名思义,也正是说取多少只好从最后放进去的不行数据开端取。

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

 以下代码实例了独家选拔Stack和Queue打字与印刷数字0~9。

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

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

输出结果:
金沙注册送58 14

出口结果:
金沙注册送58 15

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

依据以下代码对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();

测试结果:
金沙注册送58 16

测试结果:
金沙注册送58 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
在个中维护多少个数组以存款和储蓄列表中的成分;即,一个数组用于键,另多少个数组用于相关联的值。各类成分都以二个可作为
DictionaryEntry.aspx)
对象开展访问的键/值对。键不可能为null,但值能够。

1、SortedList定义

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

2.优点

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

二、可根据需要活动叠加容积。

2.优点

一、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的构造器

金沙注册送58 18

5、SortedList的属性

金沙注册送58 19

6.SortedList的方法

金沙注册送58 20

金沙注册送58 21

泛型集合SortedList<TKey,TValue>:

若果急需排好序的表,能够利用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.    }  

输出结果:
金沙注册送58 22

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

 

 

 

 

 

 

 

 

 

3.注意点:

一、SortedList 的体量是 SortedList 可以保存的成分数。SortedList
的暗中认可初始容积为 0。随着成分添加到 SortedList
中,在供给时得以因而重新分配自动增添体积。可因此调用
TrimToSize.aspx)方法
或透过显式设置
Capacity.aspx)
属性减弱体量。

二、SortedList 中不允许重复键。

3、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的构造器

金沙注册送58 23

5、SortedList的属性

金沙注册送58 24

6.SortedList的方法

金沙注册送58 25

金沙注册送58 26

泛型集合SortedList<TKey,TValue>:

假设急需排好序的表,可以使用SortedList<TKey,电视alue>。这些类根据键给元素排序。

上面的例证创造二个1如既往表,个中键和值都以string类型。默许的构造函数创制了三个空表,再用Add()方法添加两本书。使用重载的构造函数,能够定义有序表的容积,传送执行了IComparer<TKey>接口的目标,用于给有序表中得成分排序。

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

 

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

出口结果:
金沙注册送58 27

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

 

 

 

 

 

 

 

 

 

相关文章

网站地图xml地图