C#集合基础与运用

C#集合基础与运用

 转至:http://www.cnblogs.com/LiZhiW/p/3539839.html

1.集合接口与集合类型

(1)集合的命名空间

大多数集合类都可以在 System.CollectionsSystem.Collections.Generic 名称空间中找到。

泛型集合位于System.Collections.Generic 名称空间中;

专用于特定类型的集合类位于System.Collections.Specialized名称空间中;

线程安全的集合位于System.Collections.Concurrent名称空间中。

(2)集合接口介绍

1、IEnumerableIEnumerator 接口

其实IEnumerable接口是非常的简单,只包含一个抽象的方法GetEnumerator(),它返回一个可用于循环访问集合的IEnumerator对象。

    public interface IEnumerable

    {

          IEnumerator GetEnumerator();

     }

IEnumerator对象有什么呢?

它是一个真正的集合访问器,没有它,就不能使用foreach语句遍历集合或数组,因为只有IEnumerator对象才能访问集合中的项。

IEnumerator接口定义了:一个Current属性用来获取当前集合中的项;MoveNext方法将游标的内部位置向前移动;Reset方法将枚举数设置为其初始位置,该位置位于集合中第一个元素之前。

public interface IEnumerator
{
    object Current { get; }
    bool MoveNext();
    void Reset();
}

一个collection要支持foreach进行遍历,就必须实现IEnumerable,并以某种方式返回迭代器对象:IEnumerator

2、集合和列表实现的接口表

接口

说明

IEnumerable<T>

如果foreach语句用于集合,就需要此接口。

ICollection<T>

此集合定义了Count属性、CopyTo、Add、Remove、Clear方法

IList<T>

可以通过位置访问几何元素

ISet<T>

此集合不允许有重复的元素

IDictionary<K,V>

含有键值对的集合

ILookup<K,V>

含有键值对的集合,但可以通过一个键包含多个值

IComparer<T>

集合元素比较器,用于集合元素的排序

IEqualityComparer<T>

用于字典集合的比较器

IProducerConsumerCollection<T>

线程安全的集合

 

