.NET基础回顾(五)

一.字符串

1. 字符串的恒定性

(1)字符串拘留池的概念(即时窗口的使用);

(2)在创建一个字符串对象的时候,会先在字符串拘留池寻找是否有相同字符串内容的对象,如果有有就直接让变量指向这个对象,如果没有就创建新的对象;

2. 字符串部分函数用法

(1)string.Empty代表空字符串“”,而不是null;

(2)string.Compare(s1,s2),用来比较两个字符的大小;

(3)string.Concat(s1,s2),连接两个字符串并组成一个新串;

(4)s1.Contains(s2),判断指定的串是否包含指定的字串,返回bool值;

(5)s1.EndsWith(s2)(s1.StartsWith(s2)),判断指定的字符串是以指定的字串结尾(开始);

(6)s1.Equals(s2),判断是否与指定字符串相同;

(7)string.Format(“我爱{0},你爱{1}”,“你”,“他”),格式化字符串;

(8)s1.IndexOf()(s1.LastIndexOf()),查看指定子串在字符串中的索引(从字符串结尾往前查);

(9)str3.Insert(1,“我”),指定位置插入字符串;

(10)string.IsNullOrEmpty(str1),判断字符串是否为空串或者为null;

(11)str1.Remove(3),如果只穿一个int类型的数,会保留前面的,删除后面的(还有其他参数的重载方法);

(12)str1.Replace(str2,str3),替换;

(13)str1.Split(),分割成字符数组,可以用字符,字符串,空等进行分割,分割条件可以枚举出来;

(14)str1.Substring(1),从指定位置开始截取字符串;

(15)ToCharArray(),转换成字符数组;

(16)ToLow(),ToUpper(),转换大小写;

(17)Trim(),取消字符串前面和后面的空格;

3. StringBuilder(高效的字符串操作)

(1)sb.Append(),在sb对象里的字符串中追加新串;

(2)sb.AppendLine(),追加字符串并在末尾加换行符;

(3)和String比较来说,sb对象是可变的,String是不可变化的,当改变sb里的字符串时,不会重新开辟空间,而是直接在堆空间内改变sb所指的字符数组;

二.集合

1. 我们自己的集合和索引器

程序示例:

 1 class MyArrayList
 2     {
 3         int index = 0;
 4         private int[] arr;
 5 
 6         /// <summary>
 7         /// 构造函数用来指定集合的长度
 8         /// </summary>
 9         /// <param name="capacity"></param>
10         public MyArrayList(int capacity)
11         {
12             this.arr = new int[capacity];
13         }
14 
15         /// <summary>
16         /// Add方法
17         /// </summary>
18         /// <param name="value"></param>
19         public void Add(int value)
20         {
21             if (index >= arr.Length)
22             {
23                 int[] newArr = new int[arr.Length*2];
24                 Array.Copy(arr,newArr,arr.Length);
25                 arr = newArr;
26             }
27             arr[index++] = value;
28         }
29 
30         /// <summary>
31         /// 索引器
32         /// </summary>
33         /// <param name="index"></param>
34         /// <returns></returns>
35         public int this[int index]
36         {
37             get
38             {
39                 return arr[index];
40             }
41             set
42             {
43                 arr[index] = value;
44             }
45         }
46 
47         /// <summary>
48         /// 元素的个数
49         /// </summary>
50         public int Count
51         {
52             get
53             {
54                 return index; 
55             }
56         }
57 
58     }

2. ArrayList

(1)list.AddRange(ICollection c),可传参数为实现了ICollection接口的实现类的对象,添加集合;

         (2)ArrayList内部存储数据是一个object数组,创建这个类的对象的时候,这个对象里的数组长度为0;

         (3)调用Add方法加元素的时候,如果第一次增加元素,就会将数组的长度变成4往数组里加;

         (4)如果存储数据的数组满了,就会新建一个数组长度是原来数组的两倍,这个数组被原来数组的变量所引用;

         (5)list.Remove(),删除指定的值类型对象,删除的是第一个;

         程序实例:

         Person p = new Person(){Name = “新疆妹”};

list.Add();

list.Add();

list.Remove(p);

(6)list.RemoveAt(),删除指定的下标的元素;

(7)list.RemoveRange(),删除指定的范围;

(8)list.Clear(),清空动态数组,清空后数组的容量Capacity不变; 

(9)Object obj = list.Clone();

三.Foreach原理

1. 如果我们自己写的集合要被遍历,必须实现IEnumerator接口,因为foreach背后的代码如下:

IEnumerator tor = list.GetEnumerator();

While(tor.MoveNext())

{

         Console.WriteLine(tor.Current);

}

