【C#基础】常用数据结构

数组

数组是一种特殊类型的数据类型，它可以使用特殊语法顺序存储固定数量的值。

数组声明

int [] intArr;

数组初始化：使用new关键字同时声明和初始化数组，下面三种方式等价

int[] intArr = new int[5]; 
int[] intArr = new int[5]{1， 2， 3， 4， 5};
int[] intArr = {1， 2， 3， 4， 5};

延迟初始化：可以先声明后再初始化数组

string[] strArr， strArr;
strArr = new string[5]{ "1st Element"，"2nd Element"， "3rd Element"};
strArr = new string[]{ "1st Element"，"2nd Element"， "3rd Element"};

索引访问数组中元素

intArr[索引位置];

// 数组可以先声明后赋值，也可以声明同时赋值，下面的方式是等价的，数组中必须存储同一类型数据，这在数组被定义时就已经确定
// 第一种
int[] intArr = new int[5];
intArr[0] = 1;
intArr[1] = 2;
intArr[2] = 3;
intArr[3] = 4;
intArr[4] = 5;
// 第二种
//int[] intArr = new int[5] { 1， 2， 3， 4， 5 };
// 第三种
//int[] intArr = { 1， 2， 3， 4， 5 };
// 注意这里是维度不是索引
Console.WriteLine("GetLength(int维度):返回指定维度中的元素数，值为：{0}"， intArr.GetLength(0));
Console.WriteLine("GetLowerBound(int维度):返回指定维度的最低索引，值为：{0}"， intArr.GetLowerBound(0));
Console.WriteLine("GetUpperBound(int维度):返回指定维度的最高索引，值为：{0}"， intArr.GetUpperBound(0));
Console.WriteLine("GetValue(int index):    返回指定索引处的值，值为：{0}"， intArr.GetValue(2));
Console.WriteLine("属性:Length:返回数组中元素的总数，值为：{0}"， intArr.Length);
// 使用索引来访问数组元素
Console.WriteLine("使用索引访问数组元素，索引为2的值为：{0}"， intArr[2]);
// 试图访问数组中不存在的索引元素，会发生数组越界
Console.WriteLine("使用索引访问数组元素，索引为10的值为：{0}"， intArr[10]);
for (int i = 0; i < intArr.Length; i++)
{
    Console.WriteLine(intArr[i]);
}
foreach (var item in intArr)
{
    Console.WriteLine(item);
}

多维数组

多维数组是行和列的二维系列。多维数组又称为矩形数组；在本质上，是个一维数组的列表。

// 下面的两种创建方式等价
// 第一种
// int[，] intArray = { { 1， 1 }， { 1， 2 }， { 1， 3 } };
// 第二种
int[，] intArray = new int[3， 4]{    //初始化化一个三行四列的数组
                   {0， 1， 2， 3} ，   /*  初始化索引号为 0 的行 */
                   {4， 5， 6， 7} ，   /*  初始化索引号为 1 的行 */
                   {8， 9， 10， 11}   /*  初始化索引号为 2 的行 */
                };
// 下面的语句将获取数组中第3行第4个元素                                
Console.WriteLine("二维数组中的元素是通过使用下标（即数组的行索引和列索引）来访问，值为：{0}"， intArray[2， 3]);
Console.WriteLine("属性:Length:返回数组中元素的总数，值为：{0}"， intArray.Length);

可以使用两个索引访问多维数组的值。第一个索引用于行，第二个索引用于列。两个索引都从零开始。

锯齿状数组

锯齿状数组是数组的数组。Jagged数组直接存储数组而不是任何其他数据类型值。锯齿状数组用两个方括号 [][] 初始化。

第一个括号指定数组的大小，第二个括号指定将作为值存储的数组的维度。(锯齿状数组总是存储一个数组)，二维数组的大小是矩形的。

例如：3×3个元素。而锯齿数组的大小设置是比较灵活的，在锯齿数组中，每一行都可以有不同的大小

int[][] intJaggedArray = new int[2][];
intJaggedArray[0] = new int[3]{1，2，3};
intJaggedArray[1] = new int[2]{4，5};
Console.WriteLine(intJaggedArray[0][0]); // 1
Console.WriteLine(intJaggedArray[0][2]); // 3
Console.WriteLine(intJaggedArray[1][1]); // 5

Array

.NET提供了一个抽象类 Array ，作为所有数组的基类。它提供了用于创建，操作，搜索和排序数组的静态方法。**

