CS2L3——数组

本章代码关键字

1
2
3
4
5
array[]                //通过索引获取数组中的某个元素
array[,]            //二维数组
array[][]            //二维或者交错数组
array.Length        //获取数组所有元素的长度
array.GetLength()    //获取某一行（传入0）或者某一列（传入1，二维数组才能获取列数）的长度

数组

数组是存储一组相同类型数据的集合，数组分为一维、多维、交错数组
一般情况下，一维数组就简称为数组

  1. 概念：同一变量类型的连续的数据集合
  2. 一定要掌握的知识：申明，遍历，增删查改
  3. 所有的变量类型都可以申明为数组
  4. 她是用来批量存储游戏中的同一类型对象的容器，比如，所有的怪物，所有玩家

数组的申明

1
变量类型[] 数组名;    //这只是申明一个数组，但是并没有为其开辟内存空间

变量的类型，可以是我们学过的，或者没学过的，所有变量类型

以下是5种数组声明方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int[] arr1;

// 变量类型[] 数组名 = new 变量类型[数组的长度];
int[] arr2 = new int[5];                        //这种方式相当于开了五个房间 但是房间里的int值默认为0

// 变量类型[] 数组名 = new 变量类型[数组的长度]{内容1，内容2，内容3...};
int[] arr3 = new int[5] { 1, 2, 3, 4, 5 };      //如果要用这种命名方式就必须要在大括号内填入和长度一样多的数据

// 变量类型[] 数组名 = new 变量类型[]{内容1，内容2, 内容3...}
int[] arr4 = new int[] { 1, 2, 3, 4, 5, 6 };    //一开始不申明数组长度，用后面的数量决定数组的长度

// 变量类型[] 数组名 = {内容1，内容2, 内容3...}
int[] arr5 = { 1, 3, 4, 5, 6 };                 //用后面的数量决定数组的长度

//注意：数组内一定要用一样的数据类型
bool[] arr6 = { true, false, true };

数组的使用

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

获得数组的长度

1
Console.WriteLine(array.Length);

获取数组中的元素

数组中的下标和索引 他们是从****​0​​开始的！！！！！ 通过索引下标取获得数组中的某一个元素值时，
一定注意！！！！！！！！！不能越界，界限是​​0 ~ array.Length-1​​

修改数组中的元素

通过下标填入指定的索引值来决定修改数组的哪个元素

1
2
array[0] = 99;
Console.WriteLine(array[0]);

遍历数组

通过循环快速获得数组中的每一个元素

1
2
3
4
for (int i = 0; i < array.Length; i++)
{
    Console.WriteLine(array[i]);
}

增加数组的元素

数组初始化以后是不能够直接添加新元素的，只能搬家，盖新房子
（重新申请一个更大的内存空间，然后将以前的数组的元素全部转移过去，再让变量指向新数组，最后添加新的元素）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//盖新房子
int[] array2 = new int[6];
//搬家
for (int i = 0; i < array.Length; i++)
{
    array2[i] = array[i];
}
//让变量名指向新开的内存区，原内存会被自动回收
array = array2;
for (int i = 0;i < array.Length; i++)
{
    Console.WriteLine(array[i]);
}
//添加新元素
array[5] = 999;

删除数组的元素

同样数组初始化以后，数组初始化以后 是不能够直接删除元素的，只能搬家
（重新申请一个更大的内存空间，然后将以前的数组中需要保留的元素全部转移过去，再让变量指向新数组）

1
2
3
4
5
6
7
8
int[] array3 = new int[5];
//搬家
for (int i = 0; i < array3.Length; i++)
{
    array3[i] = array[i];
}
array = array3;
Console.WriteLine(array.Length);

查找数组中的元素

在 { 99, 2, 3, 4, 5 }​ 这个数组中
要查找 3​ 这个元素在哪个位置，只有通过遍历才能确定数组中是否存储了一个目标元素

1
2
3
4
5
6
7
8
9
10
int a = 3;

for (int i = 0; i < array.Length; i++)
{
    if( a == array[i] )
    {
        Console.WriteLine("和a相等的元素在{0}索引位置", i);
        break;
    }
}

二维数组

二维数组是使用两个下标（索引）来确定元素的数组，两个下标可以理解为 行标 和 列标，
二维数组也可以说是同一变量类型的行列数据集合

所有的变量类型都可以声明对应的二维数组，游戏中一般用来存储矩阵，或者表示地图格子这些

例如矩阵：

1
2
{ { 1, 2, 3 },
  { 4, 5, 6 } }

可以用二维数组 int[2, 3]​ 表示，就好比两行三列的数据集合，二维数组的数据在内存内的存储类似于：

1
2
3
4
此时内存相当于：
 0     1     2        行号
 0 1 2 0 1 2 0 1 2    列号
 1 2 3 4 5 6 7 8 9    内存条内存储的数据

​image​

