C# 数组基础

一、数组的基础知识

1、数组有什么用?

如果需要同一个类型的多个对象,就可以使用数组。数组是一种数组结构,它可以包含同一个类型的多个元素.

2、数组的初始化方式

第一种:先声明后赋值

int[] array = new int[3];
array[0] = 0;
array[1] = 1;
array[2] = 2;

第二种:使用数组初始化器对数组进行赋值。注:数组初始化器只能在声明数组变量时使用,不能在声明数组变量之后使用.

//正确
int[] array = new int[3] { 1, 2, 3 };

//错误
int[] array1=new int[3];
array1 =  { 1, 2, 3 };

关于第二种方法,C#提供了两个方式的"语法糖";

//语法糖一
int[] array = new int[] { 1, 2, 3 };

//语法糖二
int[] array={1,2,3};

3、引用类型数组

C#除了能声明和处理预定义类型的数组之外,还能声明自定义类型的数组。

public class Person
{
    public string FirstName{get;set;}
    public string LastName{get;set;}    
}
Person[] person=new Person[2];

预定义类型数组能干的事,自定义类型数组也都能干.

4、多维数组

二维数组的声明方式:

int[,] twodim = new int[2, 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},
   {7,8,9}
};

三维数组:

因为日常开发中不常用到,所以就不解释了.百度百科

5、锯齿数组

锯齿数组是一个特殊的二维数组,常规的二维数组都是矩形,大部分都是各行的个数都相同,而锯齿数组则不一样,锯齿数组的第一行有3个,第二行可能有6个,第三行可能有7个......以此类推.锯齿数组的声明方式如下:

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[4] { 6, 8, 9, 2 };
for (int row = 0; row < jagged.Length; row++)
{
      for (int element = 0; element < jagged[row].Length; element++)
      {
            Console.WriteLine("第{0}行,第{1}个,值为{2}", row, element, jagged[row][element]);
       }
}
Console.ReadKey();

二、Array类

使用方括号创建数组其实是用Array的表示法,当我们使用方括号创建了一个数组时,C#编译器会创建一个派生自抽象基类的Array的新类.这样使用方括号创建的数组对象就可以使用Array类为每个数组定义的方法和属性了.如:可以使用foreach迭代数组,其实就是使用了Array类中GetEnumerator()方法.

1、使用静态方法CreateInstance创建一维数组,并使用SetValue对数组进行赋值,使用GetValue获取数组中的值

Array array=Array.CreateInstance(typeof(int), 5);
for (int i = 0; i < array.Length; i++)
{
      array.SetValue(i + 10, i);
}
for (int i = 0; i < array.Length; i++)
{
     Console.WriteLine(array.GetValue(i));
}

2、使用静态方法CreateInstance创建二维数组,并使用SetValue对数组进行赋值,使用GetValue获取数组中的值

注:通过GetUpperBound获取维度的上限,通过GetLowerBound获取维度的下限

Array array=Array.CreateInstance(typeof(int),5,6);
int value = 0;
for(int row=0;row<array.GetUpperBound(0);row++)
for (int element = 0; element < array.GetUpperBound(1); element++)
{
     array.SetValue(value, row, element);
     value++;
}
for (int row = 0; row < array.GetUpperBound(0); row++)
     for (int element = 0; element < array.GetUpperBound(1); element++)
     {
         if (element == array.GetUpperBound(1) - 1)
         {
             Console.WriteLine();
         }
         else
         {
             string nbsp = " ";
             string res = array.GetValue(row, element).ToString().PadLeft(2, '0');
             res=element == array.GetUpperBound(1) - 1 ? res : res + nbsp;
             Console.Write(res);
         }
      }
                    
}
Console.ReadKey();

3、使用静态方法CreateInstance创建三维数组,并使用SetValue对数组进行赋值,使用GetValue获取数组中的值

注:通过GetUpperBound获取维度的上限,通过GetLowerBound获取维度的下限

Array array = Array.CreateInstance(typeof(int), 5, 6, 7);
int value = 0;
for (int x = 0; x < array.GetUpperBound(0); x++)
       for (int y = 0; y < array.GetUpperBound(1); y++)
              for (int z = 0; z < array.GetUpperBound(2); z++)
              {
                    array.SetValue(value, x, y, z);
                    value++;
               }

for (int x = 0; x < array.GetUpperBound(0); x++)
      for (int y = 0; y < array.GetUpperBound(1); y++)
            for (int z = 0; z < array.GetUpperBound(2); z++)
            {
                  Console.WriteLine("x坐标:{0},y坐标:{1},z坐标:{2},值为:{3}", x, y, z, array.GetValue(x, y, z));
             }
Console.ReadKey();

部分截图

4、复制数组

