六 c# 字符与字符串

1、字符及转义字符

char类结构标识unicode字符。unicode标准使用称为码位的唯一的21位标量数字标识每个unicode字符，并定义UTF-16编码格式，这一个事指定如何将码位编码为一个或多个16位值的序列，每个16位值的范围为十六进制的0x0000~0xFFFF,并存储在char结构中。char对象的值是其16位数字（序号）值。
定义格式： char 变量名=‘初始值’； ——注意使用的是单引号，其值必须是单字符

定义三个字符（小写字母、数字、大写字母）并初始化，判断第一个是否为字母，如果是字母转化为大写，判断第一个是否为数字，将第三个转化为小写

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 字符及转义字符
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入三个字符");
            //char a = Convert.ToChar(Console.ReadKey());
            //char b = Convert.ToChar(Console.ReadKey());
            //char c = Convert.ToChar(Console.ReadKey());
            char a = 'a';
            char b = '2';
            char c = 'D';

            if (char.IsLetter(a)) {
                //char.ToUpper(a);
                Console.WriteLine(char.ToUpper(a));
            }
            if (char.IsDigit(b)) {
                Console.WriteLine("您输入的{0}是数字",b);
            }
            //char.ToLower(c);
            Console.WriteLine(char.ToLower(c));
            Console.ReadKey();
        }
    }
}

1.2 转义字符

避免转义字符可以在字符串前加"@"符号，例如：@“C:\Users\Admin\Desktop”

2、字符串

• 字符串是由零个或多个字符组成的有限序列号，是几乎所有编程语言中可以实现的非常重要和有用的数据类型。
• 字符串是System.String类的一个引用类型，但与其他引用类型不同的是，C#将字符串视为一个基本类型，可以声明为一个变量，并未其赋值。
• 声明方式 string 变量名=“初始值”
• 记住一句话：string类型变量可以看成是char边浪的只读数组

2.1字符集（charSet）与字符编码（Character Encoding）

• 计算机中存储的信息都是有二进制来标识的，而我们在屏幕上看到的汉字、字母、数字、符号都是有二进制转化来的
• 字符集（charSet）：是一个系统支持的所有抽象字符的集合
• 字符编码（character Encoding）是一套法则，使用该法则能够对自然语言的字符的一个集合（如字母表和音节表），与其他东西的一个集合（如号码或电脉冲）进行配对

2.2常用的字符集和字符编码

3、字符串的大小写转换

提示永华输入英文名字，如果输入为 jack、Jack、JAck、jaCK等时，提示这么巧我也叫JACK,否则输出“您的名字好有个性”

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 字符串转换
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入您的英文姓名");
            string name = Console.ReadLine();
            //ToUper方法可实现将英文转换为大写
            string tempname = name.ToUpper() == "JACK" ? "这么巧，我也叫JACK" : "您的名字好有个性";
            Console.WriteLine(tempname);
            Console.WriteLine(name.ToUpper() == "JACK" ? "这么巧，我也叫JACK" : "您的名字好有个性");
            string mystr = "Thi is An example of conversation on sting";

            Console.WriteLine("大写字符串" + mystr.ToUpper());
            Console.WriteLine("小写字符串" + mystr.ToLower());

            char mychar = 'a';
            Console.WriteLine("小写字符" +char.ToLower(mychar));
            Console.WriteLine("大写字符" + char.ToUpper(mychar));
            Console.ReadKey();

        }
    }
}

3.1 字符串大小写转换与字符大小写转换比较

4、字符串的比较

方法

• ==/!=
• equals方法：Equals(字符串1，字符串2)返回布尔值 string.Equals(字符串1，字符串2)
• compare：有多个重载方法，只列举两个 compare(字符串1，字符串2)
• CompareTo：字符串1.CompareTo（字符串2）
  比较字符串Hello与字符串Hi是否相等或者他们大小

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 字符串比较
{
    class Program
    {
        static void Main(string[] args)
        {
            string mystr1 = "Hell0";
            string mystr2 = "Hi";
            // == !=
            Console.WriteLine(mystr1 == mystr2);
            Console.WriteLine(mystr1 != mystr2);

            // Equals
            Console.WriteLine(string.Equals(mystr1,mystr2));


            // Compare
            string mystr3 = "Hell0";
            string mystr4 = "Hell0";
            Console.WriteLine(string.Compare(mystr3,mystr4,true));  //第三个参数为bool类型，默认为false，当为true时，则为忽略大小写比较
            //返回负值代表字符串1小于字符串2，返回正直代表字符串1大于字符串2，
            //计算机中字符串比较是按照位比较的，
            //首先第一位，如果第一位相等则比较第二位，依次类推，如果第n位不相等，则谁的第哪位字符大，则响应字符串大,且n位后的字符不再比较

            // CompareTo
            Console.WriteLine(mystr1.CompareTo(mystr2));
            Console.ReadKey();
        }
    }
}

