.net学习之集合、foreach原理、Hashtable、Path类、File类、Directory类、文件流FileStream类、压缩流GZipStream、拷贝大文件、序列化和反序列化

时间:2023-03-08 15:32:12
.net学习之集合、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[];
int index = ;
public void Add(object obj)
{
if (index>=objArray.Length-)
{
object[] newObjArray = new object[objArray.Length*];
Array.Copy(objArray, newObjArray, objArray.Length);
objArray = newObjArray;
}
objArray[index] = obj;
index++;
}
public int Count
{
get
{
return index + ;
}
} /// <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)

“可排序键值对”集合:(插入、检索没有“哈希表”集合高效)
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 = ; i < sortedList.Count; i++)
{
Console.WriteLine(sortedList[sortedList.GetKey(i)]);
}

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

2.foreach原理
如果一个类要被foreach遍历,就要实现IEnumerable接口
比如:

public class MyArrayList:IEnumerable
{
private object[] objArray=new object[];
int index = ;
public void Add(object obj)
{
if (index>=objArray.Length-)
{
object[] newObjArray = new object[objArray.Length*];
Array.Copy(objArray, newObjArray, objArray.Length);
objArray = newObjArray;
}
objArray[index] = obj;
index++;
}
public int Count
{
get
{
return index + ;
}
} /// <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 = -;
/// <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
{

return i;
}
finally
{
i++;
}
这个程序返回的值为1
Student s = new Student();
s.ID = 1;
try
{

return s;
}
finally
{
s.ID++;
}
这个程序返回的值为s.ID=2

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[];
int len = ;
while ((len = fsRead.Read(byts, , byts.Length)) > )
{
//通过压缩流写入文件
zipStream.Write(byts, , 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[];
int len = ;
while ((len = gzipStream.Read(byts, , byts.Length)) > )
{
fsWrite.Write(byts, , len);
} }
}
}
Console.WriteLine("ok");
Console.ReadKey();

13.using
被using管理的对象一出usin块就会自动调用这个对象的Dispose方法
如果类的对象要被using管理,这个对象的类必须实现IDisposable接口
using的本质就是一个try finally,将using中的代码生成在了try中,调用该对象的Dispose()写在了finally中

14.序列化和反序列化
序列化:将对象的状态持久化到某一种设备上(磁盘)
要将类标记为Serializable,这个类的对象才可以被序列化
以二进制的方式序列化,而不是文本文档
反序列化:将之前序列化的文件还原为对象