c#学习笔记——3

1.什么是垃圾回收，什么时候回收
动态管理内存，代满的时候回收



2.str1==str2  表达式
只要是字符串的内容或地址任何一个相同，就是true




集合：
集合就是一个动态的数组
记住  增删改查


1.ArrayList    ,      Hashtable
步骤：
1.引入命名空间using Syste.Collections
2.new对象
3.增删改查




增
 ArrayList list=new ArrayList ();
 加入单个数据，用Add()方法。
 插入数据，用Insert()方法。
 加入一批数据，用AddRange()。
 插入一批数据，用InsertRange()方法。
 也可以list.AddRange(list),将自身内部的数据再次加进去。
 
 删
 ArrayList list=new ArrayList ();
 RemoveAt()，删除指定"下标"的数据，记得不要超出范围
 Remove（），删除指定数据，如果没有找到数据，就什么也不做，不会报错。
 RemoveRange（）
 
 改
  ArrayList list=new ArrayList ();
  list[0]="新数据"
  
 查
 Contains()。
 IdexOf()。
 
 
 例子：
 随机生成10个从1到100中的偶数
 ArrayList list = new ArrayList();
    Random r = new Random();
while (list.Count < 10)
            {
                int num = r.Next(1, 101);
             if (!list.Contains(num) )
              {
                    if (num % 2 == 0)
                  {
                        list.Add(num);
                  }
              }
            } 
 
 
 例子：


            // 有一个字符串是用空格分隔的一系列整数，
            // 写一个程序把其中的整数做如下重新排列打印出来：
            // 奇数显示在左侧、偶数显示在右侧。比如”2 7 8 3 22 9 5 11”
            // 显示成”7 3 9 2 8 22….”


            string str = "2 7 8 3 22 9 5 11";
            // 来两个集合
            ArrayList odd = new ArrayList();
            ArrayList even = new ArrayList();


            string[] temp = str.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            for (int i = 0; i < temp.Length; i++)
            {
                 
                 int num = Convert.ToInt32(temp[i]);     
或者用//int num = temp[i][temp[i].Length - 1] - '0';   //取出个为数字符对应的ASCII码，减去'0'对应的ASCII码，结果为个为上的数
             
                  if (num % 2 == 0)
                {
                    even.Add(temp[i]);
                }
                else
                {
                    odd.Add(temp[i]);
                }
            }


            odd.AddRange(even);


            


            // ToArray方法可以将ArrayList变成数组
            // 但是是object类型的数组(object[])
            // ToArray有一个重载，里面可以放置类型，表示转换成什么类型的数组
            // 由于string[] 是一个类型的声明，不是变量，而方法中的参数需要一个变量
            // 利用typeof运算符，获得类型的对应变量(typeof(类型名))
            // 考虑到多态，需要将数据全部转化为数组，所以ToArray方法返回一个Array类型
            // Array类型是所有数组的父类，那么就通用了，因为可以使用里氏转换原则进行转换

// 自定义的类也可以  Person[] ps = (Person[])list.ToArray(typeof(Person));
         方法一   // string[] strs = (string[])odd.ToArray(typeof(string));
         方法二
            string[] strs = new string[odd.Count];
            for (int i = 0; i < odd.Count; i++)
            {
                strs[i] = odd[i].ToString();
            }




          方法三      string s = string.Join(" ", odd.ToArray());
            Console.ReadKey();
        }
    }
}


  
  
Hashtable:
Hashtable的存在就是为了实现快速的在存储数据中找到某个数据
  
  
1.引入命名空间using Syste.Collections
2.new对象
3.增删改查 




Hashtable table =new Hashtable();


增
table.Add("key","value");




删
table.Remove("key");




改
通过key
table["key"]= 新value;




查
table.ContainsKey("key");
table.Contains("key");   Contains与ContainsKey一样




补充
1.方法
Clear（）清空


2.如何遍历
专门用来遍历hashtable的语法
foreach(object item in 集合的名字)
{
使用item
}
专门遍历key
foreach(object item in 集合的名字.Keys)
{
使用item
}


专门遍历key
foreach(object item in 集合的名字.Values)
{
使用item
}
foreach(DictionaryEntry item in 集合的名字)
{
使用item
}






