C#的Array 类使用说明

一：Array 类简单说明

Array 类是 C# 中所有数组的基类，它是在 System 命名空间中定义。Array 类提供了各种用于数组的属性和方法。

二：Array 类的属性

属性	说明
IsFixedSize	获取一个值，该值指示 Array 是否具有固定大小。
IsReadOnly	获取一个值，该值指示 Array 是否为只读。
IsSynchronized	获取一个值，该值指示是否同步对 Array 的访问（线程安全）。
Length	获取一个 32 位整数，该值表示所有维度的数组中的元素总数。
LongLength	获取一个 64 位整数，该整数表示 Array 的所有维数中元素的总数。
Rank	获取 Array 的秩（维数）。 例如，一维数组返回 1，二维数组返回 2，依次类推。
SyncRoot	获取可用于同步对 Array 的访问的对象。

三：Array 类的方法

方法	描述
Clear(Array, Int32, Int32)	根据元素的类型，设置数组中某个范围的元素为零、为 false 或者为 null。
Copy(Array, Array, Int32)	从数组的第一个元素开始复制某个范围的元素到另一个数组的第一个元素位置。长度由一个 32 位整数指定。
CopyTo(Array, Int32)	从当前的一维数组中复制所有的元素到一个指定的一维数组的指定索引位置。索引由一个 32 位整数指定。
GetLength	获取一个 32 位整数，该值表示指定维度的数组中的元素总数。
GetLongLength	获取一个 64 位整数，该值表示指定维度的数组中的元素总数。
GetLowerBound	获取数组中指定维度的下界。
GetType	获取当前实例的类型。从对象（Object）继承。
GetUpperBound	获取数组中指定维度的上界。
GetValue(Int32)	获取一维数组中指定位置的值。索引由一个 32 位整数指定。
IndexOf(Array, Object)	搜索指定的对象，返回整个一维数组中第一次出现的索引。
Reverse(Array)	逆转整个一维数组中元素的顺序。
SetValue(Object, Int32)	给一维数组中指定位置的元素设置值。索引由一个 32 位整数指定。
Sort(Array)	使用数组的每个元素的 IComparable 实现来排序整个一维数组中的元素。
ToString	返回一个表示当前对象的字符串。从对象（Object）继承。

3.1：Array.Clear(Array, Int32, Int32) 方法

int[] numbers1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Console.Write("原数组是：\r\n");
for (int i = 0; i < 9; i++)
{
    Console.Write("{0} ", numbers1[i]);
}
Console.WriteLine();

Console.Write("处理后的数组是：\r\n");
Console.WriteLine("Array.Clear(numbers1, 2, 5)");
Array.Clear(numbers1, 2, 5);
for (int i = 0; i < 9; i++)
{
    Console.Write("{0} ", numbers1[i]);
}

运行结果：

原数组是： 1 2 3 4 5 6 7 8 9 处理后的数组是： Array.Clear(numbers1, 2, 5) 1 2 0 0 0 0 0 8 9

3.2：Array.Copy 方法

重载	重载说明
Copy(Array, Array, Int32)	从第一个元素开始复制 Array 中的一系列元素，将它们粘贴到另一 Array 中（从第一个元素开始）。 长度指定为 32 位整数。
Copy(Array, Array, Int64)	从第一个元素开始复制 Array 中的一系列元素，将它们粘贴到另一 Array 中（从第一个元素开始）。 长度指定为 64 位整数。
Copy(Array, Int32, Array, Int32, Int32)	复制 Array 中的一系列元素（从指定的源索引开始），并将它们粘贴到另一 Array 中（从指定的目标索引开始）。 长度和索引指定为 32 位整数。
Copy(Array, Int64, Array, Int64, Int64)	复制 Array 中的一系列元素（从指定的源索引开始），并将它们粘贴到另一 Array 中（从指定的目标索引开始）。 长度和索引指定为 64 位整数。

1. Copy(Array, Array, Int32)的使用

int[] ints = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 1042};
int[] dest = new int[ints.Length];

Array.Copy(ints, dest, ints.Length);
foreach (int item in dest)
{
    Console.Write("{0},", item);
}

运行结果：

1,2,3,4,5,6,7,8,9,1042,

2. Copy(Array, Int32, Array, Int32, Int32)的使用

