c# 開發中最常用的幾種數據結構

說明：以下程序基於 vs2019  .Net Framework4.7.2 下進行測試。

 

一、內存上連續存儲，節約空間，可以索引訪問，讀取快，增刪慢

 

1.Array  數組，是內存上連續分配的一組數據對象

優點：可以根據下標讀取和寫入，讀取速度快

缺點：寫入較慢，固定長度，只能存儲一種基礎數據類型

//Array：在內存上連續分配的，而且元素類型是一樣的
            //可以坐標訪問  讀取快--增刪慢，長度不變
            Console.WriteLine("***************Array******************");
            int[] intArray = new int[3];
            intArray[0] = 1;
            intArray[0] = 12;
            intArray[0] = 123;

            string[] strArray = new string[] { "1", "2" };//Array

 

2.ArrayList  數組，是內存上連續分配的一組數據對象

優點：不固定長度，可以根據數據自動改變大小，可以根據下標讀取和寫入，讀取速度快

缺點：所有數據類型都會當作object類型處理，有裝箱和拆箱操作，性能較慢,，不是類型安全的

 //ArrayList  不定長的，連續分配的；
            //元素沒有類型限制，任何元素都是當成object處理，如果是值類型，會有裝箱操作
            //讀取快--增刪慢
            Console.WriteLine("***************ArrayList******************");
            System.Collections.ArrayList arrayList = new System.Collections.ArrayList();
            arrayList.Add(true);
            arrayList.Add("a");
            arrayList.Add(32);//add增加長度
                              //arrayList[4] = 26;//索引復制，不會增加長度
                              //刪除數據
                              //arrayList.RemoveAt(4);
            var value = arrayList[2];
            arrayList.RemoveAt(0);
            arrayList.Remove(true);

3.List  數組，是內存上連續分配的一組數據對象

優點：不固定長度，可以根據數據自動改變大小，讀取速度快

缺點：只能存儲一種基礎數據類型，增刪較慢,，是類型安全的

//List:也是Array，內存上都是連續擺放;不定長；泛型，保證類型安全，避免裝箱拆箱
            //讀取快--增刪慢
            Console.WriteLine("***************List<T>******************");
            List<int> intList = new List<int>() {};
            intList.Add(1);
            intList.Add(2);
            intList.Add(3);
            foreach(var i in intList)
            {
                Console.WriteLine(i.ToString());
            }

 

二、非連續擺放，存儲數據+地址，找數據的話就只能順序查找，讀取慢；增刪快

1.LinkedLis  泛型鏈表，是內存上不連續分配的一組數據對象

優點：節點值可以重復，增刪改數據時，不需要移動前后數據位置，性能較快，是類型安全的

缺點：不能通過下標訪問，查找數據只能按照順序查找，查詢較慢，只能存儲一種基礎數據類型

 //LinkedList：泛型的特點;鏈表，元素不連續分配，每個元素都有記錄前后節點
            //節點值可以重復
            //能不能下標訪問？不能，找元素就只能遍歷  查找不方便
            //增刪 就比較方便
            Console.WriteLine("***************LinkedList<T>******************");
            LinkedList<int> linkedList = new LinkedList<int>();
            //linkedList[3]
            linkedList.AddFirst(1);//添加為第一個節點元素
            linkedList.AddFirst(1);//添加為第一個節點元素
            linkedList.AddLast(3);//添加為最后一個節點元素

            bool isContain = linkedList.Contains(1);
            LinkedListNode<int> node1 = linkedList.Find(1);  //元素123的位置  從頭查找
            linkedList.AddBefore(node1, 0);//節點不存在，會報錯
            linkedList.AddBefore(node1, 0);//在指定節點前新增元素
            linkedList.AddAfter(node1, 2);//在指定節點后新增元素

            linkedList.Remove(3);//刪除指定值，不存在會報錯
            linkedList.Remove(node1);//刪除指定節點
            linkedList.RemoveFirst();//刪除第一個元素
            linkedList.RemoveLast();//刪除最后一個元素
            linkedList.Clear();

 

