C#数组

通过数组(Array),可以一次定义一组变量。

一维数组

定义

语法:

类型[] 变量名;

数组继承自System.Array

数组是引用类型,默认值为null。

数组中的每一项叫做元素(element)。

定义一个数组

int[] array;

初始化

语法:

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

初始化一个数组

int[] array1 = new int[10];//定义10个元素的数组,每个元素都是默认值0
int[] array2 = new int{1,2,3};//定义3个元素的数组1,2,3。

读写数组元素

语法:

数组名[编号]

通过方括号中的编号,可以访问数组中的元素。编号又称作索引。

通过int Length{get;}属性访问数组的长度。

数组的索引从0开始,到Length-1

如果索引不在合法范围,会报IndexOutOfRangeException.

读写数组元素

int[] array = new int[10];
array[0] = 10;
int j = array[0];
int length = array.Length;
int k = array[10];//运行时错误

循环访问数组

配合循环,很容易访问数组的所有元素

循环访问数组

int[] array = new int[10];
for(int i = 0;i<array.Lenght;i++)
{
    Console.WriteLine(array[i]);
}

可以使用foreach来访问元素


int[] array = new int[10];
foreach(int item in array)
{
    Console.WriteLine(item);
}

多维数组

上面的数组只有一个索引,被称作1维数组,数组支持多个维度。数组的维度被称作秩(rank)。

多维数组定义

语法:

元素类型[,,,] 数组名

其中的逗号表示维数多少,1个表示2维,2个表示3维,以此类推。

定义二维数组

int[,] array;

多维数组初始化

语法:

数组名 = new 元素类型[第1维长度,第2维长度]
{
    第1维第1个元素,
    第1维第2个元素
}

初始化二维数组

int[,] array = new int[2,3]
{
    {1,2,3},
    {4,5,6}
}

读写多维数组

语法:

数组[第1维索引,第2维索引]

要读写数组的元素,需要指定每一维的索引。

每个维度索引都是从0开始的,每个维度的长度可以通过int GetLength(int rank)来获取。

如果任何一个维度的索引不在范围,会报IndexOutOfRangeException.

int[,] array = new int[2,3]
{
    {1,2,3},
    {4,5,6}
};

array[1,1] = 10;//设置值
int value = array[1,2];//访问值
int rank1 = array.GetLength(1);//获取第1维的长度
int rank2 = array.GetLength(2);//获取第2维的长度

循环访问多维数组

int[,] array = new int[2,3]
{
    {1,2,3},
    {4,5,6}
};

for(int i=0;i<array.GetLength(1);i++){
    for(int j=0;i<array.GetLength(2);j++){
        Console.Write(arrray[i,j] + " ");
    }
    Console.WriteLine();
}

通过foreach也可以访问多维数组,但是无法进行维度的区分。

交错数组

数组元素本身也可以是数组,就是数组的数组,简称交错数组。

定义一个交错数组

int[][] array;

这是一个数组,数组的每个元素也是数组。

初始化交错数组

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

定义了一个4个元素的数组,每个元素都是int[]类型。

没有为元素设置默认值,它们都保持null

int[][] array = new int[4][]{
    new int[3]{1,2,3},
    new int[2]{5,6},
    new int[4]{7,8,9,10},
    new int[1]{11}
};

初始化的时候可以为数组元素赋值。每个元素的数组的长度可以不一致。这也是被称作交错数组的原因。

读写交错数组

int[][] array = new int[4][]{
    new int[3]{1,2,3},
    new int[2]{5,6},
    new int[4]{7,8,9,10},
    new int[1]{11}
};

int j = array[3][1];
array[2][3] = 20;

通过多个方括号读写元素。

循环访问交错数组

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

array[0] = new int[3]{1,2,3};
array[1] = new int[2]{5,6};
array[3] = new int[4]{7,8,9,10};
array[4] = new int[1]{11};

for(int i=0;i<array.Length;i++){
    int[] item = array[i];
    if(item != null)
    {
        for(int j = item.Length;j++){
            Console.Write(item[j] + " ");
        }
    }
    else
    {
        Console.WriteLine();
    }
    Console.WriteLine();
}

一维数组和多维数组

通过计算索引,可以将1维数组当作多维数组使用。

int[] array = new int[2*3]
{
    1,2,3,
    4,5,6
};

for(int i=0;i<2;i++){
    for(int j=0;j<3;j++){
        int index = i * 3 + j;
        Console.Write(array[index]+" ");
    }
    Console.WriteLine();
}

多维数组不过是程序内部为我们做了计算。

多维数组和交错数组

多维数组在分配是就确定了元素数量,而且每个维度的元素数量是一致的。

交错数组的每个维度(也就是元素)可以分别进行初始化,每个维度的元素数量可以不同。

如果元素数量不固定,可以使用交错数组,更节省空间。

如果元素恒定,使用多维数组更好。

非0开始的数组

Array有静态方法CreateInstance(Type type,int lenght),也可以创建数组。

int[] array = (int[])Array.CreateInstance(typeof(int), 10);

重载的CreateInstance(Type type,int[] lengths,int[] lowerBounds)可以创建非0开始的数组。

Array array = Array.CreateInstance(typeof(int),new int[]{10}, new int[]{1});

非0开始的数组只能使用其基类Array来引用,不能够通过元素类型[]来引用。

在内部,非0开始数组的类型是元素类型[*],和一般定义的数组类型不兼容。

对于非0开始的数组,要通过数组的GetLowerBoundGetUpperBound获取数组的上下边界。

Array array = Array.CreateInstance(typeof(int),new int[] {10}, new int[]{1});

for(int i = array.GetLowerBound();i<=array.GetUpperBound();i++)
{
    Console.WriteLine(array[i]);
}

一般很少使用非0开始的数组,仅作为了解。

数组与IList

Array类型没有实现IList接口,但通过元素类型[]定义的数组,是实现了IList接口的。

虽然IList接口有Add,Remove方法,但数组的实现是无法使用的。