5、字符串格式化（Format）

可进一步参考：https://www.cnblogs.com/itjeff/p/5775665.html
string.Format(要转化的格式，格式化的对象)
string.Format(要转化的格式，格式化的对象一，格式化的对象二)

使用C格式：￥2,100.00   
使用D格式：2100
使用E格式：2.100000E+003
使用F格式：2100.00
使用G格式：2100
使用N格式：2,100.00
使用P格式：210,000.00%
使用X格式：834                   // 16进制格式

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 字符串的格式化
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(21.3);
            Console.WriteLine("{0:C}", 21.3); //加入货币符号（中文系统加入￥，英文系统加入$，输出结果为￥21.3）
            Console.WriteLine("字符串的格式化输出");
            string s = string.Format("默认格式：---{0}\n" +"使用C格式：{0:C}\n" + "使用D格式：{0:D}\n" + "使用E格式：{1:E}\n" + "使用F格式：{1:F}\n" + "使用G格式：{0:G}\n" + "使用N格式：{0:N}\n" + "使用P格式：{0:P}\n" + "使用X格式：{0:X}\n", 2100,2100.33);
            Console.WriteLine(s);
            // 输出001——050
            for (int i = 1; i < 51; i++)
            {
                string mystr = string.Format("{0:D3}", i);  // 后面数字是输出几位数，例如：数字1，因为设定为3为，所以格式化后为001
                Console.WriteLine(mystr);
            }
            Console.WriteLine(string.Format("{0:P3}", 0.56));  // 百分数标识，0.56百分数是56%，p后面数字是规定保留几位小数（默认保留2位小数），此处是3位，所以最终结果是56.000%
            Console.WriteLine(string.Format("{0:C3}", 5600));  // "3"仍是保留3位小数的意思，输出结果是￥56.000
            Console.WriteLine(string.Format("{0:E1}", 5600));  //科学技术发，保留1位小数
            Console.WriteLine(string.Format("{0:F4}", 5600));  
            Console.WriteLine(string.Format("使用G格式：{0:G3}", 5600));  
            Console.WriteLine(string.Format("使用N格式：{0:N4}", 5600));  // 使用分割符“，” 每三位进行一次分割，保留4位小数
            Console.WriteLine(string.Format("{0:X}", 5600));  


            Console.ReadKey();
        }
    }
}

6、字符串截取

• 字符串1.subusring(整数n)：将字符串1前n个长度的字符串截取掉，保留后面的字符串
• 字符串1.subustring（整数n，整数m）保留从字符串1第n个长度开始m个长度的字符串
• 两种冲在格式都会返回一个心字符串

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 字符串的截取
{
    class Program
    {
        static void Main(string[] args)
        {
            //
            string mystr = "0123456789";
            string mystr0 = mystr.Substring(3);  //输出结果3456789
            Console.WriteLine(mystr0);
            Console.WriteLine(mystr.Substring(3,5)); //输出结果为345
            Console.ReadKey();
            //实现单词首字母大写，其余字母小写，如WORD转换为Word
            Console.WriteLine("请输入一个单词不区分大小写");
            string mystr2 = Console.ReadLine();
            string changeMystr = mystr2.Substring(0, 1).ToUpper() + mystr2.Substring(0).ToLower();
            Console.WriteLine(changeMystr);
            Console.ReadKey();

        }
    }
}

7、字符串分割