2.Queue 隊列，其實也是一種特殊鏈表，數據是先進先出（我們可以想象一下把數據放進水管里面））

適用場景：業務模塊解耦，提高系統負載，系統並發的處理能力。

//Queue 就是鏈表  先進先出  放任務延遲執行，A不斷寫入日志任務  B不斷獲取任務去執行
            Console.WriteLine("***************Queue<T>******************");
            Queue<string> numbers = new Queue<string>();
            numbers.Enqueue("1");//添加對象到隊列末尾
            numbers.Enqueue("2");
            numbers.Enqueue("3");
            numbers.Enqueue("4");
            numbers.Enqueue("5");
            numbers.Enqueue("6");

            foreach (string number in numbers)
            {
                Console.WriteLine(number);
            }

            Console.WriteLine($"Dequeuing '{numbers.Dequeue()}'");//Dequeue方法 移除並返回隊列的第一個元素
            Console.WriteLine($"Peek at next item to dequeue: { numbers.Peek()}");//Peek方法 返回隊列的第一個元素 但不移除元素
            Console.WriteLine($"Dequeuing '{numbers.Dequeue()}'");

            Queue<string> queueCopy = new Queue<string>(numbers.ToArray());
            foreach (string number in queueCopy)
            {
                Console.WriteLine(number);
            }

            Console.WriteLine($"queueCopy.Contains(\"4\") = {queueCopy.Contains("4")}");
            queueCopy.Clear();
            Console.WriteLine($"queueCopy.Count = {queueCopy.Count}");

 

2.Stack 棧，其實也是一種特殊鏈表，和隊列不一樣的是數據是先進后出（我們可以想象一下把數據放進瓶子里面）

適用場景：需要進行先進后出的數據處理時。

//隊列是水管,棧是有瓶底的瓶子
            {
                //Stack 就是鏈表  先進后出  解析表達式目錄樹的時候，先產生的數據后使用
                //操作記錄為命令，撤銷的時候是倒序的
                Console.WriteLine("***************Stack<T>******************");
                Stack<string> numbersStack = new Stack<string>();
                numbersStack.Push("1");
                numbersStack.Push("2");
                numbersStack.Push("3");
                numbersStack.Push("4");
                numbersStack.Push("5");//放進去

                foreach (string number in numbersStack)
                {
                    Console.WriteLine(number);
                }

                Console.WriteLine($"Pop '{numbersStack.Pop()}'");//獲取並移除
                Console.WriteLine($"Peek at next item to dequeue: { numbersStack.Peek()}");//獲取不移除
                Console.WriteLine($"Pop '{numbersStack.Pop()}'");

                Stack<string> stackCopy = new Stack<string>(numbersStack.ToArray());
                foreach (string number in stackCopy)
                {
                    Console.WriteLine(number);
                }

                Console.WriteLine($"stackCopy.Contains(\"4\") = {stackCopy.Contains("4")}");
                stackCopy.Clear();
                Console.WriteLine($"stackCopy.Count = {stackCopy.Count}");
            }

 

三、Set 純粹的集合，容器，唯一性

1.hashset 元素之間沒有關聯，hash分布，自動增加容量大小，自動去重

使用場景：統計投票明細，關注列表/粉絲集合等

