30天C#基础巩固------集合，File(文件操做 ),Encoding处理字符集

一:泛型

   关于泛型我本身也不是很好的理解，可是具体的运用仍是能够的，能够这样的理解，咱们定义一个数组，可是不知道未来它是保存什么类型的值，非常矛盾，这个时候泛型就出现了，它能够解决这个场景，list<T> 之前这里是类型，前提是咱们知道这里未来保存什么值，如今不知道了使用T(Type)来表示，未来什么类型的值均可以保存在里面。这个在集合，项目底层一些公共的接口，类之中使用的特别多。

二：集合

线型集合----List<T>

            List<int> array = new List<int>();
            int[] str = { 0, 0, 0, 0, };
            array.Add(1);
            array.Add(2);
            array.Add(5);
            array.AddRange(str);      //这里是添加一个数组到集合中。
            array.Remove(5);           //这里是添加的是一个固定的数字。
            array.RemoveAt(1);       //这里的item就是咱们数组的下标。咱们能够利用这个删除元素。
            array[0] = 23;              //修改第一个元素
            foreach (var item in array)         //这里是关于集合的循环输出。
            {
                Console.WriteLine(item.ToString());
            }
            Console.ReadKey();

离散集合

Dictionary<string,int> dic=new Dictionary<string,int>();

            Dictionary<string, string> dic = new Dictionary<string, string>();
            //初始化
            dic.Add("张辉", "1193451014");
            dic.Add("ahui", "1193451014");
            dic.Add("小辉", "1193451014");
            dic.Add("王辉", "1193451014");
            bool a=dic.ContainsKey("ahui");                     //利用键来看是否在集合里面保存
            Console.WriteLine(a);
            //这个键值对集合---咱们须要了解到如何循环的输出
            foreach (KeyValuePair<string, string> item in dic)          //输出的时候注意临时变量（item）的类型-----KeyValuePair<string, string>
            {
                Console.WriteLine(item.Key + "," + item.Value);
            }
            Console.ReadKey();

三：文件操做

    文件是什么：是硬盘里面的一个内存,是一堆字节快。

1：命名空间

System.IO; //文件的命名空间

2：FileStream文件流，将文件以字节的方式进行读写。

上面的图片是关于文件的一些经常使用的方法和类。下面是一些练习。

--->FileStream文件流。

     1：关于文件流的写。

咱们看一FileStream有哪些方法。都是一些构造函数。

---->WriteByte()方法

            //FileStream-----利用文件流来写，第一个参数是文件名，第二个是枚举类型，咱们选择从新写入。第三个是权限的选择。            
            FileStream fWrite=new FileStream("ahui.txt",FileMode.Create,FileAccess.Write);
            fWrite.WriteByte(97);              //写入了，可是咱们要是没有调用display或者Flush就不会写入文件，只是写入缓冲期。
            //Flush()-----清除此流的缓冲区，使得全部缓冲的数据都写入到文件中。
            fWrite.Flush();                        //这样才能写入文件中。
            Console.WriteLine(fWrite);
            Console.ReadKey();

上面的代码要是咱们从客户端输入就会出现乱码，咱们须要经过设置编码的格式来修改。

----->Write()

            Console.WriteLine("请输入？");
            string sInput = Console.ReadLine();
            //设置编码格式----有助于咱们往文件中写入汉字
            byte[] bs = Encoding.Default.GetBytes(sInput);
            fWrite.Write(bs,0,5);              //写入了，可是咱们要是没有调用display或者Flush就不会写入文件，只是写入缓冲期。

 

---->ReadByte()

            //利用using来写，这个最后会自动的调用Display()方法 ，使咱们写在缓冲区的内容写入到文件中。
            using (FileStream fRead=new FileStream("ahui.txt",FileMode.Open,FileAccess.Read))
            {
                List<byte> list=new List<byte>();                //设置一个集合
                int res = -1;
                while ((res=fRead.ReadByte( ))!=-1)           //利用循环来把文件中的值添加到集合中
                {
                     list.Add((byte)res);                             //集合的Add()方法。
                }
            }     
            Console.ReadKey();

这里的49和50是我文件中保存的值。

