数往知来C#之 String 集合 深拷与浅拷 序列化<五>

C# 基础常用string方法篇

复习、
1、引用类型与值类型
    --》文件的复制与快捷方式的复制
2、垃圾回收

3、静态与非静态
  --》如何定义静态成员与静态类
  --》如何调用静态成员

4、异常

    -》托管与非托管
       -》.net frameworl 
主要分为三个东西：CLR、CTS、类库
     -》由CLR管理的代码就是托管的，否则就是费托管的（如File.Create）
     ->异常是一个类，需要抛出一个异常就要new
  -》thorw关键字，抛出
二、常用类库--String
大写的String与小写的string有什么不同？
  -》可以说两个都一样
  -》String是一个类
  -》构造方法    new string(char [] shs)
2)两个常用的属性（Length/Empty(常量)）
  -》length   这一点与数组的用法类似
  -》str[0]这个中括号就不叫下标，叫索引
常用的方法（索引的使用、ToCharArrray)
不可变性
既然是不可变的，那么多个字符串，结果相同的时候，就没有必要每次生成一个对象（节省资源）
3）字符串拘留池（暂存池）
由于有字符串拘留池的存在，如果代码中有大量的字符串的值相同，那么他们都指向同一个对象，
整个代码中只创建一个对象。
字符串的内部实现与C语言的字符串的实现一样，可以参考 IL Assembly这本书

4）字符串的处理常用的
   -》比较
       1）Equals方法
      -》静态的Equals方法
   -》非静态的（string的/object的）
   Equels方法法有三个重载，StringComparison是个枚举 OrdinalIgnoreCase表示不区分大小写比较。
      // Equals方法
            // -> 静态的比较方法（静态方法由类名点出来的）

string str1="abcd";
   string str2="ABCD";
            if (string.Equals(str1, str2, StringComparison.OrdinalIgnoreCase))
            {
                Console.WriteLine("相等");
            }
            else
            {
                Console.WriteLine("不等");
            }
            // -> 非静态(string的，object的)（实例方法是有对象点出来的）
            if (str1.Equals(str2, StringComparison.OrdinalIgnoreCase))
            {
                Console.WriteLine("相等");
            }
            else
            {
                Console.WriteLine("不等");
            }

   

string.Compare方法是静态方法，比较两个字符串大小，比较的的是没一位字符的unicode码，
比较规则：分别从两个字符串的第一位两两相比，如果第一位相等就再比较第二位，知道比出大的为止。
注意：如“22”和“123”相比，此时比较第一个‘2’比‘1’大，那么就后面的不会再比较了，此时“22”比“123”大

string str1="12";
   string str2="23";
     if (string.Compare(str1, str2) > 0)
            {
                Console.WriteLine("大于");
            }
            else
            {
                Console.WriteLine("小于");
            }

   

   -》修整
    Trim()方法，修整字符传收尾的空格，，并将新的字符串返回
Trim(praram char [] chs),去除字符数组中出现的字符
TrimEnd() 去掉右边的
TrimStart() 去掉左边的
   -》检索
增加：
移除
查找
  contains()
  indexof()
  lastindexof()

   -》分割与合并

   -》格式化
三、StringBuilder
   ->Appand()     追加
   -》AppandLine   追加换行 相当于 Appand（“123 ”）
   ->AppandFramart  格式化
StringBuilder输出的时候记得要ToString()一下

C#  集合篇

1）string.format  格式化字符串（就是挖坑填坑）
可以参考console.writeline（“{0}{1}”，str1,str2）;不同的是conbsole.writeline()是输出，Format是把它作为一个字符串返回。
   -》@符号的两个好处：1）可以取消转义
                   2）写字符串的时候可以换行
二、集合
为什么要有集合？
数组不是动态的，他的长度动态的变动，为了拟补这些就有了集合
可以认为，集合就是一个动态的数组，并且提供了一些处理的方法

1）增、
ArrayList里面可以存放任何类型的数据,里面存放的数据类型是object的 （arraylist要引入命名空间  shift+alt+F10）
   arrayList.Add(要添加的数据);  （这是个实例方法）
   arrayList.AddRange(数组);     这里要注意Add方法也可以放一个数组进去，但是不同的是Add方法是把整个数组当成一个集合的元素存到集合里去，