二维数组的申明

  1. ​变量类型[,] 二维数组变量名;​

    1
    int[,] arr;        //申明过后要在后面初始化

  2. ​变量类型[,] 二维数组变量名 = new 变量行[行,列];​

    1
    int[,] arr2 = new int[3, 3];

  3. ​变量类型[,] 二维数组变量名 = new 变量行[行,列]{{0行内容1,0行内容2,...},{1行内容1,1行内容2,...},{2行内容1,2行内容2,...},...};​

    1
    2
    3
    int[,] arr3 = new int[3, 3] { { 1, 2, 3 },
                                  { 4, 5, 6 }, 
                                  { 7, 8, 9 } };    //可以换行已让申明更加直观

  4. 在 new​ 时候，可以一开始不在 []​ 内写死几行几列，而是由后面的内容决定几行几列

    1
    2
    3
    int[,] arr4 = new int[, ] { { 1, 2, 3 },
                                { 4, 5, 6 },
                                { 7, 8, 9 } };  //可以一开始不写死几行几列，而是由后面的内容决定几行几列

  5. ​变量类型[,] 二维数组变量名 = {{0行内容1,0行内容2,...},{1行内容1,1行内容2,...},{2行内容1,2行内容2,...},...};​

    1
    2
    3
    int[,] arr5 = { { 1, 2, 3 },
                    { 4, 5, 6 },
                    { 7, 8, 9 } };

二维数组的使用

  1. 获取长度

    1
    2
    3
    4
    5
    6
    7
    int[,] array = new int[,] { { 1, 2, 3 },
                                { 4, 5, 6 }, };
    //二维数组的长度
    //我们要获取行和列分别是多长
    Console.WriteLine(array.GetLength(0));  //得到多少行
    Console.WriteLine(array.GetLength(1));  //得到多少列
    Console.WriteLine(array.Length);        //得到多少个

    输出：

    1
    2
    3
    2
    3
    6

  2. 获取二维数组中的元素

    通过下标即可获取

    注意！第一个元素的索引一定是0！！！，不能越界！！！，最后一个长度的索引 肯定是长度减1，即 array.Length - 1​

    1
    2
    3
    4
    5
    6
    int[,] array = new int[,] { { 1, 2, 3 },
                                { 4, 5, 6 }, };
    //获取二维数组中的元素
    //注意：第一个元素的索引一定是0！！！，不能越界！！！，最后一个长度的索引 肯定是长度减1
    Console.WriteLine(array[0, 1]);
    Console.WriteLine(array[1, 2]);

    输出：

    1
    2
    2
    6

  3. 修改二维数组中的元素

    通过下标赋值即可修改

    1
    2
    3
    4
    5
    int[,] array = new int[,] { { 1, 2, 3 },
                                { 4, 5, 6 }, };
    //修改二维数组中的元素
    array[0, 0] = 99;
    Console.WriteLine(array[0, 0]);

    输出：

    1
    99

  4. 遍历二维数组

    看到二维数组就要知道要用两层 for​ 循环

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    int[,] array = new int[,] { { 1, 2, 3 },
                                { 4, 5, 6 }, };
    //修改二维数组中的元素
    array[0, 0] = 99;

    //遍历二维数组（看到二维数组就要知道要用两层for循环）
    for (int i = 0; i < array.GetLength(0); i++)
    {
        for (int j = 0; j < array.GetLength(1); j++)
        {
            //i 行 0 1
            //j 列 0 1 2
            Console.Write(array[i, j]);
            Console.Write("\t");
            //就可以打印出 0,0 0,1 0,2,1,0 1,1 1,2
        }
        Console.WriteLine();
    }

    输出：

    1
    2
    99      2       3
    4       5       6

  5. 增加数组的元素

    数组初始化以后是不能够直接在原有的基础上添加新元素的，只能搬家

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    int[,] array = new int[,] { { 1, 2, 3 },
                                { 4, 5, 6 }, };

    //修改二维数组中的元素
    array[0, 0] = 99;

    //增加数组中的元素
    int[,] array2 = new int[3, 3];
    //将原数组内容复制到新数组
    for (int i = 0; i < array.GetLength(0); i++)
    {
        for (int j = 0; j < array.GetLength(1); j++)
        {
            array2[i, j] = array[i, j];
        }
    }
    array = array2;
    array2[2, 0] = 7;
    array2[2, 1] = 8;
    array2[2, 2] = 9;
    for (int i = 0; i < array.GetLength(0); i++)
    {
        for (int j = 0; j < array.GetLength(1); j++)
        {
            //i 行 0 1
            //j 列 0 1 2
            Console.Write(array[i, j]);
            Console.Write("\t");
            //就可以打印出 0,0 0,1 0,2,1,0 1,1 1,2
        }
        Console.WriteLine();
    }

    输出：

    1
    2
    3
    99      2       3
    4       5       6
    7       8       9

  6. 删除数组的元素

    数组初始化以后是不能够直接在原有的基础上直接删除元素的，只能搬家

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    int[,] array = new int[,] { { 1, 2, 3 },
                                { 4, 5, 6 }, };

    //修改二维数组中的元素
    array[0, 0] = 99;

    //增加数组中的元素
    int[,] array2 = new int[3, 3];
    //将原数组内容复制到新数组
    for (int i = 0; i < array.GetLength(0); i++)
    {
        for (int j = 0; j < array.GetLength(1); j++)
        {
            array2[i, j] = array[i, j];
        }
    }
    array = array2;
    array2[2, 0] = 7;
    array2[2, 1] = 8;
    array2[2, 2] = 9;

    //删除数组的元素
    int[,] array3 = new int[2, 3];
    //将原数组内容复制到新数组
    for(int i = 0;i < array3.GetLength(0); i++)
    {
        for(int j = 0;j < array3.GetLength(1); j++)
        {
            array3[i, j] = array[i, j];
        }
    }
    array = array3;
    for (int i = 0; i < array.GetLength(0); i++)
    {
        for (int j = 0; j < array.GetLength(1); j++)
        {
            //i 行 0 1
            //j 列 0 1 2
            Console.Write(array[i, j]);
            Console.Write("\t");
            //就可以打印出 0,0 0,1 0,2,1,0 1,1 1,2
        }
        Console.WriteLine();
    }

    输出：

    1
    2
    99      2       3
    4       5       6

  7. 查找数组中的元素

    如果要在数组中查找有关元素是否等于某个值，需要通过遍历的形式去查找

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

    int a = 3;
    for (int i = 0; i < array.GetLength(0) ; i++)
    {
        for (int j = 0 ; j < array.GetLength(1) ; j++)
        {
            if (a == array[i, j])
            {
                Console.Write("和a相等的元素在[{0},{1}]索引位置", i, j);
            }
        }
    }

    输出：

    1
    和a相等的元素在[0,2]索引位置

