【C#学习5】列表、泛型、String(Builder)、正则表达式

列表List的创建和使用

1. 集合类-列表List，可以存储任何类型的数据，在创建列表对象的时候首先要指定存储类型（这种模式也被称为泛型）

namespace _020_列表List的创建和使用
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建一个空的列表，<>表示存储数据的类型
            List<int> scoreList1 = new List<int>();  //第一种
            var scoreList2 = new List<int>(); //第二种
            var scoreList3 = new List<int>() { 1, 2, 3, }; //创建了一个列表，里面的初始值有三个

            scoreList1.Add(12); //向列表末端插入数据
            Console.WriteLine(scoreList1[0]); //根据索引访问数据，索引不存在时会报错
			//Capacity表示列表的容量长度，Count表示列表的存在的元素长度
            Console.WriteLine("Capacity:" + scoreList1.Capacity + "Count:" + scoreList1.Count);
            
            Console.ReadKey();
        }
    }
}

2. 关于列表的更多内容
   
   
3. 列表List的两种遍历方式-for循环和foreach循环

for(int i=0;i<list.Count;i++){ }
foreach(int temp in list){ }

4. 操作列表的属性和方法 😐

class Program
    {
        static void Main(string[] args)
        {
            List<int> scoreList = new List<int>() { 1,2,3};          

            scoreList.Insert(1, -1);
            scoreList.RemoveAt(3);
            scoreList.IndexOf(2);
            scoreList.LastIndexOf(2);
            scoreList.Sort();

            Console.ReadKey();
        }
    }

泛型类的定义

1. 泛型是什么？

通过参数化类型来实现在同一份代码上操作多种数据类型，利用"参数化类型"将类型抽象化，从而实现灵活的复用。

2. 泛型类定义

定义一个泛型类就是指，定义一个类，这个类中某些字段的类型是不确定的，这些类型可以在类构造的时候确定下来。

namespace _021_泛型
{
    class ClassA<T> //T代表一个数据类型，当时用ClassA进行构造的时候，需要指定T的类型
    {
        private T a;
        private T b;

        public ClassA(T a, T b)
        {
            this.a = a;
            this.b = b;
        }
        public string GetSum()
        {
            return a +""+ b;
        }

    }
}

 class Program
    {
        static void Main(string[] args)
        {
            var o1 = new ClassA<int>(24, 68); //当使用泛型类进行构造的时候，需要制定泛型T的类型
            var o2 = new ClassA<string>("呀卡", "马西");
            Console.WriteLine(o1.GetSum());
            Console.WriteLine(o2.GetSum());

            Console.ReadKey();
        }      
    }

3. 泛型方法

定义泛型方法就是定义一个方法，这个方法的参数类型可以是不确定的，当调用这个方法的时候再去确定方法的参数类型，可以实现任意类型组拼成字符串的方法。

namespace _021_泛型
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(GetSum<int, string>(1, "aabb"));
            Console.ReadKey();
        }
        public static string GetSum<T, T1>(T a,T1 b)
        {
            return a + "" + b;
        }
    }
}

字符串

System.string类

1. System.string类

class Program
    {
        static void Main(string[] args)
        {
            string s = "China NO.1"; //创建字符串
            
            int length = s.Length; //获取字符串里的字符个数（长度）
            
            if (s !="xxx") { } //判断字符串是否一样
            
            s = s + "!!!!!"; //字符串连接
            
            char c = s[2]; //通过索引取得字符串中的字符

            Console.ReadKey();
        }
    }

2. 字符串类string的更多用法