而AddRange方法是把数组的每个元素排列放到集合里去。
2）删、
Remove()  把指定的元素删除，如果集合里没有这个元素就会忽略掉，不会报异常
RemoveAt()  把集合里指定下标的元素删除，如果这个下标超出集合的长度就会报异常
3）改、
和数组一样通过下标改。直接赋值
4）查
contains（要查找的元素）
如果集合里有这个元素会返回一个true,否则返回false

5）插入
arrayList.Insert(要插入位置的索引，要插入的数据);

arraylist最大缺点就是Arrayliat是object类型，处理数据需要考虑类型兼容
需要把集合里的数据拿出来的时候需要强制转换，由于是object类型存什么类型的数据都可以，当集合里存的数据多的时候
我们强制转换就会就会比较麻烦，为了解决这个问题，List<>泛型集合就出现了。

2）Hashtable<键，值>   
   -》Hashtable的出现就是为了让我们便于查找集合里的数据的，
   -》hashtable里面存的是一个 键 和 值。他们都是object类型的，可以存放任何类型的。
   -》hashtable的键就相当于一个标记，要查找的时候可以通过 hashtable.Contains(要查找的键)；方法就可以快速的找到这个键对应着的值（它是通过一个哈希散列算法来实现的）
I、增
      hashtable.Add(键，值);    //hashtable只有一个增加的方法，里面可以放任何类型的数据。
II、删
Remove(键);
    -》我们知道ArrayList是通过下标来删除的，那么 我们的hashtable也是相同的原理，hashtable的键就相当于arraylist的下标，
如果把键改成0、1、2、3、4、5........那么就相当于一个ArrayList,那么可以得到结论，hashtable[键] 通过中括号 键来删除。
三、泛型集合
List<T>   这个尖括号里写什么类型这个集合就存什么类型的数据
  -》list就相当于一个规定好存放类型的ArrayList,
  ->当我们规定好类型后就可以解决类型兼容的问题了，从几何里取数据时就方便多了。
  List的增、删、改、查方法跟ArrayList一样。
Dictionary<键，值> 
    ->Dictionary对应的就是hashtable，我们可以规定好键和值的类型，使用起来更加的方便
    -》遍历的三种方法

foreach (string item in dic.Keys)   //通过键来遍历
            {
                Console.WriteLine(item);
                Console.WriteLine(dic[item]);
            }

            foreach (Person item in dic.Values)  //通过值来遍历
            {
                Console.WriteLine(item);
            }

            foreach (KeyValuePair<string,Person> item in dic)  //我们有时候遍历的时候要同时用到集合的键和值，就可以通过这个方法
            {                                                   //KeyValuePair也是一个集合
                Console.WriteLine(item.Key + " "+item.Value);
            }

遍历集合用foreach，  ArrayList和hashtable使用要引入命名空间，而List和Dictionary不用，可以看出微软提倡我们用 List和Dictionary

二、foreach  （可以遍历任何实现了IEnumerble接口的对象）
  foreach(临时数据类型 临时变量 in 要遍历的集合)
  {
     //将临时变量作为遍历的数据使用
  }
要知道临时数据类型是什么类型的可以先写个var 然后在下面设个断点，再把光标放到var上去，就可以得到当前遍历的集合是什么类型了
尽量不要用var

四、装箱与拆箱
值类型转换为引用类型就是装箱
应用类型转换为值类型就是拆箱

对值类型装箱保持不变性，对引用类型不保持保持相关性（）

Dotnet学习_递归篇

三、递归

递归就是调用自己

--》怎么调用？（递推关系）

--》什么时候跳出

等差数列

           2   4   6   8   10  ...

求第n项

               2n

           Func(n) = Func(n-1) + 2

           Func(n) = (Func(n-1-1)+2)+2

。。。

           Func(n) = (Func(1)。。。)。。。+2

写递归

      --》首先要找到递推关系

      --》临界条件

小练习_神探福尔摩斯小说