//集合：hash分布，元素間沒關系,動態增加容量  去重
            //統計用戶IP；IP投票   交叉並補--二次好友/間接關注/粉絲合集
            Console.WriteLine("***************HashSet<string>******************");
            HashSet<string> hashSet = new HashSet<string>();
            hashSet.Add("1");
            hashSet.Add("2");
            hashSet.Add("3");
            hashSet.Add("4");
            hashSet.Add("5");
            hashSet.Add("5");
            //hashSet[0];
            foreach (var item in hashSet)
            {
                Console.WriteLine(item);
            }
            Console.WriteLine(hashSet.Count);
            Console.WriteLine(hashSet.Contains("12345"));

            {
                HashSet<string> hashSet1 = new HashSet<string>();
                hashSet1.Add("123");
                hashSet1.Add("689");
                hashSet1.Add("789");
                hashSet1.Add("12435");
                hashSet1.Add("12435");
                hashSet1.Add("12435");
                hashSet1.SymmetricExceptWith(hashSet);//補
                hashSet1.UnionWith(hashSet);//並
                hashSet1.ExceptWith(hashSet);//差
                hashSet1.IntersectWith(hashSet);//交
                                                // 找出共同的好友
            }
            hashSet.ToList();
            hashSet.Clear();

 

2.SortedSet 排序的集合，自動去重，而且是有序的

使用場景：統計排名--每統計一個就丟進去集合，各類排行榜

 //排序的集合：去重  而且排序  
            //統計排名--每統計一個就丟進去集合
            Console.WriteLine("***************SortedSet<string>******************");
            SortedSet<string> sortedSet = new SortedSet<string>();
            //IComparer<T> comparer  自定義對象要排序，就用這個指定
            sortedSet.Add("1");
            sortedSet.Add("2");
            sortedSet.Add("3");
            sortedSet.Add("4");
            sortedSet.Add("5");
            sortedSet.Add("5");

            foreach (var item in sortedSet)
            {
                Console.WriteLine(item);
            }
            Console.WriteLine(sortedSet.Count);
            Console.WriteLine(sortedSet.Contains("12345"));
            {
                SortedSet<string> sortedSet1 = new SortedSet<string>();
                sortedSet1.Add("123");
                sortedSet1.Add("689");
                sortedSet1.Add("456");
                sortedSet1.Add("12435");
                sortedSet1.Add("12435");
                sortedSet1.Add("12435");
                sortedSet1.SymmetricExceptWith(sortedSet);//補
                sortedSet1.UnionWith(sortedSet);//並
                sortedSet1.ExceptWith(sortedSet);//差
                sortedSet1.IntersectWith(sortedSet);//交
            }

            sortedSet.ToList();
            sortedSet.Clear();

 

四、有沒有讀取&增刪都比較快的數據類型呢？ 哎，還真有有，我們來看看這個 hash散列 字典

key-value結構存儲，動態擴充大小，一段連續有限空間存儲（hash是用空間換性能），根據key的散列值計算得到存儲值的的索引，這樣查詢，增刪改都比較快。不像數組那樣需要移動相鄰元素

所以效率比較高，基於key計算散列值，可能會出現重復情況（第二個散列值自動在前面+1），數據量大的話，性能會下降。

1.HashTable

優點：查詢，增刪改比較快，

缺點：存儲的key和value都是 object 類型，有裝箱和拆箱操作，影響性能。

 //Hashtable key-value  體積可以動態增加 拿着key計算一個地址，然后放入key - value
            //object-裝箱拆箱  如果不同的key得到相同的地址，第二個在前面地址上 + 1
            //查找的時候，如果地址對應數據的key不對，那就 + 1查找。。
            //浪費了空間，Hashtable是基於數組實現
            //查找個數據  一次定位； 增刪 一次定位；  增刪查改 都很快
            //浪費空間，數據太多，重復定位定位，效率就下去了
            Console.WriteLine("***************Hashtable******************");
            System.Collections.Hashtable table = new System.Collections.Hashtable();
            table.Add("1", "1111111111111111");
            table[234] = 234;
            table[567] = 567;
            table["eleven"] = 456;
            foreach (System.Collections.DictionaryEntry objDE in table)
            {
                Console.WriteLine(objDE.Key.ToString());
                Console.WriteLine(objDE.Value.ToString());
            }
            //線程安全
            System.Collections.Hashtable.Synchronized(table);//只有一個線程寫  多個線程讀

 

