一.ArrayList类
此类又名为动态数组，和StringBuilder类似，每当数据长度超过当前动态数组最大容量，就会自动向外扩大2倍容量,初始容量为4，未赋值前为0。此类的实质是对Object类对象的操作，所以所有的基础数据类型进行存储或使用时，都要进行装箱拆箱操作。
常用参数:Count,已有元素长度 Capacity,容量
常用方法如下:
public virtual int Add(object value);
将值添加到末尾，此值可以为null
public virtual void AddRange(ICollection c);
将集合c添加到末尾
public virtual void Clear();
移除所有元素
public virtual void CopyTo(int index, Array array, int arrayIndex, int count);
第一个元素是ArrayList的开始复制下标，第三个参数是目的数组的填充开始下标，第四个是复制长度。
public virtual bool Contains(object item);
有item这个元素返回true，否则返回false
public virtual int IndexOf(object value, int startIndex, int count);
如包含value，返回value第一次出现的下标，否则返回-1,第二个参数是开始搜寻的下标，第三个是搜寻长度，二三参数可不加
public virtual int LastIndexOf(object value);
返回value最后一次出现的下标，二三参数同上
public virtual void Insert(int index, object value);
插入元素,index插入下标，value值，也可直接用数组的形式实现插入。
public virtual void InsertRange(int index, ICollection c);
集合c插入下标index处
public virtual void Remove(object obj);
移除该元素
public virtual void RemoveAt(int index);
移除下标index处元素
public virtual void RemoveRange(int index, int count);
移除下标Index处长度为count的元素
public virtual void Reverse();
反转数组元素
public virtual void Sort(int index, int count, IComparer comparer);
排序，第三个参数需要实现System.Collections.IComparer（）方法,然后将自定义比较方法提供上去。如不写为默认排序。
public virtual object[] ToArray();
转成Object数组
{

class Program
{
    static void Main(string[] args)
    {
        ArrayList arrl1 = new ArrayList();
        int[] arrs = new int[5];
        for(int i=0; i<arrs.Length;i++)
        {
            arrl1.Add(i+1);
        }
        arrl1.CopyTo(2,arrs,1,3);
        foreach(int i in arrs)
        {
            Console.Write(i+" ");//0 3 4 5 0
        }
        Console.WriteLine();
        arrl1.RemoveAt(4);
        arrl1[3] = 123;
        arrl1.Insert(1,234);
        foreach(Object o in arrl1)
        {
            Console.Write(o.ToString()+" ");//1 234 2 3 123
        }
        Console.WriteLine();
        arrl1.Sort();
        foreach (Object o in arrl1)
        {
            Console.Write(o.ToString() + " ");//1 2 3 123 234
        }
        Console.WriteLine();
        arrl1.Clear();
        Console.WriteLine("长度:"+arrl1.Count+" 容量:"+arrl1.Capacity);//长度:0 容量:8
        Console.ReadKey();
    }
}

}

二.List<>泛型类
public List(int capacity);
声明方法如上，容量capacity可省略。该类由于在创建时就需要指定泛型类型的原因，比起ArrayList省略了大量的装箱拆箱操作，推荐集合常用该类型。
常用参数:Count,已有元素长度 Capacity,容量
常用方法如下：
public void Add(T item);
public void AddRange(IEnumerable collection);
public void Clear();
public bool Contains(T item);
public void CopyTo(int index, T[] array, int arrayIndex, int count);
public T Find(Predicate match);
该方法需要传递方法参数，其方法的返回值类型是bool型，且需传递一个泛型参数，match实际上是一个委托，List集合会依次判断里面的参数是否可以通过match方法返回true，如果可以则返回第一个通过该判断的参数，indexOf则是直接判断是否有这个泛型参数，如果有直接返回该参数
public int FindIndex(int startIndex, int count, Predicate match);
判断方法同上，但返回值是符合条件的参数的下标，第一二个参数可省略
public int FindLastIndex(int startIndex, int count, Predicate match);
返回最后一个符合条件的参数下标
public List GetRange(int index, int count);
public int IndexOf(T item, int index, int count);
public void Insert(int index, T item);
public void InsertRange(int index, IEnumerable collection);
public int LastIndexOf(T item, int index, int count);
public bool Remove(T item);
public int RemoveAll(Predicate match);
同样，删除符合match方法的参数
public void RemoveAt(int index);
public void RemoveRange(int index, int count);
public void Reverse(int index, int count);
public void Sort(int index, int count, IComparer comparer);
public T[] ToArray();
以上方法中，未作解释的基本同ArrayList类的方法用途相一致
{

class Program
{
    static void Main(string[] args)
    {
        List<int> lists = new List<int>();
        for(int i=0;i<10 ;i++ )
        {
            Random rd = new Random();
            lists.Add((i+1) * (i+2) + rd.Next()%2);
        }
        foreach(int i in lists)
        {
            Console.Write(i+" ");
        }
        Console.WriteLine();
        Console.WriteLine(lists.Find(match));
        Console.ReadKey();
    }
    static bool match(int x)
    {
        if (x % 7 == 0) return true;
        else return false;
    }
}

}
该程序有随机性，上传的图片是一次得到的结果

