正文

C#容器类，接口，机能详解引见【C#.Net教程】,C#，容器类，性能

搜教程
搜教程 V管理员 /220 阅读
1127

1 indexer

　　[]声明的变量必需是牢固长度的，即长度是静态的；object[] objectArray = new object[10];
objectArray是浅复制，即只在memory中给其赋一个地点值，此时每一item此时都是null援用；

　　运用举例

     AdjustablePanel[] adjustPanelArrays = new AdjustablePanel[12];     
     foreach (Control ultraControl in this.Controls)
            {                if (ultraControl.GetType() == typeof(UltraGrid) ||
                 ultraControl.GetType() == typeof(UltraChart) ||   ultraControl.GetType() == typeof(Panel))
                {                //adjustPanelArrays[index]此时为null，因而会涌现null援用bug
                    adjustPanelArrays[index].Controls.Add(ultraControl); 
                }
            }

2 Array

　　供应建立、操纵、搜刮和排序数组的要领，因而在大众言语运行时用作一切数组的基类。长度是牢固的，不能按需动态增添；Array 是抽象类，不能运用 new Array 建立；GetValue返回的是object范例。

            Array myArray = Array.CreateInstance(typeof(int),3);
            myArray.SetValue(1,0);
            myArray.SetValue(2,1);
            myArray.SetValue(3,2);            //GetValue返回的是object范例，须要举行范例提升为int
            int val2 = (int)myArray.GetValue(2);

3 ArrayList

　　运用大小可按需动态增添的数组完成 IList 接口，且是针对恣意范例。

            ArrayList al = new ArrayList();
            ArrayList arrayList = new ArrayList();
            al.Add("qaz");
            al.Add(1);
            al.Add(new List<object>());            
            string str = (string)al[0];            
            int intval = (int)al[1];
            List<object> objs = (List<object>)al[2];

总结
　　 [], Array 编译前须要已知长度，是静态的，范例须要唯一肯定的，Array是抽象类，建立须要Array.CreateInstance()；
　　 ArrayList 编译时长度未知，是动态的，而且增加的元素可所以差别的范例。

4 List-APIs

4-1 简介

List< T>是一个泛型类，完成了接口IList< T>，经由过程内部运用一个size动态调解的数组来显现外部的接口。

4-2 增添元素

完成增加一个元素

Add(obj)

批量增加元素到列表中：

AddRange(objList)

举例：

        private List<int> intList = new List<int>();        public void AddApi()
        {
            intList.Add(10); //增加1个元素
            intList.AddRange(new List<int>() { 5, 1, 1, 2, 2, 3 }); //批量增加元素
        }

将鸠合中的某个元素插进去指定索引处

void Insert(int index, T item);
void InsertRange(int index, IEnumerable《T》 collection)

4-3移除元素

假定intList是一个List范例，初始值为 {10,5,1,1,2,2,3}。实行:

intList.Remove(1);

从intList中移除特定对象的第一个婚配项。移除元素1后，intList = {10,5,1,2,2,3}；

移除肯定局限的元素 ：

intList.RemoveRange(0, 2);

intList = {2,2,3}；

移除一切反复元素后：intList = {3}；

            intList.RemoveAll(removeDuplicateElements); 
            intList.RemoveAll(i =>
            {                List<int> elementList = intList.FindAll(r => r.Equals(i));                if (elementList != null && elementList.Count > 1)                    return true;                return false;
            });

在以上推断某个元素是不是存在时，比方移除某个元素时，须要用到相称比较器。假如范例T完成了IEquatable< T> 泛型接口，相称比较器就是 Equals(T) 要领; 不然, 默许的相称比较器是 Object.Equals(Object).

下面看一个不是默许的比较器，完成接口的例子：

    public class MyObject
    {        public int Value { get; set; }        
    public MyObject(int value)
        {            this.Value = value;
        }
    }    //完成接口IEquatable<MyObject>
    public class MyObjectCollection : IEquatable<MyObject>
    {        private List<MyObject> _myObjects = new List<MyObject>()
        {            new MyObject(3),            
        new MyObject(4),            
        new MyObject(3),            
        new MyObject(2),           
         new MyObject(3)
        };        //删除一切反复的元素
        public void RemoveDuplicates()
        {
            _myObjects.RemoveAll(Equals); 
        }        public List<MyObject> MyObjects
        {            get
            {                return _myObjects;
            }
        } 

        public bool Equals(MyObject other)
        {
            MyObject duplicate = _myObjects.Find(r => r.Value == other.Value);            
            if (duplicate != null && duplicate!=other)                
            return true;            
            return false;
        }
    }

此处完成了Equals(object)，然则Remove(test)临时是失利的，今后找缘由。

4-4查找元素

肯定某元素是不是在List 中。

bool Contains(obj)

肯定是不是包括与指定谓词所定义的前提相婚配的元素。