• 分割是通过split方法来实现的，其有多重冲在形式，此章节只讲一种；
• 格式：字符串1.split(字符或字符数组)
• 分割后返回值是一个字符串数组

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 字符串分割
{
    class Program
    {
        static void Main(string[] args)
        {
            string mystr = "darly-felx-lucy";
            Console.WriteLine("源字符串为" + mystr);
            Console.WriteLine("分割后的结果是：");
            string[] changemystr = mystr.Split('-');  //结果是一个数组，因此在此声明一个字符串数组接收结果
            foreach (string onestr in changemystr)   //使用foreach遍历数组
            {
                Console.Write(onestr+"\t");
            }
            // 使用多个分割符号分割（此例用“-”“=”进行分割）
            Console.WriteLine();
            string mystr2 = "darly-felx-lucy=name";
            Console.WriteLine("源字符串为" + mystr2);
            Console.WriteLine("分割后的结果是：");
            string[] changemystr2 = mystr2.Split(new char[] {'-','=' });  //结果是一个数组，因此在此声明一个字符串数组接收结果
            foreach (string onestr in changemystr2)   //使用foreach遍历数组
            {
                Console.Write(onestr + "\t");
            }
            Console.ReadKey();
        }
    }
}

8、字符串合并

• 利用‘+’合并： 字符串3=字符串1+字符串2
• concat： string.concat(字符串1，字符串2，字符串3……)
• join： string.join(合并后的分隔符，字符串数组)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 字符串合并
{
    class Program
    {
        static void Main(string[] args)
        {
            // darly felx lucy 用（*）合并
            string mystr1 = "darly";
            string mystr2 = "felx";
            string mysrt3 = "name";
            string[] mystr4 = { "darly", "felx", "name" };
            Console.WriteLine(mystr1+"*"+mystr2+"*" +mysrt3);
            Console.WriteLine(string.Concat(mystr1, "*", mystr2, "*", mysrt3));
            Console.WriteLine(string.Join("*",mystr4));
            Console.WriteLine(string.Join("",mystr4));

            Console.ReadKey();
        }
    }
}

9、字符串的插入及填充

插入

• 插入通过insert方法实现
• 字符串.insert(插入位置，插入子串)
  填充
• 填充是通过padRight和padLeft实现的
• PadRight方法是在字符串的结尾通过添加指定的重复字符填充字符串
• 字符串.PadRight(总长度) //以空格填充
• 字符串.PadRigh（总长度，要填充的字符）
• PadLeft方法时在字符串的开头，通过添加指定的重复字符填充字符串
• 字符串.PadLeft(总长度)；//以空格填充
• 字符串.PadLeft(总长度，要填充的字符)；

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 字符串的插入与填充
{
    class Program
    {
        static void Main(string[] args)
        {
            //字符串插入
            string mystr = "www.darly.net";
            string mystr2 = ".felx";
            string insertstr = mystr.Insert(9, ".name");  //索引值8的位置开始插入字符串name
            insertstr = insertstr.Insert(9, mystr2);
            Console.WriteLine(insertstr);
            Console.ReadKey();
            //字符串填充
            //PadRight  用来在字符串的结尾处添加指定（重复）字符串以达到指定长度
            string padstr1 = "abc";
            string padstr2 = "efghi";
            string padstr3 = "haonan";
            string padRight1 = padstr1.PadRight(7);
            string padRight2 = padstr2.PadRight(7);
            string padRight3 = padstr3.PadRight(7);
            Console.WriteLine(padRight1+"a");
            Console.WriteLine(padRight2 + "a");
            Console.WriteLine(padRight3 + "a");
            Console.ReadKey();
            Console.WriteLine();
            string padstr4 = "abc";
            string padstr5 = "efghi";
            string padstr6 = "haonan";
            string padRight4 = padstr1.PadRight(7,'a');   //后面参数是单字母时必须是单引号
            string padRight5 = padstr2.PadRight(7, 'a');
            string padRight6 = padstr3.PadRight(7, 'a');
            Console.WriteLine(padRight4 );
            Console.WriteLine(padRight5 );
            Console.WriteLine(padRight6 );
            Console.ReadKey();

            string padstr7 = "bu";
            string padstr8 = "buduanxuexi";
            string padLeft1 = padstr7.PadLeft(7,'b');
            string padLeft2 = padstr8.PadLeft(7,'b');  //字符串本身已经查过规定总长度，不做补充，仍是buduanxuexi
            Console.WriteLine(padLeft1);
            Console.WriteLine(padLeft2);
            Console.ReadKey();
        }
    }
}