三.Hashtable哈希表
哈希表是一种键值对映射结构。比如数组，他的每个下标依次对应了每个下标所指向的元素，即0-array[0],1-array[1],2-array[2]......这里就可以说0是array[0]的键,array[0]是0的值,而哈希表和数组不同的是它的每个键不一定是0，1，2，3...的自然数序列，而是一个任意的对象，既可以是基础数据类型，也可以是非基础数据类型，它的值也是如此。因而对于事物联系的描述有最高的灵活程度。
常用参数:
键的集合:Keys 值的集合:Values 元素长度:Count
public Hashtable(int capacity);
public virtual void Add(object key, object value);
key是键,value是值，键和值的区别在于可以通过ht[key]来调用value，但是无法通过值调用键
public virtual void Clear();
public virtual bool Contains(object key);
Contains和ContainsKey函数完全一致，源码是在ContainsKey函数里调用了一次Contains
public virtual bool ContainsKey(object key);
public virtual bool ContainsValue(object value);
public virtual void CopyTo(Array array, int arrayIndex);
public virtual void Remove(object key);
protected virtual int GetHash(object key);
返回指定键的哈希值
{

class Program
{
    static void Main(string[] args)
    {
        Hashtable ht = new Hashtable();
        ht.Add("随便写个键","值1");
        ht.Add(345, "2");
        ht.Add(true, false);
        foreach(Object o in ht.Keys)
        {
            //应该对键默认进行了某种排序，并未按建立顺序输出
            Console.Write(ht[o]+" ");//2 false 值1
        }
        Console.ReadKey();
    }
}

}

四.Dictionary字典
字典类也是一种键值对数据结构，与哈希表不同的是，字典在一开始就对键值对的类型进行泛型声明，如
Dictionary<string, string> dic = new Dictionary<string, string>();//在声明时可加初始容量参数
通过对泛型类型的声明，可以省去大量的装箱拆箱过程，使运行速度提高。
常用参数:
Keys:键集合 Values:值集合 Count:已有元素长度
常用方法:
public void Add(TKey key, TValue value);
public void Clear();
public bool ContainsKey(TKey key);
public bool ContainsValue(TValue value);
public bool Remove(TKey key);
{

class Program
{
    static void Main(string[] args)
    {
        Dictionary<string, string> dic = new Dictionary<string, string>();
        dic.Add("key1","value1");
        dic.Add("key2", "value2");
        dic.Add("key3", "value3");
        dic.Add("key4", "value3");
        //foreach(string s in dic.Keys)
        //{
        //    Console.Write(dic[s]+" ");
        //}
        foreach(KeyValuePair<string,string> kvp in dic)
        {
            Console.WriteLine("键:"+kvp.Key+" 值:"+kvp.Value);
        }
        Console.ReadKey();
    }
}

//多行输出字有点多，截个图
}