数组是引用类型,所以将一个数组变量赋值给另一个数组变量,就会得到两个引用同一个数组的变量,所以通过任何一个引用修改数组的值,两个引用都会受影响.

int[] array = { 1, 2, 3 };
int[] otherArray = array;
array[2] = 6;
Console.WriteLine(otherArray[2]);
otherArray[2] = 66;
Console.WriteLine(array[2]);

所以单纯的通过复制引用的方法,并不能实现数组的复制,必须通过其它的方法来复制数组,C#提供了两种复制数组的方式:

第一种:C#中的数组都实现了ICloneable接口,所以通该接口中定义的Clone()方法就能实现数组的浅拷贝(什么是浅拷贝,后续会介绍).

int[] array = { 1, 2, 3 };
int[] arrayClone = (int[])array.Clone();
array[2]=66;
Console.WriteLine(object.ReferenceEquals(array,arrayClone));//False 说明使用Clone()方法拷贝后的数组是重新创建的
Console.WriteLine(arrayClone[2] +"..." + array[2]);

第二种:Array.Copy()

复制一维数组:

int[] array = { 1, 2, 3 };
int[] arrayCopy=new int[array.Length];
Array.Copy(array, arrayCopy,array.Length);//最后一个参数为要复制的个数
for (int i = 0; i < arrayCopy.Length; i++)
{
      Console.WriteLine(arrayCopy[i]);
}

复制二维数组:

int[,] array = { {1,2,3},{4,5,6},{7,8,9} };
int[,] arrayCopy = new int[array.GetUpperBound(0)+1, array.GetUpperBound(1)+1];
Array.Copy(array,arrayCopy,array.Length);//最后一个参数为要复制的个数
for (int i = 0; i <= arrayCopy.GetUpperBound(0); i++)
     for (int x = 0; x <= arrayCopy.GetUpperBound(1); x++)
            Console.WriteLine("第{0}行,第{1}个,值为:{2}",i,x,arrayCopy.GetValue(i,x));
Console.ReadKey();

第三种:CopyTo

int[] array = { 1, 2, 3 };
int[] arrayCopyTo=new int[array.Length];
array.CopyTo(arrayCopyTo,0);
            Console.WriteLine(object.ReferenceEquals(array,arrayCopyTo));
for (int i = 0; i < arrayCopyTo.Length; i++)
{
     Console.WriteLine(arrayCopyTo[i]);
}

Clone()和Array.Copy()的区别主要是:Clone()方法直接复制整个目标数组,然后进行拆箱就可以使用,但是Array.Copy()方法则必须要提供相同维数的数组和需要复制的元素个数,才能复制成功。

Clone()和CopyTo()方法的区别主要是:CopyTo()需要提供一个开始复制的起始索引.

 什么是浅拷贝和深拷贝?

当数组中存在引用类型的元素时,这个时候使用Clone()或者Array.Copy()或者CopyTo()方法进行的数组复制都是浅拷贝,只会复制引用类型的索引,这意味这当修改原数组中的引用类型的值时,拷贝后的数组中的引用类型的值也会做相应的改变,所以使用上述方法进行的数组拷贝都将是浅拷贝.所以如果你想要创建包含引用类型的数组的深层副本,就必须迭代数组并创建新对象.这个过程也叫深拷贝.

Person p = new Person("张三", 23);
object[] array = { 1, 2, 3, p,6 };
object[] arrayClone = (object[])array.Clone();
p.Name = "李四";
Console.WriteLine((arrayClone[3] as Person).Name);

class Person
{
     public Person()
     { }
     public Person(string name,int age)
      {
           this.Name = name;
           this.Age = age;
      }
       public string Name { get; set; }
       public int Age { get; set; }
}

说明Clone()方法确实是浅拷贝,至于Array.Copy()和CopyTo()也是浅拷贝-这两个请自行验证.

5、数组排序

(1)、简单类型数组排序(简单类型如:System.String、System.Int、System.Double、System.Float等)

Array类使用QuickSort算法对数组中的元素进行排序。主要通过Array.Sort()方法来进行排序,Sort()方法需要数组中元素都实现IComparable接口,因为简单类型(如System.String和System.Int32)实现了IComparable接口,所以可以对包含这些类型的元素进行排序.如下代码,就是简单的对string类型数组和int数组进行排序,代码如下:

string[] player ={
     "LeBron James",
     "Stepen Curry",
     "Kevin Durrent",
};
Array.Sort<string>(player);
foreach (var item in player)
{
      Console.WriteLine(item);
}

int[] nums = { 9, 2, 4, 5, 6, 8, 9, 2 };
Array.Sort<int>(nums);
foreach (var item in nums)
{
      Console.WriteLine(item);
}

(2)、自定义类型利用Sort()方法排序

