5.2 C# 数组声明与初始化全解

标签：5.2 C# 元素 数据类型 int 数组名 数组 new 全解

文章目录

• 5.2.1 C#数组声明
• • • 5.2.1 C# 数组声明
    • • 1. 声明数组的语法格式
      • 2. 声明一维数组的语法格式
      • • 格式1：声明但不初始化
        • 格式2：声明并初始化
        • • 方式1：使用 `new` 关键字
          • 方式2：省略 `new` 关键字
    • 总结
• 5.2.2 C# 数组的初始化
• • • 5.2.2 C# 数组的初始化
    • • 1. 声明并初始化数组
      • • 1.1 使用 `new` 关键字
        • 1.2 省略 `new` 关键字
      • 2. 声明后初始化数组
      • • 2.1 使用 `new` 关键字
        • 2.2 默认初始化
      • 3. 初始化多维数组
      • • 3.1 矩形数组
        • 3.2 锯齿数组
    • 总结
• 5.2.3 C# 数组元素的访问
• • • 5.2.3 C# 数组元素的访问
    • • 1. 访问一维数组的元素
      • • 1.1 获取数组元素
        • 1.2 修改数组元素
      • 2. 访问多维数组的元素
      • • 2.1 访问矩形数组的元素
        • 2.2 修改矩形数组的元素
        • 2.3 访问锯齿数组的元素
        • 2.4 修改锯齿数组的元素
      • 3. 遍历数组
      • • 3.1 遍历一维数组
        • 3.2 遍历矩形数组
        • 3.3 遍历锯齿数组
    • 总结

---

5.2.1 C#数组声明

5.2.1 C# 数组声明

1. 声明数组的语法格式

在C#中，声明数组的基本语法格式如下：

数据类型[] 数组名;

其中：

• 数据类型：表示数组中存储的元素类型，可以是任何有效的C#数据类型，如 int、double、string 等。
• []：方括号表示这是一个数组。
• 数组名：是你为数组选择的名称，遵循C#的变量命名规则。

2. 声明一维数组的语法格式

格式1：声明但不初始化

数据类型[] 数组名;

例如：

int[] numbers; // 声明一个整数数组
string[] names; // 声明一个字符串数组

在这种情况下，数组只是被声明了，但还没有分配内存空间。你需要使用 new 关键字来分配内存并初始化数组：

numbers = new int[5]; // 分配5个整数的内存空间
names = new string[3]; // 分配3个字符串的内存空间

格式2：声明并初始化

你可以在声明数组的同时初始化它，这是一维数组的常见做法。有两种方式：

方式1：使用 new 关键字

数据类型[] 数组名 = new 数据类型[数组长度] { 元素列表 };

例如：

int[] numbers = new int[5] { 1, 2, 3, 4, 5 }; // 声明并初始化一个包含5个整数的数组
string[] names = new string[3] { "Alice", "Bob", "Charlie" }; // 声明并初始化一个包含3个字符串的数组

方式2：省略 new 关键字

数据类型[] 数组名 = { 元素列表 };

例如：

int[] numbers = { 1, 2, 3, 4, 5 }; // 声明并初始化一个包含5个整数的数组
string[] names = { "Alice", "Bob", "Charlie" }; // 声明并初始化一个包含3个字符串的数组

这种方式更加简洁，编译器会自动推断数组的长度和类型。

总结

• 声明数组的基本语法：数据类型[] 数组名;
• 声明一维数组的两种格式：
  • 格式1：声明但不初始化，随后使用 new 关键字分配内存。
  • 格式2：声明并初始化，可以使用 new 关键字或省略 new 关键字。

这些语法格式帮助你在C#中灵活地声明和初始化一维数组，为后续的操作打下基础。

5.2.2 C# 数组的初始化

5.2.2 C# 数组的初始化

在C#中，数组的初始化是指在声明数组时或之后为其分配内存并设置初始值。初始化数组有多种方式，下面详细介绍这些方法。

1. 声明并初始化数组

1.1 使用 new 关键字

数据类型[] 数组名 = new 数据类型[数组长度] { 元素列表 };

示例：

int[] numbers = new int[5] { 1, 2, 3, 4, 5 }; // 声明并初始化一个包含5个整数的数组
string[] names = new string[3] { "Alice", "Bob", "Charlie" }; // 声明并初始化一个包含3个字符串的数组

1.2 省略 new 关键字

数据类型[] 数组名 = { 元素列表 };

示例：

int[] numbers = { 1, 2, 3, 4, 5 }; // 声明并初始化一个包含5个整数的数组
string[] names = { "Alice", "Bob", "Charlie" }; // 声明并初始化一个包含3个字符串的数组

2. 声明后初始化数组

2.1 使用 new 关键字

数据类型[] 数组名;
数组名 = new 数据类型[数组长度] { 元素列表 };

示例：

int[] numbers;
numbers = new int[5] { 1, 2, 3, 4, 5 }; // 声明后初始化一个包含5个整数的数组
string[] names;
names = new string[3] { "Alice", "Bob", "Charlie" }; // 声明后初始化一个包含3个字符串的数组

2.2 默认初始化

当你声明数组但没有立即初始化时，数组的每个元素会被自动初始化为其默认值。对于数值类型，默认值是0；对于引用类型，默认值是null。