2. GetEnumerator()这个方法,返回一个实现了IEnumerator接口的对象;

3. 所以我们要实现IEnumerator这个接口中GetEnumerator()的话,就要写一个类来实现IEnumerator(),方法返回这个类的实例;

4. IEnumerator接口中定义一个Current只读属性,MoveNext方法,Reset()方法;

5. MoveNext方法的作用,将指针向前移动一位,并判断当前位是否有元素,如果有则返回true,否则返回false;

6. Current只读属性,得到当前指针指向的值;

7. 这两个方法都是在操作数组,而这个数组在我们的集合类中,所以我们要想办法将集合类的数组传递到当前迭代器类中;

8. 迭代器对象在集合类中创建,所以可通过构造函数让集合将他的数组传递给迭代器,这个时候迭代器已经有了数组的引用;

9. 实现MoveNext方法,声明index变量,用来保存当前指针指向的数组的索引,默认在-1,每调用一次这个方法,就index++,接着再判断index元素是否存在,index<count就存在,所以迭代器还需要知道元素的有效个数,通过构造函数传入;

10. 实现Current属性,return arr[index];

程序示例:

  1 /// <summary>
  2     ///  我们自己的集合. //int类型的数.
  3     /// </summary>
  4     class MyArrayList : IEnumerable
  5     {
  6         /// <summary>
  7         ///  数组字段.  这个数组用来存储整型数据。
  8         /// </summary>
  9         private int[] arr; //10.10
 10 
 11         /// <summary>
 12         ///  保存着1次往arr里存储数据的索引
 13         /// </summary>
 14         int index = 0;//1   2 
 15 
 16         /// <summary>
 17         ///  元素的个数
 18         /// </summary>
 19         public int Count
 20         {
 21             get
 22             {
 23                 return index;
 24             }
 25         }
 26 
 27         /// <summary>
 28         ///  构造函数用来初始化数组的长度
 29         /// </summary>
 30         /// <param name="capcity"></param>
 31         public MyArrayList(int capcity)
 32         {
 33             this.arr = new int[capcity];
 34         }
 35 
 36         public MyArrayList() { }
 37 
 38         public void Add(int value) //1  index  2   3
 39         {
 40             //当新增1个元素的时候.
 41             //我判断一下 arr 有没有存满  如果没有存满就继续往里存
 42             if (index >= arr.Length)  //
 43             {
 44                 //我重新创建1个数组 数组的长度是原来的2倍
 45                 int[] newArr = new int[arr.Length * 2];
 46                 //将原来的数组中的数据拷贝到新数组中.
 47                 Array.Copy(arr, newArr, arr.Length);
 48                 //然后将旧数组的变量指向新数组
 49                 arr = newArr;
 50             }
 51             arr[index++] = value;
 52         }
 53 
 54         /// <summary>
 55         ///  索引器 
 56         /// </summary>
 57         /// <param name="index"></param>
 58         /// <returns></returns>
 59         public int this[int index]
 60         {
 61             get
 62             {
 63                 return arr[index];
 64             }
 65             set
 66             {
 67                 arr[index] = value;
 68             }
 69         }
 70 
 71         /// <summary>
 72         ///  新增1个范围.
 73         /// </summary>
 74         /// <param name="arr"></param>
 75         public void AddRange(int[] arr)
 76         {
 77             foreach (int item in arr)
 78             {
 79                 this.Add(item);
 80             }
 81         }
 82 
 83         //实现IEnumerable成员 
 84         public IEnumerator GetEnumerator()
 85         {
 86             return new MyIEnumerator(this.arr,Count);
 87         }
 88 
 89     }
 90 
 91     class MyIEnumerator : IEnumerator
 92     { 
 93         private int[] arr;
 94 
 95         /// <summary>
 96         ///  保存的是当前读到第几个元素 默认-1
 97         /// </summary>
 98         int index = -1;
 99 
100         int count;
101 
102         public MyIEnumerator(int[] arr,int count)
103         {
104             this.arr = arr;
105             this.count = count;
106         }
107 
108         /// <summary>
109         ///  返回当前指针指向的元素的值
110         /// </summary>
111         public object Current
112         {
113             get
114             {
115                return  this.arr[index];
116             }
117         }
118 
119         /// <summary>
120         ///  是将指针向前移动1位,并判断当前位有没有元素.
121         /// </summary>
122         /// <returns></returns>
123         public bool MoveNext()
124         {
125             index++;
126             if (index < this.count)
127                 return true;
128             else
129                 return false;
130         }
131 
132         public void Reset()
133         {
134             throw new NotImplementedException();
135         }
136     }

 

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。