第六讲（数组）_.NET_编程开发_程序员俱乐部

一、简单数组
    1.数组的声明
        int[]myArray;
    2数组的初始化
        数组是引用类型，他被分配在了堆上。如果不知道数组使用多少元素，可以使用集合。
            myArray=new int[4];
            或
            int[]myArry=new int[4];
            或
            int[]myArray=new int[4]{4,7,11,2};
            或
            int[]myArray=new int[]{4,7,11,2};
            或
            int[]myArray={4,7,11,2};
        
        也可以声明自定义类型的数组    
            Person[] myPersons = new Person[2];

            myPersons[0] = new Person { FirstName = "Ayrton", LastName = "Senna" };
            myPersons[1] = new Person { FirstName = "Michael", LastName = "Schumacher" };

            Person[] myPersons2 = 
            { 
                new Person { FirstName="Ayrton", LastName="Senna"},
                new Person { FirstName="Michael", LastName="Schumacher"} 
            };
二、多维数组
    1、初始化二维数组
            int[,] twodim = new int[3, 3];
            twodim[0, 0] = 1;
            twodim[0, 1] = 2;
            twodim[0, 2] = 3;
            twodim[1, 0] = 4;
            twodim[1, 1] = 5;
            twodim[1, 2] = 6;
            twodim[2, 0] = 7;
            twodim[2, 1] = 8;
            twodim[2, 2] = 9;
        或
            int[,]twodim={{1,2,3},{4,5,6}};
    2.初始化三维数组
         int[, ,] threedim = {
                    { { 1, 2 }, { 3, 4 } },
                    { { 5, 6 }, { 7, 8 } },
                    { { 9, 10 }, { 11, 12 } }
                   };
        Console.WriteLine(threedim[0, 1, 1]);
三、锯齿数组
    锯齿数组就是数组中的每一项个数都不同
    锯齿数组的声明与迭代输出如下：
         int[][] jagged = new int[3][];
            jagged[0] = new int[2] { 1, 2 };
            jagged[1] = new int[6] { 3, 4, 5, 6, 7, 8 };
            jagged[2] = new int[3] { 9, 10, 11 };

            for (int row = 0; row < jagged.Length; row++)
            {
                for (int element = 0;
                   element < jagged[row].Length; element++)
                {
                    Console.WriteLine(
                       "row: {0}, element: {1}, value: {2}",
                       row, element, jagged[row][element]);
                }
            }
四、Array类
    1.Array类时一个抽象类，不能使用构造函数来创建数组，但是可以通过静态方法CreateInstance()创建数组，他的第一个参数是创建数组元素的类型，第二个参数是数组的大小。
        例如定义一个类型为int,大小为5的数组。
            Array intArray1 = Array.CreateInstance(typeof(int), 5);
            for (int i = 0; i < 5; i++)
            {
                intArray1.SetValue(33, i);
            }

            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine(intArray1.GetValue(i));
            }    
    2.复制数组（浅拷贝）
        如果数组元素是值类型，就会复制所有值，如果数组包含引用类型，则不会复制元素，而只是复制引用。
        例如：
            static void CopyArrays()
            {
                Person[] beatles = {
                         new Person { FirstName="John", LastName="Lennon" },
                         new Person { FirstName="Paul", LastName="McCartney" }
                       };

                Person[] beatlesClone = (Person[])beatles.Clone();

            }
        除了使用Clone()方法之外，还可以使用Array.Copy()方法来创建浅表副本。两者区别是：Clone()创建一个全新数组，而Copy()必须传递阶数相同且足够元素的已有数组。如果要包含引用类型的数组的深层副本，
        就必须迭代数组并且创建对象。
    3.数组排序
        Array类的Sort()方法可以对数组中的元素进行排序，但是数组中的元素需要实现IComparable接口。
        因为简单类型System.String和System.Int32实现了IComparable接口，故可以对这些类型的元素排序。
        例如：
            static void SortNames()
            {
                string[] names = {
                       "Christina Aguilera",
                       "Shakira",
                       "Beyonce",
                       "Gwen Stefani"
                     };

                Array.Sort(names);
                foreach (string name in names)
                {
                    Console.WriteLine(name);
                }

            }
        自定义一个Person类，使之实现IComparable<person>接口
        例如：
            
            public class Person : IComparable<Person>
            {
                public string FirstName { get; set; }

                public string LastName { get; set; }

                public override string ToString()
                {
                    return String.Format("{0} {1}",
                          FirstName, LastName);
                }

                public int CompareTo(Person other)
                {
                    if (other == null) throw new ArgumentNullException("other");

                    int result = this.LastName.CompareTo(other.LastName);
                    if (result == 0)
                    {
                        result = this.FirstName.CompareTo(other.FirstName);
                    }

                    return result;
                }
         
            }
            然后调用
                class Program
                {
                    static void Main()
                    {
                        
                        Person[] persons = GetPersons();
                        SortPersons(persons);
                    }

                

                    static void SortUsingPersonComparer(Person[] persons)
                    {
                        Array.Sort(persons, 
                            new PersonComparer(PersonCompareType.FirstName));

                        foreach (Person p in persons)
                        {
                            Console.WriteLine(p);
                        }

                    }

                    static Person[] GetPersons()
                    {
                        return new Person[] {
                            new Person { FirstName="Damon", LastName="Hill" },
                            new Person { FirstName="Niki", LastName="Lauda" },
                            new Person { FirstName="Ayrton", LastName="Senna" },
                            new Person { FirstName="Graham", LastName="Hill" }
                         };
                    }

                    static void SortPersons(Person[] persons)
                    {
                        Array.Sort(persons);
                        foreach (Person p in persons)
                        {
                            Console.WriteLine(p);
                        }
                    }

                    static void SortNames()
                    {
                        string[] names = {
                               "Christina Aguilera",
                               "Shakira",
                               "Beyonce",
                               "Gwen Stefani"
                             };

                        Array.Sort(names);
                        foreach (string name in names)
                        {
                            Console.WriteLine(name);
                        }

                    }
                }