private void Form1_Load(object sender, EventArgs e)
        {
            //先添加一个根节点
            TreeNode tn = tvwDir.Nodes.Add("神探福尔摩斯-柯南.道尔");
            //获得文件的路径
            string path= Path.GetFullPath ("txt");
            RecAdd(tn, path);
        }
        private void RecAdd(TreeNode tn, string path)
        {
            //获得这个路径下的所有子目录
            string [] dirs = Directory.GetDirectories(path);
            //获得这个路径下的所有子文件
            string[] files = Directory.GetFiles(path);
            //循环把所有的子目录添加到父节点下
            foreach (string item in dirs)
            {
                //从绝对路径里提取文件名
                string file= Path.GetFileNameWithoutExtension(item);
                TreeNode tn1= tn.Nodes.Add(file);//目录名添加到父节点下
                //递归调用，因为不知道子目录下还有多少个子目录，所以递归调用
                RecAdd(tn1, item);
            }
            //循环添加所有的子文件到父节点下
            foreach (string item in files)
            {
                //同样的需要对绝对路径做一下处理，提取文件名
                string file = Path.GetFileNameWithoutExtension(item);
                TreeNode tn2= tn.Nodes.Add(file);//文件名添加到父节点下
                tn2.Tag = item;
                //tag属性石用来存储程序员需要使用的任何数据
                //把绝对路径保存到刚添加的节点的tag属性下，用于后面读取文件里的内容
            }
        }
        private void tvwDir_AfterSelect(object sender, TreeViewEventArgs e)
        {
            TreeNode tn= e.Node ;//先获取选中的节点
            if (tn.Tag !=null)//判断tag属性是不是空
            {
                txtContans.Text = File.ReadAllText(tn.Tag .ToString (),Encoding .Default );
            }
        }

C#  深拷和浅拷篇

二、深拷与浅拷
拷就是拷贝、复制的意思
      --》深拷和浅拷是指堆空间里的对象和引用类型的拷贝，而值类型不存在深拷和浅拷，因为值类型只是把值给复制了一份。
浅拷
   --》浅拷，只要有一个引用类型没有被复制就是浅考，（复制就是产生了一个完全没有关系的对象，而这个对象里德值是被复制过来的）
     

