✋编程题  
输⼊n(n<100)个数，找出其中最⼩的数，将它与最前⾯的数交换后输出这些数。  
```c#
            //35 33 45 56 2 131 435 
            string str = Console.ReadLine();
            string[] strArray = str.Split(" ");
            int[] intArray = new int[strArray.Length];
            for(int i = 0; i < strArray.Length; i++)
            {
                int number = Convert.ToInt32(strArray[i]);
                intArray[i] = number;
            }   //得到一个有序的数组
            
            int min = intArray[0];//4
            int minIndex = 0;
            for(int i = 1; i < intArray.Length; i++)
            {
                if (intArray[i] < min)
                {
                    min = intArray[i];
                    minIndex = i;
                }
            }
            int temp = intArray[0];
            intArray[0] = intArray[minIndex];
            intArray[minIndex] = temp;
            foreach(int t in intArray)
            {
                Console.Write(t + " ");
            }
            

```  
            
             
            
插入X =6     →→→→    **2** 35 33 45 56 **6** 131 435   

✋编程题  
有n(n<=100)个整数，已经按照从⼩到⼤顺序排列好，现在另外给⼀个整数x，请将该数插⼊到序列中，并使新的序列仍然有序。   
3 5 34 56 123 456  
插入x = 10  

输出新的序列  
3 5 10 34 56 123 456  
```c# 
            string str = Console.ReadLine();
            string[] strArray = str.Split(" ");
            int[] intArray = new int[strArray.Length];
            for (int i = 0; i < strArray.Length; i++)
            {
                int number = Convert.ToInt32(strArray[i]);
                intArray[i] = number;
            }   //得到一个有序的数组
            
            int x = Convert.ToInt32(Console.ReadLine());
            int m = intArray.Length - 1; 
            for (int i = 0; i < intArray.Length-1; i++)
            {
                if(x>=intArray[i] && x <= intArray[i + 1])
                {
                    m = i;
                    break;
                }
            }
            if (x < intArray[0])
            {
                m = -1;
            }
            //创建一个新的数组
            int[] intArrayNew = new int[intArray.Length + 1];
            //0-m = 0~-1    
            for (int i = 0; i < m+1; i++)
            {
                intArrayNew[i] = intArray[i];
            }
            intArrayNew[m + 1] = x;  //插入X值
            //m+1~length-1 的数移动到新数组
            for(int i = m + 1; i < intArray.Length; i++)
            {
                intArrayNew[i+1] = intArray[i];
            }
            foreach(int temp in intArrayNew)
            {
                Console.Write(temp + " ");
            }
```  

✋编程题  
输⼊⼀个字符串，判断其是否是C#的合法标识符。  
```c#
            string str = Console.ReadLine();
            // 判断 数字 字母 _
            // 数字开头
            bool isRight = true;
            for(int i = 0; i < str.Length; i++)
            {
               if( (str[i]<'0' || str[i]>'9') && //不是数字
               (str[i] < 'a' || str[i] > 'z') && //不是小写字母
               (str[i] < 'A' || str[i] > 'Z') && //不是大写字母
               (str[i] != '_'))                  //不是下划线
               {
                   isRight = false;
                   break;
               }
            }
            if(str[0] >= '0' && str[0] <= '9')  //不是数字开头
            {
               isRight = false;
            }
            if (isRight)
            {
               Console.WriteLine("是合法标识符");
            }
            else
            {
               Console.WriteLine("不是合法标识符");
            }
```  

✋编程题  
“回⽂串”是⼀个正读和反读都⼀样的字符串，⽐如“level”或者“noon”等等就是回⽂串。请写⼀个程序判断读⼊的字符串是否是“回⽂”。  
```c#
            string str = Console.ReadLine();
            // 8  8/2=4  0-3
            // 7  7/2=3  0-2
            // 7
            // 0 - 6  1-5  2-4    i ~ length-1-i
            bool isHui = true;
            for(int i = 0; i < str.Length / 2; i++)
            {
               // i  length-1-i
               if(str[i]!=str[str.Length - 1 - i])
               {
                   isHui = false;
                   break;
               }
            }
            if (isHui)
            {
               Console.WriteLine("是回文串");
            }
            else
            {
               Console.WriteLine("不是回文串");
            }
```  