10 字符串删除

删除是通过Remove来实现的

• 字符串.Remove（开始位置）：将字符串开始位置后的所有字符串删除
• 字符串.Remove(开始位置，移除数)：从开始位置开始数到移除数位置的字符串删除
• 开始位置是指字符的串索引，是一个整数，且小于字符串长度；

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 字符串删除
{
    class Program
    {
        static void Main(string[] args)
        {
            //字符串删除
            Console.WriteLine("删除字符串");
            string mystr = "abcdefghijk";
            string delstr = mystr.Remove(8);
            string delstr2 = mystr.Remove(6, 2);
            Console.WriteLine(mystr);
            Console.WriteLine(delstr);
            Console.WriteLine(delstr2);
            Console.ReadKey();
            Console.WriteLine("截取字符串");
            string submstr = mystr.Substring(8);   //输出结果是“ijk”
            string submystr2 = mystr.Substring(6, 2);  //输出结果是“gh”
            Console.WriteLine(submstr);
            Console.WriteLine(submystr2);
            Console.ReadKey();

        }
    }
}

11、字符串修剪

• 修剪即Trim，用于删除字符串头尾出现的某些字符
• C#有三个修改件字符串的方法Trim(),Trimstart()，TrimEnd()
• Trim()删除字符串首部和尾部空格
• TrimStart()只删除字符串的头部空格
• TrimEnd()只删除字符串尾部的空格
• Trim（字符1，字符2）修剪字符串中的特定字符串（字符串中特定字符都删除，无论字什么位置）
• Trim（“abcd”.toCharArray()）TrimStart(“abcd”.toCharArray()) TrimStart(“abcd”.toCharArray())
• 如果这三个函数带上字符型数组的参数，则是删除字符型数组中出现的任意字符，如Trim（“abcd”.toCharArray()）就是删除字符串头部及尾部出现的a或b或c或d字符，删除的过程直到碰到一个既不是a也不是b也不是c也不是d的字符才结束（好像不是，需进一步验证）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 字符串修剪
{
    class Program
    {
        static void Main(string[] args)
        {
            //字符串的修改件
            Console.WriteLine("通过Trime()实现");
            string username = "   darly  ";
            Console.WriteLine("原字符串是:" + username+"aa");
            Console.WriteLine("把空格修剪后:"+username.Trim()+"aa");
            Console.WriteLine("使用TrimStart():" + username.TrimStart() + "aa");
            Console.WriteLine("使用TrimEnd():" + username.TrimEnd() + "aa");
            Console.ReadKey();
            //将字符串前后端的特定字符串修剪掉
            string rawstr = "%###%%%username%%%####";
            Console.WriteLine("修剪特定字符" + rawstr.Trim('#', '%'));   //输出结果是username
            Console.WriteLine("trim(包含所有需要修剪字符的字符串.ToCharArray)"+rawstr.Trim("#%".ToCharArray()));
            string rawstr2 = "%###%%%u#ser%name%%%####";
            Console.WriteLine("修剪特定字符" + rawstr.Trim('#', '%'));   //输出结果是username
            Console.WriteLine("修剪特定字符" + rawstr.Trim('#'));   //输出结果是%###%%%username%%%,只指定一个参数时，遇到不符合的就输出
            Console.WriteLine("修剪特定字符" + rawstr.Trim('%'));   //输出结果是###%%%username%%%####
            Console.WriteLine();
            Console.ReadKey();

        }
    }
}

12、字符串复制

• 复制是通过Copy和CopyTo来实现的
• String.Copy(要复制的字符串)； 原样复制
• CopyTo（要复制字符的其实位置，目标字符数组，目标数组中的开始位置，要复制的字符个数） 有选择性的复制

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 字符串复制
{
    class Program
    {
        static void Main(string[] args)
        {
            //copy复制是静态方法，只能通过“关键字.方法”进行引用
            string mystr = "it is to test copying string";
            string copyMstr = string.Copy(mystr);
            Console.WriteLine(copyMstr);
            Console.ReadKey();
            // copyTo  非静态方法
            char[] mycharArray = new char[20];  //申明一个字符数组，20是指字符数组的长度最大为20
            //string copyToMystr = mystr.CopyTo(9, mycharArray, 0,13); 因CopyTo是无返回值的方法，所以无法赋值，此语句错误
            mystr.CopyTo(9, mycharArray, 0, 12);
            Console.WriteLine("CopyTo实现复制的结果");
            Console.WriteLine(mycharArray);
            Console.ReadKey();
        }
    }
}

