C#基础总结：常用的数据结构

Array：

需要处理的元素数量确定并且需要使用下标时可以考虑，不过建议使用List

数组的内容都是相同类型

数组可以直接通过下标访问

创建时需要固定数组大小

int size = 5; 
int [] test =  new int [size]; 
        
string [] test2 =  new string [3]; 
//赋值 
test2[0] =  "chen" ; 
test2[1] =  "j"  ; 
test2[2] =  "d" ; 
//修改 
test2[0] =  "chenjd" ; 

//排序
int[] myArray = { 4, 3, 5, 1, 2 };
Array.Sort(myArray);

//获取索引
int value = Array.IndexOf(myArray, 5);

//Array.Copy(sourceArray, destinationArray, length): 将一个数组的元素复制到另一个数组中。
int[] myArray = { 4, 3, 5, 1, 2 };
int[] newArray = new int[6];
//Array.Copy(sourceArray, destinationArray, length)
//length是从原数组复制的长度
Array.Copy(myArray, newArray, 4);

ArrayList：

不必在声明ArrayList时指定它的长度

ArrayList可以存储不同类型的元素

ArrayList不是类型安全的

引入时，泛型还未出现，后泛型集合类（如 List）因其类型安全性和性能优势而变得流行

常用方法：

//new
ArrayList arrayList = new ArrayList();

//Add
arrayList.Add("Hello");
arrayList.Add(123);

//使用 Insert 方法在特定位置插入一个对象：
arrayList.Insert(0, "First");

//移除元素 - 使用 Remove 方法移除一个对象：
arrayList.Remove("Hello");
arrayList.RemoveAt(4); 

//修改数据 
arrayList[4] = 26; 

//获取元素索引 - 使用 IndexOf 方法获取对象在 ArrayList 中的索引：
int index = arrayList.IndexOf(123);

List泛型List：

需要处理的元素数量不确定时 通常建议使用

在声明List集合时，我们同时需要为其声明List集合内数据的对象类型，这点又和Array很相似，其实List内部使用了Array来实现

融合了Array可以快速访问的优点以及ArrayList长度可以灵活变化的优点

特点：

1.顺序存储，改查快，增（插入）删慢；

使用 Add 将新元素添加在末尾是很快的，但是使用 Insert 将新元素添加在其他位置就不同了。因为这样会导致后面元素的移动位置（后移），删除同样道理，会导致后面元素的位置前移。这样效率是很低的！

2.长度可变，容量不够会自动扩容；

每次扩容，容量增加一倍。

3.需要指定数据类型，保证类型安全

常用属性：

//Capacity:容量
Console.WriteLine("intList 的当前容量为：{0}", intList.Capacity);  // intList 的当前容量为：4

//Count:获取 List<T> 中包含的元素数量。
Console.WriteLine("intList 中的元素数量为：{0}", intList.Count);  // intList 中的元素数量为：3

常用方法：

//1.New - 构造
 List<string > test4 =  new List< string >();   
 
//2.Add：新增数据   
test4.Add("Fanyoy");   
test4.Add("Chenjd");   //List<T>是无所谓初始长度的，可以用Add()方法往里面添加元素

//3.Insert: 插入数据
List<int> intList = new List<int> {1, 2, 3};
intList.Insert(1, 666);
intList.Insert(2, 888);

//[]：[]的实现，直接使用了数组的索引方式获取元素。
//修改数据   
test4[1] = "murongxiaopifu";   

//移除数据   
test4.Clear();	//移除所有元素

List<int> intList = new List<int> {1, 1, 2};
intList.RemoveAt(1); 	//移除指定下标元素
intList.Remove(1);		

//RemoveAll:移除与指定的谓词所定义的条件相匹配的所有元素。
List<int> intList = new List<int> {1, 2, 3};
intList.RemoveAll(x => x > 1);  // 删除所有大于1的元素

//Contains:确定某元素是否在 List<T> 中。
Console.WriteLine(strList.Contains(666) ? "元素存在" : "元素不存在");  // 元素存在