泛型
例子：统计字符串中，每个字符出现的次数
class Program
    {
        static void Main(string[] args)
        {
            // 就是为了解决object类型对类型处理的繁琐
            // 处理数据，一般都是单一类型
            // 怎么用泛型，有哪些泛型要掌握
            // ArrayList    List
            // Hashtable    Dictionary


            // 1、不用引用命名空间，所有泛型集合都在System.Collections.Generic下面
            // 2、创建对象，需要制定类型
            // 3、与其他结合用法一致
            //List<Person> numList = new List<Person>();
            //List<object> os = new List<object>();


            Dictionary<string, int> dir = new Dictionary<string, int>();
            string str = "我爱北京们都是好天安门，天安们都是好门天安门，天安们都是好门天安门，天安门上们都是好太阳升; 我们都是好孩子";
            for (int i = 0; i < str.Length; i++)
            {
                string temp = str[i].ToString();
                if (dir.ContainsKey(temp))
                {
                     dir[temp]++;
                    
                }
                else
                {
                    dir.Add(temp, 1);
                }
            }
            StringBuilder sb = new StringBuilder();
            foreach (KeyValuePair<string, int> item in dir)
            {
                sb.AppendFormat("{0}\t{1}\r\n", item.Key, item.Value);
            }


            Console.WriteLine(sb.ToString());
            Console.ReadKey();
        }
    }
  
  
  
  Path
