c#string的用法

1、字面量
@唯一支持的转义序列是""、{{ 、}}

 Console.WriteLine(@"abc""efg");
 int A = 100;
 string tempStr = $"{{{A}}}";

输出

 abc"efg
 {100}

也就是会把""，变成"，{{会变成一个{，}}会变成一个}，在别的情况下转义符号\不起到任何作用；
2、字符串插值

 int a = 100;
            Console.WriteLine($@"abc{a}efg");
            Console.WriteLine($@"abc
{a}efg");

输出

abc100efg
abc
100efg

说明这里的@将程序的 换行符变成了一系列的字符了，所以能否进行输出，否则的话会直接报错。
3、字符串方法
1）静态方法
1.1、string.join（以指定的字符串连接数组或者集合元素）

public class Animal
    {
        public string Kind;
        public string Order;

        public Animal(string kind, string order)
        {
            this.Kind = kind;
            this.Order = order;
        }

        public override string ToString()
        {
            return this.Kind;
        }
    }


            List<Animal> animals = new List<Animal>();
            animals.Add(new Animal("Squirrel", "Rodent"));
            animals.Add(new Animal("Gray Wolf", "Carnivora"));
            animals.Add(new Animal("Capybara", "Rodent"));
            string output = String.Join(" ", animals.Where(animal =>
                           (animal.Order == "Rodent")));
            Console.WriteLine(output);

输出

Squirrel Capybara

以上输出代表string.join将 IEnumerable 的成员进行连接时，先将成员调用了tostring()方法。

   String[] val = { "apple", "orange", "grape", "pear" };
            String sep = ", ";
            String result;

            Console.WriteLine("sep = '{0}'", sep);
            Console.WriteLine("val[] = {{'{0}' '{1}' '{2}' '{3}'}}", val[0], val[1], val[2], val[3]);
            result = String.Join(sep, val, 1, 2);
            Console.WriteLine("String.Join(sep, val, 1, 2) = '{0}'", result);

输出

sep = ', '
val[] = {'apple' 'orange' 'grape' 'pear'}
String.Join(sep, val, 1, 2) = 'orange, grape'

代表从索引为1的元素开始，总共要连接2个元素。
1.2、string.contact
连接 String 的一个或多个实例，或 String 的一个或多个实例的值的 Object 表示形式。

包含数组，几个string，集合

1.3、string.IsNullOrEmpty 判断是否为Null或者""
string str1 = null;

  string str2 = string.Empty;
  string str3 = "  ";
  Console.WriteLine(string.IsNullOrEmpty(str1));
  Console.WriteLine(string.IsNullOrEmpty(str2));
  Console.WriteLine(string.IsNullOrEmpty(str3 ));
   

输出
True
True
False

1.4、 string.IsNullOrWhiteSpace 判断是否为Null或者"“或者” "(空白字符串)

        string str1 = null;
        string str2 = string.Empty;
        string str3 = "  ";
        Console.WriteLine(string.IsNullOrWhiteSpace (str1));
        Console.WriteLine(string.IsNullOrWhiteSpace(str2));
        Console.WriteLine(string.IsNullOrWhiteSpace(str3));
        
        输出

True
True
True

1.5、string.empty

string str1 = "";
            string str2 = string.Empty;
            Console.WriteLine(str1.Equals (str2));

        输出

  true

1.6、string.copy 在堆中开辟内存

        string str1 = "123";
        string str2 = string.Copy(str1);
        Console.WriteLine(string.ReferenceEquals  (str1,str2));
       输出
       false
       满足相等的对象值，但是不满足对象同一性，也就是说，copy的时候是真的在堆中重新开辟了内存，两个内存的值相等；
  
  1.7、String.Intern
  字符串不可变性，主要作用是为了防止相同值的字符串占用了大量 的内存
   string s1 = "MyTest";
        string s2 = new StringBuilder().Append("My").Append("Test").ToString();
        string s3 = String.Intern(s2);
        Console.WriteLine(string.ReferenceEquals  (s1,s2));
        Console.WriteLine(string.ReferenceEquals(s1, s3));
        输出
        false
        true

可以理解为s1、s2、s3是存在暂存池上，而不是栈上，s1和s2具有相等的对象值，但是不具有对象同一性；
当调用string.intern时，会在暂存池上寻找有没有和s2值相等的引用，这里就是s1，这时就会把s1引用返回给s3，所以s1和s1就有了对象同一性；
1.8、string.IsInterned
判断字符串是否在暂存池，如果在的话，则返回引用，不在的话返回null。

2)实例方法
1.1、string.copy
将一个字符串拷贝到一个字符数组中，并且可以指定长度，如果时全部转换直接调用toarray方法即可；