13、字符串替换

• 替换是通过Replace来实现的。
• 字符串.Replace（要替换的原字符串，替换后的字符串）；

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 字符串替换
{
    class Program
    {
        static void Main(string[] args)
        {
            //字符串替换Replace(非静态方法)
            string mystr = "this is to replace sting";
            string replaceResult = mystr.Replace("this", "it");
            Console.WriteLine("将字符串中this替换为it");
            Console.WriteLine("原字符串"+mystr+"替换后的结果"+replaceResult);
            Console.WriteLine("将字符串中i替换为I");
            //string replaceResult2 = mystr.Replace('i', 'I');
            string replaceResult2 = mystr.Replace("i", "I");  //与上面注释的语句一样
            Console.WriteLine("原字符串" + mystr + "替换后的结果" + replaceResult2);

            Console.ReadKey();
        }
    }
}

14、字符串查找

• 查找时通过IndexOf和LastIndexO两个方法实现的
• 字符串.IndexOf（要查找的字符串或字符）：返回要找字符或字符串第一次在索要查找的字符串中出现的位置
• 字符串.LastINdexOf（要查找的字符或字符串）返回要查找的字符或字符串最后一次索要查找的字符串中出现的位置
• 均返回一个整数，如果所有查找的字符串内不包含要查找的字符或字符串则返回一个负数；

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 字符串查找
{
    class Program
    {
        static void Main(string[] args)
        {
            //字符串查找IndexOf
            string mystr = "check string or char from a string";
            Console.WriteLine("string第一次出现的位置");
            int returnvalue = mystr.IndexOf("string");
            Console.WriteLine(returnvalue);
            Console.WriteLine("g第一次出现的位置");
            int returnvalue2 = mystr.IndexOf('g');
            Console.WriteLine(returnvalue2);
            Console.ReadKey();
            //字符串查找LastIndexOf
            Console.WriteLine("string最后一次出现的位置");
            int returnvalue3 = mystr.LastIndexOf("string");
            Console.WriteLine(returnvalue3);
            Console.WriteLine("g最后一次出现的位置");
            int returnvalue4 = mystr.LastIndexOf("g");
            Console.WriteLine(returnvalue4);
            Console.ReadKey();
            //判断一个字符串中是否包含字符串"name",如果包含输出第一次或最后一次出现的位置，如果不包含输出-1
            Console.WriteLine("请输入一个字符串，用于判断是否包含name");
            string inputstr = Console.ReadLine();
            int startIndex = inputstr.IndexOf("name");
            int endIndex = inputstr.LastIndexOf("name");
            if (startIndex < 0) Console.WriteLine("您输入的字符串中不包含name");
            else if (startIndex == endIndex)
            {
                Console.WriteLine("您输入的字符串中只包含一个name，起始位置是" + startIndex);
            }
            else {
                Console.WriteLine("您输入的字符串中至少包含两个name");
                Console.WriteLine("第一次出现的位置时" + startIndex);
                Console.WriteLine("最后一次出现的位置时" + endIndex);

            }
            Console.ReadKey();


        }
    }
}

15、类型转换

15.1 类型转换的形式

类型转换采用以下两种形式：

• 隐式转换：系统自动转换，不需要我们干预，也不需要我们进行干预（目标类型存放容量大于原目标乐行的情况下可以进行隐式转换，ushort可以隐式转换为INT，但int不能隐式转换为unshort）
• 显示转换：需要我们调用响应的方法进行转换

15.2 隐式转换

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _15类型装换
{
    class Program
    {
        static void Main(string[] args)
        {
            //隐式转换
            char mychar = 'a';     //char类型存储空间是16位
            int myint = 100;
            Console.WriteLine(mychar);
            Console.WriteLine(myint);  
            int myint2 = mychar;
            //因为myint是整型变量，将字符赋值给一个整型变量时，编译器隐式将字符转换为整型，
            //因字符a对应的ASCI码是97所以将字符转换为整型后，对应的值是97，因此下面输出结果为97            
            Console.WriteLine(myint2);
            //字符可以隐式转换为整型，但整型不能隐式转换为字符   
            //mychar = myint;
            mychar = (Char)myint;
            Console.WriteLine(mychar);   // 100对应ASIC码100对应字符d，所以输出为d       

        }
    }
}