✋编程题  
最近夏⽇炎热，令张三⾮常的不爽。最近张三开始研究天⽓的变化。历经千⾟万苦，他收集了连续N（1<N<1000000）天的最⾼⽓温数据。现在他想知道⽓温⼀直上升的最⻓连续天数。  
样例输⼊：  
1 3 5 2 3 5 7 8 6 9  
样例输出  
5  
```c#
            string str = Console.ReadLine();
            string[] strArray = str.Split(" ");
            int[] intArray = new int[strArray.Length];
            for (int i = 0; i < strArray.Length; i++)
            {
               int number = Convert.ToInt32(strArray[i]);
               intArray[i] = number;
            }  //获得一组数字
            
            int maxDays = 1;//记录最高 气温连续升高的天数
            int count = 1;//记录气温连续升高的天数
            for(int i = 0; i < intArray.Length - 1; i++)
            {
               if (intArray[i] < intArray[i + 1])
               {
                   count++;
               }
               else
               {
                   if (count > maxDays)
                   {
                       maxDays = count;
                   }
                   count = 1;
               }
            }
            if (count > maxDays)
            {
               maxDays = count;
            }
            Console.WriteLine("气温连续升高的最长天数" + maxDays);
```  

✋编程题  
输⼊是个不相等的正整数，输出这10个正整数中的第⼆⼤的数。  
样例输⼊  
3 5 7 2 9 5 3 10 3 8  
样例输出  
9  
```c#
            string str = Console.ReadLine();
            string[] strArray = str.Split(" ");
            int[] intArray = new int[strArray.Length];
            for (int i = 0; i < strArray.Length; i++)
            {
                int number = Convert.ToInt32(strArray[i]);
                intArray[i] = number;
            }    //获得一组数字

            int max1 = 0;int max2 = 0;
            for(int i = 0; i < intArray.Length; i++)
            {
                if (intArray[i] > max1)
                {
                    max2 = max1;
                    max1 = intArray[i];
                }
                else
                {
                    if (intArray[i] > max2)
                    {
                        max2 = intArray[i];
                    }
                }
            }
            Console.WriteLine("第一大值是" + max1 + " 第二大值是" + max2);
```  

✋编程题  
描述给定⼀个只包含⼩写字⺟的字符串，请你找出第⼀个仅出现⼀次的字符。如果没有，输出
no。  
```c#
方法1：
            string str = Console.ReadLine();
            char temp = ' ';// 20x20
            for(int i = 0; i < str.Length; i++)
            {
               int count = 0;
               for(int j = 0; j < str.Length; j++)
               {
                   if (str[j] == str[i])
                   {
                       count++;
                       if (count == 2)
                       {
                           break;
                       }
                   }
               }
               if (count==1)
               {
                   temp = str[i];
                   break;
               }
            }
            if(temp==' ')
            {
               Console.WriteLine("no");
            }
            else
            {
               Console.WriteLine(temp);
            }
```  

```c#
方法2：
            string str = Console.ReadLine();
            int[] countArray = new int[26];//计数，保存每个字符出现的个数
            for(int i = 0; i < str.Length; i++)
            {
               countArray[str[i] - 'a'] = countArray[str[i] - 'a'] + 1;
            }

            bool isFind = false;  //是否找到
            char c = ' ';
            for(int i = 0; i < str.Length; i++)
            {
               if(countArray[str[i] - 'a'] == 1)
               {
                   isFind = true;
                   c = str[i];
                   break;
               }
            }
            if (isFind == false)
            {
               Console.WriteLine("no");
            }
            else
            {
               Console.WriteLine(c);
            }
```  


✋编程题  
⼤⼩写字⺟互换  
把⼀个字符串中所有出现的⼤写字⺟都替换成⼩写字⺟，同时把⼩写字⺟替换成⼤写字⺟。   
```c#
            string str = Console.ReadLine();
            //a-z  A-Z
            int cha = 'A' - 'a';
            for(int i = 0; i < str.Length; i++)
            {
               if (str[i] >= 'a' && str[i] <= 'z')
               {
                   char c = (char)(str[i] + cha);
                   Console.Write(c);
               }else if (str[i] >= 'A' && str[i] <= 'Z')
               {
                   char c = (char)(str[i] - cha);
                   Console.Write(c);
               }
               else
               {
                   Console.Write(str[i]);
               }
            }
```