示例：

int[] numbers = new int[5]; // 声明一个包含5个整数的数组，所有元素默认为0
string[] names = new string[3]; // 声明一个包含3个字符串的数组，所有元素默认为null

3. 初始化多维数组

3.1 矩形数组

数据类型[,] 数组名 = new 数据类型[行数, 列数] { { 行1元素列表 }, { 行2元素列表 }, ... };

示例：

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

3.2 锯齿数组

数据类型[][] 数组名 = new 数据类型[行数][];
数组名[0] = new 数据类型[行1长度] { 行1元素列表 };
数组名[1] = new 数据类型[行2长度] { 行2元素列表 };
...

示例：

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

总结

• 声明并初始化数组：

  • 使用 new 关键字：数据类型[] 数组名 = new 数据类型[数组长度] { 元素列表 };
  • 省略 new 关键字：数据类型[] 数组名 = { 元素列表 };

• 声明后初始化数组：

  • 使用 new 关键字：数据类型[] 数组名; 数组名 = new 数据类型[数组长度] { 元素列表 };
  • 默认初始化：数据类型[] 数组名 = new 数据类型[数组长度];

• 初始化多维数组：

  • 矩形数组：数据类型[,] 数组名 = new 数据类型[行数, 列数] { { 行1元素列表 }, { 行2元素列表 }, ... };
  • 锯齿数组：数据类型[][] 数组名 = new 数据类型[行数][]; 数组名[0] = new 数据类型[行1长度] { 行1元素列表 };

5.2.3 C# 数组元素的访问

5.2.3 C# 数组元素的访问

在C#中，数组元素的访问是通过索引来实现的。索引是一个整数值，用于指定数组中的特定位置。C#数组的索引从0开始，这意味着第一个元素的索引是0，最后一个元素的索引是数组长度减1。

1. 访问一维数组的元素

1.1 获取数组元素

数据类型 元素 = 数组名[索引];

示例：

int[] numbers = { 1, 2, 3, 4, 5 };
int firstElement = numbers[0]; // 获取第一个元素，值为1
int lastElement = numbers[numbers.Length - 1]; // 获取最后一个元素，值为5

1.2 修改数组元素

数组名[索引] = 新值;

示例：

int[] numbers = { 1, 2, 3, 4, 5 };
numbers[2] = 10; // 将第三个元素修改为10
Console.WriteLine(numbers[2]); // 输出10

2. 访问多维数组的元素

2.1 访问矩形数组的元素

数据类型 元素 = 数组名[行索引, 列索引];

示例：

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

int element = matrix[1, 2]; // 获取第二行第三列的元素，值为7
Console.WriteLine(element); // 输出7

2.2 修改矩形数组的元素

数组名[行索引, 列索引] = 新值;

示例：

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

matrix[1, 2] = 20; // 将第二行第三列的元素修改为20
Console.WriteLine(matrix[1, 2]); // 输出20

2.3 访问锯齿数组的元素

数据类型 元素 = 数组名[行索引][列索引];

示例：

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

int element = jaggedArray[1][2]; // 获取第二行第三列的元素，值为6
Console.WriteLine(element); // 输出6

2.4 修改锯齿数组的元素

数组名[行索引][列索引] = 新值;

示例：

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

jaggedArray[1][2] = 20; // 将第二行第三列的元素修改为20
Console.WriteLine(jaggedArray[1][2]); // 输出20

3. 遍历数组

3.1 遍历一维数组

使用 for 循环遍历一维数组：

for (int i = 0; i < 数组名.Length; i++)
{
    数据类型 元素 = 数组名[i];
    // 处理元素
}

示例：

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

3.2 遍历矩形数组

使用嵌套的 for 循环遍历矩形数组：

for (int i = 0; i < 数组名.GetLength(0); i++)
{
    for (int j = 0; j < 数组名.GetLength(1); j++)
    {
        数据类型 元素 = 数组名[i, j];
        // 处理元素
    }
}

示例：

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

for (int i = 0; i < matrix.GetLength(0); i++)
{
    for (int j = 0; j < matrix.GetLength(1); j++)
    {
        Console.WriteLine(matrix[i, j]);
    }
}

3.3 遍历锯齿数组

使用嵌套的 for 循环遍历锯齿数组：

for (int i = 0; i < 数组名.Length; i++)
{
    for (int j = 0; j < 数组名[i].Length; j++)
    {
        数据类型 元素 = 数组名[i][j];
        // 处理元素
    }
}

示例：

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

for (int i = 0; i < jaggedArray.Length; i++)
{
    for (int j = 0; j < jaggedArray[i].Length; j++)
    {
        Console.WriteLine(jaggedArray[i][j]);
    }
}

总结

• 访问一维数组的元素：使用 数组名[索引]。
• 访问多维数组的元素：
  • 矩形数组：使用 数组名[行索引, 列索引]。
  • 锯齿数组：使用 数组名[行索引][列索引]。
• 遍历数组：
  • 一维数组：使用 for 循环。
  • 矩形数组：使用嵌套的 for 循环。
  • 锯齿数组：使用嵌套的 for 循环，注意每个子数组的长度可能不同。

标签：5.2,C#,元素,数据类型,int,数组名,数组,new,全解
From： https://blog.csdn.net/Argonaut_/article/details/142491934