一、数组的基础知识
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; } }
综合上面的三种方法,个人推荐第三种方法,进行自定义类型数组的排序工作,当然如果排序的逻辑很复杂,第三种未必就是最好的.