✋在⼀个数组中查找⼀个给定的值，输出第⼀次出现的位置（从1开始）   
输⼊第⼀⾏是数组中的元素  
第⼆⾏是要查找的数  
输出输出第⼀次出现的位置  
输⼊  
3 8 23 45 2 5  
23  
输出3  
```c#
            string str = Console.ReadLine();
            string[] strArray = str.Split(" ");
            int[] intArray = new int[strArray.Length];
            for (int i = 0; i < strArray.Length; i++)
            {
                int n = Convert.ToInt32(strArray[i]);
                intArray[i] = n;
            }  //得到一组数字

            int number = Convert.ToInt32(Console.ReadLine());
            int location = -1;
            for(int i = 0; i < intArray.Length; i++)
            {
                if (number == intArray[i])
                {
                    location = i + 1;
                    break;
                }
            }
            Console.WriteLine(location);
```

练习题9

**字符串**   

字符串的处理是编程⾥⾯的重要⽅⾯之⼀，因为很多数据都是字符串。  
⽐如登录的时候邮箱 ⽤户名 密码 验证码等都是字符串。  
字符串有字符组成，每个字符在底层是⼀个数字存储的。每个字符对应什么数字。  
```c#
            string name = "Micheal";
            name = "Micheal" + " 123";
            name = "" + 45;// "45"
```
ASCII码
https://baike.baidu.com/item/ASCII/309296?fr=aladdin  
字符串是⼀串字符，在程序中，⼀个字符串可以当做⼀个字符数组。  

```c#
            string name = "Micheal";
            name = "Micheal" + " 123";
            name = "" + 45;// "45"
            Console.Write(name.Length);   // str.length取得字符⻓度 
            Console.Write(name[3]);
            for(int i = 0; i < name.Length; i++)
            {
               Console.WriteLine(name[i]);     //str[i]访问某个字符元素  
            }
```
✋编程题  
如果倒序遍历⼀个字符串中的每⼀个字符。  
```c#
            for(int i = name.Length - 1; i >= 0; i--)
            {
               Console.WriteLine(name[i]);
            }
```
关于字符串操作的常⽤⽅法：  
1、ToLower() ToUpper()  
2、Trim() TrimStart() TrimEnd()  
3、Split()  
```c#
            string name = "xiaoming,zhangsan,xiaohong";
            name.methodName();
            string str2 = name.ToLower();
            Console.WriteLine(name + "-" + str2); //字母大写变小写

            string str3 = name.ToUpper(); 
            Console.WriteLine(name + "-" + str3);  //字母小写变大写

            string str4 = name.Trim();
            Console.WriteLine(name + "-" + str4);  //去除字符串中间空格

            string str5 = name.TrimStart();
            Console.WriteLine(name + "-" + str5 + "|");  //去除字符串首部空格

            string str6 = name.TrimEnd();
            Console.WriteLine(name + "-" + str6 + "|");  //去除字符串尾部空格

            string[] strArray = name.Split(",");  //分割
            foreach(string str in strArray)
            {
                Console.WriteLine(str);
            }
```
✋编程题  
3个可乐瓶可以换⼀瓶可乐，现在有364瓶可乐，问⼀共可以喝多少瓶可乐，剩下⼏个空瓶。 
```c#
            int pingNumber = 364;
            int heNumber = 364;
            while (pingNumber > 2)
            {
               heNumber += pingNumber / 3;
               pingNumber=(pingNumber / 3) + (pingNumber % 3);
            }
            Console.Write("一共可以喝" + heNumber + "，剩下" + pingNumber);
```  
✋编程题  
编写⼀个应⽤程序⽤来输⼊的字符串进⾏加密，对于字⺟字符串加密规则如下：  
‘a’→’d’ ‘b’→’e’ ‘w’→’z’ …… ‘x’→’a’ ‘y’→’b’ ‘z’→’c’‘A’→’D’ ‘B’→’E’ ‘W’→’Z’ …… ‘X’→’A’ ‘Y’→’B’‘Z’→’C’?对于其他字符，不进⾏加密。
```c#
            String str = Console.ReadLine();
            char[] strArray = str.ToCharArray();
            for(int i = 0; i < strArray.Length; i++)
            {
               if( (strArray[i]>='a' &&strArray[i]<='z')||(strArray[i] >= 'A' && strArray[i] <= 'Z'))
               {
                   strArray[i] = (char)(strArray[i] + 3);// 'a'+3    97+3  = 100  = 'd'
                   if(strArray[i]>'z'&& strArray[i]< 'z' + 4)//xyz
                   {
                       strArray[i] = (char)(strArray[i] - 26);
                   }
                   if (strArray[i] > 'Z' && strArray[i] < 'Z' + 4)//XYZ
                   {
                       strArray[i] = (char)(strArray[i] - 26);
                   }
               }
            }

            foreach(char temp in strArray)
            {
               Console.Write(temp);
            }
```