int[] ints = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 1042};
int[] dest = { 11, 22, 33, 44, 55, 66, 77, 88, 99, 1000 };
Array.Copy(ints, 3, dest, 5, 4);
foreach (int item in dest)
{
    Console.Write("{0},", item);
}

运行结果：

11,22,33,44,55,4,5,6,7,1000,

3.3：Array.CopyTo 方法

将当前一维数组的所有元素复制到指定的一维数组中。

重载	重载说明
CopyTo(Array, Int32)	从指定的目标数组索引处开始，将当前一维数组的所有元素复制到指定的一维数组中。 索引指定为 32 位整数。
CopyTo(Array, Int64)	从指定的目标数组索引处开始，将当前一维数组的所有元素复制到指定的一维数组中。 索引指定为 64 位整数。

string[] ArrayOne = { "1", "2", "3", "4", "5" };
Console.WriteLine(string.Format("数组1：[\"{0}\"]", string.Join("\",\"", ArrayOne)));
string[] ArrayTwo = { "one", "two", "three", "four", "five", "six", "seven" };
Console.WriteLine(string.Format("数组2：[\"{0}\"]", string.Join("\",\"", ArrayTwo)));
string[] TemarArray = new string[ArrayOne.Length + ArrayTwo.Length];

ArrayTwo.CopyTo(TemarArray, 0);//ArrayTwo 源数组，TemarArray目标数组，0 目标数组的起始下标
Console.WriteLine(string.Format("合并后数组：[\"{0}\"]", string.Join("\",\"", TemarArray)));

ArrayOne.CopyTo(TemarArray, ArrayTwo.Length);
Console.WriteLine(string.Format("合并后数组：[\"{0}\"]", string.Join("\",\"", TemarArray)));

运行结果：

数组1：["1","2","3","4","5"] 数组2：["one","two","three","four","five","six","seven"] 合并后数组：["one","two","three","four","five","six","seven","","","","",""] 合并后数组：["one","two","three","four","five","six","seven","1","2","3","4","5"]

3.4：Array.GetLength(Int32) 方法

获取一个 32 位整数，该整数表示 Array 的指定维中的元素数。

int[] numbers1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int Length_num1 = numbers1.GetLength(0);//一维数组的元素数量
int Length_num2 = numbers1.Length;

Console.WriteLine(Length_num1);
Console.WriteLine(Length_num2);

运行结果：

9 9

注意说明：
1）length() 是一个方法，会自动计算具体哪个维数里面，有多少个元素，适用于数量会变化的集合。
2）length 是一个属性，适用于数量尺寸不会变化的数组，字符串等 。

3.5：Array.GetLowerBound(Int32)和GetUpperBound(Int32) 方法

获取数组中指定维度第一个元素的索引。

// 创建一维整数数组
int[] integers = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
// 获取数组的上下界
int upper = integers.GetUpperBound(0);
int lower = integers.GetLowerBound(0);
Console.WriteLine($"元素索引从 {lower} 到 {upper}:");
// 迭代数组.
for (int ctr = lower; ctr <= upper; ctr++)
    Console.Write($"{(ctr == lower ? "   " : "")}{integers[ctr]}" +
                  $"{(ctr < upper ? ", " : Environment.NewLine)}");

运行结果：

元素索引从 0 到 9: 2, 4, 6, 8, 10, 12, 14, 16, 18, 20

3.6：Array.GetValue(Int32)和SetValue(Object, Int32)方法

1：GetValue 获取当前 Array 中指定元素的值。
2：SetValue 将当前 Array 中的指定元素设置为指定值。

GetValue 重载	重载说明
GetValue(Int32)	获取一维 Array 中指定位置的值。 索引指定为 32 位整数。
GetValue(Int32[])	获取多维 Array 中指定位置的值。 索引指定为一个 32 位整数数组。
GetValue(Int64)	获取一维 Array 中指定位置的值。 索引指定为 64 位整数。
GetValue(Int64[])	获取多维 Array 中指定位置的值。 索引指定为一个 64 位整数数组。
GetValue(Int32, Int32)	获取二维 Array 中指定位置的值。 索引指定为 32 位整数。
GetValue(Int64, Int64)	获取二维 Array 中指定位置的值。 索引指定为 64 位整数。
GetValue(Int32, Int32, Int32)	获取三维 Array 中指定位置的值。 索引指定为 32 位整数。
GetValue(Int64, Int64, Int64)	获取三维 Array 中指定位置的值。 索引指定为 64 位整数。

