C#学习基础语法加深（二）

家和万事兴#

于 2022-05-16 16:04:41 发布

阅读量400

点赞数

分类专栏： C# 笔记文章标签： c# 学习开发语言

本文链接：https://blog.csdn.net/caoguanghui0804/article/details/121439737

版权

C# 同时被 2 个专栏收录

38 篇文章 2 订阅

订阅专栏

笔记

5 篇文章 0 订阅

订阅专栏

流程控制语句

选择语句

选择语句用于根据某个表达式的值从若干条给定语句中选择一个来执行。选择语句包括if语句和switch语句两种。

if…else语句

在if语句中，可以使用return语句退出if语句所在的类的方法中。

if(布尔表达式)
{
	【语句块】
}
else
{
	【语句块】
}

使用switch语句实现多分支选择

switch语句是多分支选择语句，它根据表达式的值来使程序从多个分支中选择一个用于执行的分支。
语法

case 【常量表达式】:【语句块】
break;
case 【常量表达式】:【语句块】
break;
...
case 【常量表达式】:【语句块】
default：【语句块】
break;

示例：

    static void Main(string[] args)
    {
        Console.WriteLine("请您输入一个月份："); //输出提示信息
        int MyMouth = int.Parse(Console.ReadLine());//声明一个int类型变量，用于获取输入的数据
        string MySeason;  //声明一个字符串变量
        switch (MyMouth)
        {
            case 12:
            case 1:
            case 2:
                MySeason = "您输入的月份属于冬季！";
                break;
            case 3:
            case 4:
            case 5:
                MySeason = "您输入的月份属于春季！";
                break;
            case 6:
            case 7:
            case 8:
                MySeason = "您输入的月份属于夏季！";
                break;
            case 9:
            case 10:
            case 11:
                MySeason = "您输入的月份属于秋季！";
                break;
            //如果输入的数据不满足以上4个分支的内容，则执行default语句
            default:
                MySeason = "月份输入错误";
                break;
        }
        Console.WriteLine(MySeason);
        Console.ReadLine();
    }

迭代语句

迭代语句主要用于重复执行嵌入语句，在C#中，常见的迭代语句有while语句、do…while语句、
for语句和foreach语句。

while语句

while语句用于根据条件值执行一条语句零次或多次，当每次while语句中的代码执行完毕时，将重新查看是否符合条件值，若符合则再次执行相同的程序代码；否则跳出while语句，执行其他程序代码。

while (【布尔表达式】)
{
【语句块】
}

示例1：

    static void Main(string[] args)
    {
        //声明一个int类型的数组，并初始化
        int[] myNum = new int[9] { 927, 112, 111, 524, 521, 2008, 1, 2, 3 };
        int s = 0;
        while (s < 9)
        {
            //输出数组中的值
            Console.WriteLine("myNum[{0}]的值为{1}",s,myNum[s]);
            s++; //s 自增1
        }
        Console.ReadLine();
    }

输出结果：
myNum[0]的值为927
myNum[1]的值为112
myNum[2]的值为111
myNum[3]的值为524
myNum[4]的值为521
myNum[5]的值为2008
myNum[6]的值为1
myNum[7]的值为2
myNum[8]的值为3

示例2 ：

    static void Main(string[] args)
    {
        //声明一个int类型的数组，并初始化
        int s = 0, num = 80; 
        while (s < num)
        {
            s++;  //s 自增1
            if (s > 40)
            {
                break;
            }
            if ((s % 2) == 0)  //调用id语句判断s是否为偶数
            {
                continue;   //使用continue语句将程序转到下一次循环
            }
            //输出数组中的值
            Console.WriteLine(s);
        }
        Console.ReadLine();
    }
输出结果：1~39的所有奇数

do…while语句和for语句

do…while语句与while语句相似，它的判断条件在循环后。do…while循环会在计算条件表达式之前执行一次，基本如下
for语句用于计算一个初始化序列，然后当某个条件为真时，重复执行嵌套语句并计算一个迭代表达式序列。如果为假则终止循环，退出for循环。

do
{
		【语句块】
}while (【布尔表达式】)

程序先执行【语句块】。
当程序到达【语句块】的结束点，计算【布尔表达式】的值。如果【布尔表达式】的值是true，程序转到do…while语句的开头；否则，结束循环。
示例：

 static void Main(string[] args)
    {
        bool term = false; //声明一个bool类型变量term，并初始化为false
        int[] myArray = new int[5] { 0, 1, 2, 3, 4 }; //声明一个int数组并初始化
        do
        {
            for (int i = 0; i < myArray.Length; i++) //调用for语句输出数组中的所有数据
            {
                Console.WriteLine(myArray[i]); //输出数组中的数据
            }
        } while (term);  
        Console.ReadLine();
    }

