√ C# - 22.怎么使用集合（P436）

1. 集合分为泛型集合和非泛型集合，泛型集合的元素类型为指定类型，非泛型集合的元素类型为object，一般使用泛型集合。
2. List类的底层是数组，适合读多写少，访问顺序与添加顺序相同。
3. LinkedList类的底层是链表，适合写多读少，可以在链表尾部添加元素，也可以在链表头部添加元素，访问顺序是从链表头部到链表尾部。
4. Stack类是先进后出的数据结构，只能在栈顶进行入栈出栈操作。
5. Queue类是先进先出的数据结构，只能在队尾进行入队操作，队首进行出队操作。
6. HashSet类的底层是哈希表，具有元素不重复性。
7. SortedSet类的底层是哈希表，具有元素不重复性，添加元素时自动进行排序。
8. Dictionary类的底层是哈希表，key值不能重复，value值可以重复。
9. SortedDictionary类的底层是哈希表，key值不能重复，value值可以重复，添加元素时自动进行排序。
10. SortedSet类和SortedDictionary类默认从小到大进行排序，若需要自定义排序规则，则自定义一个类，实现IComparer接口，实例化对象时传入该自定义类的对象即可。

using System;
using System.Collections.Generic;

namespace _22
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("*****测试List类*****");
            TestList();
            Console.WriteLine();

            Console.WriteLine("*****测试LinkedList类*****");
            TestLinkedList();
            Console.WriteLine();

            Console.WriteLine("*****测试Stack类*****");
            TestStack();
            Console.WriteLine();

            Console.WriteLine("*****测试Queue类*****");
            TestQueue();
            Console.WriteLine();

            Console.WriteLine("*****测试HashSet类*****");
            TestHashSet();
            Console.WriteLine();

            Console.WriteLine("*****测试SortedSet类*****");
            TestSortedSet();
            Console.WriteLine();

            Console.WriteLine("*****测试Dictionary类*****");
            TestDictionary();
            Console.WriteLine();

            Console.WriteLine("*****测试SortedDictionary类*****");
            TestSortedDictionary();
            Console.WriteLine();
        }

        /// <summary>
        /// List类
        /// </summary>
        public static void TestList()
        {
            List<int> list = new List<int>();
            list.Add(1);
            list.Add(2);
            list.Add(3);
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }
        }

        /// <summary>
        /// LinkedList类
        /// </summary>
        public static void TestLinkedList()
        {
            LinkedList<int> linkedList = new LinkedList<int>();
            linkedList.AddLast(1);
            linkedList.AddLast(2);
            linkedList.AddFirst(3);
            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }
        }

        /// <summary>
        /// Stack类
        /// </summary>
        public static void TestStack()
        {
            Stack<int> stack = new Stack<int>();
            stack.Push(1);
            stack.Push(2);
            stack.Push(3);
            while (stack.Count != 0)
            {
                Console.WriteLine(stack.Pop());
            }
        }

        /// <summary>
        /// Queue类
        /// </summary>
        public static void TestQueue()
        {
            Queue<int> queue = new Queue<int>();
            queue.Enqueue(1);
            queue.Enqueue(2);
            queue.Enqueue(3);
            while (queue.Count != 0)
            {
                Console.WriteLine(queue.Dequeue());
            }
        }

        /// <summary>
        /// HashSet类
        /// </summary>
        public static void TestHashSet()
        {
            HashSet<int> hashSet = new HashSet<int>();
            hashSet.Add(1);
            hashSet.Add(2);
            hashSet.Add(3);
            hashSet.Add(3);
            foreach (var item in hashSet)
            {
                Console.WriteLine(item);
            }
        }

        /// <summary>
        /// SortedSet类
        /// </summary>
        public static void TestSortedSet()
        {
            SortedSet<int> sortedSet = new SortedSet<int>(new MyComparer());
            sortedSet.Add(1);
            sortedSet.Add(2);
            sortedSet.Add(3);
            sortedSet.Add(3);
            foreach (var item in sortedSet)
            {
                Console.WriteLine(item);
            }
        }

        /// <summary>
        /// Dictionary类
        /// </summary>
        public static void TestDictionary()
        {
            Dictionary<int, string> dictionary = new Dictionary<int, string>();
            dictionary.Add(1, "d");
            dictionary.Add(2, "dic");
            dictionary.Add(3, "dictionary");
            foreach (var item in dictionary)
            {
                Console.WriteLine(item);
            }
        }

        /// <summary>
        /// SortedDictionary类
        /// </summary>
        public static void TestSortedDictionary()
        {
            SortedDictionary<int, string> sortedDictionary = new SortedDictionary<int, string>(new MyComparer());
            sortedDictionary.Add(1, "sorted");
            sortedDictionary.Add(2, "sortedDic");
            sortedDictionary.Add(3, "sortedDictionary");
            foreach (var item in sortedDictionary)
            {
                Console.WriteLine(item);
            }
        }
    }

    class MyComparer : IComparer<int>
    {
        public int Compare(int x, int y)
        {
            if (x > y)
            {
                return -1;
            }
            if (x < y)
            {
                return 1;
            }
            return 0;
        }
    }
}