bool Exists(Predicate<T> match)

搜刮与指定谓词所定义的前提相婚配的元素，并返回第一个婚配元素。

T Find(Predicate<T> match)

检索与指定谓词定义的前提婚配的一切元素。

List<T> FindAll(Predicate<T> match)

搜刮与指定谓词所定义的前提相婚配的元素，并返回第一个婚配元素的从零最先的索引

int FindIndex(Predicate<T> match)

搜刮与指定谓词所定义的前提相婚配的元素，并返回从指定索引到末了一个元素的元素局限内第一个婚配项的从零最先的索引。

int FindIndex(int startIndex, Predicate<T> match)

搜刮与指定谓词所定义的前提相婚配的元素，并返回从指定的索引最先并包括指定元素数目的元素局限内的第一个婚配项的零始索引

int FindIndex(int startIndex, int count, Predicate<T> match)
T FindLast(Predicate<T> match)
int FindLastIndex(Predicate<T> match)
int FindLastIndex(int startIndex, Predicate<T> match)
int FindLastIndex(int startIndex, int count, Predicate<T> match)

搜刮指定的对象，并返回第一个婚配项的从零最先的索引

int IndexOf(T item)

搜刮指定的对象，并返回从指定索引到末了一个元素的元素局限内第一个婚配项的从零最先的索引

int IndexOf(T item, int index)
int IndexOf(T item, int index, int count)

搜刮指定的对象，并返回末了一个婚配项的从零最先的索引。

int LastIndexOf(T item)
int LastIndexOf(T item, int index)
int LastIndexOf(T item, int index, int count)

4-5二分查找

运用默许的比较器在全部已排序的List中搜刮元素，并返回该元素从零最先的索引。

 int BinarySearch(T item);

运用指定的比较器在全部已排序的List中搜刮元素，并返回该元素从零最先的索引。

int BinarySearch(T item, IComparer<T> comparer)
int BinarySearch(int index, int count, T item, IComparer<T> comparer)

4-6排序

运用默许比较器对全部List中的元素举行排序。

void Sort()

运用指定的 System.Comparison 对全部 List中的元素举行排序。

void Sort(Comparison<T> comparison)

运用指定的比较器对List中的元素举行排序。

void Sort(IComparer<T> comparer)
void Sort(int index, int count, IComparer<T> comparer)

4-7机能剖析

操纵 时候复杂度
Add O(1)或O(n)
Insert O(n)
Remove O(n)
GetAnItem O(1)
Sort O(nlogn)，最坏O(n^2)
Find O(n)

4-8 附运用圈套点：

1 list.Min() 和 list.Max() 和 Average()等Linq要领，当list元素个数为0，则会涌现“序列不包括任何元素”的非常。

2 object.ToString() 运用前要检测object是不是为null。

3 Foreach遍用时，迭代器是不许可增添或删除的。比方： 

 public List<MDevice> GetNormalDevices(List<MDevice> devices)
    {
        rtnDevices = devices;        foreach (var device in devices)
        {            var tmpdevices = bslMDevice.GetMDeviceByDeviceCode(device.DeviceCode);            
        if (!devices[0].IsNormal)
            {            //这是不法的，因为移除rtnDevices列表的一个元素，等价于移除devices列表。
                rtnDevices.Remove(device); 
            }
        }
    }

5 SortedList

5-1 SortedList简介

Sorted表清楚明了它内部完成自动排序，List表清楚明了它有点像List，能够经由过程index接见鸠合中的元素。

5-2 内部完成机理

一个SortedList对象内部保护了2个数组，以此来存储元素，个中一个数组用来寄存键（keys），另一个寄存键关联的值（values）。每个元素都是键值对（key/value pair）。key不能是null，value能够。

5-3 总结API

5-3-1 Capacity

一个SortedList对象的容量是SortedList能包容的元素数，这个值是动态变化，自动调解的。以下所示：

SortedList mySL = new SortedList();
mySL.Add("Third", "!");
mySL.Add("Second", "World");
mySL.Add("First", "Hello");
Console.WriteLine( "mySL" );
Console.WriteLine( "  Capacity: {0}", mySL.Capacity );

此时Capacity: 16

假如增加到mySL中的元素增加，响应的Capacity会响应的自动变大。

5-3-2 接见元素

经由过程index接见

SortedList对象要想经由过程index接见，须要运用组织函数SortedList() 或 SortedList(IComparer icompared)。

SortedList sortedList = new SortedList();
sortedList.Add(3,"gz");
sortedList.Add(9, "lhx");
sortedList.Add(3, "gz");object getByIndex = sortedList.GetByIndex(2);
经由过程key接见

SortedList对象要想经由过程key接见，须要运用带有TKey,TValue的泛型组织函数。

SortedList<int,string> sortedList = new SortedList<int,string>();
sortedList.Add(3,"gz");
sortedList.Add(9, "lhx");object getByIndex = sortedList[3];