a、通过自定义类型实现IComparable接口,来实现自定义类型数组的排序。注:该方法适用于要进行的自定义实体类(本例中为Person类)可修改的情况下!

如果数组的类型为自定义类型,且需要使用Sort()对该书组进行排序,那么当前自定义类就必须实现IComparable接口,该接口只定义了一个方法CompareTo(),如果要比较的对象相等,该方法就返回0,如果该实例应排在参数的前面,该方法返回-1,如果该实例应排在参数的后面,该方法返回1.CompareTo方法的返回值规则和string.Compare()方法相同,如下图:

 如上图示,当前实例应该排在参数的前面,所以result的值应为-1

 

ok,说明上面的结论正确(这里对象相等和当前实例排在参数后面的情况自行证明).那么CompareTo()方法的返回也应该这么写,代码如下:

static void Main(string[] args)
{
            Person[] people =
            {
                new Person{FirstName="Damon",LastName="Hill"},
                new Person{FirstName="Niki",LastName="Lauda"},
                new Person{FirstName="Ayrton",LastName="Senna"}
                
            };
            Array.Sort<Person>(people);
            foreach (var item in people)
            {
                if (item == null)
                    Console.WriteLine("null");
                else
                Console.WriteLine(item.ToString());
            }
            Console.ReadKey();

}
class Person:IComparable<Person>
{
            public string FirstName { get; set; }
            public string LastName { get; set; }

            public int CompareTo(Person other)
            {
                if (other == null) return 1;
                int result = string.Compare(this.FirstName, other.FirstName);
                if (result == 0)//如果FirstName相等,则判断LastName
                    result = string.Compare(this.LastName, this.LastName);
                return result;
            }

            public override string ToString()
            {
                return this.FirstName + " " + this.LastName;
            }
}

b、当要进行排序的自定义类型不能进行修改的时候,就采用b方法

        static void Main(string[] args)
        {
            Person[] people =
            {
                new Person{FirstName="Damon",LastName="Hill"},
                new Person{FirstName="Damon",LastName="Green"},
                new Person{FirstName="Niki",LastName="Lauda"},
                new Person{FirstName="Ayrton",LastName="Senna"}
                
            };
            Array.Sort<Person>(people,new PersonCompare(PersonCompareType.LaseName));
            foreach (var item in people)
            {
                if (item == null)
                    Console.WriteLine("null");
                else
                Console.WriteLine(item.ToString());
            }
            Console.ReadKey();

        }
        public enum PersonCompareType
        { 
            FirstName=0,
            LaseName=1
        }
        public class PersonCompare : IComparer<Person>
        {
            private PersonCompareType _compareType;
            public PersonCompare(PersonCompareType compareType)
            {
                this._compareType = compareType;
            }
            public int Compare(Person x, Person y)
            {
                if (x == null && y == null)
                    return 0;
                if (x == null) return 1;
                if (y == null) return -1;
                switch (this._compareType)
                {
                    case PersonCompareType.FirstName: return string.Compare(x.FirstName, y.FirstName);
                    case PersonCompareType.LaseName: return string.Compare(x.LastName, y.LastName);
                    default: throw new ArgumentException("unexcepted compare type");
                }
            }

            
        }
        public class Person
        {
            public string FirstName { get; set; }
            public string LastName { get; set; }
            public override string ToString()
            {
                return this.FirstName + " " + this.LastName;
            }
        }

c、传递一个比较两个对象大小的委托delegate int Comparison<in T>(T x, T y),该方法最为简洁,即不污染要进行排序的对象,又能使用lambda表达式

        static void Main(string[] args)
        {
            Person[] people =
            {
                new Person{FirstName="Damon",LastName="Hill"},
                new Person{FirstName="Damon",LastName="Green"},
                new Person{FirstName="Niki",LastName="Lauda"},
                new Person{FirstName="Ayrton",LastName="Senna"}
                
            };
            Comparison<Person> compare = (Person x, Person y) =>
                {
                    if (x == null && y == null)
                        return 0;
                    if (x == null) return 1;
                    if (y == null) return -1;
                    int result = string.Compare(x.FirstName, y.FirstName);
                    if (result == 0)
                        result = string.Compare(x.LastName, x.LastName);
                    return result;
                };
            Array.Sort<Person>(people, compare);
            foreach (var item in people)
            {
                if (item == null)
                    Console.WriteLine("null");
                else
                    Console.WriteLine(item.ToString());
            }
            Console.ReadKey();
        }
        public class Person
        {
            public string FirstName { get; set; }
            public string LastName { get; set; }
            public override string ToString()
            {
                return this.FirstName + " " + this.LastName;
            }
        }

综合上面的三种方法,个人推荐第三种方法,进行自定义类型数组的排序工作,当然如果排序的逻辑很复杂,第三种未必就是最好的.