五、数组段
    1.数组段 ArraySegment<T>
        结构ArraySegment<T>表示数组的一段。如果某方法应返回数组的一部分，或者给某方法传递数组的一部分，就可以使用数组段。
        例如：
            static void Main()
            {
                int[] ar1 = { 1, 4, 5, 11, 13, 18 };
                int[] ar2 = { 3, 4, 5, 18, 21, 27, 33 };
                var segments = new ArraySegment<int>[2] 
                { 
                    new ArraySegment<int>(ar1, 0, 3), 
                    new ArraySegment<int>(ar2, 3, 3)
                };


                var sum = SumOfSegments(segments);
                Console.WriteLine("sum of all segments: {0}", sum);

            }

            static int SumOfSegments(ArraySegment<int>[] segments)
            {
                int sum = 0;
                foreach (var segment in segments)
                {
                    for (int i = segment.Offset; i < segment.Offset + segment.Count; i++)
                    {
                        sum += segment.Array[i];
                    }

                }
                return sum;
            }
六、枚举器
        1.IEnumerator接口
            foreach语句使用IEnumeratro接口的属性和方法，迭代集合中的元素。它提供了Curret属性，返回光标所在的元素。该接口的MoveNext方法移动到集合的下一个元素上，如果有这个元素返回true,否则返回false;
            例如：
                foreach(ar p in persons)
                {
                    Console.WriteLine(p);
                }
                会被解析为
                IEnumberator<Person>enumerator=persons.GetEnumerator();
                while(enumerator.MoveNext())
                {
                    Person p=enumerator.Current;
                    Console.WriteLine(p);
                }
        2.yield语句
            它用来创建枚举器。yield return语句返回集合中的一个元素，并移动到下一个元素上。yield break可停止迭代。
            例如：
                public class HelloCollection
                {
                    public IEnumerator<string> GetEnumerator()
                    {
                        yield return "Hello";
                        yield return "World";
                    }
                }
                static void HelloWorld()
                {
                    var helloCollection = new HelloCollection();
                    foreach (string s in helloCollection)
                    {
                        Console.WriteLine(s);
                    }
                }
        3.元组
            数组合并了相同类型的对象，而元组合并了不同类型的对象。
            例如：
                public static Tuple<int, int> Divide(int dividend, int divisor)
                {
                    int result = dividend / divisor;
                    int reminder = dividend % divisor;

                    return Tuple.Create<int, int>(result, reminder);
                }    
                调用方法：
                    var result = Divide(5, 2);
                    Console.WriteLine("result of division: {0}, reminder: {1}", result.Item1, result.Item2);