C# 数组增加元素_【自学C#】|| 笔记 13 数组

上一章最后讲的是正则表达式做一下总结。

    总之就是通过“/d”这样的符号代替数字或字符什么的，然后通过“{n}”这种方式确定重复多少个，再通过“|”这样的符号进行或运算之类的判断。

    然后再通过Regex 类中的方法进行一些操作。

一、数组

    数组从字面上理解就是存放一组数，但在 C# 语言中数组存放的并不一定是数字，也可以是其他数据类型。

    在一个数组中存放的值都是同一数据类型的，并且可以通过循环以及数据操作的方法对数组的值进行运算或操作。
    数组中某个指定的元素是通过索引来访问的。

    所有的数组都是由连续的内存位置组成的。最低的地址对应第一个元素，最高的地址对应最后一个元素。
    C# 中数组从零开始建立索引，即数组索引从零开始。
    C# 中数组的工作方式与在大多数其他流行语言中的工作方式类似。但还有一些差异应引起注意。
    声明数组时，方括号[]必须跟在类型后面，而不是标识符后面。

        数组的大小不是其类型的一部分，这使得可以声明一个数组并向它分配 int 对象的任意数组，而不管数组长度如何。

    (总之这字数很多，所以还是看操作吧！)

二、一维数组

        1.定义数组，表达形式是：

            数据类型[] 数组名

        例：

int[] a;

        一维数组在数组中最常用，即将一组值存放到一个数组中，并为其定义一个名称，通过数组中元素的位置来存取值。

        2.初始化数组中的元素

            表达形式是：

            数据类型[]  数组名 = new  数据类型[长度];
            数据类型[]  数组名 = {值 1, 值 2, ...}
            数据类型[]  数组名 = new  数据类型[长度]{值 1，值 2,...}

        例：

int[] a = new int[5];int[] b = {0,1,2,3,4};int[] c = new int[5]{0,1,2,3,4};

        第一行：

            只声明的一个5个长度的数组，并没有赋值。

        第二行：

            采用简写的方式，直接赋值。长度赋值几个就是几个-1；

            因为从0开始计算。

        第三行：

            既定义了长度，又进行了赋值。

    注意：

        定义了长度，就不能赋值的数量超过长度的数量。

        定义的数据类型要一致。

        在使用数组时，必须要先进行赋值。

        定义了长度，但没有赋值的话，会被默认给定一个值。

            值类型的为0，引用类型的为null。

            int类型的，也就是值类型，所以是0.

            string字符串类型的，也就是引用类型，所以是null。

        3.数组的访问赋值

             表达形式是：

                   数据类型  变量名 = 数组名[元素]；

                   数组名[元素] = 值;

            例：

int[] a = new int[5];a[0] = 1;a[1] = 2;a[2] = 3;a[3] = 4;a[4] = 5;int b = a[0];

            第一行：

                先定义了一个长度为5的数组，但并没有直接赋值。

            第二行~第六行：

                对数组进行赋值。【】中括号里面的数为数组元素。

                如数组中第一个元素下标为0，第二个元素下标为1.

                依旧从0开始计算。

            第七行：

                a[0]表示数组中第一个元素的值，也就是1.

                并且将其赋值给新定义的变量b中。

                如果直接输出打印的话，到不需要再声明一个变量。

        4.例：

        有一个 int 类型的数组，输出数组中的第一个元素和最后一个元素，语句如下。

//定义 int 类型的数组int[] a = {1,2,3};//输岀数组中的一个元素Console.WriteLine(a[0]);//输出数组中的最后一个元素Console.WriteLine(a[a.Length-1]);

分析：

        这个就是先定义一个简化的已经赋值了的数组。

        然后通过”数组名“加”中括号和下标“来确定导出的数据，并直接打印。

        第6行：

           a.Length，输出的是数组的长度。

                这里由于是从1开始计算，所以需要-1；

                也就成了数组最后一个元素的”下标“。

            a[下标]，就是数组的最后一个元素了.

        5.例

        在 Main 方法中创建一个字符串类型的数组，并存入 5 个值，然后将数组中下标是偶数的元素输出。

class Program{    static void Main(string[] args)    {        string[] strs = { "aaa", "bbb", "ccc", "ddd", "eee" };        for(int i = 0; i < strs.Length; i = i + 2)        {            Console.WriteLine(strs[i]);        }    }}

分析：

    这里存的是一个字符串的数组。

    然后通过for循环进行输出。

        首先从i=0开始，因为数组的元素下标也是0.

        然后小于数组的长度，也就是strs.Length。

            因为是小于，而不是小于等于，所以这里并不需要-1；

        i=i+2；则表示0、2、4，间隔一个数进行输出。

        输出的是数组中的第 1 个、第 3 个、第 5 个元素

        6.例

        在 Main 方法中创建 int 类型数组，并从控制台输入 5 个值存入该数组中，最后将数组中的最大数输出。    

class Program{    static void Main(string[] args)    {        int[] a = new int[5];        Console.WriteLine("请输入5个整数：");        for(int i = 0; i < a.Length; i++)        {            a[i] = int.Parse(Console.ReadLine());//将字符串类型转换成整型        }        int max = a[0];//这里假设a[0]是最大的        for(int i = 1; i < a.Length; i++)        {            if (a[i] > max)            {                max = a[i];            }        }        Console.WriteLine("数组中最大值为：" + max);    }}

分析：