输出结果：
0
1
2
3
4

foreach语句

foreach语句用于枚举一个集合的元素，并对该集合中的每个元素执行一次嵌入语句。但是，foreach语句不应用于更改集合内容，以避免不可预知的错误。
foreach语句也可以用于循环访问数组中的元素。
示例：

   static void Main(string[] args)
    {
        ArrayList alt = new ArrayList();//实例化ArrayList类
        alt.Add("用一生下载你");
        alt.Add("高迷糊");
        alt.Add("天天睡不醒");
        Console.WriteLine("您写的名字有：");
        foreach (string Name in alt)  //使用foreach语句输出数据
        {
            Console.WriteLine(Name);  //输出ArrayList对象中的所有数据
        }
        Console.ReadLine();
    }

输出结果
您写的名字有：
用一生下载你
高迷糊
天天睡不醒

跳转语句

跳转语句主要用于无条件地转移控制，跳转语句会将控制转到某个位置，这个位置就成为跳转语句的目标。如果跳转语句出现在一个语句块内，二跳转语句的目标却在该语句块之外，则称该跳转语句退出该语句块。跳转语句主要包括break语句、continue语句、goto语句和return语句。

break语句

只能应用在switch、while、do…while、for或foreach语句中，break语句包含在这几种语句中，否则会出现编译错误。

continue语句

continue语句只能应用于while、do…while、for或foreach语句中，用来忽略循环语句块内位于它后面的代码而直接开始一次新的循环。当多个while、do…while、for或foreach语句互相嵌套时，continue语句只能使直接包含它的循环语句开始一次新的循环。

goto语句

goto语句用于将控制转移到由标签标记的语句。goto语句可以被应用在switch语句中的case标签和default标签，以及标记语句所表明的标签。goto语句的3中形式

goto 【标签】
goto case 【参数表达式】
goto default

示例：

 static void Main(string[] args)
    {
        Console.WriteLine("请输入要查找的文字:");
        string inputstr = Console.ReadLine();  //获取输入值
        string[] mystr = new string[5];
        mystr[0] = "用一生下载你";
        mystr[1] = "小迷糊";
        mystr[2] = "唯一";
        mystr[3] = "冉冉";
        for (int i = 0; i < mystr.Length; i++) //调用for循环语句
        {
            //通过if语句判断是否存在输入的字符串
            if (mystr[i].Equals(inputstr))
            {
                goto Found;
            }
        }
        Console.WriteLine("你查找的{0}不存在！",inputstr);
        goto Finish;
        Found:
        Console.WriteLine("你查找的{0}存在！",inputstr);
        Finish:
        Console.WriteLine("查找完毕！");

        Console.ReadLine();
    }

数组和集合

数组能够按一定的规律把相关的数据组织在一起，并能通过“索引”或“下标”快速地管理这些数据。集合也可以存储多个数据，C#中常用的集合包括ArrayList集合和Hashtable(哈希表)。

数组概述

数组是包含若干相同类型的变量，这些变量都可以通过索引进行访问。数组中的变量称为数组的元素，数组能够容纳元素的数量称为数组的长度。数组的每个元素都具有唯一的索引与其相对应，一个数组的索引从零开始。

一维数组的声明和使用

一维数组是最常用的数组类型，一维数组即数组的维数为1。
需要存储多个值时，可以使用一维数组，而且可以通过使用foreach语句或数组的下标将数组中的元素值读出来。
1.声明语法示例如下

type[] arrayName;

int[] arr;

2.初始化
数组的初始化有很多形式，可以通过new运算符创建数组，并将数组元素初始化为它们的默认值。

int[] arr=new int[5];//arr数组中的每个元素都初始化为0
int[] arr=new int[5]{1,2,3,4,5};
//不使用new运算符，直接对该数组进行初始化
string[] arrStr={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};

    static void Main(string[] args)
    {
        int[] arr = { 1, 2, 3, 4, 5 }; //定义一个一维数组，并为其赋值
        foreach (int n in arr) //使用foreach语句循环遍历一维数组中的元素
        {
            Console.WriteLine("{0}",n+""); 
        }
        Console.ReadLine();
    }
    输出结果
    1
    2
    3
    4
    5

二维数组的声明和使用