15.3 显示转换

• 显示转换共有四种方法：（转换目标类型）需要转换内容、convert.To目标类型（需要转换的内容）、转换的内容.To目标类型（）、Parse()
• 显示转换过程中会有可能数据溢出，通过checked（）检查溢出情况，溢出时会报错。例如：checked((char)myint3)
  
• 转换目标类型（需要转换内容）
  例如：char（需要转换的内容）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _15类型装换
{
    class Program
    {
        static void Main(string[] args)
        {
            //字符可以隐式转换为整型，但整型不能隐式转换为字符   此时需要显示转换
            //mychar = myint;  
            
            mychar = (Char)myint;
            Console.WriteLine(mychar);   // 100对应ASIC码100对应字符d，所以输出为d

            //强制转换会丢失部分信息，例如char为16位存储空间，最大存储数为65536；当转换为65538时则会移除
            int myint3 = 65636;
            char mychar3 = (char)myint3;    //因为65636-65536=100（即溢出100）；因此实际转换后为ASIC码100对应的字符d
            Console.WriteLine("强制转换数据溢出后的，转换结果");
            Console.WriteLine(mychar3);
            //检查溢出
            //char mychar4 = checked((char)myint3);  //当转换结果有溢出时报错
            Console.ReadKey();

        }
    }
}

15.4 convert.To目标类型()

当转换为字符串类型时：可以用Convert.ToString（转换内容）也可以用 转换内容.ToString()

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _15类型装换
{
    class Program
    {
        static void Main(string[] args)
        {
            string mystr= "abc";
            string mystr2 = "100";
            int myint = 100;
            Console.WriteLine("将整型转换为字符串");
            string mystr3 = Convert.ToString(myint);
            string mystr4 = myint.ToString();
            Console.WriteLine("convert" + mystr3);
            Console.WriteLine("ToString转换"+mystr4);  //与上面的语句完全相同
            Console.WriteLine("将字符串转换为整型");
            int myint2 = Convert.ToInt32(mystr2);            
            Console.WriteLine(mystr2);
            Console.ReadKey();            
        }
    }
}

15.5 parse

当转换为整型时可以中 int.parse()进行转换

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _15类型装换
{
    class Program
    {
        static void Main(string[] args)
        {
 
            string mystr1 = "100";
            int myint = int.Parse(mystr1);
            Console.WriteLine(myint);
            Console.ReadKey();
            int myint2 = 100;       
            
        }
    }
}

15.6（int）与Convert.ToInt32()及int.parse()区别

• 处理控制null：Convert.Toint()会将null转换为0，int.parse() 不能转换空值报异常，
• 处理述职时：（int）强制转换不进行四舍五入
• Convert.ToInt32的参数比较多，Int.parse只能转换string类型
• parse就是把String转换成int，char,double……等，也就是*.parse(string)括号中一定要是string
• Convert可以提供多种类型的转换，也就是convert.*()括号中可以为很多种类型（包括字符串string）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 转换类型的不同
{
    class Program
    {
        static void Main(string[] args)
        {
            string mystr = "123";
            int myint = 100;
            double mydouble = 12.33;
            string strResult;
            int intResult;
            // string——>int

            //1、（int） 次方法不适用将string转换为int,只能转换数值类型为int，而不能转换引用类型
            // 不会四舍五入，直接舍掉小数
            //intResult = (int)mystr;
            intResult = (int)mydouble;
            Console.WriteLine(intResult);

            //2、Convert.Toint();   他会将null转换为0
            //小数是0-4;直接舍掉， 
            //小数5:看整数位，返回一个临近的偶数位，例如4.5返回是4,7.5则返回8
            //小数是6-9：进位
            intResult = Convert.ToInt32(mystr);
            Console.WriteLine(intResult);

            //3. int.parse()   不能转换空值  只能将string转换为int，

            intResult = int.Parse(mystr);
            //int intResult2 = int.Parse(mydouble);  //只能将string转换为int，
            string mystr2 = "14.33";
            //int intResult2 = int.Parse(mystr2);  //执行过程中会报错，因为只能转换不带小数点的数字字符串
            double doubleResult = double.Parse(mystr2);

            Console.WriteLine(intResult);
            Console.WriteLine(doubleResult);

            //int——>string
            // strResult = (string)myint //强制缓缓只能转换数值类型的
            strResult = Convert.ToString(myint);
            string strResult2 = myint.ToString(); //与上面方法完全一样
            //没有string.Parse()方法
            Console.ReadKey();
        }
    }
}