SetValue重载	重载说明
SetValue(Object, Int32)	将值设置为一维 Array 中指定位置的元素。 索引指定为 32 位整数。
SetValue(Object, Int32[])	将值设置为多维 Array 中指定位置的元素。 索引指定为一个 32 位整数数组。
SetValue(Object, Int64)	将值设置为一维 Array 中指定位置的元素。 索引指定为 64 位整数。
SetValue(Object, Int64[])	将值设置为多维 Array 中指定位置的元素。 索引指定为一个 64 位整数数组。
SetValue(Object, Int32, Int32)	将某值设置给二维 Array 中指定位置的元素。 索引指定为 32 位整数。
SetValue(Object, Int64, Int64)	将某值设置给二维 Array 中指定位置的元素。 索引指定为 64 位整数。
SetValue(Object, Int32, Int32, Int32)	将值设置为三维 Array 中指定位置的元素。 索引指定为 32 位整数。
SetValue(Object, Int64, Int64, Int64)	将值设置为三维 Array 中指定位置的元素。 索引指定为 64 位整数。

GetValue(Int32)和SetValue(Object, Int32)的使用举例

// 创建并初始化一维数组
String[] myArr1 = new String[5];
// 设置索引3处的元素
myArr1.SetValue("three", 3);
Console.WriteLine("[3]:   {0}", myArr1.GetValue(3));

// 创建并初始化二维数组
String[,] myArr2 = new String[5, 5];
// 设置索引1、3处的元素
myArr2.SetValue("one-three", 1, 3);
Console.WriteLine("[1,3]:   {0}", myArr2.GetValue(1, 3));

// 创建并初始化三维数组。
String[,,] myArr3 = new String[5, 5, 5];
// 设置索引1、2、3处的元素。
myArr3.SetValue("one-two-three", 1, 2, 3);
Console.WriteLine("[1,2,3]:   {0}", myArr3.GetValue(1, 2, 3));

// 创建并初始化一个七维数组。
String[,,,,,,] myArr7 = new String[5, 5, 5, 5, 5, 5, 5];
// 设置索引1、2、3、0、1、2、3处的元素。
int[] myIndices = new int[7] { 1, 2, 3, 0, 1, 2, 3 };
myArr7.SetValue("one-two-three-zero-one-two-three", myIndices);
Console.WriteLine("[1,2,3,0,1,2,3]:   {0}", myArr7.GetValue(myIndices));      

运行结果：

[3]: three [1,3]: one-three [1,2,3]: one-two-three [1,2,3,0,1,2,3]: one-two-three-zero-one-two-three

3.7：Array.IndexOf 方法

在一个一维数组或该数组的一系列元素中搜索指定对象 ，并返回其首个匹配项的索引。

重载	重载说明
IndexOf(Array, Object)	在一个一维数组中搜索指定对象，并返回其首个匹配项的索引。
IndexOf(Array, Object, Int32)	在一个一维数组的一系列元素中搜索指定对象，然后返回其首个匹配项的索引。 范围从指定索引到该数组结尾。
IndexOf(Array, Object, Int32, Int32)	在一个一维数组的一系列元素中搜索指定对象，然后返回其首个匹配项的索引。 该元素系列的范围从指定数量的元素的指定索引开始。
IndexOf(T[], T, Int32)	在一个一维数组的一系列元素中搜索指定对象，然后返回其首个匹配项的索引。 范围从指定索引到该数组结尾。
IndexOf(T[], T, Int32, Int32)	在一个一维数组的一系列元素中搜索指定对象，然后返回其首个匹配项的索引。 该元素系列的范围从指定数量的元素的指定索引开始。
IndexOf(T[], T)	在一个一维数组中搜索指定对象，并返回其首个匹配项的索引。

Array.IndexOf的使用举例

// 创建一个包含3个具有相同值的字符串数组。
String[] strings = { "the", "quick", "brown", "fox", "jumps",
         "over", "the", "lazy", "dog", "in", "the",
         "barn" };
// 显示数组的元素。
Console.WriteLine("该数组包含下列值：");
for (int i = strings.GetLowerBound(0); i <= strings.GetUpperBound(0); i++)
    Console.WriteLine("   [{0,2}]: {1}", i, strings[i]);
    