✋编程题  
编写⼀个控制台程序，要求⽤户输⼊⼀组数字⽤空格间隔，对⽤户输⼊的数字从⼩到⼤输出。
(Array.Sort⽅法和冒泡排序)  
排序演⽰⽹站：https://visualgo.net/en/sorting?slide=1  
```c#
            string str = Console.ReadLine();
            string[] strArray = str.Split(" ");
            int[] intArray = new int[strArray.Length];
            for (int i = 0; i < strArray.Length; i++)
            {
               int number = Convert.ToInt32(strArray[i]);
               intArray[i] = number;
            }
           //得到一个有序的数组
           
            Array.Sort(intArray);
            foreach(int temp in intArray)
            {
               Console.Write(temp + " ");
            }

拓展：
            string str = Console.ReadLine();
            string[] strArray = str.Split(" ");
            int[] intArray = new int[strArray.Length];
            for (int i = 0; i < strArray.Length; i++)
            {
               int number = Convert.ToInt32(strArray[i]);
               intArray[i] = number;
            }
            //得到一个有序的数组
            //19-19-18
            for(int j = 0; j < intArray.Length - 1; j++)//进行length-1轮比较
            {
               //进行比较 j=0 length-1   j=1 length-1-1   j=2 length-1-2
               bool isChange = false;//需要一个变量标志，记录当前轮次比较是否有发生交换
               for(int i = 0; i < intArray.Length - 1-j; i++)
               {
                   if (intArray[i] > intArray[i + 1])  //如果左边大于右边 ，就交换
                   {
                       int temp = intArray[i];
                       intArray[i] = intArray[i + 1];
                       intArray[i + 1] = temp;
                       isChange = true;
                   }
               }
               if (isChange == false)
               {
                   break;
               }
            }

            foreach (int temp in intArray)
            {
               Console.Write(temp + " ");
            }
```

字符串

怎么存储⼀个⼈的年龄？  
```c#
            int age = 30;
```
怎么存储10个⼈的年龄？  
```c#
            int age1 = 12;
            int age2 = 12;
            int age3 = 12;
            int age4 = 12;
            int age5 = 12;
            int age6 = 12;
            int age7 = 12;
            int age8 = 12;
            int age9 = 12;
            int age10 = 12;
```
:::tip{title="解决办法？"}
1、定义10个变量  
2、使⽤⼀个数组 
:::

:::note{title="注"}
数组⽤来存储同种类型的⼤量数据。
:::

   

**数组的声明**
类型[] 数组名;  
数组名遵守变量名命名规则   
```c#
            double[] temp1;
            char[] temp2;
            string[] temp3;
```
**数组的赋值**  
```c#
int[] ages={34,2,3,2,2,45}  
ages=new int[10]  
ages=new int[]{3,4,12,312,321}  
ages=new int[10]{3,4,12,312,321} //⻓度和个数要对应 
```
 

**数组的使⽤**（修改和读取）  
通过索引（下标），索引从0开始。  
可以把数组想象⻋⼀个⽕⻋，⼀个⻋厢⾥⾯存储的就是数据元素。  
age[index]  