17、StringBuilder类

在使用system.string类中方法时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的空间。在需要对字符串执行重复修改的情况下与创建性的String对象相关的系统开销可能非常高

17.1 stringBuilder类的使用

步骤

• 引入命名空间System.Text
• 通过new关键字初始化
• 进行使用，与steing类的使用一样

实例： 原有字符串 https://blog.csdn.net/Mwyldnje2003?spm=1001.2100.3001.5343
要求：

• 追加“是一个很好的学习播客”
• 利用插入进行换行
• 再移除换行
• 替换“很好”为“神奇”

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;   // 1、引入命名空间
using System.Threading.Tasks;

namespace _17stringBuilder类
{
    class Program
    {
        static void Main(string[] args)
        {
            //2、初始化
            StringBuilder mystrBuilder = new StringBuilder("https://blog.csdn.net/Mwyldnje2003?spm=1001.2100.3001.5343");
            //3、使用
            //3.1 追击字符串
            Console.WriteLine("=============================Append==================================");
            Console.WriteLine(mystrBuilder.Append("是一个很好的学习播客"));
            //3.2 插入字符串
            Console.WriteLine("=============================Insert==================================");
            Console.WriteLine(mystrBuilder.Insert(57, "\n"));  //第一个参数是插入的位置，第二个参数是插入的字符串
            //3.3 移除字符串
            Console.WriteLine("=============================Remove==================================");
            Console.WriteLine(mystrBuilder.Remove(57, 1));   //第一个参数是移除字符的起始位置，第二个参数是移除几个字符
            //3.4 替换字符串
            Console.WriteLine("=============================Repalce==================================");
            Console.WriteLine(mystrBuilder.Replace("很好", "神奇"));   //第一个参数是移除字符的起始位置，第二个参数是移除几个字符
            //3.5 按照指定格式来添加对应的字符串
            Console.WriteLine("=============================AppendFormat==================================");
            int money = 20000000;
            Console.WriteLine(mystrBuilder.AppendFormat("我可以涨工资{0:c}",money));   //第一个参数是移除字符的起始位置，第二个参数是移除几个字符
            //3.6 在字符串末尾添加一个换行符
            Console.WriteLine("=============================AppendLine==================================");
            Console.WriteLine(mystrBuilder);
            Console.Write(mystrBuilder.AppendLine());
            Console.WriteLine("上一条语句应该能够自动换行，此内容另起一行输出就说明上一条语句自动换行了");


            Console.ReadKey();
        }
    }
}

总结及实例

提示用户输入字符串1和字符串2，然后比较字符串1与字符串2，并将大的字符串中的各元素用|进行间隔输出

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 总结及实例
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入两个字符串，每个字符串以回车确认输入，我们将会以\"|\"来进行分隔");

            string mystr = Console.ReadLine();
            string mystr2 = Console.ReadLine();
            string maxstr;
            if (string.Compare(mystr, mystr2) > 0)
            {
                maxstr = mystr;
            }
            else {
                maxstr = mystr2;
            }

            maxstr = string.Compare(mystr, mystr2) > 0 ? mystr : mystr2;  // 与上面的if语句作用相同

            if (string.Compare(mystr, mystr2) > 0) maxstr = mystr;
            else maxstr = mystr2;                                          //if语句简略写法

            //利用SubString来进行分割
            for (int i = 0; i < maxstr.Length; i++)   // Length是获取长度
            {
                Console.Write(maxstr.Substring(i, 1));
                //if (i < maxstr.Length) Console.Write("|");
                //i < maxstr.Length ? Console.Write("|") : Console.WriteLine();  此语句错误
                
            }
            Console.ReadKey();
        }
    }
}