五.HashSet哈希集合
哈希集合是一个无序去重复的列表，因为这样的特性，里面定义了一些关于集合操作的方法。
public HashSet(int capacity);
构造函数，容量可省略
常用属性:
Count 长度
常用方法：
public bool Add(T item);
public bool Remove(T item);
public void Clear();
public bool Contains(T item);
public void CopyTo(T[] array, int arrayIndex, int count);
因为哈希集合是无序的，所以复制时没有开始下标,arrayIndex是目标数组开始存储的下标
public void ExceptWith(IEnumerable other);
假设调用该方法的对象是hs,hs = hs-other,即hs对other的差集
public void SymmetricExceptWith(IEnumerable other);
hs = hs并other - hs交other,即hs和other的对称差集
public void IntersectWith(IEnumerable other);
hs = hs交other
public void UnionWith(IEnumerable other);
hs = hs并other
public bool IsSubsetOf(IEnumerable other);
hs是other的子集则返回true，否则返回false
public bool IsSupersetOf(IEnumerable other);
hs是other的超集则返回true，否则返回false
public bool SetEquals(IEnumerable other);
两HashSet集合内容相等则返回true,否则返回false
{

class Program
{
    static void Main(string[] args)
    {
        HashSet<int> hs = new HashSet<int>();
        HashSet<int> hs2 = new HashSet<int>();
        hs.Add(1);
        hs.Add(2);
        hs.Add(2);//1,2
        hs2.Add(2);
        hs2.Add(3);//2,3
        writeHashSet(hs);
        hs.ExceptWith(hs2);//差集
        writeHashSet(hs);//1
        hs.SymmetricExceptWith(hs2);//对称差集
        writeHashSet(hs);//1 3
        hs.IntersectWith(hs2);//交集
        writeHashSet(hs);//2
        hs.UnionWith(hs2);//并集
        writeHashSet(hs);//1 3 2
        Console.ReadKey();
    }
    static void writeHashSet(HashSet<int> hs)
    {
        Console.Write("无序列表:");
        foreach(var i in hs)
        {
            Console.Write(i+" ");
        }
        Console.WriteLine();
        hs.Add(1); hs.Add(2); hs.Remove(3);//为展示方法效果，这句用来复位
    }
}

}

六.LinkedList
链表，在C#里是一个类结构，但依旧保持了链表的特性，即插入删除较快，查找较慢。这里的链表是双向列表，每个结点都提供了前一个结点和后一个结点的引用。另外，其他有序集合都有一定的排序方式，而链表的排序方式就是存储顺序。
public LinkedList();
构造函数
常用属性:
public LinkedListNode Last { get; } 尾结点
public LinkedListNode First { get; } 首结点
public int Count { get; } 长度
在LinkedListNode类内部里的常用属性:
public LinkedListNode Next { get; } 向后结点引用
public LinkedListNode Previous { get; } 向前结点引用
public T Value { get; set; } 值
常用方法:
public LinkedListNode AddAfter(LinkedListNode node, T value);
向后添加结点，有一个重载方法，无返回值，参数是两个结点
public LinkedListNode AddBefore(LinkedListNode node, T value);
向前添加结点
public LinkedListNode AddFirst(T value);
添加首结点
public LinkedListNode AddLast(T value);
添加尾结点
public void Clear();
public bool Contains(T value);
public void CopyTo(T[] array, int index);
index是array数组存储的开始下标
public LinkedListNode Find(T value);
查找存储该值的第一个结点
public LinkedListNode FindLast(T value);
查找存储该值的最后一个结点
public bool Remove(T value);
public void Remove(LinkedListNode node);
public void RemoveFirst();
public void RemoveLast();
{

class Program
{
    static void Main(string[] args)
    {
        LinkedList<int> link = new LinkedList<int>();
        for(int i=0;i<10 ;i++ )
        {
            link.AddLast(i);
        }
        foreach (var i in link)
        {
            Console.Write(i+" ");//0 1 2 3 4 5 6 7 8 9
        }
        Console.ReadKey();
    }
}

}

