.net學習之集合、foreach原理、Hashtable、Path類、File類、Directory類、文件流FileStream類、壓縮流GZipStream、拷貝大文件、序列化和反序列化

時間  2019-11-12
標籤 學習 集合 foreach 原理 hashtable path file directory 文件 filestream 壓縮 gzipstream 拷貝 序列 欄目 快樂工作 简体版
原文   原文鏈接

1.集合
（1）ArrayList內部存儲數據的是一個object數組，建立這個類的對象的時候，這個對象裏的數組的長度爲0
（2）調用Add方法加元素的時候，若是第一次增長元神，就會將數組的長度變爲4往裏面加
（3）若是存儲數據的數組滿了，就會新建一個數組長度是原來的數組的兩倍，這個數組被原來的數組的變量所引用
好比本身實現簡單的ArrayList Add方法數組

public class MyArrayList
    {
        private object[] objArray=new object[2];
        int index = 0;
        public void Add(object obj)
        {
            if (index>=objArray.Length-1)
            {
                object[] newObjArray = new object[objArray.Length*2];
                Array.Copy(objArray, newObjArray, objArray.Length);
                objArray = newObjArray;
            }
            objArray[index] = obj;
            index++;
        }
        public int Count
        {
            get
            {
                return index + 1;
            }
        }

        /// <summary>
        /// 索引器
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        public object this[int i]
        {
            get
            {
                return objArray[i];
            }
            set
            {
                objArray[i] = value;
            }
        }

 

（4）經常使用集合
「相似數組」集合：ArrayList、List<T>
「鍵值對」集合（「哈希表」集合）：Hashtable、Dictionary<K,V>
「堆棧」集合：Stack、Stack<T>（LIFO）
「隊列」集合：Queue、Queue<T>（FIFO）this

「可排序鍵值對」集合：（插入、檢索沒有「哈希表」集合高效）
SortedList、SortedList<K,V> （佔用內存更少，能夠經過索引訪問）
SortedDictionary<K,V> （佔用內存更多，沒有索引，但插入、刪除元素的速度比SortedList快）
Set 集合：無序、不重複。HashSet<T>,能夠將 HashSet類視爲不包含值的 Dictionary集合。與List<T>相似。SortedSet<T>（.net4.0支持，有序無重複集合）
「雙向鏈表」集合：LinkedList<T>，增刪速度快。編碼

 SortedList sortedList = new SortedList();
            sortedList.Add("a", "A");
            sortedList.Add("x", "X");
            sortedList.Add("w", "W");
            sortedList.Add("b", "B");

            foreach (DictionaryEntry item in sortedList)
            {
                Console.WriteLine(item.Key + "  " + item.Value);
            }
            for (int i = 0; i < sortedList.Count; i++)
            {
                Console.WriteLine(sortedList[sortedList.GetKey(i)]);
            }

 

ArrayList (非泛型)→ List<T>（泛型）
Hashtable（非泛型） → Dictionary<K,V>（泛型）spa

2.foreach原理
若是一個類要被foreach遍歷，就要實現IEnumerable接口
好比：.net

public class MyArrayList:IEnumerable
    {
        private object[] objArray=new object[2];
        int index = 0;
        public void Add(object obj)
        {
            if (index>=objArray.Length-1)
            {
                object[] newObjArray = new object[objArray.Length*2];
                Array.Copy(objArray, newObjArray, objArray.Length);
                objArray = newObjArray;
            }
            objArray[index] = obj;
            index++;
        }
        public int Count
        {
            get
            {
                return index + 1;
            }
        }

        /// <summary>
        /// 索引器
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        public object this[int i]
        {
            get
            {
                return objArray[i];
            }
            set
            {
                objArray[i] = value;
            }
        }

        public IEnumerator GetEnumerator()
        {
            return new MyIEnumerator(objArray, Count);
        }
    }

    public class MyIEnumerator : IEnumerator
    {

        private object[] objArr;
        /// <summary>
        /// 保存的是當前讀到的第幾個元素，默認-1
        /// </summary>
        int index = -1;
        /// <summary>
        /// 存儲在數組中元素的個數
        /// </summary>
        int count;
        public MyIEnumerator(object[] obj,int count)
        {
            this.objArr = obj;
            this.count = count;
        }

        /// <summary>
        /// 返回當前指針指向的元素的值
        /// </summary>
        public object Current
        {
            get { return objArr[index]; }
        }

        /// <summary>
        /// 將指針向前移動一位並判斷當前元素有沒有元素
        /// </summary>
        /// <returns></returns>
        public bool MoveNext()
        {
            index++;
            if (index<count)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public void Reset()
        {
            throw new NotImplementedException();
        }
    }
foreach 遍歷其實是這樣的
    IEnumerator tor = list.GetEnumerator();
    while (tor.MoveNext())
    {
        Console.WriteLine(tor.Current);
    }

 

3.Hashtable
鍵值對是以鍵的hash值算出其所對應的下標，存的時候算一下下標，而後存儲在下標所對應的位置，取的時候也是同樣
Hashtable中的值是存儲在bucket[] buckets這個結構數組中
bucket b = new bucket();
b.Key="1";
b.Value="2";
b.hash_coll=b.Key.GetHashCode();
int index = b.hash_coll%buckets.Lenth;
buckets[index]=b
存儲的值的順序是根據鍵的hash值算出指針

4.異常處理
int i = 1;
try
{code

return i;
}
finally
{
i++;
}
這個程序返回的值爲1
Student s = new Student();
s.ID = 1;
try
{對象

return s;
}
finally
{
s.ID++;
}
這個程序返回的值爲s.ID=2blog

5.Path類
string path = @"d\a\1.txt";
string newPath = Path.ChangeExtension(@"d\1.txt","avi");更改路徑字符串的後綴名
newPath = Path.Combine(@"d\12","12.txt");合併多個字符串路徑，若是沒有"\"，自動加上
newPath = Path.GetDirectoryName(path);獲得文件路徑所在的目錄，若是自己就是一個目錄，就直接返回這個目錄字符串
newPath = Path.GetExtension(path);獲得指定文件路徑的後綴名，若是不是一個文件路徑，返回空字符串
newPath = Path.GetFileName(path);獲得指定路徑的文件名（帶後綴名）
newPath = Path.GetFileNameWithoutExtension(path);獲得指定路徑的文件名（不帶後綴名）
newPath = Path.GetFullPath(path);獲得絕對路徑
newPath = Path.GetTempPath();獲得系統的臨時目錄
newPath = Path.GetTempFileName();獲得一個剛剛建立的臨時的文件名
newPath = Assembly.GetExecutingAssembly().Location獲得當前運行程序集的路徑排序

6.File類
string path = @"d\a\1.txt";
File.Create(path);建立指定的文件，若是文件已存在，則覆蓋
File.AppendAllText(path,"aaaa");向已有的文本文件中追加字符，若是文件不存在，則建立一個新的文件
File.Copy(「source」, 「targetFileName」, true);//文件拷貝,true表示當文件存在時「覆蓋」，若是不加true,則文件存在報異常。
File.Delete(path);
File.Exists(path);
File.Move(原路徑，目標路徑);
string str = File.ReadAllText(path,Encoding.Default);讀取的文件用什麼編碼存儲就用什麼編碼讀取，有的時候必須指定的編碼
格式
string[] lines = File.ReadAllLines(path,Encoding.Default);讀取文本文檔，返回字符串數組

7.Directory類
Delete(string path) 刪除目錄,若是要遞歸刪除 調用Delete(string path,bool recursive)
Exists(string) 指定目錄是否存在
Move(string oldDir,string newDir) 移動目錄 ----更名原理一致
CreateDiectory() 建立目錄
string[] GetDirectories() 獲得指定目錄下的全部的子目錄 返回string數組
string[] GetDirectories(string path,string searchPattern,SearchOption opton) 能夠按統配符查找子目錄
GetFiles() 獲得指定目錄下的全部的文件

8.字符編碼
字符編碼就是字符以什麼樣的二進制排序存入到電腦的硬盤,並按照什麼樣的規則讀取出來並還原.
ASCII碼 GB2312 Unicode UTF-8

9.DirectoryInfo類
是1個操做目錄的實例類,提供了與靜態類Directory類相同的方法 可是作了少部分擴展
當須要對目錄進行屢次操做的時候 最好是將該目錄封裝到實例對象中 以便屢次操做

10.FileInfo類
是1個操做文件的實例類 提供了靜態File相同的方法 可是作了擴展 好比能夠獲得文件的大小.....等
當須要對同1個文件進行屢次操做的時候 最好是將該文件封裝到改對象中操做

11.FileStream類
文件的讀取：
//1.建立一個文件流對象，並給這個文件流對象指定操做的文件（路徑）還有指定操做方式
FileStream fs = new FileStream(@"e:\1.txt", FileMode.Open);
//2.準備一個byte數組，以供文件流對象讀取數據並放到這個數組裏面
byte[] bytes = new byte[1024 * 1024];
//3.調用文件流的讀數據方法，將讀出來的字節放入到bytes數組中
fs.Read(bytes, 0, bytes.Length);
//4.將字節數組以指定的編碼轉換爲字符串
string content = Encoding.Default.GetString(bytes);
//5.關閉文件流
fs.Dispose();
推薦使用using關鍵字釋放
文件的寫入：
//1.建立一個文件流對象，並給這個文件流對象指定操做的文件（路徑）還有指定操做方式
FileStream fs = new FileStream(@"e:\1.txt", FileMode.Create);
//2.將要寫人的文字轉換爲字節數組
byte[] bytes = Encoding.Default.GetBytes("我是要寫入的文字");
//3.調用文件流的寫入數據方法
fs.Write(bytes, 0, bytes.Length);
//4.關閉文件流
fs.Dispose();

拷貝大文件
using (FileStream fsRead = new FileStream(@"e:\1.wmv",FileMode.Open))
{
using (FileStream fsWrite = new FileStream(@"e:\2.wmv", FileMode.Create))
{
byte[] bytes = new byte[1024 * 1024];
int length;
do
{
length = fsRead.Read(bytes, 0, bytes.Length);//length表示讀取的真實的字節數,bytes.Length表示一次預讀取的
//字節數
fsWrite.Write(bytes, 0, length);
} while (length == bytes.Length);

}

12.壓縮流GZipStream

壓縮原理：1.圖片2.文本文件3.電影4.字符串
1>壓縮：
1.建立讀取流File.OpenRead()
2.建立寫入流File.OpenWrite();
3.建立壓縮流new GZipStream();將寫入流做爲參數與。
4.每次經過讀取流讀取一部分數據，經過壓縮流寫入。
2>解壓
1.建立讀取流：File.OpenRead()
2.建立壓縮流：new GZipStream();將讀取流做爲參數
3.建立寫入流File.OpenWrite();
4.每次經過壓縮流讀取數據，經過寫入流寫入數據。

//GZipStream就是對FileStream的又一個包裝
            //將文本文件1.txt壓縮
            //1.建立讀取文本文件的流
            using (FileStream fsRead = File.OpenRead("1.txt"))
            {
                //2.建立寫入文本文件的流
                using (FileStream fsWrite = File.OpenWrite("yasuo.txt"))
                {
                    //3.建立壓縮流
                    using (GZipStream zipStream = new GZipStream(fsWrite, CompressionMode.Compress))
                    {
                        //4.每次讀取1024byte
                        byte[] byts = new byte[1024];
                        int len = 0;
                        while ((len = fsRead.Read(byts, 0, byts.Length)) > 0)
                        {
                            //經過壓縮流寫入文件
                            zipStream.Write(byts, 0, len);
                        }
                    }
                }
            }
            Console.WriteLine("ok");
            Console.ReadKey();

            using (FileStream fsRead = File.OpenRead("yasuo.txt"))
            {

                using (GZipStream gzipStream = new GZipStream(fsRead, CompressionMode.Decompress))
                {
                    using (FileStream fsWrite = File.OpenWrite("jieya.txt"))
                    {

                        byte[] byts = new byte[1024];
                        int len = 0;
                        while ((len = gzipStream.Read(byts, 0, byts.Length)) > 0)
                        {
                            fsWrite.Write(byts, 0, len);
                        }

                    }
                }
            }
            Console.WriteLine("ok");
            Console.ReadKey();

 

13.using
被using管理的對象一出usin塊就會自動調用這個對象的Dispose方法
若是類的對象要被using管理，這個對象的類必須實現IDisposable接口
using的本質就是一個try finally，將using中的代碼生成在了try中，調用該對象的Dispose()寫在了finally中

14.序列化和反序列化序列化：將對象的狀態持久化到某一種設備上（磁盤）要將類標記爲Serializable，這個類的對象才能夠被序列化以二進制的方式序列化，而不是文本文檔反序列化：將以前序列化的文件還原爲對象

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程