5-3-3排序

SortedList有一种默许的比较递次，比方下面的代码：

SortedList<int,string> sortedList = new SortedList<int,string>();
sortedList.Add(9,"gz");
sortedList.Add(3, "lhx");

结果是 sortedList中第一个对是3,”lhx”

假如不想根据默许的排序递次，须要本身在组织时定制一种排序递次，以下面的代码：

完成排序接口

新建一个私有排序类，完成接口IComparer

private class ImplementICompare: IComparer<int>
  {      public int Compare(int x, int y)
      {          return x < y ? 1 : -1;
      }
  }
组织SortedList
ImplementICompare impleCompare = new ImplementICompare();
SortedList<int, string> sortedList = new SortedList<int, string>(impleCompare);
sortedList.Add(9,"gz");
sortedList.Add(3, "lhx");

根据键从大到小的递次排序，结果是 sortedList中第一个对是9,”gz”

5-3-4 增加元素

用add接口完成增加某个元素到鸠合中，不许可反复增加雷同键。

SortedList<int,string> sortedList = new SortedList<int,string>();
sortedList.Add(9,"gz");
sortedList.Add(3, "lhx");

5-3-5 移除元素

移除鸠合中指定元素Remove(object removedElement)；指定index处移除元素RemoveAt(int index)。

Remove(object)
SortedList mySL = new SortedList();
mySL.Add( "3c", "dog" );
mySL.Add( "2c", "over" );
mySL.Add( "3a", "the" );
mySL.Add( "3b", "lazy" );   
mySL.Remove( "3b" ); //sucessful to remove
SortedList<int, string> sortedList = new SortedList<int, string>();
sortedList.Add(9,"gz");
sortedList.Add(3, "lhx");bool removedFlag = sortedList.Remove(3); //true
ImplementICompare impleCompare = new ImplementICompare();
SortedList<int, string> sortedList = new SortedList<int, string>(impleCompare);
sortedList.Add(9,"gz");
sortedList.Add(3, "lhx");bool removedFlag = sortedList.Remove(3); //false

这是须要注重的一个处所，组织器带有impleCompare完成了排序接口时，彷佛不能移除某个元素，须要待确认。

RemoveAt(int index)
SortedList sorted = new SortedList();
sorted.Add(9, "gz");
sorted.Add(3, "lhx");
sortedList.RemoveAt(1); //在排序后的位置移除，sortedList的一个对的键 为3，第二个对的键为9，因而移除了9这个键值对

5-4 机能

一个SortedList的操纵比拟Hashtable对象是要慢些的，因为它完成了排序功能。然则，SortedList供应了接见的方便性，因为既能够经由过程index，也能够经由过程key去接见元素。

6 .net容器相干接口

接口 形貌
IEnumerable< T> 完成foreach语句须要完成此接口，接口要领GetEnumerator返回罗列器。
ICollection< T> 要领：Count属性，CopyTo(Array),Add, Remove, Clear
IList< T> 定义了indexer,Insert, RemoveAt要领，继续ICollection< T>
ISet< T> 要领：求并集，交集，继续于ICollection< T>
IDictionary< TKey, TValue> 有key和value的鸠合完成
ILookup< TKey, TValue> 相似上，许可multiple values with one key.
IComparer< T> comparer完成，排序比较的划定规矩
IEqualityComparer< T> 对象be compared for equality另一个对象
IProducerConsumerCollection< T> thread-safe collection classes



7 接口UML



C#容器类，接口，机能详解引见【C#.Net教程】,C#，容器类，性能


8 各个容器时候复杂度

鸠合范例 Add Insert Remove Item Sort Find
List< T> O(1)或O(n) O(n) O(n) O(1) O(nlogn) O(n)
Stack< T> O(1)或O(n) 不实用 pop() O(1) 不实用 不实用 不实用
Queue< T> O(1)或O(n) 不实用 O(1) 不实用 不实用 不实用
HashSet< T> O(1)或O(n) O(1)或O(n) O(1) 不实用 不实用 不实用
LinkedList< T> O(1) O(1) O(1) O(n) 不实用 O(n)
Dictionary<, > O(1)或O(n) 不实用 O(1) O(1) 不实用 不实用
SortedDictionary<,> O(logn) 不实用 O(logn) O(logn) 不实用 不实用
SortedList<,> O(logn) 不实用 O(n) O(logn) 不实用 不实用

以上就是C#容器类，接口，机能详解引见的内容，更多相干内容请关注ki4网（www.ki4.cn）！

本站所有文章、图片、资源等如无特殊说明或标注，均为来自互联网或者站长原创；版权归原作者所有，仅作为个人学习、研究以及欣赏！如若本站内容侵犯了原著者的合法权益，可联系我们进行处理，邮箱：i-hu@foxmail.com