C# 数组（Array）

定义以及细节：

数组是一个存储相同类型元素的固定大小的顺序集合。

int [ ] intArray;

其中，

int 用于指定被存储在数组中的元素的类型。

[ ] 指定数组的秩（维度）。秩指定数组的大小。

intArray指定数组的名称。

 细节：

一维数组	只有一种元素固定的集合
多维数组	多维数组最简单的形式是二维数组。
交错数组	C# 支持交错数组，即数组的数组。
传递数组给函数	您可以通过指定不带索引的数组名称来给函数传递一个指向数组的指针。
参数数组	这通常用于传递未知数量的参数给函数。
Array类	在 System 命名空间中定义，是所有数组的基类，并提供了各种用于数组的属性和方法。

---

一维数组：

数组初始化：

在定义数组后，必须对其进行初始化才能够使用。

初始化数组有两种方法： 动态初始化 和 静态初始化

动态初始化：

格式为：

数据类型 [] 数组名 = new 数据类型 [ 数组长度 ]{ 元素 1, 元素 2} ；

动态初始化借助 new 运算符为数组元素分配内存空间，并赋初值 .

不给定初值情况下，各元素取默认值

例： int[] intArray = new int[6];

数值类型初始值为 0 ，布尔类型初值为 false ，字符串初值为 null

给定初值情况下，各元素取相应的初值

例： int[] intArray = new int[ 3 ]{1,2,3};

或例： int[] intArray = new int[]{1,2,3};

注意：此情况下数组大小不允许为变量

 

静态初始化：

静态初始化的格式为：

数据类型 [] 数组名 = { 元素 1 ，元素 2 ， … ，元素 n} ；

例： int[] myArr = {1,2,3,4,5};

注意：在这种情况下，不能将数组定义和静态初始化分开

 

数组元素：

数组元素 的访问：数组名 + 下标

数组下标 ：数组元素在数组中的序号。

从 0 开始，到数组总个数 -1 ；

下标可以是常量，也可以是变量

数组长度 ： arr.Length 表示数组的长度

 

 注意事项：

1，系统不会检测 数组元素的下标是否越界，编程时，必须保证数组下标

不能越界。

2， 数组是一个整体，不能直接参加运算，只能对单个元素进行处理，通

常用到数组的地方都会用到循环。

总结： 

数组通常与循环结合使用。

数组下标从 0 开始，最大到数组容量 -1 。

一定要注意下标越界问题。

注意几种循环的使用场合。

 

下面是一个实例，使用上面提到的三个概念，即声明、赋值、访问数组：

using System;
namespace ArrayApplication
{
   class MyArray
   {
      static void Main(string[] args)
      {
         int []  n = new int[10]; /* n 是一个带有 10 个整数的数组 */
         int i,j;


         /* 初始化数组 n 中的元素 */        
         for ( i = 0; i < 10; i++ )
         {
            n[ i ] = i + 100;
         }

         /* 输出每个数组元素的值 */
         for (j = 0; j < 10; j++ )
         {
            Console.WriteLine("Element[{0}] = {1}", j, n[j]);
         }
         Console.ReadKey();
      }
   }
}
//当上面的代码被编译和执行时，它会产生下列结果：
Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

使用 foreach 循环:
在前面的实例中，我们使用一个 for 循环来访问每个数组元素。您也可以使用一个 foreach 语句来遍历数组。
using System;

namespace ArrayApplication
{
   class MyArray
   {
      static void Main(string[] args)
      {
         int []  n = new int[10]; /* n 是一个带有 10 个整数的数组 */


         /* 初始化数组 n 中的元素 */        
         for ( int i = 0; i < 10; i++ )
         {
            n[i] = i + 100;
         }

         /* 输出每个数组元素的值 */
         foreach (int j in n )
         {
            int i = j-100;
            Console.WriteLine("Element[{0}] = {1}", i, j);
         }
         Console.ReadKey();
      }
   }
}

 

---

多维数组：

多维数组中最常用的就是二维数组，就简单的以二维数组为例为大家讲解：

多维数组最简单的形式是二维数组。一个二维数组，在本质上，是一个一维数组的列表。

一个二维数组可以被认为是一个带有 x 行和 y 列的表格。下面是一个二维数组，包含 3 行和 4 列：