![image.png](/static/img/e2da963ff3c0dea8994407588ba316fe.image.png)  

```c#
    修改：
            int[] ages = { 34, 12, 56, 67, 2, 3, 4, 6, 6, 2 };
            ages[10] = 20;
            Console.Write(ages[10]);    2 → 20
            
    读取：       
          // 声明int类型的数组
            int[] ages = { 34, 12, 56, 67, 2, 3, 4, 6, 6, 2 };
           // 数组的数据有下标 0  1   2  3   4  5  6  7  8  9（索引） 
           // 数组名[索引]
            Console.WriteLine(ages[7]);   = 6
```
:::warning{title="注意"}
1、不能访问索引不存在的值 
:::   
```c#
            ages = new int[4] { 12, 1, 2, 4 };
            Console.Write(ages[7]);
```

❓练习  
1、声明⼀个int的数组，数组⼤⼩为9  
2、声明⼀个char数组，数组⻓度为20  
3、声明⼀个float数组，数组⻓度为5  
4、声明⼀个字符串数组，数组⻓度为8  
```c#
            int[] intArray = new int[9];//0
            char[] charArray = new char[20];
            float[] floatArray = new float[5];
            string[] stringArray = new string[8];
```

✋判断对错
```c#
1:
int[] ar;
ar={1,2,3};        X  赋值需在同一行
2:
int[] ar = {2,3,4};     V  
3:
int[] ar = new int[4]{1,2,3}     X   不能访问索引不存在的值
```  


❓怎么遍历⼀个数组？（正序和倒序）    
**遍历就是取得数组中的每⼀个值**
```c#
            //0-9
            int[] ages = { 34, 12, 56, 67, 2, 3, 4, 6, 6, 2 };
            Console.Write(ages.Length);
            for(int i = 0; i < ages.Length; i++)
            {
                Console.Write(ages[i] + " ");
            }
```
遍历索引 - 通过索引访问元素  
- 通过for和while遍历⼀个数组  
  
```c#
            int[] ages = { 34, 12, 56, 67, 2, 3, 4, 6, 6, 2 };
            for(int i = 0; i < 10; i++) //正序
            {
               Console.Write(ages[i]+" ");
            }

            for(int i = 9; i >= 0; i--) //倒序
            {
               Console.Write(ages[i] + " ");
            }
            //34 12 56 67 2 3 4 6 6 2 
            //2 6 6 4 3 2 67 56 12 34 
```  
```c#
            int[] ages = { 34, 12, 56, 67, 2, 3, 4, 6, 6, 2 };
            int i = 0;
            while (i < 10)
            {
               Console.Write(ages[i] + " ");
               i++;
            }
            //34 12 56 67 2 3 4 6 6 2 
```  
- 通过foreach遍历⼀个数组  （**只能正序**）
```c#
            int[] ages = { 34, 12, 56, 67, 2, 3, 4, 6, 6, 2 };
            foreach(int temp in ages){
               Console.Write(temp + " ");
            }
            //34 12 56 67 2 3 4 6 6 2 

```

数组

计算机中的数据怎么存储的？  
每⼀位，只能存储0和1，所以计算机中所有的数据都是使⽤⼆进制来计算的。  
⼆进制是计算机使⽤的计算数制，我们⼈类平时使⽤⼗进制，是因为我们是以10为单位，⽅便我们计量，我们双⼿就是正好⼗个⼿指头  


使⽤⼆进制存储的  


1、什么是⼆进制  
  
**⼗进制**  
- 十进制是Decimal，简写为D  
- 由（0-9）组成  

**⼆进制**  
- 二进制是Binary，简写为B
- 由（0-1）组成

**⼋进制**  
- 八进制是Octal，简写为O
- 由（0-7）组成

**⼗六进制**  
- 十六进制为Hexadecimal，简写为H
- 表示方式为0x开头
- 由（0-9）和（A-F)组成  
  
（⼆进制和⼗六进制）  
⼆进制是数据存储的基础，内存地址⼀般使⽤⼗六进制表⽰。  

 例如：  
 - （110010011111）2 代表二进制数 ； 
 - （6137）8 代表八进制数
 - （3AB）H 代表十六进制数；
 - （2654）O 代表八进制数