七.Stack堆栈
先进后出，后进先出，有点像杯子的结构。
public Stack(int initialCapacity);
构造方法，初始容量可省略,即可进行泛型声明，也可以不加，不加默认处理Object对象
常用参数Count 栈数据的长度
常用方法：
public virtual void Clear();
public virtual bool Contains(object obj);
public virtual void CopyTo(Array array, int index);//index是目标数组array的
public virtual object[] ToArray();
public virtual object Peek();
获取出栈的数据但不删除该数据
public virtual object Pop();
出栈，返回存储的最后一个元素
public virtual void Push(object obj);
入栈，将数据存储在栈末尾
{

class Program
{
    static void Main(string[] args)
    {
        Stack st1 = new Stack();
        st1.Push(1);
        st1.Push(2);
        st1.Push(3);
        Console.WriteLine(st1.Peek());//3
        Console.WriteLine(st1.Pop());//3
        Console.WriteLine(st1.Pop());//2
        Console.WriteLine(st1.Peek());//1
        Console.WriteLine(st1.Peek());//1
        Console.WriteLine(st1.Pop());//1
       // Console.WriteLine(st1.Peek());已空报错
        Console.ReadKey();
    }
}
//这是另一段测试程序
class Program
{
    static void Main(string[] args)
    {
        Stack st1 = new Stack();
        st1.Push(1);
        st1.Push(2);
        st1.Push(3);
        Console.WriteLine(st1.Count);//3
        foreach(var i in st1)
        {
            Console.WriteLine(i);//3 2 1
        }
        Console.WriteLine(st1.Count);//3
        Console.ReadKey();
    }
}

}
下列代码为手动建立简易堆栈
{

class Program
{
    static void Main(string[] args)
    {
        MyStack ms = new MyStack();
        ms.Push(1);
        ms.Push(2);
        ms.Push(3);
        Console.WriteLine(ms.Pop());//3
        Console.WriteLine(ms.Peek());//2
        Console.WriteLine(ms.Pop());//2
        Console.ReadKey();
    }
}
class MyStack
{
    private StackNode top;
    public MyStack()
    {
        
    }
    class StackNode
    {
        public object value;
        public StackNode previous;
        public StackNode(object value, StackNode previous)
        {
            this.value = value;
            this.previous = previous;
        }
    }
    public void Push(object value)
    {
        top = new StackNode(value,top);
    }

    public object Pop()
    {
        object tmp = top.value;
        top = top.previous;
        return tmp;
    }
    public object Peek()
    {
        return top.value;
    } 
}

}

八.Queue队列
先进先出，后进后出，像排队一样。
public Queue(int capacity);
构造函数，容量可省略，同可施加泛型，不加默认处理Object对象
常用参数Count 队列数据长度
常用方法:
public virtual void Clear();
public virtual bool Contains(object obj);
public virtual void CopyTo(Array array, int index);
public virtual object[] ToArray();
public virtual object Dequeue();
出队列，返回最先存储的元素
public virtual void Enqueue(object obj);
入队列，将数据存储在队列末尾处
public virtual object Peek();
返回出队列的元素，但不删除该元素
{

class Program
{
    static void Main(string[] args)
    {
        Queue que = new Queue();
        que.Enqueue(1);
        que.Enqueue(2);
        que.Enqueue(3);
        Console.WriteLine("长度:"+que.Count);//长度:3
        foreach(var i in que)
        {
            Console.Write(i+" ");//1 2 3
        }
        Console.WriteLine();
        Console.WriteLine("长度:" + que.Count);//长度:3
        Console.WriteLine(que.Dequeue());//1
        Console.WriteLine("长度:" + que.Count);//长度:2
        Console.WriteLine(que.Peek());//2
        Console.WriteLine("长度:" + que.Count);//长度:2
        Console.WriteLine(que.Dequeue());//2
        Console.ReadKey();
    }
}

}
自定义队列代码
{

 class Program
{
    static void Main(string[] args)
    {
        MyQueue mq = new MyQueue();
        mq.EnQueue(1);
        mq.EnQueue(2);
        mq.EnQueue(3);
        Console.WriteLine(mq.DeQueue());//1
        Console.WriteLine(mq.Peek());//2
        Console.WriteLine(mq.DeQueue());//2
        Console.ReadKey();
    }
}
class MyQueue
{
    private QueueNode first;
    private QueueNode last;
    class QueueNode
    {
        public object value;
        public QueueNode next;
        public QueueNode(object value)
        {
            this.value = value;
        }
    }
    public void EnQueue(object value)
    {
        if (first == null)
            first = last = new QueueNode(value);
        else
        {
            last.next = new QueueNode(value);
            last = last.next;
        }
    }

    public object DeQueue()
    {
        object tmp = first.value;
        first = first.next;
        return tmp;
    }
    public object Peek()
    {
        return first.value;
    } 
}

}