其他如下：

 string str1 = "12345,ab,, A cde";

            char[] charArray = new char[10];
            str1.CopyTo(0, charArray, 0, 4);
            int length = str1.Length;
            Console.WriteLine(length);
            Console.WriteLine(str1.Contains("1"));
            string str2 = str1.Replace('1', '6');
            Console.WriteLine(str2);
            string str3 = str1.Replace("12", "67");
            string[] stringArray = str1.Split(new char[] { ',' });
            string[] string2Array = str1.Split(new char[] { ',' }, 2);
            string[] string3Array = str1.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);//返回值中不包含空数组的元素
            string[] string4Array = str1.Split(new string[] { "a","b" }, StringSplitOptions.RemoveEmptyEntries);
            string str4 = str1.Trim();
            string str5 = str1.Trim(new char[] { 'd', 'e', '1' });
            Console.WriteLine(str1.EndsWith("e"));

            Console.WriteLine(str1.EndsWith("E", StringComparison.OrdinalIgnoreCase)); //忽略大小写，二进制序号
            string str6 = str1.Substring(1);//一直截断到末尾
            string str7 = str1.Substring(1, 2);
            string str8 = str1.ToUpper();//大写
            string str9 = str1.ToLower();//小写
            int index1 = str1.IndexOf("3");//从前往后搜索第一个满足的字符串的索引
            int index2 = str1.IndexOf('1', 5);//从第几个字符开始搜索
            str1.IndexOf("1", 1, 4);//从第几个字符开始搜索，搜索多少长度
            int index3 = str1.IndexOf("a", StringComparison.OrdinalIgnoreCase);
            int index4 = str1.LastIndexOf('c');//从前往后搜索最后一个满足的字符串的索引
            string str10 = str1.Remove(1);//也可以用substring实现，从指定索引开始移除字符
            string str11 = str1.Remove(1, 4);

            string str12 = str1.Insert(0, "ggg");//往前插入字符串
            int index5 = str1.LastIndexOfAny(new char[] { 'a', 'c' });//指定多个字符，但是返回最后一个匹配项的索引
            string str13 = str1.TrimEnd(new char[] { 'd', 'e' });
            string str14 = str1.TrimStart(new char[] { '1', '2' });
            string str15 = str1.PadLeft(20);//填充空格，达到指定长度
            string str16 = str1.PadLeft(20, 'f');
            string str17 = str1.PadRight (20);//填充空格，达到指定长度
            string str18 = str1.PadRight(20, 'f');
            Console.WriteLine(str1.StartsWith("1"));

            Console.WriteLine(str1.StartsWith("1", StringComparison.OrdinalIgnoreCase)); //忽略大小写，二进制序号
            char[] charArray2 = str1.ToCharArray();
            char[] charArray3 = str1.ToCharArray(1, 10);