交错数组

交错数组是数组的数组，每个维度的数量可以不同，或者说交错数组是存储同一类型的固定数量行而不确定列的数组
所有变量类型都可以申明为交错数组，交错数组一般很少使用

注意：二维数组的每行的列数，交错数组每行的列数可能不同

交错数组的申明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//变量类型[][] 交错数组名;
int[][] arr1;

//变量类型[][] 交错数组名 = new 变量类型[行数][]; （列数不能直接写！！！）
int[][] arr2 = new int[3][];

//变量类型[][] 交错数组名 = new 变量类型[行数][]{一维数组1,一维数组2,...};
int[][] arr3 = new int[3][] {new int[] {1, 2, 3},
                             new int[] {1, 2},
                             new int[] {1} }; //可见行数必须一致，但列数可以不一致

//变量类型[][] 交错数组名 = new 变量类型[][]{一维数组1,一维数组2,...};
int[][] arr4 = new int[][] {new int[] {1, 2, 3},
                            new int[] {1, 2},
                            new int[] {1} };

//变量类型[][] 交错数组名 = {一维数组1,一维数组2,...};
int[][] arr5 = {new int[] {1, 2, 3},
                new int[] {1, 2},
                new int[] {1} };

交错数组的使用

  1. 获取数组的长度

    注意，交错数组的列数获取和二维数组不一样，需要想获取对应的行，再通过行得到这一行的列数

    1
    2
    3
    4
    5
    6
    7
    int[][] array = {new int[] {1, 2, 3},
                     new int[] {4, 5} };
    //数组的长度
    //行
    Console.WriteLine(array.GetLength(0));
    //得到某一行的列数（比较特殊）
    Console.WriteLine(array[0].Length);

    输出：

    1
    2
    2
    3

  2. 获取交错数组的元素

    注意！第一个元素的索引一定是0！！！，不能越界！！！，最后一个长度的索引 肯定是长度减1，即 array.Length - 1​

    1
    2
    3
    int[][] array = {new int[] {1, 2, 3},
                     new int[] {4, 5} };
    Console.WriteLine(array[0][1]);

    输出：

    1
    2

  3. 修改交错数组的元素

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

    //修改交错数组的元素
    array[0][1] = 99;
    Console.WriteLine(array[0][1]);

    输出：

    1
    99

  4. 遍历交错数组

    和二维数组遍历方法一致

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    int[][] array = {new int[] {1, 2, 3},
                     new int[] {4, 5} };
    //修改交错数组的元素
    array[0][1] = 99;

    //遍历交错数组
    for (int i = 0; i < array.GetLength(0); i++)
    {
        for (int j = 0; j < array[i].Length; j++)
        {
            Console.Write(array[i][j] + "\t");
        }
        Console.WriteLine();
    }

    输出：

    1
    2
    1       99      3
    4       5

交错数组的增删查改的步骤，和二维数组一致，直接参考二维数组即可