Array arr = Array.CreateInstance(Type.GetType("System.Int32")， 3);           
arr.SetValue(1， 0);
arr.SetValue(3， 1);
Console.WriteLine("IsFixedSize:取一个值，该值指示数组是否带有固定大小，值为:{0}"， arr.IsFixedSize);
Console.WriteLine("IsReadOnly:取一个值，该值指示数组是否只读，值为:{0}"， arr.IsReadOnly);
Console.WriteLine("Length:获取一个 32 位整数，该值表示所有维度的数组中的元素总数，值为:{0}"， arr.Length);
Console.WriteLine("LongLength:获取一个 64 位整数，该值表示所有维度的数组中的元素总数，值为:{0}"， arr.LongLength);
Console.WriteLine("Rank:获取数组的秩（维度），值为:{0}"， arr.Rank);
foreach (var item in arr)
{
    Console.WriteLine(item);
}

集合

C＃包括在特定系列中包含许多值或对象的专用类，称为集合。C＃中有两种类型的集合：非泛型集合和泛型集合。每个集合类都实现 IEnumerable 接口，因此可以使用 foreach 循环访问集合中的值。

非泛型集合

System.Collections中命名空间包括以下非泛型集合：

ArrayList

可以包含任何数据类型的元素。类似于数组，但是在添加元素时不需要指定ArrayList的大小会自动增长。

要点：

• 可以存储任何数据类型的项(元素)
• 添加元素时会自动调整大小
• 可以包含多个null
• 可以使用 foreach 或 for 循环或索引器访问

**

ArrayList arrayList = new ArrayList();
arrayList.Add("wang");
arrayList.Add(1);
// ArrayList允许插入null
arrayList.Add(null);
foreach (var item in arrayList)
{
    Console.WriteLine(item);
}

SortedList

SortedList集合默认按键的升序存储键值对。SortedList类实现IDictionary和ICollection接口，因此可以通过键和索引访问元素。

C＃包括两种类型的SortedList，泛型SortedList和非泛型SortedList

要点：

• C#具有泛型和非泛型 SortedList
• SortedList 按键的升序存储键值对。键必须是唯一的，不能为null，而值可以为null或重复项
• 非泛型 SortedList 存储任何数据类型的键和值。因此，需要将值转换为适当的数据类型
• 键值对可以强制转换为DictionaryEntry
• 使用索引器访问单个值。SortedList 索引器接受键并返回与之关联的值

**

SortedList sortedList = new SortedList();
sortedList.Add(2， "wang");
sortedList.Add(5， "li");
sortedList.Add(3， 5);
//SortedList键可以是任何数据类型，但不能在同一SortedList中添加不同数据类型的键。
sortedList.Add("wang"， 32);
for (int i = 0; i < sortedList.Count; i++)
{
    Console.WriteLine("key:{0}，value:{1}"， sortedList.GetKey(i)， sortedList.GetByIndex(i));
}
foreach (DictionaryEntry item in sortedList)
{
    Console.WriteLine("key:{0}，value:{1}"， item.Key， item.Value);
}

Stack

C＃包含一种特殊类型的集合，它以 LIFO 样式存储元素(后进先出)。

C#包括通用和非通用堆栈，非泛型堆栈。Stack允许空值以及重复值。它提供了一个 Push() 方法来添加一个值， Pop() 或 Peek() 方法来检索值。

要点：

• Stack将值存储在LIFO(后进先出)样式中。最后添加的元素将是首先出现的元素
• 使用Push()方法将元素添加到Stack中
• Pop()方法返回并从堆栈顶部删除元素。在空Stack上调用Pop()方法将引发异常
• Peek()方法总是返回Stack中最顶层的元素

**

Stack stack = new Stack();
stack.Push("1");
stack.Push(1);
stack.Push(false);
foreach (var item in stack)
{
    Console.WriteLine(item);
}

Queue

C＃包含System.Collection命名空间中的Queue集合类。队列以FIFO样式(先进先出)存储元素。

与Stack集合完全相反。它按照添加顺序包含元素。队列集合允许多个空值和重复值。使用Enqueue()方法添加值，使用Dequeue()方法从队列中检索值。

要点：

• 队列将值存储在FIFO(先进先出)样式中。首先添加的元素将首先出现
• 使用Enqueue()方法将元素添加到Queue中
• Dequeue()方法返回并从队列的开头删除元素。在空队列上调用Dequeue()方法将引发异常
• Peek()方法总是返回最顶层的元素

Queue queue = new Queue();
queue.Enqueue("1");
queue.Enqueue(1);
queue.Enqueue(false);
foreach (var item in queue)
{
    Console.WriteLine(item);
}