---->Read

            using (FileStream fReader=new FileStream("ahui.txt",FileMode.Open,FileAccess.Read))
            {
                //使用数组来存储一个块字节
                byte []bs=new byte[10];                                     //这个就至关于缓冲区同样
                int count = fReader.Read(bs,0,bs.Length);        //要求读取10个字节，从数组的第0位开始，所有存储完。     
            }

---->复制文件

            //思路---------------先读取文件，后写入文件。
            Console.Write("请输入你要复制的路径#");
            string str = Console.ReadLine();
            if (!File.Exists(str))          //判断文件是否存在
            {
                Console.WriteLine("文件不存在，，，你搞我呀，");
                Console.ReadKey();
                return; //直接跳出.
            }
            //走到这里就表示文件存在
            Console.Write(" 请输入要往哪里复制#");
            string strM = Console.ReadLine();
            using (FileStream fReader=new FileStream(str,FileMode.Open,FileAccess.Read))                //进行读的操做
            {
                using (FileStream rWrite=new FileStream(strM,FileMode.Create,FileAccess.Write))      //进行写操做
                {
                    //第一种------利用ReadByte()和WriteByte()按照字节来进行处理
                    int res = -1;
                    while ((res=fReader.ReadByte())!=-1)             //这里看是否读取到值，是否进行循环，没读取到res=-1,则不进行写入操做。
                    {
                        rWrite.WriteByte((byte)res);                     //参数只能是byte类型的，咱们须要强制类型转换。
                    }                    
                }
            }
            Console.WriteLine("OK");
            Console.ReadKey();

上面的效率不是很高，咱们能够利用Read()/Write()来进行，效率比以前的高不少。

                    //第二种------利用Read()和Write()按照字节来进行处理
                    //这里利用的是buffer,咱们须要一个字节数组来处理。
                    byte [] buBytes=new byte[1024*1024*10];         //申请了一个10M大小的空间。                          
                    int count = 0;
                    while ((count = fReader.Read(buBytes, 0, buBytes.Length)) > 0)       //把读取到的内容写入到了buffer中，咱们只要文件中有值，count就会大于0。
                    {
                        rWrite.Write(buBytes, 0, count);                                   //把buffer中的值写入到文件中。          
                    }  

四：Encoding处理字符集。

声明一个字符编码，

Encoding en = Encoding.GetEncoding("gb2312"); //声明一个gb2312的字符编码

获得计算机中的全部字符编码

            EncodingInfo[] ens = Encoding.GetEncodings();  //获得全部的编码 ，返回的是一个数组。+EncodingInfo是一个类，里面有一些关于编码的属性。
            for (int i = 0; i <ens.Length ; i++)
            {
                Console.WriteLine("{0},{1},{2}",ens[i].CodePage,ens[i].DisplayName,ens[i].Name);
            }
            Console.ReadKey();

咱们经过控制台能够看到PC中的全部的编码。

上面的代码中有注释，咱们能够发现有些编码咱们能够经过一个类来声明一个数组，这样就能够点 出来咱们的全部的编码，其中有编码的编码数，编码名称，编码说明。

eg:将数字转换为16进制。

            for (int i = 0; i < 17; i++)
            {
                Console.WriteLine(i.ToString("x2"));           //这里面的x表示的是编码的格式为16进制。 2表示保留2位数。
            }
            Console.ReadKey();

五：关于继承被初识化的调用问题

   子类继承基类，当子类被初始化的时候，咱们是先调用基类的构造函数，在调用子类的构造函数，这里有个叫作回溯的问题。是从里到外的。

    /// <summary>
    /// 基类
    /// </summary>
    public class Parset
    {
        public Parset()
        {
            Console.WriteLine("基类被调用了。");
        }
    }
    /// <summary>
    /// 子类
    /// </summary>
    public class ChildA:Parset
    {
        private string name = "阿辉";
        public ChildA()
        {
            Console.WriteLine("子类被调用了，，，");
        }

        public void SayHello()
        {
            Console.WriteLine(name);
        }
    }

            ChildA ca=new ChildA();
            ca.SayHello();
            Console.ReadKey();

咱们经过这里就能够发现这个规则。