非泛型集合和泛型集合的超级详解【官方澳门新永利下载】

C#非泛型集合和泛型集结的一级详细解释,

C# 泛型集结之非泛型集合类与泛型会集类的对应:

ArrayList对应List

HashTable对应Dictionary

Queue对应Queue

Stack对应Stack

SortedList对应SortedList

 

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

ArrayList 是数组的复杂版本。ArrayList 类提供在大大多 Collections
类中提供但不在 Array 类中提供的一些成效:

1.Array 的容积是牢固的,而 ArrayList 的体量是遵照要求活动扩大的。

2.ArrayList 提供充裕、插入或移除某生机勃勃限量成分的方法。在 Array
中,您必须要三回得到或安装三个因素的值。

3.应用 Synchronized 方法能够超轻巧地创造 ArrayList 的同台版本。而 Array
将直接保持它直到顾客达成同步截至。

4.ArrayList 提供将只读和一向大小包裹再次来到到集合的法子。而 Array 不提供。

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

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

   b.Array 能够享有几个维度,而 ArrayList 始终只是生机勃勃维的。

   c.特定类型(不蕴涵 Object卡塔 尔(阿拉伯语:قطر‎的 Array 的特性比 ArrayList 好,那是因为
ArrayList 的要素归属 Object
类型,所以在存款和储蓄或索求值类型时经常发生装箱和收回装箱。

   d.需求一个数组的大部情景也得以代之以使用
ArrayList。它更便于使用,并且普通全体与 Object 类型的数组相通的习性。

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

ArrayList类对象方法:

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

一:ArrayList:

ArrayList能够毫无内定维数 可动态赋值  赋分歧类型值

 

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

二:Array:

Array的体量是稳固的 先钦定大小 在赋值

 

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

List泛型集合:

泛型群集List<T>
  泛型最要害的利用就是群集操作,使用泛型集结能够增长代码重用性,类型安全和更佳的质量。
  List<T>的用法和ArrayList相像,List<T>有更加好的门类安全性,无须拆,装箱。
在泛型定义中,泛型类型参数“<T>”是必得内定的,在那之中T是概念泛型类时的占位符,其而不是大器晚成种类型,仅表示某种大概的项目。在概念时T会被采用的项目取代。泛型会集List<T>中只可以有二个参数类型,“<T>”中的T能够对聚聚集的成分类型实行约束。

eg:
List<T>增多、删除、检索成分的方法和ArrayList相通,分明的表征是没有必要像ArrayList那样装箱和拆箱。

List < Student > students = new List < Student > ();
   Student stu1 = new Student();
   stu1.Name = "陆小凤";
   stu1.Number = "0801";
   stu1.Score = 20;
   Student stu2 = new Student();
   stu2.Name = "西门吹雪";
   stu2.Number = "0802";
   stu2.Score = 23;
   students.Add(stu1);
   students.Add(stu2);
   Console.WriteLine("集合中的元素个数为{0}", students.Count);
   foreach (Student stu in students)
   {
    Console.WriteLine("/t{0}/t{1}/t{2}", stu.Name, stu.Number, stu.Score);
   }
   students.Remove(stu1);
   Console.WriteLine("集合中的元素个数为{0}", students.Count);
   Console.ReadLine();

List<T>和ArrayList的区别
     
List<T>和ArrayList的雷同点:添美成分、删除成分、通过索引访谈成分方法风度翩翩致。
  List<T>和ArrayList的差别点:
ArrayList能够拉长大肆等级次序成分;List<T>对丰裕的要素具备类型节制;
ArratList增添衣裳箱,读取时拆箱;List<T>无需装箱,拆箱操作;

//创建Person对象
   Person p1 = new Person("张三", 30);
   Person p2 = new Person("李四", 20);
   Person p3 = new Person("王五", 50);
   //创建类型为Person的对象集合
   List < Person > persons = new List < Person > ();
   //将Person对象放入集合
   persons.Add(p1);
   persons.Add(p2);
   persons.Add(p3);
   //输出第2个人的姓名
   Console.WriteLine(persons[1].Name);
   foreach (Person p in persons)
   {
    Console.WriteLine("/t{0}/t{1}", p.Name, p.Age);
   }

其次 :HashTable(非泛型集结)对应Dictionary(泛型会集卡塔 尔(阿拉伯语:قطر‎

Hashtable 和 Dictionary <K, V> 类型

 1:单线程程序中援引应用 Dictionary, 有泛型优势, 且读取速度很快,
容积利用更充足.
 2:三十二线程程序中推荐介绍应用 Hashtable, 私下认可的 Hashtable 允许单线程写入,
八线程读取, 对 Hashtable 进一层调用 Synchronized()
方法能够获取完全线程安全的类型. 而 Dictionary 非线程安全, 必需人为使用
lock 语句进行体贴, 效用大减.
 3:Dictionary 有按插入顺序排列数据的天性 (注: 但当调用 Remove()
删除过节点后逐生机勃勃被打乱), 由此在须要反映顺序的境地中动用 Dictionary
能收获一定方便.

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

Dictionary<(Of <(TKey, 电视alue>)>) 泛型类还贯彻IDictionary<(Of <(TKey, 电视alue>)>)
泛型接口。因而,这几个聚集中的各个成分都以叁个键/值对。

Dictionary<(Of <(TKey, 电视alue>)>) 类与 Hashtable
类的机能相同
对此值类型,特定类型(不包涵 Object卡塔尔国的 Dictionary<(Of <(TKey,
TValue>)>) 的属性卓绝 Hashtable,那是因为 Hashtable 的成分属于Object 类型,所以在蕴藏或探究值类型时常常发生装箱和裁撤装箱操作。

eg:

HashTable ht=new HashTable();//实现 IDictionary接口
ht.Add(1,"A");
 ht.Add(2,"B");
 ht.Add(3,"c");
 foreach(DictionaryEntry de in ht)//HashTable返回的是DictionaryEntry类型
 {
     de.Key;
     de.Value;
  }

Dictionary<int,string> myDictionary=new Dictionary<int,string>();//实现IDictionary接口,IDictionary<T key,T value>类
myDictionary.Add(1,"a");
 myDictionary.Add(2,"b");
 myDictionary.Add(3,"c");
 foreach(int i in myDictionary.Keys)
{
   Console.WriteLine("Key="+i+"Value="+myDictionary);
 }
 Or
 foreach(KeyValuePair<string, double> temp in myDictionary)//返回的是KeyValuePair<string, double>泛型数组
  {
        temp.Key;
        temp.Value;
   }

一:HashTable:

1.HashTable是大器晚成种散列表,他里头维护广大对Key-Value键值对,其还会有三个周边索引的值叫做散列值(HashCode),它是依照GetHashCode方法对Key通过一定算法获取获得的,全体的找寻操作定位操作都以基于散列值来兑现找到相应的Key和Value值的。

2.我们须求运用贰个算法让散列值对应HashTable的半空中地址尽量不重复,那就是散列函数(GetHashCode)需求做的事。

3.当四个HashTable被占有一大半的时候大家经过测算散列值得到之处值恐怕会再一次指向同风流浪漫地方,这正是哈希冲突。

4.在.Net中键值对在HashTable中的地点Position= (HashCode& 0x7FFFFFFF) %
HashTable.Length,.net中是透过探测法灭绝哈希冲突的,当通过散列值得到的职分Postion以致被占用的时候,就能够增加一个位移x值判别下二个地方Postion+x是还是不是被占用,假使依然被挤占就继续往下位移x剖断Position+2*x地方是还是不是被占用,若无被侵占则将值归入个中。当HashTable中的可用空间更加小时,则赢得获得可用空间的难度进一步大,消耗的时光就更加多。

5..脚下HashTable中的被占用空间达到一个比例的时候就将该空间活动扩大容积,在.net中这些比例是72%,也叫.net中HashTable的填写因子为0.72。比方有三个HashTable的长台湾空中大学小是100,当它供给增加第九公斤个值的时候将会扩大体量此HashTable.

6.这几个自动扩大容积的分寸是有个别呢?答案是当下空间尺寸的两倍最附近的素数,例如当前HashTable所占空间为素数71,就算扩大体量,则扩容大小为素数131.

官方澳门新永利下载 1

二:Dictionary

1.Dictionary是大器晚成种变种的HashTable,它接受意气风发种抽离链接散列表的数据结构来消除哈希冲突的标题。

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

3.那个变种HashTable的填写因子是1

官方澳门新永利下载 2

eg:本文将以代码的款型索求HashTable和Dictionary的插入和三种读取形式的作用(for/foreach/GetEnumerator)

public class HashTableTest

    {

        static Hashtable _Hashtable;

        static Dictionary<string, object> _Dictionary;

        static void Main()

        {

            Compare(10);

            Compare(10000);

            Compare(5000000);

            Console.ReadLine();

        }

        public static void Compare(int dataCount)

        {

            Console.WriteLine("-------------------------------------------------n");

            _Hashtable = new Hashtable();

            _Dictionary = new Dictionary<string, object>();

            Stopwatch stopWatch = new Stopwatch();

            //HashTable插入dataCount条数据需要时间

            stopWatch.Start();

            for (int i = 0; i < dataCount; i++)

            {

                _Hashtable.Add("Str" + i.ToString(), "Value");

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable插入" + dataCount + "条数据需要时间:" + stopWatch.Elapsed);



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            stopWatch.Start();

            for (int i = 0; i < dataCount; i++)

            {

                _Dictionary.Add("Str" + i.ToString(), "Value");

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary插入" + dataCount + "条数据需要时间:" + stopWatch.Elapsed);



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            int si = 0;

            stopWatch.Start();

            for(int i=0;i<_Hashtable.Count;i++)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable遍历时间:" + stopWatch.Elapsed + " ,遍历采用for方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            foreach (var s in _Hashtable)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable遍历时间:" + stopWatch.Elapsed + " ,遍历采用foreach方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            IDictionaryEnumerator _hashEnum = _Hashtable.GetEnumerator();

            while (_hashEnum.MoveNext())

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" HashTable遍历时间:" + stopWatch.Elapsed + " ,遍历采用HashTable.GetEnumerator()方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            for(int i=0;i<_Dictionary.Count;i++)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary遍历时间:" + stopWatch.Elapsed + " ,遍历采用for方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            foreach (var s in _Dictionary)

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary遍历时间:" + stopWatch.Elapsed + " ,遍历采用foreach方式");



            //Dictionary插入dataCount条数据需要时间

            stopWatch.Reset();

            si = 0;

            stopWatch.Start();

            _hashEnum = _Dictionary.GetEnumerator();

            while (_hashEnum.MoveNext())

            {

                si++;

            }

            stopWatch.Stop();

            Console.WriteLine(" Dictionary遍历时间:" + stopWatch.Elapsed + " ,遍历采用Dictionary.GetEnumerator()方式");





            Console.WriteLine("n-------------------------------------------------");

        }

    }

 四:从下面的结果可以见到

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

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

3.在foreach形式遍历时Dictionary遍历速度更加快。

五:在单线程的时候使用Dictionary越来越好一些,二十四线程的时候利用HashTable更加好。

因为HashTable能够经过Hashtable tab = Hashtable.Synchronized(new
Hashtable());拿到线程安全的对象。

eg: hashtable

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


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

三:遍历格局:

Dictionary的三种遍历格局:

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

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

HashTable的遍历格局:

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

 第四:Queue集合和Stack

Queue:它是三个先进先出的集聚(它存款和储蓄于队列中卡塔尔国,先进先出的乐趣也正是第风流倜傥放进集结的数目,拿多少的时候从早先时代放进去的数目初步拿。

Stack:它是四个后进先出的汇聚(它存款和储蓄于栈中卡塔尔,后进先出的情致看名就可以预知意思,也正是说取多少只可以从最终放进去的不行数据起始取。

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

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

出口结果:
官方澳门新永利下载 3

听闻以下代码对Queue 与
Stack举办了品质测量试验,他们的性质都比数组要高差相当少2~倍。

Stopwatch sw_queue = new Stopwatch();
2. sw_queue.Start();
3. 
4. //写入数据到Queue中
5. Queue q = new Queue();
6. for (int i = 0; i < 1000000; i++)
7. {
8.     q.Enqueue(i);
9. }
10. 
11. //循环输出Queue所有数据
12. while (q.Count > 0)
13. {
14.     q.Dequeue();
15. }
16. 
17. sw_queue.Stop(); // 停止监视
18. Console.WriteLine("Queue 100万数据写入读取消耗时间:{0}毫秒", sw_queue.Elapsed.TotalMilliseconds.ToString());
19. 
20. //---------------------------------分割线--------------------------------//
21. 
22. Stopwatch sw_stack = new Stopwatch();
23. sw_stack.Start();
24. 
25. 
26. //写入数据到Stack中
27. Stack s = new Stack();
28. for (int i = 0; i < 1000000; i++)
29. {
30.     s.Push(i);
31. }
32. 
33. //循环输出所有Stack数据
34. while (s.Count > 0)
35. {
36.     s.Pop();
37. }
38. 
39. sw_stack.Stop(); // 停止监视
40. Console.WriteLine("Stack 100万数据写入读取消耗时间:{0}毫秒", sw_stack.Elapsed.TotalMilliseconds.ToString());
41. 
42. 
43. Console.R
eadKey();

测量检验结果:
官方澳门新永利下载 4

Queue 的基本点成员:

属性  

Count    //元素数     

方法 

Clear()   //清空 

Contains() //是否含有 

Dequeue() //出列 

Enqueue() //入列 

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

Stack 的要害成员:

属性   Count       //     

方法 

Clear()      // 

Contains()    // 

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

Pop()       //出栈 

Push()       //压栈 

第五:SortedList

1、SortedList定义

System.Collections.SortedList类表示键/值对的聚合,那一个键值对开关排序并可遵照键和目录访问。SortedList
在内部维护多少个数组以存款和储蓄列表中的成分;即,多个数组用于键,另八个数组用于相关联的值。每一种成分都以三个可用作
DictionaryEntry 对象进行拜谒的键/值对。键不能够为null,但值能够。

2.优点

1、SortedList
允许通过相关联键或通过索引对值进行拜见,可提供越来越大的灵活性。

2、可依照必要活动叠合体量。

3.注意点:

1、SortedList 的体量是 SortedList 能够保留的元素数。SortedList
的暗许初阶体积为 0。随着成分增加到 SortedList
中,在急需时能够透过重新分配自动扩大容积。可透过调用 TrimToSize方法
或透过显式设置 Capacity 属性减弱体量。

2、SortedList 中不允许重复键。

3、SortedList的目录顺序基于排序依次。当添港元素时,元素将按正确的排序依次插入
SortedList,同不常候索引会相应地展开调节。当移除成分时,索引也会相应地拓宽调节。因而,当在
SortedList 中拉长或移除成分时,特定键/值没错目录只怕会变动。

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

5、通过设置 SortedList
中不设有的键值(譬喻,myCollection[“myNonexistentKey”] =
myValue卡塔尔,还是能够使用 Item 属性增多新成分。但是,假设钦命的键已经存在于
SortedList 中,则设置 Item 属性将改写旧值。比较之下,Add
方法不改换现存元素。

键无法为 空援引(在 Visual Basic 中为
Nothing卡塔尔,但值能够。若要区分由于未找到钦命键而回到的 空引用(在 Visual
Basic 中为 Nothing卡塔尔国 和出于内定键的值为 空援引(在 Visual Basic 中为
Nothing卡塔尔 而回到的 空援用(在 Visual Basic 中为 Nothing卡塔 尔(英语:State of Qatar),请使用
Contains 方法或 ContainsKey 方法明确列表中是不是留存该键。

  1. SortedList的构造器

官方澳门新永利下载 5

5、SortedList的属性

官方澳门新永利下载 6

6.SortedList的方法

官方澳门新永利下载 7

官方澳门新永利下载 8

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

假若急需排好序的表,能够应用SortedList<TKey,TValue>。这一个类遵照键给成分排序。

上面的例证成立多少个不改变表,个中键和值都是string类型。默许的构造函数创立了三个空表,再用Add()方法增加两本书。使用重载的构造函数,能够定义有序表的容积,传送实行了IComparer<TKey>接口的目的,用于给有序表中得成分排序。

Add()方法的首先个参数是键(书名卡塔尔国,第4个参数是值(ISBN号卡塔尔国。除了利用Add()方法之外,还是能够动用索引器将成分增添到平稳表中。索引器要求把键作为目录参数。假如键已存在,那么Add()方法就抛出一个ArgumentException类型的十分。如若索引器使用肖似的键,就用新值替代旧值。

 

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

输出结果:
官方澳门新永利下载 9

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

 

 

 

 

 

 

 

 

 

C#
泛型集结之非泛型会集类与泛型会集类的相应: ArrayList对应List
HashTable对应Dictionary Queue对应Queue…

发表评论

电子邮件地址不会被公开。 必填项已用*标注