Hashtable

C＃包含System.Collections命名空间中的Hashtable集合，类似于通用字典集合。Hashtable集合存储键值对。通过计算每个密钥的哈希码来优化查找，并在内部将其存储在不同的存储桶中，然后在访问值时匹配指定密钥的哈希码。

要点：

• 存储Key必须唯一的任何数据类型的键值对
• 键不能为null，而值可以为null
• 通过比较键的哈希码来检索项目。因此它的性能比Dictionary集合慢
• 使用默认的哈希码提供程序，即object.GetHash()。还可以使用自定义哈希码提供程序
• 将DictionaryEntry与foreach语句一起使用以迭代Hashtable

**

Hashtable hashtable = new Hashtable();
hashtable.Add(1， "wang");
hashtable.Add(3， false);
hashtable.Add(2， "li");
foreach (DictionaryEntry item in hashtable)
{
    Console.WriteLine("key:{0}， value:{1}"， item.Key， item.Value);
}

BitArray

BitArray 类管理一个紧凑型的位值数组，它使用布尔值来表示，其中true表示位是开启的(1)，false 表示位是关闭的(0)。当需要存储位，但是事先不知道位数时，则使用点阵列。可以使用整型索引从点阵列集合中访问各项，索引从零开始。

泛型集合

同传统的集合相比，泛型集合是一种强类型的集合，它解决了类型安全问题，同时避免了集合中每次的装箱与拆箱的操作，提升了性能。

List

List<T>在C#应用程序中是一种快捷、易于使用的泛型集合类型，使用泛型编程为编写面向对象程序增加了极大的效率和灵活性，不会强行对值类型进行装箱和拆箱，或对引用类型进行向下强制类型转换。

List<intintList = new List<int>();
intList.Add(3);
intList.Add(54);
intList.Add(14);
foreach (var item in intList)
{
    Console.WriteLine(item);
}

Stack

以后进先出的方式维护数据的集合，包含pop()和push()，从栈内压入或移除数据。

Quenue

以先进先出的方式访问数据，使用Enqueue()和Dequeue()添加数据和移除数据。

SortedSet

这个类中的数据是排序的，在插入和移除数据之后仍然能自动排序，需要向其构造函数中传递一个实现了IComparer<T>，该接口定义了Compare方法。

ObservableCollection

表示能在添加、移除或者刷新整个列表时提供通知的动态数据集合， ReadOnlyObservableCollection<T> 的操作与之类似，不过是只读的。 ObservableCollection<T> 实现了一个名为CollectionChanged事件，该事件在插入新的数据或者移除数据时触发。

Dictionary

提供快速的基于键值的元素查找。结构是：Dictionary <[key],[value]>，当有很多元素的时候可以用它。在使用前，必须声明它的键类型和值类型。

数组/ArrayList/List三者的区别

• 数组：针对特定类型固定长度，值不可为null，在声明数组的时候必须指定数组的长度，可有多个维度
• Array：数组的另一种创建方式抽象类，作为所有数组的基类，针对任意类型固定长度，值可以为null，输出会被替换为0
• ArrayList：针对任意类型、任意长度的，值可以为null，存储或检索值类型时通常发生装箱和拆箱操作，带来很大的性能耗损

• List：强类型的集合，固定类型、任意长度，值不可为null，是类型安全的

  索引器(Indexer)

  Indexer是一种特殊类型的属性，允许以与其内部集合的数组相同的方式访问类或结构。除了使用带有方括号和参数的此关键字定义的属性外，它与属性相同。

• 索引器与属性相同，除了它使用带有方括号的此关键字定义，该参数具有参数

• 可以通过具有不同类型的参数来覆盖索引器
• 不支持使用索引器的Ref和out参数
• 索引器可以作为接口成员包含在内

public <return typethis[<parameter typeindex]
{
    Get{
    // return the value from the specified index
    }
    Set{
    // set values at the specified index
    }
}

public class Indexer
{
        private int[] indexs = new int[10];
        public int this[int index]
        {
            get { return indexs[index]; }
            set
            {
                indexs[index] = value;
            }
        }
}
/*
Indexer是一种特殊类型的属性，允许以与其内部集合的数组相同的方式访问类或结构。
除了使用带有方括号和参数的此关键字定义的属性外，它与属性相同。
*/
Console.WriteLine("********************索引器*********************");
Indexer indexer = new Indexer();
indexer[0] = 1;
indexer[1] = 2;
Console.WriteLine(indexer[1]);