C# 的数组定义，访问，及相关方法汇总（学习心得 14）

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

超级小白友好，讲解C#基础，每集5分钟轻松学习，拒绝从入门到放弃！

超级小白友好，讲解C#基础，每集5分钟轻松学习，拒绝从入门到放弃！

一、声明数组

语法：

datatype[] arrayName;

参数：

• datatype：元素的数据类型
• []：表示数组（这里不能填写数组大小！）
• arrayName：数组名称

例：

double[] balance;

二、初始化数组

数组是一个引用类型。

需要使用 new 关键词来创建数组实例，以达到初始化。

例：

double[] balance = new double[10];

三、数组赋值

创建一个数组时，C# 编译器会根据数组类型隐式初始化每个数组元素为一个默认值。

例如，int 数组的所有元素都会被初始化为 0。

3.1 初始化后，利用索引赋值

例：

double[] balance = new double[10];
balance[0] = 4500.0;

3.2 声明的同时赋值

这里用大括号。

例：

double[] balance = { 2340.0, 4523.69, 3421.0};

3.3 初始化的同时赋值

例：

int [] marks = new int[5]  { 99,  98, 92, 97, 95};

3.4 省略数组大小

例：

int [] marks = new int[]  { 99,  98, 92, 97, 95};

3.5 把一个数组赋值给另一个数组

例：

int [] marks = new int[]  { 99,  98, 92, 97, 95};
int[] score = marks;

四、访问数组元素

索引从 0 开始。

例：

double salary = balance[9];

4.1 for 循环访问

例：综合声明，赋值，访问

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


         // 赋值
         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

4.2 foreach 循环访问

这样的访问方式不需要知道数组长度。

例：

using System;

namespace ArrayApplication
{
   class MyArray
   {
      static void Main(string[] args)
      {
         int []  n = new int[10]; 
   
         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();
      }
   }
}

运行结果：

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

五、数组的重要细节

5.1 多维数组

二维数组：

string [,] names;

三维数组：

int [ , , ] m;

5.1.1 初始化二维数组

例：

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

2 层大括号。

第一层表示第一个维度，第二层表示第二个维度。

5.1.2 访问二维数组元素

表示方法：

int val = a[2,3];

例：

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

5.2 交错数组

数组的元素也是数组。

声明方法：

int [][] scores;

初始化并赋值：

int[][] scores = new int[2][]{new int[]{92,93,94},new int[]{85,66,87,88}};

scores 是一个由两个整型数组组成的数组。

scores[0] 是一个带有 3 个整数的数组。

scores[1] 是一个带有 4 个整数的数组。

例：

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

5.3 传递数组给函数

过指定不带索引的数组名称，来给函数传递一个指向数组的指针。

例：

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

5.4 参数数组

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

这里使用 params 关键字：

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

例：

using System;

namespace ArrayApplication
{
   class ParamArray
   {
      public int AddElements(params int[] arr)
      {
         int sum = 0;
         foreach (int i in arr)
         {
            sum += i;
         }
         return sum;
      }
   }
     
   class TestClass
   {
      static void Main(string[] args)
      {
         ParamArray app = new ParamArray();
         int sum = app.AddElements(512, 720, 250, 567, 889);
        // 相当于把 512, 720, 250, 567, 889 这 5 个参数传递给 int[] arr 这个数组
         Console.WriteLine("总和是： {0}", sum);
         Console.ReadKey();
      }
   }
}

运行结果：

总和是： 2938

5.5 数组 Array 类的属性和方法

Array 类是 C# 中所有数组的基类，它是在 System 命名空间中定义。

5.5.1 Array 类的属性

常用属性：

序号	属性 & 描述
1	IsFixedSize 获取一个值，该值指示数组是否带有固定大小。
2	IsReadOnly 获取一个值，该值指示数组是否只读。
3	Length 获取一个 32 位整数，该值表示所有维度的数组中的元素总数。
4	LongLength 获取一个 64 位整数，该值表示所有维度的数组中的元素总数。
5	Rank 获取数组的秩（维度）。

5.5.2 Array 类的方法

常用方法：

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