• C#之再议数组和集合



     1.数组

      1.1简单数组

      1.2 多维数组

      1.3锯齿数组

      1.4Array数组

      1.5作为参数的数组

      1.6枚举

      1.7结构

        以上部分可参考 http://www.cnblogs.com/ztb123/articles/4195864.html

      1.8元组

        数组合并了相同类型的对象,而元组合并了不同类型的对象.Net 4定义了 8个泛型 Tuple类 和一个静态 Tuple类 ,它们用作元组的工厂。 这里的不同泛型 Tuple类支持不同数量的元素。 例如,Tuple<T1> 包含-个元素,Ttple<T1,T2> 包含两个元素,以此类推,元组用Tuple的静态Create()方法创建。

    1   public static Tuple<int, int> Divide(int dividend, int divisor)
    2         {
    3             int result = dividend / divisor;
    4             int reminder = dividend % divisor;
    5             return Tuple.Create(result, reminder);
    6         }
    7      
    8             var result = Divide(2,3);
    9             Console.WriteLine("result if division:{0},reminder:{1}", result.Item1, result.Item2);
    Demo

     

    如果元组包含的项超过 8个,就可 以使用 带 8个参数的 Tuple类 定义。 最后一个模板参数是 TRrest,表示必须给它传递一个元组。 这样,就可以创建带任意个参数的元组了,可在类上右键转到定义查看。

    2集合

      2.1集合和接口类型

      大多数集合类都可在 systm.Collections和 system.Collections.Generic名称空间中找到 。 泛型集合 类 位 于System.Collections.Generic名 称 空 间 中,专门于特定类型的集合类位于System.Collections.Specialized名称空间中,线程安全的集合位于System.Collections.Concurrent名称空间中。

      集合和列表实现的接口:  

    • IEnumerable<T>  如果将Foreache语句用于集合,就需要IEnumerable接口,这个接口定义了GetEnumerator()方法,它返回一个实现了IEnumable接口的枚举。
    • ICollection<T> 这个接口由泛型集合类实现。使用这个接口可以获得集合中的元素个数(Count属性),把集合复制到数组中(CopyTo()方法),还可以从集合中添加和删除元素(Add(),Remove(),Clear())
    • IList<T> 此接口用于 可通过位置访问其中的元素的列表,这个接口定义了一个索引器,可以在集合的指定位置插入或删除某些项,此接口派生自ICollection<T>接口
    • ISet<T> 实现这个接口的集合可以允许合并不同的集,获得2个集合的交集,检查2个集合是否重叠,此接口派生自ICollection<T>接口
    • IDictionary<TKey,TValue> 此接口有包含键和值的泛型集合实现,使用这个接口可以访问所有的键和值,使用键类型的索引可以访问某些项,还可以添加和删除某些项。
    • ILookup<TKey,TValue> 此接口类似于IDictionary<TKey,TValue>接口,实现此接口的集合有键和值,且可以通过一个键包含多个值。
    • IComparer<T> 此接口由比较器实现,通过compare()方法给集合中的元素排序
    • IEquaityComparer<T>此接口由一个比较器实现,发、该比较器可以用于字典中的键。使用这个接口可以对对象进行相等性比较。
    • IProducerConsumerCollection<T>此接口支持新的线程安全的集合类

      2.2列表

      .Net Framework为动态列表提供了泛型类List<T>.这个类实现了IList,IConllection,IEnumerable IList<T>,ICollection<T>和IEnunerable<T>接口。

      使用默认的构造函数创建一个空列表,元素添加到列表后,列表的容量就会扩大为可接纳4个元素,如果添加了第5个元素,列表的大小就会变为原来的2倍,以此类推。如果列表的容量改变了,整个集合就会重新分配到一个新的内存中,所以为了节省时间,如果事先知道列表的容量,就可以用构造函数定义其容量。 

       List<int> list = new List<int>() { 1, 2 };
                list.Add(3);//添加
                list.Insert(0, 4);//插入
                for (int i = 0; i < list.Count; i++)
                {
                    Console.WriteLine(list[i]);//访问元素
                }
                list.RemoveAt(3);//删除
                int num=  list.IndexOf(2);//查找
                list.Sort();//排序
                foreach (var item in list)
                {
                    Console.WriteLine(item);
                }
                list.AsReadOnly();//设置为只读集合,所有的修改集合的方法和属性都会抛出NotSupportedExection异常
    List

      2.3队列

       队列是其元素 以先进先出的 方式来处理的集合。使用泛型类Queue<T>实现

      Queue<T>类的方法:

    • Count 返回队列中的元素个数
    • Enqueue()在队列的一段添加一个元素
    • Dequeue()在队列的头部读取和删除一个元素。如果队列中没有元素会抛出一个InvalidOperationException类型的异常。
    • Peek() 从队列的头部读取一个元素,但不会删除它
    • TrimExcess() 重新设置队列的容量,Dequeue()方法从队列中删除元素,但不会重新设置队列的容量,要从队列的头部去除空元素,应使用此方法。

      2.4栈

       栈是与队列非常相似的一个容器,但它是先进后出。

      

      Statck<T>类的成员:

    • Count 返回栈中的元素个数
    • Push() 在栈顶部添加一个元素
    • Pop()从栈顶部移除一个元素,并返回该元素。如果栈是空的,就会抛出一个InvalidOPerationExcepron异常
    • Peek() 返回栈顶部的元素,但不删除
    • Contains() 确定某个元素是否在栈中,如果是返回true 

      2.5链表

      LinkList<T>是一个双向链表,其元素指向它前面和后面的元素。链表的优点是,如果将元素插入到列表的中间位置,使用链表会非常快,在插入一个元素时,只需修改上一个元素的 Next引 用和下一个元素的Previous引用 ,使 它们引用所插入的元素。缺点是链表元素只能一个接一个的访问。

      2.6有序列表

      如果需要基于键对所需集合排序,就可 以使用 SoftedList<TKey,TValue>类。这个类按照键给元素排序。 集合中的键和值都可以使用任意类型。 

     1 var books = new SortedList<string, string>();
     2             books.Add("C# 2012 wrox box","978-987-9989-7");
     3             books.Add("Professional", "978-987-9989-9");
     4             books["Beginning Visual C# 2008"] = "978-987-9989-8";
     5             books["C# 2008"] = "978-987-9989-5";
     6 
     7             foreach (KeyValuePair<string,string> book in books)
     8             {
     9                 Console.WriteLine("{0},{1}",book.Key,book.Value);
    10             }
    SoftList

       输出默认按键的顺序输出。

      2.7字典

      字典表示一种非常复杂的数据结构,这种数据结构允许按照某个键来访问元素字典也称为映射或散列表。字典的主要特性是能根据键快速查找值 。也可以自由添加和删除元素,但 没有在 内存中移动后续元素的性能开销。

     1 Dictionary<int, int> dic = new Dictionary<int, int>();
     2             dic.Add(1, 1);
     3             dic[2] = 2;
     4             dic[3] = 3;
     5             dic.Add(4,4);
     6             dic.Remove(2);
     7             foreach (var item in dic)
     8             {
     9                 Console.WriteLine("key:{0},Value:{1}",item.Key,item.Value);
    10             }
    Dictionary

           2.7.1 有序字典

      SortedDictionary<TKey,TValue>类是一个二叉搜索树,其中的元素根据键来排序。
    • SortedList<TKey,TValue>类使用的内存比SortedDictionay<TKey,TValue>类少
    • SortedDictionay<TKey,TValue>类的元素的插入和删除速度比较快
    • 在用 已排好序的数据填充集合时,若 不需要修改容量,SortedList<TKey,TValue> 比较决

       2.8 集合

      包含不重复元素的集合称为"集" 。 .NET4包 含两个集(HashSet<T>(无序)和SortedList<T>(有序))。 

     1  var set1 = new HashSet<int>() { 1, 2, 3, 4, 5 };
     2             var set2 = new HashSet<int>() { 4, 5, 6, 7, 8 };
     3             set1.ExceptWith(set2);
     4             foreach (var item in set1)
     5             {
     6                 Console.WriteLine(item);
     7             }
     8 
     9 
    10             set1.UnionWith(set2);
    11 
    12             foreach (var item in set1)
    13             {
    14                 Console.WriteLine(item);
    15             }
    HashSet

             2.9可观察的集合

      如果需要集合中的元素何时删除或添加的信息,就可以使用ObservableCollection<T>类,这个类是为WPF定义的,这样UI就可以知道集合的变化。这个类需要映入程序集WindowBase,

     1  var date =new  ObservableCollection<string>();
     2             date.CollectionChanged += Date_CollectionChanged;
     3             date.Add("1");
     4             date.Insert(0, "2");
     5             date.Remove("1");
     6             Console.ReadKey();
     7  private static void Date_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
     8         {
     9             Console.WriteLine("action{0}",e.Action.ToString());
    10             if (e.OldItems != null)
    11             {
    12                 Console.WriteLine("starting index for old item(s):{0}",e.OldStartingIndex);
    13                 Console.WriteLine("OldItem(s):");
    14                 foreach (var item in e.OldItems)
    15                 {
    16                     Console.WriteLine(item);
    17                 }
    18             }
    19             if (e.NewItems != null)
    20             {
    21                 Console.WriteLine("starting index for new item(s):{0}", e.NewStartingIndex);
    22                 Console.WriteLine("NewItem(s):");
    23                 foreach (var item in e.NewItems)
    24                 {
    25                     Console.WriteLine(item);
    26                 }
    27             }
    28             Console.WriteLine();
    29         }
    ObservableCollection

      2.10并发集合

      为了对集合进行线程安全的访问,定义了IProducerConsumerCollection<T>接口,这个接口重要的方法是TryAdd() (尝试给集合添加一项,如果集合禁止添加,这个操作就可能失败,返回一个Bool值)和TryTake()(工作方式和TryAdd相同,以通知调用者操作是成功还是失败,并在操作成功后返回集合中的项).

    • ConcurrentQueue<T>  这个集合类用 一种免锁定的算法实现,使用在 内部合并到一个链表中的 32项数组.访 问队列元素的方法有 Enqueue()、 TryDequeue()和 TryPeek()。 这些方法的命名非常类似Queue<T>累的方法,只是个可能调用失败的方法前边加了Try.因为这个类实现了IProducerConsumerCollection<T>接口,所以TryAdd()和TryTake()方法值调用Enqueue()和TryDequeue()方法。
    • ConurrentStack<T> 类似于ConcurrentQueue<T> 只 是带有另外的元素访 问方法。此类定义了Push().PushRange().TryPeek().TryPop()和TryPopRange()方法。
    • ConcurrentDictionary<TKey,TValue> 这是一个线程安全的键值集合。TryAdd().TryGetValue().TryRemove()和TryUpdate()方法以非阻塞的方式访问成员,因为元素基于键和值,所以此类没有实现IProducerConsumerCollection<T>接口。
    • BlockingCollection<T> 这个集合在可以添加和删除之前会阻塞线程并一直等待。它提供了一个接口,以使用Add()和Take()方法来添加和删除元素。
     1  var sharedCollection = new BlockingCollection<int>();
     2             var events = new ManualResetEventSlim[2];
     3             var waits = new WaitHandle[2];
     4             for (int i = 0; i < 2; i++)
     5             {
     6                 events[i] = new ManualResetEventSlim(false);
     7                 waits[i] = events[i].WaitHandle;
     8             }
     9 
    10             var producer = new Thread(obj=> { var state = (Tuple<BlockingCollection<int>,ManualResetEventSlim>)obj;
    11                 var coll = state.Item1;
    12                 var ev = state.Item2;
    13                 var r = new Random();
    14                 for (int i = 0; i < 300; i++)
    15                 {
    16                     coll.Add(r.Next(3000));
    17                     ev.Set();
    18                 }
    19             });
    20 
    21             producer.Start(Tuple.Create<BlockingCollection<int>, ManualResetEventSlim>(sharedCollection, events[0]));
    22 
    23             var consumer = new Thread(obj=> {
    24             var state = (Tuple<BlockingCollection<int>, ManualResetEventSlim>)obj;
    25             var coll = state.Item1;
    26             var ev = state.Item2;
    27 
    28                 for (int i = 0; i < 300; i++)
    29                 {
    30                     int result = coll.Take();
    31                 }
    32                 ev.Set();
    33             });
    34 
    35             consumer.Start(Tuple.Create<BlockingCollection<int>,ManualResetEventSlim>(sharedCollection,events[1]));
    36 
    37             if (!WaitHandle.WaitAll(waits))
    38                 Console.WriteLine("wait failed");
    39             else
    40                 Console.WriteLine("reading/writing finished");
    41 
    42             Console.ReadKey();
    BlockingCollection

     

  • 相关阅读:
    第1章习题
    生成树相关问题
    cf 710 E Generate a String
    树状数组(BIT)
    HDU 5360 Hiking(2015多校联合)
    Apache HttpClient4.0&HtmlCleaner用法
    Android中的长度单位详解(dp、sp、px、in、pt、mm)
    HDU 5328 Problem Killer(2015多校联合)
    HDU 5327 Olympiad(2015多校联合)
    HDU 5335 Walk Out(2015多校联合)
  • 原文地址:https://www.cnblogs.com/saodiseng2015/p/5042397.html
Copyright © 2020-2023  润新知