本章將和大家分享.NET中常用的資料結構。下面直接給大家Show一波API:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace MyStructure
{
    /// <summary>
    /// Array/ArrayList/List/LinkedList/Queue/Stack/HastSet/SortedSet/Hashtable/SortedList/Dictionary/SortedDictionary
    /// IEnumerable、ICollection、IList、IQueryable
    
 
/// 介面是標識功能的，不同的介面拆開就是為介面隔離，雖然我們介面內容也可能重複。
    /// 
    /// IEnumerable 任何資料集合都實現了的，為不同的資料結構提供了統一的資料訪問方式，這個就是迭代器模式。
    /// </summary>
    public static class CollectionDemo
    {
        public static void Show()
        {
            //1 記憶體連續儲存，節約空間，可以索引訪問，讀取快，增刪慢。
            #region Array、ArrayList、List<T>

            //
 
Array
            {
                //Array：在記憶體上連續分配的，而且元素型別是一樣的
                //可以座標訪問  讀取快--增刪慢，長度不變
                Console.WriteLine("***************Array***************");
                int[] intArray = new int[3];
                intArray[0] = 123;
                string[] stringArray = new string
 
[] { "123", "234" };
            }
            //ArrayList
            {
                //ArrayList：不定長的，連續分配的；
                //元素沒有型別限制，任何元素都是當成object處理，如果是值型別，會有裝箱操作
                //讀取快--增刪慢
                Console.WriteLine("***************ArrayList***************");
                ArrayList arrayList = new ArrayList();
                arrayList.Add("TianYa");
                arrayList.Add(32); //Add增加長度
                //刪除資料
                var value = arrayList[2];
                arrayList.RemoveAt(0);
                arrayList.Remove("TianYa");
            }
            //List<T>
            {
                //List：也是Array，記憶體上都是連續擺放、不定長、泛型，保證型別安全，避免裝箱拆箱
                //讀取快--增刪慢
                Console.WriteLine("***************List<T>***************");
                List<int> intList = new List<int>() { 1, 2, 3, 4 };
                intList.Add(123);
                intList.Add(123);
                List<string> stringList = new List<string>();
                //stringList[0] = "123"; //異常的
                foreach (var item in intList)
                {

                }
            }

            #endregion Array、ArrayList、List<T>

            //2 非連續擺放，儲存資料+地址，找資料的話就只能順序查詢，讀取慢，增刪快。
            #region 連結串列（LinkedList<T>、Queue<T>、Stack<T>）

            //LinkedList<T>
            {
                //LinkedList：連結串列，泛型的特點，元素不連續分配，每個元素都有記錄前後節點。
                //節點值可以重複
                //能不能下標訪問？不能，找元素就只能遍歷  查詢不方便
                //增刪 就比較方便
                Console.WriteLine("***************LinkedList<T>***************");
                LinkedList<int> linkedList = new LinkedList<int>();
                linkedList.AddFirst(123);
                linkedList.AddLast(456);

                bool isContain = linkedList.Contains(123);
                LinkedListNode<int> node123 = linkedList.Find(123); //元素123的位置  從頭查詢
                linkedList.AddBefore(node123, 123);
                linkedList.AddBefore(node123, 123);
                linkedList.AddAfter(node123, 9);

                linkedList.Remove(456);
                linkedList.Remove(node123);
                linkedList.RemoveFirst();
                linkedList.RemoveLast();
                linkedList.Clear();
            }
            //Queue<T>
            {
                //Queue佇列： 就是連結串列  先進先出  放任務延遲執行；A不斷寫入日誌任務，B不斷獲取任務去執行。
                Console.WriteLine("***************Queue<T>***************");
                Queue<string> numbers = new Queue<string>();
                numbers.Enqueue("one"); //入隊
                numbers.Enqueue("two");
                numbers.Enqueue("three");
                numbers.Enqueue("four");
                numbers.Enqueue("four");
                numbers.Enqueue("five");

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

                Console.WriteLine($"Dequeuing '{numbers.Dequeue()}'"); //出隊
                Console.WriteLine($"Peek at next item to dequeue: { numbers.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(\"four\") = {queueCopy.Contains("four")}");
                queueCopy.Clear();
                Console.WriteLine($"queueCopy.Count = {queueCopy.Count}");
            }
            //Stack<T>
            {
                //Stack棧：就是連結串列  先進後出  解析表示式目錄樹的時候，先產生的資料後使用。
                //操作記錄為命令，撤銷的時候是倒序的
                Console.WriteLine("***************Stack<T>******************");
                Stack<string> numbers = new Stack<string>();
                numbers.Push("one");
                numbers.Push("two");
                numbers.Push("three");
                numbers.Push("four");
                numbers.Push("five"); //放進去 入棧

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

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

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

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

            #endregion 連結串列（LinkedList<T>、Queue<T>、Stack<T>）

            //3 Set純粹的集合，容器，東西丟進去，唯一性，無序的。
            #region Set集合（HashSet<T>、SortedSet<T>）

            //HashSet<T>
            {
                //集合：hash分佈，元素間沒關係，動態增加容量  去重
                //統計使用者IP；IP投票；交叉並補---二次好友/間接關注/粉絲合集
                Console.WriteLine("***************HashSet<T>***************");
                HashSet<string> hashSet = new HashSet<string>();
                hashSet.Add("123");
                hashSet.Add("689");
                hashSet.Add("456");
                hashSet.Add("12435");
                hashSet.Add("12435");
                hashSet.Add("12435");
                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();
            }
            //SortedSet<T>
            {
                //排序的集合：去重  而且排序  
                //統計排名--每統計一個就丟進去集合
                Console.WriteLine("***************SortedSet<T>***************");
                SortedSet<string> sortedSet = new SortedSet<string>();
                //IComparer<T> comparer  自定義物件要排序，就用這個指定
                sortedSet.Add("123");
                sortedSet.Add("689");
                sortedSet.Add("456");
                sortedSet.Add("12435");
                sortedSet.Add("12435");
                sortedSet.Add("12435");

                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();
            }

            #endregion Set集合（HashSet<T>、SortedSet<T>）

            //讀取&增刪都快？ 有 hash雜湊 字典
            //key-value，一段連續有限空間放value(開闢的空間比用到的多，hash是用空間換效能)，基於key雜湊計算得到地址索引，這樣讀取快
            //增刪也快，刪除時也是計算位置，增加也不影響別人
            //肯定會出現2個key(雜湊衝突)，雜湊結果一致時可以讓第二次的+1
            //可能會造成效率的降低，尤其是資料量大的情況下，以前測試過Dictionary在3w條左右效能就開始下降的厲害

            #region key-value（Hashtable、Dictionary、SortedDictionary、SortedList）

            //Hashtable
            {
                //Hashtable：key-value  體積可以動態增加，拿著key計算一個地址，然後放入key - value
                //object-裝箱拆箱  如果不同的key得到相同的地址，第二個在前面地址上 + 1
                //查詢的時候，如果地址對應資料的key不對，那就 + 1查詢。。
                //浪費了空間，Hashtable是基於陣列實現
                //查找個資料  一次定位；增刪 一次定位；增刪改查 都很快
                //浪費空間，資料太多，重複定位，效率就下去了
                Console.WriteLine("***************Hashtable***************");
                Hashtable table = new Hashtable();
                table.Add("123", "456");
                table[234] = 456;
                table[234] = 567;
                table[32] = 4562;
                table[1] = 456;
                table["TianYa"] = 456;
                foreach (DictionaryEntry objDE in table)
                {
                    Console.WriteLine(objDE.Key.ToString());
                    Console.WriteLine(objDE.Value.ToString());
                }
                //執行緒安全
                Hashtable.Synchronized(table);//只有一個執行緒寫  多個執行緒讀
            }
            //Dictionary
            {
                //字典：泛型，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";
                dic.Add(4, "HuHu");
                foreach (var item in dic)
                {
                    Console.WriteLine($"Key:{item.Key}, Value:{item.Value}");
                }
            }
            //SortedDictionary
            {
                //排序字典
                Console.WriteLine("***************SortedDictionary***************");
                SortedDictionary<int, string> dic = new SortedDictionary<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";
                dic.Add(4, "HuHu");
                foreach (var item in dic)
                {
                    Console.WriteLine($"Key:{item.Key}, Value:{item.Value}");
                }
            }
            //SortedList
            {
                //"a".GetHashCode();
                Console.WriteLine("***************SortedList***************");
                SortedList sortedList = new SortedList();//IComparer
                sortedList.Add("First", "Hello");
                sortedList.Add("Second", "World");
                sortedList.Add("Third", "!");

                sortedList["Third"] = "~~";//
                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();
            }

            #endregion key-value（Hashtable、Dictionary、SortedDictionary、SortedList）

            {
                //ConcurrentQueue 執行緒安全版本的Queue
                //ConcurrentStack 執行緒安全版本的Stack
                //ConcurrentBag 執行緒安全版本的物件集合
                //ConcurrentDictionary 執行緒安全版本的Dictionary
                //BlockingCollection
            }

            {
                List<string> fruits =
                new List<string> { "apple", "passionfruit", "banana", "mango",
                    "orange", "blueberry", "grape", "strawberry" };

                IEnumerable<string> query = fruits.Where(fruit => fruit.Length < 6);
                foreach (var item in query)//遍歷才會去查詢比較  迭代器yield
                {

                }

                IQueryable<string> queryable = fruits.AsQueryable<string>().Where(s => s.Length > 5);
                foreach (var item in queryable)//表示式目錄樹的解析，延遲到遍歷的時候才去執行  EF的延遲查詢
                {

                }
            }
        }
    }
}

程式碼中都有註釋了，此處就不再做過多的解釋了。

Demo原始碼：

連結：https://pan.baidu.com/s/1f5-xKmR1QiWIrN7EgzZiCA 
提取碼：zr3z

此文由博主精心撰寫轉載請保留此原文連結：https://www.cnblogs.com/xyh9039/p/13910171.html

版權宣告：如有雷同純屬巧合，如有侵權請及時聯絡本人修改，謝謝！！！