二维数组即数组的维数为2，它相当于一个表格。
1.声明语法如下
type[,] arrayName;
2.初始化
二维数组的初始化有两种形式，可以通过new运算符创建数组并将数组元素初始化为它们的默认值。

int[,] arr =new int[2,2]; //声明
int[,] arr =new int[,]{{1,2},{3,4}}; //初始化

    static void Main(string[] args)
    {
        int[,] arr = new int[2,2] { { 1, 2 }, { 3, 4 } }; //定义一个二维数组
        Console.WriteLine("数组的行数为：");
        Console.WriteLine(arr.Rank);  //获得二维数组的行数
        Console.WriteLine("\n");
        Console.WriteLine( "数组的列数为：");
        Console.WriteLine(arr.GetUpperBound(arr.Rank-1)+1);  //获取二维数组的列数
        Console.WriteLine("\n");
        
        for (int i=0; i< arr.Rank;i++) 
        {
            string str = "";
            for (int j = 0; j < arr.GetUpperBound(arr.Rank - 1) + 1; j++)
            {
                str = str + Convert.ToString(arr[i, j]) + "";  //循环输出二维数组中的每个元素
            }
            Console.WriteLine(str);
            Console.WriteLine("\n");
        }
        Console.ReadLine();
    }

动态二维数组的声明及使用

动态数组的声明实际上就是将数组的定义部分和初始化部分分别写在不同的语句中。动态数组的初始化也需要使用new关键字为数组元素分配内存空间，并为数组元素赋初值。
1.声明语法如下
type[] arrayName;
arrayName = new type[n1,n2,…]
2.初始化

int m=2;
int n=2;
int[,] arry2 = new int[m,n];

    static void Main(string[] args)
    {
        Console.Write("请输入动态数组的行数：");
        int row = Convert.ToInt32(Console.ReadLine()); //定义动态数组的行数
        Console.Write("请输入动态数组的列数");
        int col = Convert.ToInt32(Console.ReadLine()); //定义动态数组的列数
        int[,] arr = new int[row, col];  //根据定义的行数和列数定义动态数组
        Console.WriteLine("结果：");
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
            {
                Console.Write(i+j.ToString()+"");//输出动态数组中的元素
            }
            Console.ReadLine();
        }       
    }
    输出结果：
 请输入动态数组的行数：3
请输入动态数组的列数3
结果：
00 01 02

数组的基本操作

C#中的数组是由System.Array类派生而生的引用对象，因此可以使用Array类中的各种方法对数组进行各种操作。对数组的操作可以分为静态操作和动态操作，静态操作主要包括查找、遍历和排序等，动态操作主要包括插入、删除、合并和拆分等。

如何遍历数组

使用foreach语句可以实现数组的遍历功能，开发人员可以用foreach语句访问数组中的每个元素，而不需要确切地知道每个元素的索引号。

  static void Main()
    {
        int[] arr = new int[3] { 10, 20, 30 };
        //采用foreach语句对arr数组进行遍历
        foreach (int number in arr)
        {
            Console.WriteLine(number);
        }
        Console.ReadLine();
    }
    输出结果：
10
20
30

添加/删除数组元素

添加/删除数组元素就是在数组中的指定位置对数组元素进行添加和删除，添加数组元素一般是通过使用ArrayList类实现。

static void Main()
    {
        int[] arr = new int[4] { 10, 20, 30 ,40};
        //删除数组中的第二个元素
        int n = 1;
        for (int i = n; i < arr.Length - n; i++)
        {
            arr[i] = arr[i + 1];
            Console.WriteLine(arr[i]);
        }
        Console.ReadLine();
    }
输出结果：
30
40

对数组进行排序

排序是编程中最常用的算法之一，排序的方法有很多种，可以用遍历的方法对数组进行排序，也可以用Array类的Sort方法和Reverse方法对数组进行排序。
1.遍历排序的方法有很多种，如冒泡法、直接插入法和选择排序法等。
冒泡法示例：

    static void Main()
    {
        int[] arr = new int[] { 3, 9, 27, 6, 18, 12, 21, 15 };//定义一个一维数组，并赋值
        foreach (int m in arr)
            Console.Write(m+" ");
        Console.WriteLine();
        //定义两个int类型的变量，分别用来表示数组下标和存储新的数组元素
        int j,temp;
        for (int i = 0; i < arr.Length - 1; i++)  //根据数组下标的值遍历数组元素
        {
            j = i + 1;
        id:                           //定义一个标识，以便从这里开始执行语句
            if (arr[i] > arr[j])    //判断前后两个数的大小
            {
                temp = arr[i];     //将比较后大的元素赋值给定义的int变量
                arr[i] = arr[j];   //将后一个元素的值赋值给前一个元素
                arr[j] = temp;     //将int变量中存储的元素值赋值给后一个元素
                goto id;           //返回标识，继续判断后面的元素
            }
            else
                if (j < arr.Length - 1)   //判断是否执行到最后一个元素
            {
                j++;                      //如果没有，则再往后判断
                goto id;                  //返回标识，继续判断后面的元素
            }
        }
        foreach (int n in arr)            //循环遍历排序后的数组元素并输出
           Console.Write(n+" ");
        Console.WriteLine();
        Console.ReadLine();
    }
    输出结果：
