c# 循环给数组每个元素加个逗号_【自学C#】|| 笔记 14 数组的使用

一、foreach循环

    foreach 循环用于列举出集合中所有的元素，foreach 语句中的表达式由关键字 in 隔开的两个项组成。

    in 右边的项是集合名，in 左边的项是变量名，用来存放该集合中的每个元素。

    该循环的运行过程如下：每一次循环时，从集合中取出一个新的元素值。放到只读变量中去，如果括号中的整个表达式返回值为 true，foreach 块中的语句就能够执行。

    一旦集合中的元素都已经被访问到，整个表达式的值为 false，控制流程就转入到 foreach 块后面的执行语句。

    表达形式：

    foreach(数据类型  变量名  in  数组名)
    {
        //语句块；
    }

    例：

int[] a = {1,2,3,4,5};foreach(int a1 in a){  Console.WriteLine(a1);}

    分析：

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

        然后通过foreach进行循环。

        定义了一个int类型的变量a1，a是数组。

        然后进行输出。

        这里循环的次数，是数组的长度。从1开始。

            如果第一次循环输出，则相当于a[0]==1;

            如果第二次循环输出，则相当于a[1]==2；

            如果第三次循环输出，则相当于a[2]==3；

            如果第四次循环输出，则相当于a[3]==4；

            如果第五次循环输出，则相当于a[4]==5；

        这里变量名的数据类型必须与数组的数据类型相兼容。

        在 foreach 循环中，如果要输出数组中的元素，不需要使用数组中的下标，直接输出变量名即可。
        foreach 语句仅能用于数组、字符串或集合类数据类型。

    1.例

        在 Main 方法中创建一个 double 类型的数组，并在该数组中存入 5 名学生的考试成绩，计算总成绩和平均成绩。

class Program{    static void Main(string[] args)    {        double[] points = { 80, 88, 86, 90, 75.5 };        double sum = 0;        double avg = 0;        foreach(double point in points)        {            sum = sum + point;        }        avg = sum / points.Length;        Console.WriteLine("总成绩为：" + sum);        Console.WriteLine("平均成绩为：" + avg);    }}

分析：

    首先是定义了一个double类型的数组。

    然后又定义了两个double类型的变量。

    sum变量为总成绩，avg变量为平均成绩。

    然后通过foreach进行循环。

        point为新定义的变量，points为数组。

        逐一输出数组里的数，并叠加到sum变量中，得到总成绩。

    然后用 “总成绩sum”/“数组个数Points.Length”，来获得平均成绩。

    最后再进行输出函数输出。

    foreach的优势，就是在不知数组长度也能输出数组中的元素。

二、Split：将字符串拆分为数组

    Split 方法用于按照指定的字符串来拆分原有字符串，并返回拆分后得到的字符串数组。
    1.例：

    在 Main 方法中从控制台输入一个字符串，然后计算该字符串中包含的逗号的个数。

    根据题目要求，如果要查询逗号的个数，通过拆分方法 Split 将拆分结果存放到字符串数组中，数组的长度减 1 即为字符串中含有逗号的个数，代码如下。

class Program{    static void Main(string[] args)    {        string str = "a,b,c,d,e,f";        string[] condition = { "," };        string[] result = str.Split(condition, StringSplitOptions.None);        Console.WriteLine("字符串中含有逗号的个数为：" + (result.Length - 1));                foreach (string a1 in result) {                Console.Write(a1+"  ");            }    }}

分析：

    先手动输入一个字符串。

    然后又定义了一个字符串数组condition，作为以什么方式进行分隔。

        这里是以逗号进行分隔。

    第7行，就是把字符串进行了以“,”逗号的方式进行分隔。

    str.Split(condition, StringSplitOptions.None);

        第一个参数condition是拆分的条件数组，可以在该数组中存放多个字符串作为拆分的条件。
    第二个 参数 StringSplitOptions.None 是拆分的选项，表示如果在拆分时遇到空字符也拆分出一个元素。

    然后返回的是一个数组。

    2.例

        例如在上例中将 StringSplitOptions.None 更改成 StringSplitOptions.RemoveEmptyEntries, 语句如下。