//Find:搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List<T> 中的第一个匹配元素
List<int> intList = new List<int> {1, 2, 3};
int ret = intList.Find(x => x > 2);
Console.WriteLine(ret);  // 3
 
//IndexOf:返回 List<T> 或它的一部分中某个值的第一个匹配项的从零开始的索引
List<string> strList = new List<string> {"a", "b", "c"};
Console.WriteLine(strList[1]);  // b
Console.WriteLine(strList.IndexOf("b"));  // 1  

//Reverse:将 List<T> 或它的一部分中元素的顺序反转。
List<int> intList = new List<int> {1, 2, 3};
intList.Reverse();

//Sort:排序
List<int> intList = new List<int> {4, 5, 1, 3, 2};
intList.Sort();
foreach(var element in intList)
{
    Console.Write(element + " ");
}
// 1 2 3 4 5

Dictionary<K,T>：

需要键值对，快速操作

字典的实现方式就是哈希表的实现方式，只不过 字典是类型安全的 ，也就是说当创建字典时，必须声明key和item的类型

键值对中的键和值都可以是任何类型的（泛型），但是键必须唯一且不能为 null，而值可以不唯一；

增删改查速度快，查找一个值的时间复杂度接近 O(1)；

长度不固定，动态扩容；

比较消耗内存（以空间换时间）；

Dictionary<int, string> testDict = new Dictionary<int, string>();
testDict.Add(1, "a");
testDict.Add(2, "b");
testDict.Add(3, "c");
foreach (KeyValuePair<int, string> element in testDict)
{
    Console.WriteLine("{0} {1}", element.Key, element.Value);
}

常用属性：

//Count:获取包含在 Dictionary<TKey,TValue> 中的键/值对的数目。
Console.WriteLine("testDict 中元素（键值对）的数量为：{0}", testDict.Count);

//Keys:获得一个包含 Dictionary<TKey,TValue> 中的键的集合。
foreach (object key in testDict.Keys)
{
    Console.Write(key + " ");
}
// 1 2 3

//Values:获得一个包含 Dictionary<TKey,TValue> 中的值的集合。
foreach (object value in testDict.Values)
{
    Console.Write(value + " ");
}
// a b c

常用方法：

//add
testDict.Add(2, "b");

//Clear:清空字典
testDict.Clear();

//ContainsKey:确定是否 Dictionary<TKey,TValue> 包含指定键。
Console.WriteLine(testDict.ContainsKey("王五"));  // True
Console.WriteLine(testDict.ContainsKey("赵六"));  // False

//ContainsValue:确定 Dictionary<TKey,TValue> 是否包含特定值。
Console.WriteLine(testDict.ContainsValue(99));  // True
Console.WriteLine(testDict.ContainsValue(100));  // False

//Remove:将带有指定键的元素（键值对）从 Dictionary<TKey,TValue> 中移除。
testDict.Remove("sex");

//TryGetValue
string value = "";
bool ret = testDict.TryGetValue("name", out value);  // 存在：true 不存在：false
Console.WriteLine("以 name 为键的键值对 {0}，对应的值为：{1}", ret ? "存在" : "不存在", value);

区别：

List只是一组项目，Dictionary是一组键值对

---

项目使用场景：

字典跟枚举一起使用

字典：

public Dictionary<SENSOR_POWER, double> StandbyCurrent = new Dictionary<SENSOR_POWER, double>();

private static Dictionary<string, DTController> _dtControllers = new Dictionary<string, DTController>();

设置枚举结构数据的数组：

public enum CURRENT_RANGE

{

CURRENT_RANGE_MA = 0, ///<电流测试量程为mA

CURRENT_RANGE_UA, ///<电流测试量程为uA

CURRENT_RANGE_NA ///<电流测试量程为nA

};

CURRENT_RANGE[] currentRange = new CURRENT_RANGE[7];

static可作为流程间的交互方法来使用