2.集合的基本操作

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CollectionDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 1、集合的基本操作

            //1)、创建集合
            //CreateCollection();

            //2)、添加元素至集合
            //AddCollection();

            //3)、插入元素至集合
            //InsertCollection();

            //4)、访问集合中的元素
            //VisitCollection();

            //5)、遍历集合
            //IteratesCollection();

            //6)、删除集合中的元素
            //DeleteCollection();

            //7)、查找元素
            //FindCollection();

            //8)、集合排序
            //SortCollection();

            //9)、集合数据类型转换
            //ConvertCollection();

            //11)、集合常见扩展方法Select
            //SelectCollection();

            //12)、集合常见扩展方法Where
            //WhereCollection();

            #endregion 集合的基本操作

            #region 2、常见集合的特性

            //队列(Queue)
            //QueueCollection();

            //栈(Stack)
            //StackCollection();

            //链表(LinkedList)
            //LinkedCollection();

            //有序列表(SortedList<K,V>)
            //SortedListCollection();

            //字典 Lookup
            //LookupCollection();
            #endregion 常见集合的特性
        
        }

        #region 1、集合的基本操作

        /// <summary>
        /// 1)、创建集合
        /// 使用默认的构造函数创建一个空集合,元素添加到集合之后,集合的容量就会扩大为4。
        /// 当集合的容量被使用完,且还在向集合中添加元素时,集合的容量就会扩大成原来的2倍!
        /// 可使用Capacity属性设置或访问集合的容量,使用Count属性访问集合的元素个数。
        /// 也可使用TrimExcess方法调整集合容量,节省内存!
        /// </summary>
        public static void CreateCollection()
        {
            List<int> list = new List<int>();
            //List<int> list = new List<int>(3); //指定初始容量
            //创建集合时可以为集合设置初始值 如下:
            //List<int> list1 = new List<int>() { 1,2,3,4,5,6,7,8,9,0};
            //List<string> list2 = new List<string>() { "aa", "bb", "cc" };

            for (int i = 0; i < 1025; i++)
            {
                if (list.Count == list.Capacity)
                {
                    Console.WriteLine("容量使用量:" + list.Count + "/" + list.Capacity);
                }
                list.Add(i);
                Console.WriteLine("容量使用量:" + list.Count + "/" + list.Capacity);
            }

            Console.WriteLine("容量使用量:" + list.Count + "/" + list.Capacity);
            list.TrimExcess(); //整集合容量
            Console.WriteLine("容量使用量:" + list.Count + "/" + list.Capacity);

            Console.Read();
        }

        /// <summary>
        /// 2)、添加元素集合
        /// 为集合添加元素可使用Add方法,还可以使用AddRange方法一次添加多个元素,
        /// 因为AddRange方法的参数是IEnumerable<T>类型的对象,所以可以添加数组到集合里。
        /// </summary>
        public static void AddCollection()
        {
            List<string> list = new List<string>();
            
            list.AddRange(new string[] { "bb", "cc", "dd" }); //添加数组
            list.AddRange(list);

            list.Add("aa");

            foreach (string item in list)
            {
                Console.WriteLine(item);
            }
            Console.Read();
        }

        /// <summary>
        /// 3)、插入元素至集合
        /// 插入元素可以使用Insert方法,同样使用InsertRange方法插入多个元素
        /// </summary>
        public static void InsertCollection()
        {
            List<string> list = new List<string>() { "aa", "bb","ff" };
            list.Insert(2, "cc"); //插入元素
            list.InsertRange(3, new string[] { "dd", "ee" }); //插入集合

            foreach (string item in list)
            {
                Console.WriteLine(item);
            }
            Console.Read();
        }

        /// <summary>
        /// 4)、访问集合中的元素
        /// 使用索引器访问集合中某个位置的元素
        /// </summary>
        public static void VisitCollection()
        {
            List<string> list = new List<string>() { "aa", "bb", "cc", "ee" };
            Console.WriteLine(list[1]); //访问第1个位置上的元素,下标从0开始
            Console.Read();
        }

        /// <summary>
        /// 5)、遍历集合
        /// 集合的遍历,除了使用for、foreach外,还可以使用集合的Foreach方法,
        /// 该方法的参数是一个Action<T>委托类型,可以使用Lambda表达式
        /// </summary>
        public static void IteratesCollection()
        {
            List<string> list = new List<string>() { "aa", "bb", "cc" };
            list.ForEach(tmp => Console.WriteLine("元素:" + tmp));
            //也可以这样使用:list.ForEach(Console.WriteLine);

            Console.Read();
        }


        /// <summary>
        /// 6)、删除集合中的元素
        /// 使用RemoveAt删除指定位置的元素,使用Remove删除指定的元素,
        /// 使用RemoveRange删除指定位置范围的元素,使用Clear删除所有元素
        /// 使用RemoveAll选择删除的元素。注意:RemoveAll方法的参数是一个Predicate<T>委托类型
        /// </summary>
        public static void DeleteCollection()
        {
            List<string> list = new List<string>() { "12", "123", "1234", "12345" };

            //删除长度小于4的元素
            list.RemoveAll(x => { bool flag = x.Length < 4; return flag; });
            list.ForEach(Console.WriteLine);

            Console.Read();
        }

        /// <summary>
        /// 7)、查找元素
        /// 用于搜索的方法有:IndexOf、LastIndexOf、FindIndex、FindLastIndex、FindLast、Find、FindAll、Exists等方法。
        /// IndexOf、LastIndexOf、FindIndex、FindLastIndex 方法用于搜索元素的位置。
        /// FindLast、Find、FindAll 方法用于搜索满足条件的元素。
        /// Exists 用于判断集合是否存在某些元素。
        /// 参数可以使用Predicate<T>委托类型(Lambda表达式)的方法有:FindIndex、FindLastIndex、Find、FindLast、FindAll、Exists。
        /// </summary>
        public static void FindCollection()
        {
            List<string> list = new List<string>() { "12", "123", "1234", "12345" };

            list = list.FindAll(x => { bool flag = x.Length < 4; return flag; });
            list.ForEach(Console.WriteLine);

            Console.Read();
        }

        /// <summary>
        /// 8)、元素排序
        /// 可以使用Sort方法对元素排序,也可以调用Reverse方法逆转集合顺序,Sort方法使用快速排序算法
        /// Sort使用了几个重载的方法,可以传递的参数有泛型委托Comparison<T>和泛型接口IComparer<T>
        /// </summary>
        public static void SortCollection()
        {
            List<string> list = new List<string>() { "12", "123", "1234", "12345" };

            //按字符串长度排序
            list.Sort((x, y) => { return y.Length - x.Length; });
            list.ForEach(Console.WriteLine);

            Console.Read();

            #region Sort例子
            /*
             // 把Student继承IComparer<Student>, IComparable<Student> 这两个接口,List<Student>就可以Sort了
                public class Student : IComparer<Student>, IComparable<Student>        
                {
                    public string name;
                    public int num;

                    //下面是一些方法及属性
                    public int Compare(Student s1, Student s2)
                    {
                        if (s1.num > s2.num)
                            return 1;
                        if (s1.num < s2.num)
                            return -1;
                        return 0;
                    }

                    public int CompareTo(Student s)
                    {
                        return Compare(this, s);
                    }
                }
                //测试
                List<Student> l = new List<Student>();
                Student s1 = new Student();
                s1.num = 5;
                Student s2 = new Student();
                s2.num = 3;
                Student s3 = new Student();
                s3.num = 6;

                l.Add(s1);
                l.Add(s2);
                l.Add(s3);

                l.Sort();
             */
            #endregion Sort例子
        
        }

        /// <summary>
        /// 9)、集合类型转换
        /// 使用ConvertAll<TOutput>方法可以把集合里的所有元素转换成另一种类型,ConvertAll<TOutput>使用了Converter委托,其定义如下:
        /// public sealeddelegate TOutput Converter<TInput, TOutput>(TInput from)
        /// TInput是委托方法的参数类型,TOutput是委托方法的返回值类型。例如:
        /// </summary>
        public static void ConvertCollection()
        {
            List<string> list = new List<string>() { "12", "123", "1234", "12345" };

            //把字符串集合转换成数字集合
            List<int> array = list.ConvertAll<int>(tmp => Int32.Parse(tmp));
            array.ForEach(Console.WriteLine);
            
            Console.Read();
        }


        //10)、只读集合
        //集合的AsReadOnly方法可以返回一个ReadOnlyCollection<T>类型的集合;
        //ReadOnlyCollection<T>是一个只读集合类型,除了不能使用修改集合的方法与属性,其它与集合一样。

        /// <summary>
        /// 11)、集合常用的扩展方法[Select]
        /// Select:将序列中的每个元素投影到新表中
        /// </summary>
        public static void SelectCollection()
        {
            List<int> list = new List<int>() { 1, 3, 5, 7, 9 };
            IEnumerable<string> array = list.Select<int, string>(x => (x * x).ToString());

            foreach (string s in array)
            {
                Console.WriteLine(s);
            }

            Console.Read();
        }


        /// <summary>
        /// 12)、集合常用的扩展方法[Where]
        /// Where:基于谓词筛选值序列
        /// </summary>
        public static void WhereCollection()
        {
            List<string> list = new List<string> { "1", "12", "123", "1234" };

            //查询长度小于3的元素
            IEnumerable<string> query = list.Where(temp => temp.Length < 3);

            foreach (string s in query)
            {
                Console.WriteLine(s);
            }

            Console.Read();
        }

        #endregion 集合的基本操作

        #region 2、常见集合的特性

        //(1)非泛型集合对应的泛型集合 
            // 非泛型集合类   对应的泛型集合类
            // ArrayList    List<T>
            // HashTable    DIctionary<T>
            // Queue        Queue<T>
            // Stack        Stack<T>
            // SortedList   SortedList

        /// <summary>
        /// 1、队列(Queue)
        /// 队列是其元素以先进先出的方式来处理的集合。该集合没有Add与Remove方法,其重要的方法:
        /// Enqueue():在队列的尾端添加元素
        /// Dequeue():在队列的头部读取并删除元素
        /// Peek()   :只读取队列头部的元素
        /// </summary>
        public static void QueueCollection()
        {
            Queue<string> queue = new Queue<string>();

            for (int i = 0; i < 5; i++)
            {
                queue.Enqueue(i.ToString());//在尾部添加元素
            }

            PrintQueue(queue);//输出元素

            string s = queue.Dequeue(); //读取并删除头部元素
            Console.WriteLine("读取并删除头部元素:" + s);

            queue.Enqueue("5"); //在尾部添加元素
            s = queue.Peek(); //读取头部元素
            Console.WriteLine("读取头部元素:" + s);

            PrintQueue(queue);//输出元素

            Console.Read();
        }

        private static void PrintQueue(Queue<string> q)
        {
            IEnumerable<string> list = q.Where(t => true);
            foreach (string s in list)
            {
                Console.WriteLine(s);
            }
        }

        /// <summary>
        /// 2、栈(Stack<T>)
        /// 栈是一个后进先出的容器,其重要的方法:
        /// Push() :在栈顶压入一个元素入栈
        /// Pop()  :从栈顶读取并删除一个元素
        /// Peek() :只从栈顶读取一个元素而不删除
        /// </summary>
        public static void StackCollection()
        {
            Stack<string> stack = new Stack<string>();

            for (int i = 0; i < 5; i++)
            {
                stack.Push(i.ToString()); //入栈
            }

            PrintStack(stack); //输出

            string s = stack.Pop(); //读取并删除栈顶元素
            Console.WriteLine("读取并删除栈顶元素:" + s);

            s = stack.Peek();
            Console.WriteLine("只读取栈顶元素:" + s);

            PrintStack(stack);

            Console.Read();
        }

        private static void PrintStack(Stack<string> stack)
        {
            IEnumerable<string> list = stack.Where(t => true);
            foreach (var t in list)
            {
                Console.WriteLine(t);
            }
        }

        /// <summary>
        /// 3、链表(LinkedList<T>/// LinkedList<T>是一个双向链表。
        /// 链表的优点是,如果将元素插入列表的中间位置,使用链表就会非常快,只需要修改下一个元素的Next引用与上一个元素的Previous引用。
        /// 链表不能在集合中只存储元素,必须要把元素存到LinkedListNode<T>类型的对象中,LinkedListNode<T>定义了属性:List、Next、Value、Previous。
        /// List属性返回与该节点相关的LinkedList<T>对象,Next、Previous用于遍历链表。
        /// 
        /// LinkedList<T>对象可以访问第一个和最后一个元素(Frist与Last)、
        /// 在指定位置插入元素(AddAfter()、AddBefore()、AddFirst()、AddLast()方法),
        /// 删除指定位置的元素(ReMove()、ReMoveFirst()、RemoveLast()方法),
        /// 从链表的开头(Find())或结尾(FindLast())开始搜索元素。
        /// </summary>
        public static void LinkedCollection()
        {
            LinkedList<int> link = new LinkedList<int>();

            LinkedListNode<int> node;

            for (int i = 0; i < 10; i++)
            {
                node = new LinkedListNode<int>(i);
                if (i % 2 == 0)
                {
                    link.AddFirst(node); //从头部添加节点
                }
                else
                {
                    link.AddLast(node);//从尾部添加节点
                }
            }

            PrintLink(link); //输出元素

            Console.Read();
        }

        private static void PrintLink(LinkedList<int> link)
        {
            IEnumerable<int> list = link.Where(t => true);
            foreach (int t in list)
            {
                Console.WriteLine(t);
            }
        }

        /// <summary>
        /// 4、有序列表(SortedList<K,V>)
        /// SortedList<K,V>是基于键对集合进行排序的集合类,它只允许每个键只有一个对应值,如果需要每个键对应多个值可以使用Lookup<K,V>/// 可以使用foreach遍历该集合,枚举器返回的是KeyValuePair<K,V>类型的元素。
        /// 除了使用Add方法添加元素,还可以使用索引器添加。
        /// </summary>
        public static void SortedListCollection()
        {
            SortedList<string, string> sort = new SortedList<string, string>();

            sort.Add("K1", "K1的值"); //Add方法添加元素
            sort["K2"] = "K2的值";    //索引器添加元素

            PrintSorted(sort);

            Console.WriteLine("是否存在[K3]:" + sort.ContainsKey("K3"));

            string value = null;
            Console.WriteLine("是否存在[K2]:" + sort.TryGetValue("K2",out value));
            Console.WriteLine("[K2的值]:" + value);
            Console.Read();
        }

        private static void PrintSorted(SortedList<string, string> sort)
        {
            IEnumerable<KeyValuePair<string, string>> list = sort.Where(tmp => true);
            foreach (KeyValuePair<string,string> item in list)
            {
                Console.WriteLine(item.Key + " ----> " + item.Value);
            }
        }


        //5、字典
        /*
         * 字典中键的类型必须重写Object类的GetHashCode()方法。
         * 只要字典类需要确定元素的位置,他就会调用GetHashCode()方法。除了实现GetHashCode()方法外,键类型还必须实现IEquatable<T>.Equals()方法,或重写Object类的Equals()方法。
         * 因为不同的对象可能返回相同的散列码(GetHashCode方法返回值),但是如果A.Equals(B)返回true,则A和B的散列码就必须相同。
         * 这似乎有点奇怪,但这非常重要,因为字典的性能取决于GetHashCode()方法实现的代码。
        */

        //字典1): Dictionary<K,V>
        //      Dictionary<K,V>类支持每个键关联一个值,与SortedList<K,V>很类似,具体参考SortedList<K,V>。


        /// <summary>
        /// 字典2):Lookup<K,V>
        /// Lookup<K,V>类把键映射到一个值集上。
        /// 创建Lookup<K,V>类对象必须调用ToLookup()扩展方法,该方法返回一个Lookup<K,V>对象。
        /// ToLookup()方法需要一个Func<T,K>类型的委托参数,Func<T,K>类型定义了键的选择器。
        /// ToLookup()用于对一个集合进行操作,创建一个1:n 的映射。 它可以方便的将数据分类成组,并生成一个字典供查询使用。
        /// </summary>
        public static void LookupCollection()
        {
            List<string> list = new List<string>() { "1", "12", "123", "1234", "a", "ab", "abc" };

            var lookup = list.ToLookup(x => x.Length);
            foreach (var t in lookup)
            {
                List<string> temp = t.ToList<string>(); //把一组数据转换成集合
                temp.ForEach(x => Console.Write(x + "")); //输出集合
                Console.WriteLine();
            }

            Console.Read();
        }

        /*
        * 字典3):SortedDictionary<K,V>
        * SortedDictionary<K,V>类是一个二叉搜索树,其中的元素根据键来排序,该键类型必须实现IComparable<T>接口。
        * SortedDictionary<K,V>与SortedList<K,V>的区别:
        * SortedList<K,V>类使用的内存比SortedDictionary<K,V>少。
        * SortedDictionary<K,V>类的元素的插入与删除比较快。
        * 在用于已排好序的集合,若不需要修改容量SortedList<K,V>会比较快。
        * 区别的根本原因:SortedList<K,V>实现的是一个基于数组的集合,SortedDictionary<K,V>实现的是一个基于字典的集合。
        */

        //6、集(ISet<T>接口)
        //不包含重复元素的集合称为集,.NET Framework包含两个集(HashSet<T>和SortedSet<T>),它们都实现ISet<T>接口。
        //HashSet<T>是不包含重复元素的无序列表,SortedSet<T>是不包含重复元素的有序列表。


        #endregion 常见集合的特性

    }
}

 

 

posted @ 2014-02-08 04:28  飞花雪月  阅读(1830)  评论(0编辑  收藏  举报