初始化二维数组： 

多维数组可以通过在括号内为每行指定值来进行初始化。下面是一个带有 3 行 4 列的数组。

int [,] a = new int [3,4] {
 {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
};

访问二维数组元素 ：

二维数组中的元素是通过使用下标（即数组的行索引和列索引）来访问的。例如：

int val = a[2,3];

上面的语句将获取数组中第 3 行第 4 个元素。您可以通过上面的示意图来进行验证。让我们来看看下面的程序，我们将使用嵌套循环来处理二维数组：

using System;

namespace ArrayApplication
{
    class MyArray
    {
        static void Main(string[] args)
        {
            /* 一个带有 5 行 2 列的数组 */
            int[,] a = new int[5, 2] {{0,0}, {1,2}, {2,4}, {3,6}, {4,8} };

            int i, j;

            /* 输出数组中每个元素的值 */
            for (i = 0; i < 5; i++)
            {
                for (j = 0; j < 2; j++)
                {
                    Console.WriteLine("a[{0},{1}] = {2}", i, j, a[i,j]);
                }
            }
           Console.ReadKey();
        }
    }
}

 当上面的代码被编译和执行时，它会产生下列结果：

a[0,0]: 0
a[0,1]: 0
a[1,0]: 1
a[1,1]: 2
a[2,0]: 2
a[2,1]: 4
a[3,0]: 3
a[3,1]: 6
a[4,0]: 4
a[4,1]: 8

---

 

交错数组：

交错数组是数组的数组。

交错数组是一维数组。

using System;

namespace ArrayApplication
{
    class MyArray
    {
        static void Main(string[] args)
        {
            /* 一个由 5 个整型数组组成的交错数组 */
            int[][] a = new int[][]{new int[]{0,0},new int[]{1,2},
            new int[]{2,4},new int[]{ 3, 6 }, new int[]{ 4, 8 } };

            int i, j;

            /* 输出数组中每个元素的值 */
            for (i = 0; i < 5; i++)
            {
                for (j = 0; j < 2; j++)
                {
                    Console.WriteLine("a[{0}][{1}] = {2}", i, j, a[i][j]);
                }
            }
           Console.ReadKey();
        }
    }
}
当上面的代码被编译和执行时，它会产生下列结果：
a[0][0] = 0
a[0][1] = 0
a[1][0] = 1
a[1][1] = 2
a[2][0] = 2
a[2][1] = 4
a[3][0] = 3
a[3][1] = 6
a[4][0] = 4
a[4][1] = 8

---

传递数组给函数：

在 C# 中，您可以传递数组作为函数的参数。您可以通过指定不带索引的数组名称来给函数传递一个指向数组的指针。

using System;

namespace ArrayApplication
{
   class MyArray
   {
      double getAverage(int[] arr, int size)
      {
         int i;
         double avg;
         int sum = 0;

         for (i = 0; i < size; ++i)
         {
            sum += arr[i];
         }

         avg = (double)sum / size;
         return avg;
      }
      static void Main(string[] args)
      {
         MyArray app = new MyArray();
         /* 一个带有 5 个元素的 int 数组 */
         int [] balance = new int[]{1000, 2, 3, 17, 50};
         double avg;

         /* 传递数组的指针作为参数 */
         avg = app.getAverage(balance, 5 ) ;

         /* 输出返回值 */
         Console.WriteLine( "平均值是： {0} ", avg );
         Console.ReadKey();
      }
   }
}
当上面的代码被编译和执行时，它会产生下列结果：
平均值是： 214.4

---

参数数组：

参数数组通常用于传递未知数量的参数给函数。

params 关键字

在使用数组作为形参时，C# 提供了 params 关键字，使调用数组为形参的方法时，既可以传递数组实参，也可以传递一组数组元素。params 的使用格式为：

public 返回类型 方法名称( params 类型名称[] 数组名称 )

params 关键字可以指定采用数目可变的参数的 参数方法。

可以发送"参数声明中所指定类型的"参数列表（各参数用逗号隔开）或指定类型的参数数组，还可以不发送参数。

在方法声明中，params关键字之后不允许任何其他参数。

示例：

public class MyClass
{
    public static void UseParams(params int[] list)
    {
        for(int i = 0; i < list.Length; i++)
        {
            Console.Write( list[i] + " ");
        }
        Console.WriteLine();
    }
    public static void UseParams2( params object[] list)
    {
        for(int i = 0; i < list.Length; i++)
        {
            Console.Write(list[i] + " ");
        }
        Console.WriteLine();
    }
    static void Main()
    {
        UseParams(1, 2, 3, 4);
        UseParams2(1, 'a', "Apple");
        UseParams2();   //不填入参数
        int[] myIntArray = {5, 6, 7, 8, 9, };
        UseParams(myIntArray);
        object[] myObjArray = { 1, 'b', "boom", "app" };
        UseParams2(myObjArray);
        UseParams2(myIntArray);  //输出为"System.Int32[]"
    }
}//end of MyClass

 运行结果：

1  2  3  4
1  a  Apple
5  6  7  8  9
1  b  boom   app
System.Int32[]

params 用法补充： 

•  1.带 params 关键字的参数类型必须是一维数组，不能使用在多维数组上；
•  2.不允许和 ref、out 同时使用；
•  3.带 params 关键字的参数必须是最后一个参数，并且在方法声明中只允许一个 params 关键字。
•  4.不能仅使用 params 来使用重载方法。
•  5.没有 params 关键字的方法的优先级高于带有params关键字的方法的优先级

我们通常的入口函数 static void Main(string [] args) 就是用数组来作形参的，它实际可以写成 static void Main()，不需要参数的传入。同样使用数组作为形参，调用普通方法函数时，有无params是有区别的：

•  1.带params关键字的数组形参，既可以接受数组（直接传数组名，应该是地址），也可以接受多个和形参同类型的值（不是数组形式），如有方法 public int test (params int [] array), int [] a=new int [2] 作为数组时可以 test(a) 来调用，也可以 test(1,2,3,4) 来调用。
•  2.不带params关键字的数组形参，如方法public int test (int [] array),不通过传值的方式调用，只能传数组的方式调用。

 

测试如下：（带params和不带params的方法只能存在一个，不能仅凭params来重载一个方法，故注释掉了一个，再测试时注释掉另一个。）

using System;

namespace mypro
{
    class myclass1
    {
        static void test(int a, int b)
        {
            Console.WriteLine("a+b= {0}", a + b);
        }
       /* static void test(int[] list)
        {
            foreach(int i in list)
            {
                Console.Write("-{0}",i);
            }
        }*/
        static void test(params int[] list)
        {
            foreach (int i in list)
            {
                Console.Write("+{0}", i);
            }
        }
        static void Main()
        {
            test(1, 2);
            int[] a = new int[] { 1, 2, 3, 4, 5 };
            test(a);
            test(1, 23, 4, 5, 6);
            Console.ReadKey();
        }
    }
}

 

---

Array 类：

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

下表列出了 Array 类中一些最常用的属性：

IsFixedSize	获取一个值，该值指示数组是否带有固定大小
IsReadOnly	获取一个值，该值指示数组是否只读
Length	获取一个 32 位整数，该值表示所有维度的数组中的元素总数
LongLength	获取一个 64 位整数，该值表示所有维度的数组中的元素总数
Rank	获取数组的秩（维度）

下表列出了 Array 类中一些最常用的方法：

Clear	根据元素的类型，设置数组中某个范围的元素为零、为 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）继承。

实例： 

using System;
namespace ArrayApplication
{
    class MyArray
    {
       
        static void Main(string[] args)
        {
            int[] list = { 34, 72, 13, 44, 25, 30, 10 };

            Console.Write("原始数组： ");
            foreach (int i in list)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
           
            // 逆转数组
            Array.Reverse(list);
            Console.Write("逆转数组： ");
            foreach (int i in list)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();
           
            // 排序数组
            Array.Sort(list);
            Console.Write("排序数组： ");
            foreach (int i in list)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();

           Console.ReadKey();
        }
    }
}

当上面的代码被编译和执行时，它会产生下列结果：

原始数组： 34 72 13 44 25 30 10
逆转数组： 10 30 25 44 13 72 34
排序数组： 10 13 25 30 34 44 72