例子：
class Program
    {
        static void Main(string[] args)
        {
           
            string str1 = @"c:\desktop\1.txt";
           string str_ = @"c:\desktop";
            string str2 = @"1.txt";
           string str3= Path.Combine(str_, str2);                     Combine      结果   c:\desktop\1.txt           
           Console.WriteLine(str3);                                                            




         string str4=  Path.GetDirectoryName(str1);                 GetDirectoryName 返回文件或文件夹所在的文件夹路径  结果   c:\desktop
         Console.WriteLine(str4);


       string str5=  Path.GetExtension(str1);                       GetExtension  返回扩展名                            结果       .txt
       Console.WriteLine(str5);
 
       string str6 = Path.GetFileName(str1);                        GetFileName    返回文件名（包括扩展名）              结果         1.txt
       string str8 = Path.GetFileNameWithoutExtension(str1);       GetFileNameWithoutExtension  返回文件名（不包括扩展名）  结果         1
       Console.WriteLine(str6);
       Console.WriteLine(str8);
       string str7 = Path.ChangeExtension(str1, "xls");            ChangeExtension 只把扩展名改了，全部返回               结果    c:\desktop\1.xls
       Console.WriteLine(str7);


       string str9 = Path.GetFullPath(str1);                        GetFullPath返回全路径                          结果 c:\desktop\1.txt
       Console.WriteLine(str9);


       char[] ch1 = Path.GetInvalidFileNameChars();                  返回一个char[]  里面的成员都是不允许在文件名中使用， ▲ ？之类的
       char[] ch2 = Path.GetInvalidPathChars();                         返回一个char[]  里面的成员都是不允许在路径名中使用， ▲之类的


       Console.WriteLine(new string(ch1));
       Console.WriteLine(new string(ch2));


       string str10 = Path.GetPathRoot(str1);                       GetPathRoot返回根目录      结果  c:\
       Console.WriteLine(str10);


       Console.WriteLine(Path.HasExtension(str1));               HasExtension   确定路径是否包括文件扩展名    结果   True
       Console.WriteLine(Path.IsPathRooted (str1));   IsPathRooted获取一个值，该值指示指定的路径字符串是包含绝对路径信息还是包含相对路径信息  结果   True


           string str11 = Path.GetRandomFileName();   GetRandomFileName 返回随机文件夹名或文件名     结果 mj03stap.3sw
           Console.WriteLine(str11);


           string str12 = Path.GetTempFileName();     GetTempFileName 返回电脑临时文件夹中一个文件的全路径 结果c:\Users\吕植哥哥\AppData\Local\Temp\tmp1056.tmp
           string str13 = Path.GetTempPath();       GetTempPath     返回电脑临时文件夹完整路径  结果c:\Users\吕植哥哥\AppData\Local\Temp\
           Console.WriteLine(str12);
           Console.WriteLine(str13);
    




                 Console.ReadKey();
        }
    }
   
   
   
   FileStream：
   典型用法
   文件读取
   
   
    FileStream file = new FileStream(@"G:\1.txt", FileMode.Open, FileAccess.Read);
  
  int res = -1;
            do
            {
                res = file.ReadByte();   //返回索引，并将索引指向下一位
                if (res != -1)
                {
                    Console.WriteLine((char)res);
                }
            } while (res != -1);          //文件结束返回-1


            Console.ReadKey();

  
 using(FileStream f1 = new FileStream(@"d:\Desktop\1.txt", FileMode.Open, FileAccess.Read));
  byte[] b = new byte[10]; //定义一个长度为10的数组接收数据
   fi1.Read(b, 0, b.Length); 将读出的数据放入b中索引为0，长度为数组长度的位置  返回值为读出来的个数，如果为0则表示读出0个，即读完了
   如果:第二个参数为1，第三个参数不变则报错，因为此参数组合表示，放入数组索引为1，长度将达不到 b.Length
   如果：读到文件结尾，数组长度大于文件剩余字节数时，没有覆盖的数组元素不变。
   返回值为读到的个数，如果文件读完，则返回0
 
 经典用法：
    byte[] bs = new byte[5];
               int res = 0;
                while ((res = file.Read(bs, 0, bs.Length)) != 0)
                {
                    for (int i = 0; i < res; i++)
                  {
                        Console.Write((char)bs[i]);
                    }
                }
           }
 
 
 文件复制的经典方法：
 static void Main(string[] args)
        {
            string path = @"D:\Desktop\Source";
            string path1 = Path.Combine(path, "座位名单2.jpg");
            string path2 = Path.Combine(path,"123.jpg");


            FileStream reader = new FileStream(path1, FileMode.Open, FileAccess.Read);
            FileStream writer = new FileStream(path2, FileMode.Create, FileAccess.Write);


            using (reader)
            {
                using (writer)
                {
                    byte[] bs = new byte[5];
                    int count = 0;
                    while ((count = reader.Read(bs, 0, bs.Length)) != 0)
                    {
                        writer.Write(bs, 0, count);
                    }
                }
            }


        }
 
 OpenFileDialog专门用来选择文件
  string.IsNullOrWhiteSpace() 判断字符串是否为空或空白字符串组成
  
  
  
  
  
  加密文件经典用法：
   static void Main(string[] args)
        {
            Console.WriteLine("请输入要加密的文件");
            string path = Console.ReadLine();


            string dir = Path.GetDirectoryName(path);
            string name = Path.GetFileNameWithoutExtension(path);
            string exetension = Path.GetExtension(path);


            // D:\1.mp3  -> D:\1_已加密.mp3
            string fileName = Path.Combine(dir, string.Format("{0}_已加密{1}", name, exetension));


            FileStream reader = new FileStream(path, FileMode.Open, FileAccess.Read);
            FileStream writer = new FileStream(fileName, FileMode.Create, FileAccess.Write);
            using (reader)
            {
                using (writer)
                {
                    int count = 0;
                    byte[] bs = new byte[1024];


                    while ((count = reader.Read(bs, 0, bs.Length)) != 0)
                    {
                        // 改变字节里面的数字
                        for (int i = 0; i < count; i++)
                        {
                            bs[i] = (byte)(bs[i] + 1);   //每个字节都增加一个数字，解密的时候，每个字节都减去那个数字
                        }
                        writer.Write(bs, 0, count);
                    }
                }
            }




        }
 
 StreamReader经典用法：
using (FileStream file = new FileStream(path, FileMode.Open, FileAccess.Read))
           {
              using (StreamReader reader = new StreamReader(file))
                {
                    string res = string.Empty;
                    while ((res = reader.ReadLine()) != null)
                    {
                       Console.WriteLine(res);
                    }
                    // 或者直接用res = reader.ReadToEnd();
                    Console.WriteLine(res);
                }
            }
 
 StreamWriter经典用法：