class Mark
    {
        string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
    }
    class MyClass
    {
        string _name;
        Mark mark;
        public Mark Marks
        {
            get { return mark; }
            set { mark = value; }
        }
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        public MyClass Coby()
        {
            MyClass temp=new MyClass ();
            temp.Name = this.Name;
            temp.mark = new Mark();
            temp.mark.Name = this.mark.Name;
            return temp;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyClass m1 = new MyClass();
            m1.Name = "张三";
            m1.Marks = new Mark();
            m1.Marks.Name = "哈哈哈";
            MyClass m = m1;   //这里只是把m1的引用复制了一份赋给了m   并没有复制m1里的对象也没有复制引用类型所以既不是深考也不是浅考
            MyClass m2 = new MyClass();  //浅考
            m2.Name = m1.Name;
            m2.Marks = m1.Marks;//这里是把m1Marks里的对象复制了，m1.marks存的引用又复制了一份赋给m2.marks此时他们都是指向了堆空间里的另一个对象mark，引用类型没有被完全复制在mark这里断开了，所以是浅考
            MyClass m3 = new MyClass();
            m3.Name = m1.Name;
            m3.Marks = new Mark();
            m3.Marks.Name = m1.Marks.Name;//这里m3是重新New一个对象，然后把m1.marks.name的值复制给m3.marks.name，他们是两个完全不一样的对象，此时m1里的引用类型被m3完全的复制了一份，所以叫深考，
                                                                   //只要 所有的引用类型都被复制了没有一个被断开就是深考
        }

C#  序列化篇

一、序列化
为什么要序列化？    --》为了把内存里的数据写到硬盘里。
序列化首先 第一步：给类加一个标签，标记为可以被序列化，要序列化的对象类与父类均需标记

[Serializable]   //标记 （特性的意思）
Class myClass
{
}
     static void Main(string[] args)
        {
            #region 传统方法
            //Student stu = new Student();
            //stu.Name = "张三";
            //stu.Sex='男';
            //stu.Age = 20;
            ////将student对象存到
            //StringBuilder sb = new StringBuilder();
            //sb.AppendLine(stu.Name );
            //sb.AppendLine(stu.Age.ToString () );
            //sb.AppendLine(stu.Sex .ToString ());
            //File.WriteAllText("E:\sb.txt", sb.ToString());
            //string []input= File.ReadAllLines("E:\sb.txt");
            //Student s=new Student ();
            //s.Name = input[0];
            //s.Age =Convert .ToInt32 ( input[1]);
            //s.Sex = Convert.ToChar(input[2]);
            #endregion
            List<Student> list = new List<Student>();
            list.Add(new Student ("张三1",20,'男'));
            list.Add(new Student("张三2", 20, '男'));
            list.Add(new Student("张三3", 20, '男'));
            list.Add(new Student("张三4", 20, '男'));
            list.Add(new Student("张三5", 20, '男'));
            list.Add(new Student("张三6", 20, '男'));
            list.Add(new Student("张三7", 20, '男'));
            list.Add(new Student("张三8", 20, '男'));
            list.Add(new Student("张三9", 20, '男'));
            #region 荣誉代码
            //using (FileStream file = new FileStream("E:\1.dat", FileMode.Create, FileAccess.Write))
            //{
            //    BinaryFormatter bin = new BinaryFormatter();
            //    bin.Serialize(file, list);
            //}
            //Console.WriteLine("序列化完成");
            //using (FileStream wfile = new FileStream("E:\1.dat", FileMode.Open, FileAccess.Read))
            //{
            //    BinaryFormatter bin=new BinaryFormatter ();
            //    Student s = (Student)bin.Deserialize(wfile);
            //}
            #endregion
            //序列化
            //首先需要一个写得流
            using (FileStream filewrite = new FileStream("E:\1.dat", FileMode.Create, FileAccess.Write))
            {
                //再需要一个工具
                BinaryFormatter bin = new BinaryFormatter();
                bin.Serialize(filewrite, list);  //第一个是流，第二个是对象
            }
            //反序列化
            //首先也需要一个读的流
            using (FileStream fileread = new FileStream("E:\1.dat", FileMode.Open, FileAccess.Read))
            {
                //再需要一个工具
                BinaryFormatter fbin = new BinaryFormatter();
                List <Student > s = (List <Student >)fbin.Deserialize(fileread);
            }
            Console.WriteLine("完成");
        }

序列化的一个应用---保存窗体上一次关闭时的位置
--》首先写一个方法，保存窗体的位置（窗体的左上角的坐标）和窗体的长和宽，在关闭窗体的时候调用这个方法。（写在Dispose方法里 关闭窗体时都会调用这个方法）
  

protected override void Dispose(bool disposing)
        {
            //调用保存窗体关闭时的位置大小
            Save();
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
--》然后要一个类，这个类里面有两个字段 来存储窗体的location和size属性，把这儿两个属性分别赋值给这个类的两个字段
    class MyPoint
    {
        Point mPoint;
        Size mySize;
        public Point  MPoint
        {
            get;
            set;
        }
        public Size  MySize
        {
            get;
            set;
        }
    }

--》然后序列化把数据写到硬盘里保存，当窗体关闭的时候调用这个方法就保存了窗体关闭时的位置和大小。
--》再写一个方法反序列化，把存到硬盘里德数据再拿出来，写窗体的 Lode事件（窗体启动前都会执行lode事件，lode事件一般都用来初始化），
把定义类的两个字段里存的数据再赋给窗体。
   

private void Save()
        {//需要一个流
            using (FileStream filewrite = new FileStream("location.dat", FileMode.Create, FileAccess.Write))
            {
                //new一个MyPoint类用来存储窗体的位置大小
                MyPoint mypoint = new MyPoint();
                mypoint.MPoint = this.Location;//把窗体的位置赋给字段（窗体的左上角的point）
                mypoint.MySize = this.Size;//把窗体的大小赋给字段
                //需要一个序列化的工具
                BinaryFormatter bin = new BinaryFormatter();
                //开始序列化
                bin.Serialize(filewrite, mypoint);
            }
        }
        private void ReadLocatoin()
        {
            if (File.Exists("location.dat"))//判断一下窗体的位置大小被改变了没有，如果改变了会产生一个"location.dat"文件
            {
                //需要一个流
                using (FileStream fileread = new FileStream("location.dat", FileMode.Open, FileAccess.Read))
                {
                    //需要一个反序列化的工具
                    BinaryFormatter bin = new BinaryFormatter();
                    //开始反序列化
                    MyPoint p = (MyPoint)bin.Deserialize(fileread);
                    //把窗体的启动起始位置设置为自定义
                    this.StartPosition = FormStartPosition.Manual;
                    this.Location = p.MPoint;
                    this.Size = p.MySize;
                }
            }
        }
        private void Form1_Load(object sender, EventArgs e)
        {
            ReadLocatoin();
        }

//最近工作事情多，本系列下章应该会延时。