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，这个类的对象才可以被序列化
以二进制的方式序列化，而不是文本文档
反序列化：将之前序列化的文件还原为对象