StreamWriter writer = new StreamWriter(path);
            using (writer)
            { 
               writer.Write("字符串");        写完
   writer.WriteLine("字符串");  感觉差不多，写完转第二行
            }


            或者File.WriteAllText("路径", "内容");


            Console.ReadKey(); 
 
 
   常用的读写方法
              读：
               File.ReadAllLines(路径, 格式编码); 返回路径所表示的文本文件，并以行为单位作为string数组返回
               File.ReadAllText(路径, 格式编码); 返回路径表示的文本文件中的所有字符串
               
               StreamReader对象的ReadLine方法与ReadToEnd方法
              
              写：
               File.WriteAllLines(路径, string数组, 格式编码);
                   将数组以行单位写到路径表示的文件中
               File.WriteAllText(路径, string内容, 格式编码);
               
               File.AppendAllText(路径, 内容, 格式编码);
               File.AppendAllLines(路径, string[]内容, 格式编码);
  

获取文件夹下的子文件夹：Directory.GetDirectories(路径)   如string[] pathes = Directory.GetDirectories(@"d:\desktop\Source");
获取文件夹下的子文件：Directory.GetFiles(路径)       如string[] pathes = Directory.GetFiles(@"d:\desktop\Source", "*.bmp"); 只要后缀名是bmp的文件




序列化：
步骤：
1.在上面类前面加  [Serializable]   表示该类可以被序列化
2.使用FileStream            
            3.使用序列化对象BinaryFormatter    调用Serialize(流,object)
例子：
List<Person> listperson = new List<Person>();
            listperson.Add(new Person("小明", 12, '男'));
            listperson.Add(new Person("小a", 12, '男'));
            listperson.Add(new Person("小b", 12, '女'));
            using (FileStream file = new FileStream(@"d:\desktop\1.aaa", FileMode.Create, FileAccess.Write))
           {
               BinaryFormatter bf = new BinaryFormatter();
               bf.Serialize(file,listperson);
           }
    [Serializable]
     class Person
    {
        string name;


        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        char gender;


        public char Gender
        {
            get { return gender; }
            set { gender = value; }
        }
        int age;


        public int Age
        {
            get { return age; }
            set { age = value; }
        }
        public Person()
        {
 
        }
        public Person(string name,int age,char gender)


        {
            this.name = name;
            this.age = age;
            this.gender = gender;
        }
    }

解读序列化：
步骤：
1.在上面类前面加  [Serializable]   表示该类可以被序列化
2.使用FileStream            
    3.使用序列化对象BinaryFormatter    调用Deserialize(流)

 List<Person> listperson;
            using (FileStream file = new FileStream(@"d:\desktop\1.aaa", FileMode.Open, FileAccess.Read))
            {
                BinaryFormatter bf = new BinaryFormatter();
                listperson = (List<Person>)bf.Deserialize(file);
                for (int i = 0; i < listperson.Count; i++)
                {
                    Console.WriteLine(listperson[i].Name);
                }
            }
            Console.ReadLine();



Directory类：
string path=@"d:\desktop\new_folder";
            
Directory.CreateDirectory（path）  创建文件夹               结果 ：在d:\desktop\目录下创建一个new_folder文件夹
Directory.Delete(path, true);      删除文件夹                    结果 ：删除d:\desktop\new_folder文件夹（包括子文件）
string path1=Directory.GetCurrentDirectory()  获取当前应用程序所在目录   结果：path1=@“d:\visual Studio\Projects\CZ7月2日\Directory test\bin\Debug”
string[] str= Directory.GetDirectories(path);   获取指定目录中所有文件夹全路径名称 （不包括孙子文件夹）
string [] str1=  Directory.GetDirectories(path,"*",SearchOption.AllDirectories);获取指定目录中所有文件夹全路径名称 （包括孙子文件夹）
string str2=Directory.GetDirectoryRoot(path);   获取根名称      结果d:\   
string [] str3= Directory.GetFiles(path); 取指定目录中所有文件全路径名称（不包括孙子文件夹）
 string [] str4= Directory.GetFiles(path,".txt",SearchOption.AllDirectories);取指定目录中所有txt文件全路径名称（包括孙子文件夹）
DirectoryInfo str3= Directory.GetParent(path); 获取指定路径父目录的对象
Directory.Move(path,@"d:\desktop\a"); d:\desktop\new_folder没了，多了个d:\desktop\a文件夹，和之前的new_folder一样