class Program{    static void Main(string[] args)    {        Console.WriteLine("请输入一个字符串：");        string str = Console.ReadLine();        string[] condition = { "," };        string[] result = str.Split(condition, StringSplitOptions.RemoveEmptyEntries);        Console.WriteLine("字符串中含有逗号的个数为：" + (result.Length - 1));    }}

分析：

    其实就是把Split方法中的第二个参数换成了StringSplitOptions.RemoveEmptyEntries。

    也就是输入的字符串的逗号后面没有其他内容的话，会被忽略。

三、冒泡排序(Sort方法)

    就是对数组进行排序。

    在应聘的笔试题目中经常被考到，冒泡排序的原理是将数组元素中相邻两个元素的值进行比较，将较小的数放到前面，每一次交换都将最大的数放到最后，依次交换后最终将数组中的元素从小到大排序。

    1.例

    在 Main 方法中创建一个整型数组，并在该数组中存放 5 个元素，使用冒泡排序算法将数组中的元素从小到大排序。

class Program{    static void Main(string[] args)    {        int[] a = { 5, 1, 7, 2, 3 };        for(int i = 0; i < a.Length; i++)        {            for(int j = 0; j < a.Length - i - 1; j++)            {                if (a[j] > a[j + 1])                {                    int temp = a[j];                    a[j] = a[j + 1];                    a[j + 1] = temp;                }            }        }        Console.WriteLine("升序排序后的结果为：");        foreach(int b in a)        {            Console.Write(b + "");        }        Console.WriteLine();    }}

这是通过基础循环的方式来完成的冒泡排序。

    分析：

        首先是定义了一个数组。

        然后通过循环来进行逐一比较。

        在6~17行：

        首先是数组【5，1，7，2，3】

            外循环i=0时：

                内循环j=0时：

                    “数组a[0]” 跟 “数组a[1]”进行比较，也就是5>1是否成立，成立就进行交换。

                这时a[1]就等于5了。

                内循环j=1时：

                    “数组a[1]” 跟 “数组a[2]”进行比较，也就是5>7是否成立，不成立就放弃。

                因为没有成立，所以a[2]还是7。

                内循环j=2时：

                    “数组a[2]” 跟 “数组a[3]”进行比较，也就是7>2是否成立，成立就进行交换。

                这时a[3]就等于7。

                内循环j=3时：

                    “数组a[3]” 跟 “数组a[4]”进行比较，也就是7>3是否成立，成立就进行交换。

                这时a[4]就等于7。

                (因为这里是j跟j+1进行比较，所以在循环时，长度还需要-1。)

                (至于a.Length - i - 1，中的-i；也就是-0，是因为最大的数已经被放到最后了，所以就不用再跟最后的元素进行对比了。)

            这时数组其实就变成了【1，5，2，3，7】

            外循环i=1时：

                内循环j=0时：

                    “数组a[0]” 跟 “数组a[1]”进行比较，也就是1>5是否成立，不成立就放弃。

                所以a[1]，就是5.

                内循环j=1时：

                    “数组a[1]” 跟 “数组a[2]”进行比较，也就是5>2是否成立，成立就交换。

                所以a[2]变成了5。

                内循环j=2时：

                    “数组a[2]” 跟 “数组a[3]”进行比较，也就是5>3是否成立，成立就进行交换。

                所以a[3]变成了5。

            由于这时a.Length - i - 1;等价于 5-1-1 ==3.

            再加上是小于，不是小于等于。所以这里就循环0、1、2，不会到3.

            这时数组其实就变成了【1，2，3，5，7】

            外循环i=2时：

                内循环j=0时：

                    “数组a[0]” 跟 “数组a[1]”进行比较，也就是1>2是否成立，不成立就放弃。

                所以a[1]，就是2.

                内循环j=1时：

                    “数组a[1]” 跟 “数组a[2]”进行比较，也就是2>3是否成立，

不成立就放弃。

                所以a[1]，就是3.

            这时数组其实就变成了【1，2，3，5，7】    

            外循环i=3时：

                内循环j=0时：

                    “数组a[0]” 跟 “数组a[1]”进行比较，也就是1>2是否成立，不成立就放弃。

                所以a[1]，就是2.

                内循环j=1时：

                    “数组a[1]” 跟 “数组a[2]”进行比较，也就是2>3是否成立，