**二进制 → 十进制**  
　　方法：二进制数从低位到高位（即从右往左）计算，第0位的权值是2的0次方，第1位的权值是2的1次方，第2位的权值是2的2次方，依次递增下去，把最后的结果相加的值就是十进制的值了。

:::note{title="将二进制的(10010110)B转换为十进制"}
1. 第0位 0 x 2^0 = 0；
2. 第1位 1 x 2^1 = 2；
3. 第2位 1 x 2^2 = 4；
4. 第3位 0 x 2^3 = 0；
5. 第4位 1 x 2^4 = 16；
6. 第5位 0 x 2^5 = 0；
7. 第6位 0 x 2^6 = 0；  
8. 第7位 1 x 2^7 = 128；
9. 读数，把结果值相加，0+2+4+0+16+0+0+128=150，即(10010110)B=(150)D。
:::

![image.png](/static/img/4ae9555393b4014b02a4804d75e3502f.image.png)


**八进制 → 十进制**   

　　方法：八进制数从低位到高位（即从右往左）计算，第0位的权值是8的0次方，第1位的权值是8的1次方，第2位的权值是8的2次方，依次递增下去，把最后的结果相加的值就是十进制的值了。

　　**八进制就是逢8进1**，八进制数采用 0～7这八数来表达一个数。

:::note{title="八进制的(26)O转换为十进制"}
1. 第0位 6 x 8^0 = 6；
2. 第1位 2 x 8^1 = 16；
3. 读数，把结果值相加，6+16=22，即(26)O=(22)D。
:::

![image.png](/static/img/2d2e194e5f329934708ef106000c3f74.image.png)  

**十六进制 → 十进制**  
　　方法：十六进制数从低位到高位（即从右往左）计算，第0位的权值是16的0次方，第1位的权值是16的1次方，第2位的权值是16的2次方，依次递增下去，把最后的结果相加的值就是十进制的值了。

　　**十六进制就是逢16进1**，十六进制的16个数为0123456789ABCDEF。

:::note{title="十六进制的(23da)H转换为十进制"}
1. 第0位 a x 16^0 = (10 × 16^0) = 10；
2. 第1位 d x 16^1 = (13 × 16^1) = 208；
3. 第2位 3 x 16^2 = 768；
4. 第3位 2 x 16^3 = 8192；

3. 读数，把结果值相加，10+208+768+8192=9178，即(23da)H=(9178)D。
:::

![image.png](/static/img/865aa1374f739d56f431a6571264b9a1.image.png)  
:::tip{title="提示"}
**x进制就是遇x进1的意思**
:::

**十进制 → 二进制** 
:::note{title="(67)10 → (1000011)2"}
将67除以2得商33，余数1。将商（33）作为第二次的被除数一次类推，直到商为0.
:::

![image.png](/static/img/e64955160b7a6c2b36eab66d159e3c43.image.png)  


758（十进制）→ 1366（八进制）    951（十进制）→ 3B7（十六进制）

![image.png](/static/img/ff1797c832850426e765de017eead55c.image.png)  

**二进制转八进制**

![image.png](/static/img/e1710e4f62930620d36482eb8abfbc66.image.png)  

**二进制转十六进制**
![image.png](/static/img/e313561ed776677ba759b0b743d4a8ff.image.png)



:::warning{title="特殊情况：小数点的处理"}
如果遇到十进制数例如23.76，如何转换？

![image.png](/static/img/627703d4e9f17df10670066b408b7313.image.png)
:::
数制之间的转换
https://baike.baidu.com/item/⼗进制转⼆进制/393189?fr=aladdin  
进制在线转换⼯具 ：https://tool.lu/hexconvert/  

为什么使⽤⼆进制  
计算机中的数据⼤⼩怎么衡量的（包括我们计算机中的变量和⽇常⽣活中的⽹速硬盘，因为这些都是承载数据的，所有都是有⼤⼩的）  

![image.png](/static/img/4d6a204d710a30164523a4ba2e440115.image.png)
⼤⼩是怎么算的  
不要求记住，但是理解存储单位有助于理解计算机和程序  