class Program
    {
        static void Main(string[] args)
        {
            string s = "www.bilibili.com";

            //当两个字符串相等的时候，返回0；不相等的时候，通过比较不相同的字符在ASCII中的位置，若靠前则返回-1，反之返回1
            int res = s.CompareTo("zzz.bilibili.com");

            string newStr = s.Replace(".", "__"); //把指定的字符转换为指定的字符
            string[]strArray1 = s.Split('.'); //以给定的字符为基础，把字符串拆分为一个字符串数组

            string str1 = s.Substring(4); //以索引为起点，截取后面所有的内容
            string str2 = s.Substring(4, 8); //以索引为起点，截取之后长度为8的字符串

            string str3 = s.ToUpper(); //把字符串转换为大写形式
            string str4 = s.ToLower(); //把字符串转换为小写形式

            string str5 = s.Trim(); //删除首尾两端的空格
            string str6 = s.Replace(" ", ""); //删除中间空格

            string str7 = string.Concat(str1, str2); //合并字符串，等于+=
            string str8 = string.Copy(s); //字符串复制，静态方法string.方法来引用
            //CopyTo-非静态方法(要复制字符的起始位置(从第几个字符开始往后复制（不包括第几个字符）)，目标字符数组，目标数组中的开始存放位置，要复制的字符个数);
            char[] char1 = new char[20];
            str1.CopyTo(0, char1, 0, 1);

            //在指定 String 数组B的每个元素之间串联指定的分隔符 A，从而产生单个串联的字符串
            string[] strArray2 = { "www", "bilibli", "com" };
            string str9 = string.Join(".", strArray2);

            string str10 = string.Format("{0:C3}", 2) ; //格式化字符串

            int index1 = s.IndexOf("bilibili"); //判断是否包含子字符串，如果不包含则返回-1；如果包含就返回第一个字符的索引
            //s.IndexOf("bilibili",5,2) 第5个字符开始，到第（5+2）=7位结束，查找在这个里面" "的位置
            char[] charArray = { 'b', 'c' };
            int index2 = s.IndexOfAny(charArray); //返回数组中任何一个字符最早出现的下标位置
            //s.IndexOfAny(charArray,5,2)

            //在指定位置插入字符串
            string date = "20191023";
            date = date.Insert(4, "-");
            date = date.Insert(7, "-");
   
            Console.ReadKey();
        }
    }

3. C#格式化数值结果表 string.Format()
   

StringBuilder

string里的内容是不可变的，stringbuilder里的内容是可变的，所以可以创建一些内容频繁变换的字符串。

1. 创建StringBuilder对象

using System.Text;//位于System.Text命名空间下
class Program
    {
        static void Main(string[] args)
        {
            //创建StringBuilder对象
            StringBuilder sb1 = new StringBuilder("wryyyyy");
            StringBuilder sb2 = new StringBuilder(20); //初始一个空的stringbuilder对象，占有20个字符的大小
            StringBuilder sb3 = new StringBuilder("JOJO", 20); //初始字符串，初始容量大小
        }
    }

2. StringBuilder的更多方法

 class Program
    {
        static void Main(string[] args)
        {
            //当我们需要对一个字符串进行频繁的操作的时候，使用stringbuilder效率比较高
            //因为stringbuilder一开始定义的容量大，string需要开辟新的内存空间，然后GC再去回收旧的内存空间
            StringBuilder sb = new StringBuilder("Sword Art Online", 30);

            sb.Append(" Alicization"); //字符串相加
            sb.Insert(0, "SAO:"); //指定位置插入字符串
            sb.Remove(0, 4); //删除字符
            sb.Replace(" ", "-"); //替换字符（串）
            Console.WriteLine(sb.ToString()); //将实例的值转换为string            

            Console.ReadKey();
        }
    }

正则表达式

定义：

正则表达式使用了一种数学算法来解决计算机中的文本检索，匹配等问题，正则表达式语言是一种专门用于字符串处理的语言，在C#可以解决以下问题：

• 检索：通过正则表达式，从字符串中获取我们想要的部分。
• 匹配：判断给定的字符串是否符合正则表达式的过滤逻辑,表述一个字符串的书写规则

可以用在判断用户的密码输入或邮箱输入上面

正则表达式的组成

正则表达式就是由普通字符以及特殊字符（成为元字符）组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。格式为：@" "

定位元字符 ^ $