3 9 27 6 18 12 21 15
3 6 9 12 15 18 21 27

插入法示例：

    static void Main()
    {
        int[] arr = new int[] { 3, 9, 27, 6, 18, 12, 21, 15 };//定义一个一维数组，并赋值
        foreach (int n in arr)      //循环遍历定义的一维数组，并输出其中的元素
            Console.Write("{0}", n + " ");
        Console.WriteLine();
        for (int i = 0; i < 6; ++i)
        {
            int temp = arr[i];  //定义一个int变量，并使用获得的数组元素值赋值
            int j = i;
            while ((j > 0) && (arr[j - 1] > temp))  //判断数组中的元素是否大于获得的值
            {
                arr[j] = arr[j - 1];    //如果是，则将后一个元素的值提前
                --j;
            }
            arr[j] = temp;             //最后将int变量存储的值赋值给最后一个元素
        }
        Console.WriteLine("排序后结果为：");
        foreach (int n in arr)    //循环访问排序后的数组元素并输出
            Console.Write("{0}",n +" ");
        Console.WriteLine();
        Console.ReadLine();
    }
    输出结果：
3 9 27 6 18 12 21 15
排序后结果为：
3 6 9 12 18 27 21 15

排序法示例：

    static void Main()
    {
        int[] arr = new int[] { 3, 9, 27, 6, 18, 12, 21, 15 };//定义一个一维数组，并赋值
        foreach (int n in arr)      //循环遍历定义的一维数组，并输出其中的元素
            Console.Write("{0}", n + " ");
        Console.WriteLine();
        int min;       //定义一个int变量，用来存储数组下标
        for (int i = 0; i < arr.Length-1; i++)  //循环访问数组中的元素值（除最后一个）
        {
            min = i;   //为定义的数组下标赋值
            for(int  j=i+1; j<arr.Length; j++)   //循环访问数组中的元素值（除第一个）
            {
                if (arr[j] < arr[min])       //判断相邻两个元素值的大小
                    min = j;
            }
            int t = arr[min];                  //定义一个int变量，用来存储比较大的数组元素值
            arr[min] = arr[i];                //将小的数组元素值移动到前一位
            arr[i] = t;                       //将int变量中存储的较大的数组元素值向后移
        }
        Console.WriteLine("排序后结果为：");
        foreach (int n in arr)    //循环访问排序后的数组元素并输出
            Console.Write("{0}", n + " ");
        Console.WriteLine();
        Console.ReadLine();
    }
    输出结果：
3 9 27 6 18 12 21 15
排序后结果为：
3 6 9 12 15 18 21 27

2.Array类的Sort和Reverse排序方法进行排序是非常麻烦的，而实际应用中会经常应用到数组的排序。

int[] arr=new int[] {3,9,27,6,18,12,21,15};
Array.Sort(arr);  //对数组元素排序

int[] arr =new int []{3,9,27,6,18,12,21,15};
Array.Reverse(arr);   //对数组元素反向排序

数组的合并与拆分

数组的合并与拆分在很多情况下都会被应用，在对数组进行合并或拆分时，数组与数组之间的类型应一致。