    首先是定义了一个长度5的数组a。

    然后打印一个字符串，作为提示。

    通过循环，来解决重复操作。

        即重复5次输入一个数值。

        Console.ReadLine()输入语句。返回的是一个字符串。

        int.Parse()，转换为int类型。将字符串转换成int数值类型。

    然后把数组第一个数先拿出来，作为比较的数值。

        并赋给一个新定义的变量Max。

    接下来又是不断的重复比较的过程。

        不过这里是从i=1的开始，因为a[0]这个数值已经被取出来放进了变量Max中。

        而循环内部的判断，也就是从数值第二个元素开始，如果大于变量Max，就把这个元素赋给变量Max，替换掉之前的数。

        如果条件不成立，所以也就不执行。

三、多维数组

    但比较常用的还是二维数组。

    1.定义多维数组，语法形式如下。

            数据类型[ , , ...]  数组名;

    例：

int[5,2] a;

    这是一个二维数组，可以理解成一个矩阵。5行*2列。

    2.创建多维数组并初始化
            数据类型[ , , ...]   数组名 = new  数据类型[m,n,...]  {{ , , ...},{ , , ...}};

    例：

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

    简写

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

    再简写

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

    再换个好读的写法。

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

    像不像一个，5*2的矩阵？

    而从上面定义的语法可以看出，它与一维数组的定义非常类似，每多一个维度则在定义时的[]中增加一个“,”。
    存取数组中的值也是将下标用“,”隔开。

    3.例

        在 Main 方法中定义一个存放学生成绩的二维数组，并将该数组中每个学生的成绩输出。

        根据题目要求，定义二维数组为 double 类型的，代码如下。

class Program{    static void Main(string[] args)    {        double[,] points = { { 90, 80 }, { 100, 89 }, { 88.5, 86 } };        for(int i = 0; i < points.GetLength(0); i++)        {            Console.WriteLine("第" + (i + 1) + "个学生成绩：");            for(int j = 0; j < points.GetLength(1); j++)            {                Console.Write(points[i, j] + " ");            }            Console.WriteLine();        }    }}

分析：

    这里是定义了double类型的二维数组，3*2的矩阵。

    然后通过for循环进行打印输出。就像是打印*号。

    points.GetLength(0)，这个表示外围数组的长度。也就是3.

     points.GetLength(1)，这个表示内部数组的长度。也就是2.

    然后进行输出。

    在遍历多维数组元素时使用 GetLength(维度) 方法能获取多维数组中每一维的元素，维度也是从 0 开始的，因此在该实例中获取数组中第一维的值时使用的是 points.GetLength(0)。

四、锯齿型数组

    即在多维数组中的每一维中所存放值的个数不同。

    锯齿型数组也被称为数组中的数组。

    表达形式：

        数据类型[][]  数组名 = new 数据类型[数组长度][];
        数组名[0] = new 数据类型[数组长度];

    例：

int[][] a = new int[5][];a[0] = new int[5];

     总之就是把一个数组当成一个整体去看。

    在这里，数据类型指的是整个数组中元素的类型，在定义锯齿型数组时必须要指定维度。

    1.例

    在 Main 方法中创建一个锯齿型数组，第一维数组的长度是 2、第二维数组的长度是 3、第三维数组的长度是 4，并直接向数组中赋值，最后输出数组中的元素。

class Program{    static void Main(string[] args)    {        int[][] arrays = new int[3][];        arrays[0] = new int[] { 1, 2 };        arrays[1] = new int[] { 3, 4, 5 };        arrays[2] = new int[] { 6, 7, 8, 9 };        for(int i = 0; i < arrays.Length; i++)        {            Console.WriteLine("输出数组中第" + (i + 1) + "行的元素：");            for(int j=0;j            {                Console.Write(arrays[i][j] + " ");            }            Console.WriteLine();        }    }}

分析：

    这里可以把int[][] arrays = new int[3][];

        看成int[] arrays = new int[];

        或者说，这是一个行为3，列为自定义的二维数组。

        再或者说，是数组的数组。

    总之再定义了int[][] arrays = new int[3][];后，

        就把arrays摘出来，再声明一个数组。

        因为之前已经定义了长度为3的数组，所以这回就只能往里面定义3个。

    然后通过for循环进行输出。

        外层输出个数，内层输出的是之前的数值。

        运行结果：

    1.锯齿型数组中的值也可以通过循环语句来赋值，与输岀语句类似。

    在上面的实例中, arrays 数组中的元素从控制台输入的具体语句如下。

int[][] arrays = new int[3][];arrays[0] = new int[2];arrays[1] = new int[3];arrays[2] = new int[4];for(int i = 0; i < arrays.Length; i++){    Console.WriteLine("输入数组中第" + (i + 1) + "行的元素：");    for(int j=0;j<arrays[i].Length; j++)    {        arrays[i][j] = int.Parse(Console.ReadLine());    }    Console.WriteLine();}

分析：

    首先是定义，外层定义好了后，再定义内层的长度。

    再通过循环逐一赋值。

    而这种数组的优势，其实就是更好的控制内层数组的个数，避免资源的浪费。