![image.png](/static/img/fd354202589f4cfd56722f77829a6240.image.png)  

![image.png](/static/img/8bcafec55efff0bcecc948f5a8adfe3f.image.png)  

上述数据是以2的10次⽅ 间隔⼀个单位。（中国以⼀万，美国以1000）  
计算机中的硬盘⼤⼩，内存⼤⼩，⽹速⼤⼩。  

MB和Mb的区别  

1mB = 1m字节  
1Byte = 8bit  
1mb = 1兆位  
1mB = 8mb   

千兆路由器和千兆宽带  
100mb 、200mb 、500mb

数据存储

所有的数据类型  
http://c.biancheng.net/view/2780.html  
其他数据类型怎么使⽤  
-  整型  
-  浮点型
-  字符型
-  字符串型
-  布尔类型  
```c#
            byte int long
            sbyte a = 100;
            sbyte b = -100;
            int c = 2100000000;
            long d = 1234567891234567891;
            byte e = 30;
            c = a;
            a = (sbyte)c;
            Console.Write(a);
            //a = e;
            //e = a;
```
类型的显⽰转换和隐式转换  
赋值的时候，两边类型是需要⼀致的，如果不⼀致的话，就需要转换类型。有些条件下，会⾃动进⾏转换，叫做**隐式转换**。  
有些情况下，需要我们告诉编译器进⾏类型转换，叫做**显⽰转换**，也叫做强制类型转换，强塞。    

:::note{title="注"}
小数赋值需加 f
:::
```c#
            float f = 4.5f;
            f = 2123456789;
            Console.WriteLine(f);
```
隐式转换 - 不需要写更多的代码，⾃动进⾏。  
当⼩盒⼦放⼊⼤盒⼦的时候，肯定可以放得下，所有会⾃动进⾏转换。不需要做多余操作    
|类型      | 可以安全的转换为 |
| ----------- | ----------- |
|sbyte|short,int,long,float,double,或decimal|
|byte|short,ushort,int,uint,long,ulong,float,double,或decimal|
|short|int,long,float,double,或decimal|
|ushort|int,uint,long,ulong,float,double,或decimal|
|int|long,float,double,或decimal|
|uint|long,ulong,float,double,或decimal|
|long|float,double,或decimal|
|ulong|float,double,或decimal|
|char|ushort,int,uint,long,ulong,float,double,或decimal|
|float|double|  

显⽰转换 - 需要写代码告诉转换成什么类型。  

```c#
            byte a = 32;
            int b = 200;
            //b = a;// 隐式转换
            //a = b;//显示转换 &
            Console.Write(a);
            int i = Convert.ToInt32("234");
            double j = Convert.ToDouble("4.5");
```
把⼀个⼤盒⼦⾥⾯的东⻄放进⼩盒⼦的时候，编译器不确定能不能放得下，所以默认是不允
许放的，除⾮你告诉他 我⾮要放。  
编译器只检查容器⼤⼩，不检查容器内的具体数值⼤⼩，为什么？因为变量⾥⾯的东⻄是变
化的，变量⾥⾯的值需要在程序运⾏的时候才确定下来。  

类型的转换，得是同⼀类型，⽐如数字类型之间可以相互转换，但是我们不能把⼀个字符串转换成整数类型。但是如果要把⼀个数字字符串，转换成数字的话，我们是有对应的⽅法的。  


![image.png](/static/img/b09f4b10c3aaecc9d1f6a26ffabf5b80.image.png)

同理，如何把⼀个数字转成数字字符串  
1、Convert.ToString()  
2、 number + "";  
```c#
            string s = 123 + "";//"123"
            string s2 = Convert.ToString(123);//"123"
            // 8bit 8位 1位只能存储一个0或1
```

数据类型

msvalidate.01

360-site-verification

sogou_site_verification

script

《千纸鹤》是一个关于个人成长、心灵探索和生活哲学的博客。通过结合纸鹤的象征意义，博客传递着希望、自由、勇气和梦想的理念，分享作者在人生旅途中所遇到的挑战与感悟。每一篇文章都如同一只飞翔的纸鹤，轻盈地载着思想与情感，带领读者在迷茫与困顿中找到属于自己的方向。