C# 数组基础

一、数组的基础知识

1、数组有什么用?

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

2、数组的初始化方式

第一种:先声明后赋值

int[] array = new int[];
array[] = ;
array[] = ;
array[] = ;

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

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

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

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

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

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

3、引用类型数组

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

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

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

4、多维数组

二维数组的声明方式:

int[,] twodim = new int[, ];
twodim[, ] = ;
twodim[, ] = ;
twodim[, ] = ;
twodim[, ] = ;
twodim[, ] = ;
twodim[, ] = ;
twodim[, ] = ;
twodim[, ] = ;
twodim[, ] = ;

语法糖:

int[,] twodim ={
   {,,},
   {,,},
   {,,}
};

三维数组:

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

5、锯齿数组

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

int[][] jagged = new int[][];
jagged[]=new int[]{,};
jagged[] = new int[] { , , , , ,  };
jagged[] = new int[] { , , ,  };
for (int row = ; row < jagged.Length; row++)
{
      for (int element = ; 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), );
for (int i = ; i < array.Length; i++)
{
      array.SetValue(i + , i);
}
for (int i = ; i < array.Length; i++)
{
     Console.WriteLine(array.GetValue(i));
}

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

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

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

}
Console.ReadKey();

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

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

Array array = Array.CreateInstance(typeof(int), , , );
int value = ;
for (int x = ; x < array.GetUpperBound(); x++)
       for (int y = ; y < array.GetUpperBound(); y++)
              for (int z = ; z < array.GetUpperBound(); z++)
              {
                    array.SetValue(value, x, y, z);
                    value++;
               }

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

部分截图

4、复制数组

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

int[] array = { , ,  };
int[] otherArray = array;
array[] = ;
Console.WriteLine(otherArray[]);
otherArray[] = ;
Console.WriteLine(array[]);

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

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

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

第二种:Array.Copy()

复制一维数组:

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

复制二维数组:

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

第三种:CopyTo

int[] array = { , ,  };
int[] arrayCopyTo=new int[array.Length];
array.CopyTo(arrayCopyTo,);
            Console.WriteLine(object.ReferenceEquals(array,arrayCopyTo));
for (int i = ; 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("张三", );
object[] array = { , , , p, };
object[] arrayClone = (object[])array.Clone();
p.Name = "李四";
Console.WriteLine((arrayClone[] 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 = { , , , , , , ,  };
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 ;
                int result = string.Compare(this.FirstName, other.FirstName);
                if (result == )//如果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=,
            LaseName=
        }
        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 ;
                if (x == null) return ;
                if (y == null) return -;
                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 ;
                    if (x == null) return ;
                    if (y == null) return -;
                    int result = string.Compare(x.FirstName, y.FirstName);
                    if (result == )
                        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;
            }
        }

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