不成立就放弃。

                所以a[1]，就是3.

            这时数组其实就变成了【1，2，3，5，7】    

            外循环i=4时：

                内循环j=0时：

                    “数组a[0]” 跟 “数组a[1]”进行比较，也就是1>2是否成立，不成立就放弃。

                所以a[1]，就是2.

            然后由于外循环结束，所以最终输出的就是【1，2，3，5，7】    

        通过第一次循环得【5，1，7，2，3】

        通过第二次循环得【1，5，2，3】

        通过第三次循环得【1，2，3】

        通过第四次循环得【1，2】

        通过第四次循环得【1】

        可以看出，每一次循环，都会把最大数排到最后，并切掉最后一个元素。就好像后面的数比前面的数小，就会被平移到前面一样。

    2.例

     从大到小排序。

    只需要将 if(a[j]>a[j+1]) 语句更改成 if(a[j]

class Program{    static void Main(string[] args)    {        int[] a = { 5, 1, 7, 2, 3 };        for(int i = 0; i < a.Length; i++)        {            for(int j = 0; j < a.Length - i - 1; j++)            {                if (a[j] 1])                {                    int temp = a[j];                    a[j] = a[j + 1];                    a[j + 1] = temp;                }            }        }        Console.WriteLine("升序排序后的结果为：");        foreach(int b in a)        {            Console.Write(b + "");        }        Console.WriteLine();    }}

分析：

    就改动了第10行。

    所以你会看到：

        第一次循环结果为【5，7，2，3，1】

        第二次循环结果为【7，5，3，2，1】

        第三次循环结果为【7，5，3，2，1】

        第四次循环结果为【7，5，3，2，1】

    因为执行第二次循环后，就已经达到了从大到小排序，所以后面只是单纯的过一遍。

    3.例

    使用数组中的 Sort 方法完成对数组元素的排序。

class Program{    static void Main(string[] args)    {        int[] a = { 5, 3, 2, 4, 1 };        Array.Sort(a);        Console.WriteLine("排序后的结果为：");        foreach(int b in a)        {            Console.Write(b + " ");        }        Console.WriteLine();    }}

分析：

    这里使用了Sort方法，也就是将上面的排序部分代码打包成Sort方法函数，然后进行直接调用就好。

    4.System.Array 是所有数组的基类，其提供的属性和方法也可以被用到任何数组中。

    例如前面使用的 Length 属性也是该基类中提供的。
    数组中常用的方法如下表所示。

编号	方法	描述
1	Clear()	清空数组中的元素
2	Sort()	冒泡排序，从小到大排序数组中的元素
3	Reverse()	将数组中的元素逆序排列
4	IndexOf()	查找数组中是否含有某个元素，返回该元素第一次出现的位置，如果没有与之匹配的元素，则返回 -1
5	LastIndexOf()	查找数组中是否含有某个元素，返回该元素最后一次出现的位置

四、Reverse 方法

    虽然在数组中并没有提供对其降序排序的方法，但可以先将数组中的元素使用 Sort 排序,再使用 Reverse 方法将数组中的元素逆序，这样就完成了从大到小的排序。

    1.例

using System;using System.Linq;using System.Text.RegularExpressions;namespace ConsoleApplication11{    class Program    {        static void Main(string[] args)        {            int[] num = { 1, 3, 2, 4 };            num = num.Reverse().ToArray();            for (int i = 0; i < num.Length; i++)            {                Console.WriteLine(num[i]);            }            Console.ReadKey();        }    }}

分析：

    注意，在使用Reverse 方法时，需要导入包。

using System.Text.RegularExpressions;

    主要部分为12行代码，通过num = num.Reverse().ToArray();进行倒序，并且在存放进num数组中。

    也可以使用Array.Reverse(num);这种方式，直接倒叙。

例：

 static void Main(string[] args)        {            int[] num = { 1, 3, 2, 4 };            Array.Reverse(num);            for (int i = 0; i < num.Length; i++)            {                Console.WriteLine(num[i]);            }            Console.ReadKey();        }