class Program
    {
        static void Main(string[] args)
        {
            //定位元字符^$，搜索字符串，是否符合正则表达式的情况，然后把所有符合的位置，替换成规定的字符串
            string s = "I am a blue cat";
            string res1 = Regex.Replace(s, "^", "开始："); //"^"符号匹配字符串的开始
            string res2 = Regex.Replace(s, "$", "结束"); //"$"符号匹配字符串的结束
            Console.WriteLine(res1);
            Console.WriteLine(res2);

            Console.ReadKey();
        }
    }

基本语法元字符

class Program
    {
        static void Main(string[] args)
        {
            //校验只允许输入数字
            string s = Console.ReadLine();
            string pattern = @"^\d*$"; //正则表达式，“^”表示(以数字)开始，“\d”代表数字，“*”0个或多个元字符，“$”以\d（数字）结尾
            bool isMatch = Regex.IsMatch(s, pattern);

            //校验只允许输入 除大小写字母、0-9的数字、下划线_ 以外的任何字
            string pattern = @"^\W*$";
            bool isMatch = Regex.IsMatch(s, pattern);
            Console.WriteLine(isMatch);

            Console.ReadKey();
        }
    }

反义字符

class Program
    {
        static void Main(string[] args)
        {
             //查找除了ahou以外的所有字符
            string str = "I am a cat";
            string pattern = @"[^ahou]"; //[]它代表一个字符。除了ahou之外的任何一个字符

            string s = Regex.Replace(str,pattern,"*"); //把str里除了pattern之外的都替换成*字符
            Console.WriteLine(s);
        }
    }

xxaxxaxxax

重复描述字符

class Program
    {
        static void Main(string[] args)
        {
              //检测输入内容是否为合法QQ号（QQ号为5-12位数字）
            string qq1 = "126544";
            string qq2 = "126543565734752";
            string qq3 = "dd12654";
            string pattern = @"^\d{5,12}$";

            Console.WriteLine(Regex.IsMatch(qq1,pattern));
            Console.WriteLine(Regex.IsMatch(qq2, pattern));
            Console.WriteLine(Regex.IsMatch(qq3, pattern));

            Console.ReadKey();
        }
    }

True
False
False

择一匹配

class Program
    {
        static void Main(string[] args)
        {
             string s1 = "23 ^()^ wryyy 呀卡马西";
            string pattern1 = @"\d|[a-z]"; //数字 或者 a-z的字母
            MatchCollection col = Regex.Matches(s1, pattern1); //在指定的字符串中搜索搜索正则表达式的所有匹配项
            foreach (Match match in col)
            {
                Console.WriteLine(match.ToString()); //调用tostring方法，会输出match所匹配到的字符串
            }

            string s2 = "www.bilibili,com;";
            //string pattern2 = @"[.,;]";
            string pattern2 = @"[.]|[,]|[;]";
            string[] resArray = Regex.Split(s2, pattern2); //按照正则表达式进行分割
            foreach (var res in resArray)
            {
                Console.WriteLine(res);
            }

            Console.ReadKey();
        }
    }

对正则表达式分组（）

用小括号来指定子表达式（也叫做分组）

class Program
    {
        static void Main(string[] args)
        {
        	//重复 多个字符 使用（abcd）{n}进行分组限定
            string inputstr = Console.ReadLine(); //=="ab\w{2} ab\w{2}"，ab后面跟两个字符+ab后面跟两个字符
            string strGroup = @"(ab\w{2}){2}";
            string res = Regex.Replace(inputstr, strGroup, "1111");
            Console.WriteLine(res);
            
            //检测IP4地址
            string inputStrIp4= "192.168.1.4";
            string regexStrIp4 = @"^(((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?))$";
            Console.WriteLine(Regex.IsMatch(inputStrIp4, regexStrIp4));
            
            Console.ReadKey();
        }
    }

ab34ab__gdrfgdfdab__ab654dfgdfh4
1111gdrfgdfd11114dfgdfh4
True