3）扩展方法

               string sss = "abcde";
            string sss1 = "ccdefgh";
            var sss2 = sss.Join(sss1, first => first, second => second, (first, second) => new { First = first, Second = second });//寻找内连接,返回指定的类型
            var sss3 = sss.GroupJoin(sss1, first => first, second => second, (first, seconds) => new { First = first, seconds });//链接不到也返回，只不过值为空，并且值为键对应的Inner中的集合



            var sss4 = sss.Intersect(sss1);//字符内连接，无法指定返回类型


            Dictionary<int, DateTime> dic = new Dictionary<int, DateTime>() { };
            DateTime dt1 = Convert.ToDateTime("2012-11-5");
            DateTime dt2 = Convert.ToDateTime("2012-11-5");
            DateTime dt3 = Convert.ToDateTime("2012-11-7");
            DateTime dt4 = Convert.ToDateTime("2012-11-7");
            DateTime dt5 = Convert.ToDateTime("2012-11-9");

            dic.Add(1, dt1);
            dic.Add(2, dt2);
            dic.Add(3, dt3);
            dic.Add(4, dt4);
            dic.Add(5, dt5);


            Persons[] person = new Persons[3] { new Persons(), new Persons(), new Persons() };


            person[1].Name = "ac";
            person[0].Name = "ab";
            person[2].Name = "b";

            person[0].Age = 15;
            person[1].Age = 15;
            person[2].Age = 24;
            List<Persons> person6 = person.OrderBy(per => per.Age).ThenBy(per2 => per2.Name).ToList();

            foreach (var item in person6)
            {
                Console.WriteLine($"{item.Name }:{item.Age }");
            }


            String str100 = "aacaba";
            Console.WriteLine(str100.All(new Func<char, bool>((item) => item.Equals('a'))));//确定所有字符是否都满足条件
            Console.WriteLine(str100.Any(new Func<char, bool>((ittm) => ittm.Equals('b'))));//确定是否存在字符满足条件
            IEnumerable<char> charArray1 = str100.Append('g');//将字符添加到字符串末尾
            IEnumerable<char> charArray2 = str100.Prepend('f');//将字符添加到字符串前面
            IEnumerable<char> charArray3 = str100.Where(new Func<char, bool>((item) => item != 'a')).ToArray();//根据集合中的项，从而选择某个条件筛选源集合中的元素
            IEnumerable<char> charArray33 = str100.Where(new Func<char, int, bool>((index, item) => item != 'a' && index > 2)).ToArray();//根据集合中的项，以及元素的索引，从而选择某个条件筛选源集合中的元素

            char[] charArray4 = str100.Select((item) => item).ToArray();//将元素的项作为参数传入
            char[] charArray44 = str100.Select((item, index) => { if (index < 3) return item; else return '0'; }).ToArray();//将元素的索引也作为参数传入
            string[] string1Array = str100.Where(new Func<char, bool>((item) => item != 'a')).Select(new Func<char, string>((item) => string.Concat(item.ToString(), "6"))).ToArray();//传入多少个参数，返回多少个参数


            string1Array.ToList().ForEach(item => Console.WriteLine(item));
            char[] string2Array = str100.Where(new Func<char, bool>((item) => item != 'a')).SelectMany((item) => string.Concat(item.ToString(), "6")).ToArray();//必须将每个传入的参数经过指定函数改变后变成一个单个的集合（所有集合称为二维集合），然后将所有二维集合元素进行合并形成一维集合
            string2Array.ToList().ForEach(item => Console.WriteLine(item));



            char[] charArray5 = str100.Where((item, index) => index > 100).ToArray();

            string str101 = string.Empty;
            List<char> charList6 = str101.DefaultIfEmpty().ToList();
            charList6.ForEach(item => Console.WriteLine(item));
            char defaultChar = 'g';
            List<char> charList7 = str101.DefaultIfEmpty(defaultChar).ToList();//指定为空时的默认值
            charList7.ForEach(item => Console.WriteLine(item));

            string str102 = "abc";
            char char2 = str102.First();//返回集合中第一个元素
            char char22 = str102.First(item => item == 'c');//返回指定条件的第一个元素
            char char222 = str102.FirstOrDefault();//返回集合中第一个元素
            char char2222 = str102.FirstOrDefault(item => item == 'b');//返回指定条件的第一个元素
            char char3 = str102.ElementAtOrDefault(2);//返回指定索引的元素

            string str103 = "abbaac";
            string str104 = "bbgfrc";
            List<char> charList8 = str100.Distinct().ToList();//反回非重复元素
            List<char> charList9 = str103.Except(str104).ToList();//用第一个集合减去第二个集合，如果有重复的元素则剔除
            List<char> charList10 = str103.Intersect(str104).ToList();//生成两个序列的交集,如果有重复的元素则剔除


            List<char> charList11 = str103.Reverse().ToList();//反转序列元素
            char char7 = str103.Single();//返回序列唯一元素，空或者没有元素会引发异常,
            char char77 = str103.Single(item => item == 'a');//返回序列指定条件的唯一元素，空或者没有元素会引发异常,
            char char8 = str103.SingleOrDefault();//如果为空返回默认值，多个元素引发异常
            char char88 = str103.SingleOrDefault(item => item == 'a');//返回指定条件唯一元素，如果为空返回默认值，多个元素引发异常
            List<char> charList12 = str103.Skip(2).ToList();//跳过从索引0开始的指定数量的元素
            List<char> charList122 = str103.SkipWhile(item => item != 'b').ToList();//跳过指定条件的元素，和where正好相反
            List<char> charList1222 = str103.SkipWhile((item, index) => item != 'b' && index > 2).ToList();//根据索引和项跳过指定条件的元素，和where正好相反


            List<char> charList14 = str103.OrderBy(item => item).ToList();
            List<Student> studentList = new List<Student>() { new Student() { Age =1,Name ="小王"},new Student() { Age =10,Name ="小李"} };
            List<Student> charList144 = studentList.OrderBy(item => item.Age ).ToList();//指定项的键，然后根据键来排序
            List<char> charList15 = str103.OrderBy(item => item).TakeWhile(item => item.Equals('a')).ToList();//要先进行排序，然后留下指定条件的元素
        
            List<char> charList13 = str103.Take(2).ToList();//返回从索引0开始的指定数量的元素
            List<char> charList133 = str103.TakeWhile((item,index)=> item=='b'&&index ==3).ToList();//返回满足条件的元素，这个和where不同，因为where是把所有的元素进行枚举，但是takewhile，在枚举的过程，如果遇到不符合条件的，就不继续枚举了，所以takewhile相当于while break。

            string str105 = "acfgbh";
            Dictionary<string, char> dictionary = str105.ToDictionary(item => string.Concat(item, ':'));//源集合元素为键的值，返回值根据函数任意指定

            long shortCount = str103.LongCount();
            long longCount = str103.Count();

            List<char> charList16 = str103.OrderByDescending(item => item).ToList();//降序
            List<Student> studentList2 = new List<Student>() { new Student() { Age = 1, Name = "小王" }, new Student() { Age = 10, Name = "小李" } };
            List<Student> charList166 = studentList2.OrderByDescending(item =>item.Age ).ToList();//指定键降序
          

            List<char> charList17 = str103.ToList();//返回重复元素
            HashSet<char> charHashSet = str103.ToHashSet();//返回非重复元素，且为HashSet的集合，和Distinct作用相同


            ILookup<char, char> charLookup = str103.ToLookup(item => item);//一个键可以对应多个元素,返回键以及元素
            ILookup<int, Student > charLookup2 = studentList2.ToLookup(item => item.Age);//根据集合，返回键以及集合元素组成的集合
            ILookup<int,string > charLookup3 = studentList2.ToLookup(item =>item.Age,index=> index.Name );//根据集合，返回键以及其他集合中的元素
            
            foreach (IGrouping<char, char> item in charLookup)
            {

                foreach (char subitem in item)
                {
                    Console.WriteLine(subitem);
                }
            }

            foreach (IGrouping< int, Student> item in charLookup2)
            {

                foreach (Student  subitem in item)
                {
                    Console.WriteLine($"{subitem.Age}:{subitem.Name }" );
                }
            }

            foreach (IGrouping<int, string> item in charLookup3)
            {

                foreach (string subitem in item)
                {
                    Console.WriteLine(subitem);
                }
            }
            string str106 = "abcdee";
            string str107 = "dfghj";
            List<string> stringList10 = str106.Zip(str107, (first, second) => string.Concat(first, second)).ToList();//将两个集合的元素进行组合后成为一个新的集合，集合元素个数不变


            List<char> charList20 = str106.Union(str107).ToList();//生成两个集合的并集

            bool isEqual = str106.SequenceEqual(str107);//对两个集合的所有元素进行比较，如果相同则返回true


            IEnumerable<IGrouping<char, char>> groups= str106.GroupBy(item=>item).ToList ();

            groups.ToList().ForEach(item => item.ToList().ForEach(subitem => Console.WriteLine(subitem)));

            string str111 = "adrgghggh";
         var ddd=   str106.GroupJoin(str111, item => item, second => second, (item, second) => new {id= item,name= second.Select(subitem => subitem) });
            int[] intArray = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
            int charResult = intArray.Aggregate((first, next) =>
            {

                Console.WriteLine($"first:{first},next:{next},{first + next}");
                return first + next;
            });//累加器，每次函数返回值都作为下次的第一个值first,next从第二个元素开始







            int[] intArray2 = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
            int a = 100;
            int charResult2 = intArray2.Aggregate<int, int>(a, (first, next) =>
            {

                Console.WriteLine($" a:{a} first:{first},next:{next},{first + next}");
                return first + next;
            });//累加器的初始值为a,每次函数返回值都作为下次的第一个值first,next从第一个元素开始


            int[] intArray3 = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
            a = 100;
            int charResult3 = intArray3.Aggregate<int, int, int>(a, (first, next) =>
             {

                 Console.WriteLine($" a:{a} first:{first},next:{next},{first + next}");
                 return first + next;
             },
             (item) =>
             {
                 return item + 1000;
             }
            );//累加器的初始值为a,每次函数返回值都作为下次的第一个值first,next从第一个元素开始，并且将最后的累加器经过函数变换后返回
            Console.WriteLine(charResult3);//返回对累加器结果进行指定函数变换的值