1.数组的合并
数组的合并实际上就是将多个一维数组合并成一个一维数组，或将多个一维数组合并成一个二维数组或多维数组。

        //两个一维数组合并成一个新的二维数组
        static void Main(string[] args)
        {
            //定义两个一维数组
            int[] arr1 = new int[] { 1, 2, 3, 4, 5};
            int[] arr2 = new int[] { 6, 7, 8, 9, 10 };
            int n = arr1.Length + arr2.Length;
            int[] arr3 = new int[n]; //根据定义的两个一维数组的长度和定义一个新的一维数组
            for (int i = 0; i < arr3.Length; i++) //将定义的两个一维数组中的元素添加到新的一维数组中
            {
                if (i < arr1.Length)
                    arr3[i] = arr1[i];
                else
                    arr3[i] = arr2[i - arr1.Length];
            }
            Console.WriteLine("合并后的一维数组：");
            foreach (int i in arr3)
                Console.Write("{0}", i + " ");
            Console.WriteLine();

            int[,] arr4 = new int[2, 5];  //定义一个要合并的二维数组
            for (int i = 0; i < arr4.Rank; i++)  //将两个一维数组循环添加到二维数组中
            {
                switch (i)
                {
                    case 0:
                        {
                            for (int j = 0; j < arr1.Length; j++)
                                arr4[i, j] = arr1[j];
                            break;
                        }
                    case 1:
                        {
                            for (int j = 0; j < arr2.Length; j++)
                                arr4[i, j] = arr2[j];
                            break;
                        }
                }
            }
            Console.WriteLine("合并后的二维数组：");
            for (int i = 0; i < arr4.Rank; i++)  //显示合并后的二维数组
            {
                for (int j = 0; j < arr4.GetUpperBound(arr4.Rank - 1) + 1; j++)
                    Console.Write(arr4[i, j] + " ");
                Console.WriteLine();
            }
            Console.ReadLine();
        }
输出结果：
合并后的一维数组：
1 2 3 4 5 6 7 8 9 10
合并后的二维数组：
1 2 3 4 5
6 7 8 9 10

2.数组的拆分
数组的拆分实际上就是将一个一维数组拆分成多个一维数组，或是将多维数组拆分成多个一维数组或多个多维数组。
示例

 static void Main(string[] args)
        {
            int[,] arr1 = new int[2, 3] { { 1, 3, 5 }, { 2, 4, 6 } };//定义一个二维数组，并赋值
            //定义两个一维数组，用来存储拆分的二维数组中的元素
            int[] arr2 = new int[3];
            int[] arr3 = new int[3];
            for (int i = 0; i < 2; i++)
            {
                for (int j = 0; j < 3; j++)
                {
                    switch (i)
                    {
                        case 0: arr2[j] = arr1[i, j];break;  //判断如果是第1行中的元素，则添加到第1个数组中
                        case 1: arr3[j] = arr1[i, j];break;  //判断如果是第2行中的元素，则添加到第2个数组中
                    }
                }
            }
            Console.WriteLine("数组一：");
            foreach (int n in arr2)    //输出拆分后的第1个一维数组
                Console.Write(n +"");
            Console.WriteLine();
            Console.WriteLine("数组二："); //输出拆分后的第2个一维数组
            foreach (int n in arr3)
                Console.Write(n + "");
            Console.WriteLine();

            Console.ReadLine();
        }

显示结果
数组一：
135
数组二：
246

ArrayList类

ArrayList类概述

ArrayList类位于System.Collections命名空间下，它可以动态地添加和删除元素。可以将ArrayList类看作扩充了功能的数组，但它并不等同于数组。
语法

ArrayList list =new ArrayList();

例：声明一个ArrayList对象，并给其添加10个int类型的元素值。

ArrayList List = new ArrayList(10);
for (int i=0;i<10;i++) //给ArrayList对象添加10个int元素
      List.Add(i);

                                       ArrayList的常用属性及说明

属性	说明
Capacity	获取或设置ArrayList可包含的元素数
Count	获取ArrayList中实际包含的元素数
IsFixedSize	获取一个值，该值指示ArrayList是否具有固定大小
IsReadonly	获取一个值，该值指示ArrayList是否为只读
IsSynchronized	获取一个值，该值指示是否同步ArrayList的访问
Item	获取或设置指定索引处的元素
SyncRoot	获取可用于同步ArrayList访问的对象

ArrayList元素的添加

向ArrayList集合中添加元素时，可以使用ArrayList类提供的Add方法和Insert方法。
Add方法：

            int[] arr = new int[] { 1, 2, 3, 4, 5, 6 };
            ArrayList List = new ArrayList(arr);  //使用声明的一维数组实例化一个ArrayList对象
            List.Add(7); //为ArrayList对象添加元素
            Console.WriteLine(List[1]);
            Console.ReadLine();

Insert方法：

            int[] arr = new int[] { 1, 2, 3, 4, 5, 6 };
            ArrayList List = new ArrayList(arr);  //使用声明的一维数组实例化一个ArrayList对象
            List.Insert(3, 7);//在ArrayList集合的指定位置添加一个元素
            for (int i = 0; i < List.Count; i++)
            {
                Console.WriteLine(List[i]);
            }        
            Console.ReadLine();