2.Dictionary字典：泛型；key - value，增刪查改 都很快；有序的

 //字典：泛型；key - value，增刪查改 都很快；有序的
            //  字典不是線程安全 ConcurrentDictionary
            Console.WriteLine("***************Dictionary******************");
            Dictionary<int, string> dic = new Dictionary<int, string>();
            dic.Add(1, "HaHa");
            dic.Add(5, "HoHo");
            dic.Add(3, "HeHe");
            dic.Add(2, "HiHi");
            dic.Add(4, "HuHu1");
            dic[4] = "HuHu";//相同key替換原值
            dic.Add(4, "HuHu");//相同key,會報錯
            foreach (var item in dic)
            {
                Console.WriteLine($"Key:{item.Key}, Value:{item.Value}");
            }

3.SortedDictionary 排序字典

Console.WriteLine("***************SortedDictionary******************");
            SortedDictionary<int, string> dicS = new SortedDictionary<int, string>();
            dicS.Add(1, "HaHa");
            dicS.Add(5, "HoHo");
            dicS.Add(3, "HeHe");
            dicS.Add(2, "HiHi");
            dicS.Add(4, "HuHu1");
            dicS[4] = "HuHu";//相同key替換原值
            dicS.Add(4, "HuHu");//相同key,會報錯
            foreach (var item in dicS)
            {
                Console.WriteLine($"Key:{item.Key}, Value:{item.Value}");
            }

4.SortedList 排序集合

  Console.WriteLine("***************SortedList******************");
            System.Collections.SortedList sortedList = new System.Collections.SortedList();//IComparer
            sortedList.Add("First", "Hello");
            sortedList.Add("Second", "World");
            sortedList.Add("Third", "!");

            sortedList["Third"] = "~~";//相同key替換原值
            sortedList.Add("Fourth", "!");
            sortedList.Add("Fourth", "!");//重復的Key Add會錯
            sortedList["Fourth"] = "!!!";
            var keyList = sortedList.GetKeyList();
            var valueList = sortedList.GetValueList();

            sortedList.TrimToSize();//用於最小化集合的內存開銷

            sortedList.Remove("Third");
            sortedList.RemoveAt(0);
            sortedList.Clear();

 

五、線程安全的幾種數據結構

//ConcurrentQueue 線程安全版本的Queue
//ConcurrentStack 線程安全版本的Stack
//ConcurrentBag 線程安全的對象集合
//ConcurrentDictionary 線程安全的Dictionary
//BlockingCollection

 

六、總結

如果實現了IList了的就可以用下標訪問，實現IConllection了的可以用Add添加

數據結名稱	聲明方式	優點，缺點	是否線程安全	線程安全的版本
Array(數組)		固定長度，讀取快,增刪慢	否
ArrayList(動態數組)		不固定長度，動態長度，讀取快,增刪慢	否
List(泛型集合)		不固定長度，動態長度，讀取快,增刪慢	否
SortedList		不固定長度，動態長度，讀取快,增刪慢	否
LinkedList(雙向鏈表)		1、鏈表在內存中的空間不是連續的，每塊空間稱作一個節點，每個節點都存有與它之前和之后相連接的節點的地址，因此向鏈表中添加和刪除元素時只需要更改相關節點存儲的地址的指向，效率高 2、查找元素時不能通過下標訪問，只能從頭開始通過地址按順序查找，效率低	否
Queue(隊列)		先進先出的數據結構	否	ConcurrentQueue
Stack(棧)		先進后出的數據結構	否	ConcurrentStack
Dictionary(字典)		鍵值對形式存儲，讀取，增刪快，消耗內存	否	ConcurrentDictionary
SortDictionary		排序的字典	否
Hashtable(哈希表)			否	BlockingCollection
HashSet(哈希集合)			否	ConcurrentBag