// 搜索重复值的第一个匹配项
string searchString = "the";
int index = Array.IndexOf(strings, searchString);
Console.WriteLine("第一次出现 \"{0}\" 的索引是 {1} .", searchString, index);

// 在数组的最后一段中搜索重复值的第一个匹配项。
index = Array.IndexOf(strings, searchString, 4);
Console.WriteLine("第一次出现 \"{0}\" 在索引4到末尾之间的索引是：{1}.", searchString, index);

// 在数组的某个部分中搜索重复值的第一个匹配项。
int position = index + 1;
index = Array.IndexOf(strings, searchString, position, strings.GetUpperBound(0) - position + 1);
Console.WriteLine("第一次出现 \"{0}\" ，在索引 {1} 后 {2} 个元素之内， 其索引号是 {3}.",
                  searchString, position, strings.GetUpperBound(0), index);

运行结果：

该数组包含下列值： [ 0]: the [ 1]: quick [ 2]: brown [ 3]: fox [ 4]: jumps [ 5]: over [ 6]: the [ 7]: lazy [ 8]: dog [ 9]: in [10]: the [11]: barn 第一次出现 "the" 的索引是 0 . in 第一次出现 "the" 在索引4到末尾之间的索引是：6. 第一次出现 "the" ，在索引 7 后 11 个元素之内， 其索引号是 10.

3.8：Reverse(Array)方法

反转一维 Array 或部分 Array 中元素的顺序。

重载	重载说明
Reverse(Array, Int32, Int32)	反转一维 Array 中，元素子集的顺序。
Reverse(Array)	反转一维 Array 中，整个元素的顺序。

String[] strings = { "the", "quick", "brown", "fox"};

Array.Reverse(strings, 1, 3);
foreach (String item in strings)
{
    Console.Write("[{0}]",item);
}
Console.WriteLine();

Array.Reverse(strings);
foreach (String item in strings)
{
    Console.Write("[{0}]", item);
}

运行结果：

[the][fox][brown][quick] [quick][brown][fox][the]

3.9：Sort(Array)方法

对一维数组中的元素进行排序。

重载	重载说明
Sort(Array, Array)	基于第一个 Array 中的关键字，使用每个关键字的 IComparable 实现，对两个一维 Array 对象（一个包含关键字，另一个包含对应的项）进行排序。
Sort(Array)	使用 Array 中每个元素的 IComparable 实现，对整个一维 Array 中的元素进行排序。
Sort(Array, Int32, Int32)	使用 Array 中每个元素的 IComparable 实现，对一维 Array 中的部分元素进行排序。

1）Sort(Array)的使用举例一：

int[] nums_1 = { 1, 2, 3, -44, 55, 88, 99, 70, -88, 100 };

Array.Sort(nums_1);//升序排列
for (int i = 0; i < nums_1.Length; i++)
{
    Console.Write("{0} ,", nums_1[i]);
}

运行结果：

-88 ,-44 ,1 ,2 ,3 ,55 ,70 ,88 ,99 ,100 ,

2）Sort(Array)的使用举例二：

string[] names = { "Lili", "Heicer", "Lucy" };
Array.Sort(names);
foreach (string name in names)
{
    Console.Write("{0},",name);
}

运行结果：

Heicer,Lili,Lucy,

3）Sort(Array, Int32, Int32)的使用举例

int[] nums_1 = { 1, 2, 3, -44, 55, 88, 99, 70, -88, 100 };
int[] nums_2 = { 1580, 1204, 2589, -44, 12, 88, 99, 54612, -998, -100 };
Array.Sort(nums_1, 1, 3);//使用默认比较器对第1元素到后面3个元素进行排序：
Array.Sort(nums_2, 3, 5);//使用默认比较器对第3元素到后面5个元素进行排序：

for (int i = 0; i < nums_1.Length; i++)
{
    Console.Write("[ {0} ]", nums_1[i]);
}
Console.WriteLine();

for (int i = 0; i < nums_1.Length; i++)
{
    Console.Write("[ {0} ]", nums_2[i]);
}

运行结果：

[ 1 ][ -44 ][ 2 ][ 3 ][ 55 ][ 88 ][ 99 ][ 70 ][ -88 ][ 100 ] [ 1580 ][ 1204 ][ 2589 ][ -44 ][ 12 ][ 88 ][ 99 ][ 54612 ][ -998 ][ -100 ]