C#基础深入学习02

C#基础深入学习02

哈希表（Hashtable）

Hashtable 类代表了一系列基于键的哈希代码组织起来的键/值对。它使用键来访问集合中的元素。

当您使用键访问元素时，则使用哈希表，而且您可以识别一个有用的键值。哈希表中的每一项都有一个键/值对。键用于访问集合中的项目。

Hashtable 类的方法和属性

下表列出了 Hashtable 类的一些常用的 属性：

属性	描述
Count	获取 Hashtable 中包含的键值对个数。
IsFixedSize	获取一个值，表示 Hashtable 是否具有固定大小。
IsReadOnly	获取一个值，表示 Hashtable 是否只读。
Item	获取或设置与指定的键相关的值。
Keys	获取一个 ICollection，包含 Hashtable 中的键。
Values	获取一个 ICollection，包含 Hashtable 中的值。

下表列出了 Hashtable 类的一些常用的 方法：

序号	方法名 & 描述
1	public virtual void Add( object key, object value ); 向 Hashtable 添加一个带有指定的键和值的元素。
2	public virtual void Clear(); 从 Hashtable 中移除所有的元素。
3	public virtual bool ContainsKey( object key ); 判断 Hashtable 是否包含指定的键。
4	public virtual bool ContainsValue( object value ); 判断 Hashtable 是否包含指定的值。
5	public virtual void Remove( object key ); 从 Hashtable 中移除带有指定的键的元素。

using System;
using System.Collections;

namespace day21test02
{
    class Program
    {
        /// <summary>
        /// Hashtable 集合 哈希表
        /// 哈希表的顺序与插入顺序，值顺序均无关，只与哈希表的key （hash运算）排列顺序有关
        /// 
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            Hashtable ht = new Hashtable(10);
            //不能出现重复值，比较笨重
            ht.Add("id", 145);
            ht.Add("name", "q");
            ht.Add("sex", 's');
            //判断哈希表中是否存在该值
            if (ht.Contains("sex")) { Console.WriteLine(ht["sex"]); }
            //可以将之前填充的数据覆盖，不会出现异常
            ht["id"] = 45;
            Console.WriteLine("Hello World!");
        }

    }
    class T
    {

    }
}

using System;
using System.Collections;
using System.Collections.Generic;

namespace day21test03
{
    class Program
    {
        /// <summary>
        /// Hashtable 和 SortedList的排序问题
        /// hashtable本身没有排序方法，需要借助list
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            //初级方法
            Hashtable ht = new Hashtable(20);
            ArrayList ay = new ArrayList();
            ht.Add("k1", "v1"); ay.Add("k1");
            ht.Add("k2", "v2"); ay.Add("k2");
            ht.Add("k3", "v3"); ay.Add("k3");
            ht.Add("k4", "v4"); ay.Add("k4");
            ay.Sort();
            for(int i = 0; i < ay.Count; i++)
            {
                Console.WriteLine(ht[ay[i].ToString()].ToString());
            }

            //高级方法，sortedList自动排序，创建时就进行了排序
            SortedList sort = new SortedList();
            sort.Add("kk1", "vv1");
            sort.Add("kk2", "vv2");
            sort.Add("kk3", "vv3");
            sort.Add("kk4", "vv4");
            Console.WriteLine("Hello World!");
        }
    }
}

ArrayList 和 List 的比较

ArrayList

ArrayList是一个特殊数组，通过添加和删除元素就可以动态改变数组的长度。
ArrayList集合相对于数组的优点：支持自动改变大小，可以灵活的插入元素，可以灵
活的删除元素，可以灵活的访问元素，但是ArrayList只支持一维，并且查询和检索的
速度比较慢。
在C#中数据类型分为两类：值类型和引用类型。
int bool char double enum struct DateTime等都是值类型（值类型和引用类型的重
要特征在于，值类型的长度固定，而引用类型的长度不固定），string Array class
集合 等都是引用类型。如果是值类型直接存储在栈中（局部变量），如果是引用类
型，先把数据存储在堆中，然后把堆的地址存储在栈中。
object类是所有类的基类，所有的数据类型都可以转换成object类，这就是为什么
ArrayList可以存储值类型和引用类型，因为在存储的时候全被转换成object类型存储
这也是ArrayList的一个缺点，就是存储的时候需要把值类型封装成object类型，取出
来的时候需要再把object类型再转换成值类型，这一装箱和拆箱的过程非常消耗性能
。
装箱：如果往ArrayList中存储值类型的数据，在存储的时候需要转换成object类型存
储，由值类型封装成object类型的过程称为装箱。
拆箱：由object类型转换成值类型的过程称为拆箱。

using System;
using System.Collections;

namespace day21test01
{
    class Program
    {
        /// <summary>
        /// ArrayList类
        /// 存储时会将值类型装箱为object类型，检索时又将object类型拆箱为值类型，性能的消耗比较大。
        /// 并且它只能是一维的
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            ArrayList list = new ArrayList();
            list.Add(1);
            list.Add("1");
            list.Add('1');
            list.Add(null);
            Console.WriteLine(list[0].GetType());
            Console.WriteLine(list[1].GetType());
            Console.WriteLine(list[2].GetType());
            //Console.WriteLine(list[3].GetType());
            Console.WriteLine("Hello World!");
        }
    }
}

List

List是由ArrayList发展而来的集合，同样具备了ArrayList相对于Array的优点，List是一种泛型集合，解决了ArrayList对于值类型需要拆箱和装箱的缺点，List在声明的时候需要指定存储集合的数据类型

//定义及其初始化
//第一种方法
List objList = new List();
objList.Add(10);
objList.Add(2);
//第二种方法
int[] array = {1,2,3,4,5};
List objList = new List(array);//用array这个数组来填充
//第三种
List nameList = new List(){“小李”，“校长”};

队列（Queue）

队列（Queue）代表了一个先进先出的对象集合。当您需要对各项进行先进先出的访问时，则使用队列。当您在列表中添加一项，称为入队，当您从列表中移除一项时，称为出队。

Queue 类的方法和属性

下表列出了 Queue 类的一些常用的 属性：

属性	描述
Count	获取 Queue 中包含的元素个数。

下表列出了 Queue 类的一些常用的 方法：

序号	方法名 & 描述
1	public virtual void Clear(); 从 Queue 中移除所有的元素。
2	public virtual bool Contains( object obj ); 判断某个元素是否在 Queue 中。
3	public virtual object Dequeue(); 移除并返回在 Queue 的开头的对象。
4	public virtual void Enqueue( object obj ); 向 Queue 的末尾添加一个对象。
5	public virtual object[] ToArray(); 复制 Queue 到一个新的数组中。
6	public virtual void TrimToSize(); 设置容量为 Queue 中元素的实际个数。

using System;
using System.Collections;

namespace day21test07
{
    class Program
    {
        /// <summary>
        /// 队列，有入队和出队的操作
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            Queue q = new Queue();
            //入队
            q.Enqueue(12);
            q.Enqueue(24);
            q.Enqueue(36);
            //出队，自动先出先进入的元素
            int a = (int)q.Dequeue();
            //查看当前需要出队的元素
            int b = (int)q.Peek();
            Console.WriteLine("Hello World!");
        }
    }
}

点阵列（BitArray）

BitArray 类管理一个紧凑型的位值数组，它使用布尔值来表示，其中 true 表示位是开启的（1），false 表示位是关闭的（0）。

当您需要存储位，但是事先不知道位数时，则使用点阵列。您可以使用整型索引从点阵列集合中访问各项，索引从零开始。

BitArray 类的方法和属性

下表列出了 BitArray 类的一些常用的 属性：

属性	描述
Count	获取 BitArray 中包含的元素个数。
IsReadOnly	获取一个值，表示 BitArray 是否只读。
Item	获取或设置 BitArray 中指定位置的位的值。
Length	获取或设置 BitArray 中的元素个数。

下表列出了 BitArray 类的一些常用的 方法：

序号	方法名 & 描述
1	public BitArray And( BitArray value ); 对当前的 BitArray 中的元素和指定的 BitArray 中的相对应的元素执行按位与操作。
2	public bool Get( int index ); 获取 BitArray 中指定位置的位的值。
3	public BitArray Not(); 把当前的 BitArray 中的位值反转，以便设置为 true 的元素变为 false，设置为 false 的元素变为 true。
4	public BitArray Or( BitArray value ); 对当前的 BitArray 中的元素和指定的 BitArray 中的相对应的元素执行按位或操作。
5	public void Set( int index, bool value ); 把 BitArray 中指定位置的位设置为指定的值。
6	public void SetAll( bool value ); 把 BitArray 中的所有位设置为指定的值。
7	public BitArray Xor( BitArray value ); 对当前的 BitArray 中的元素和指定的 BitArray 中的相对应的元素执行按位异或操作。

using System;
using System.Collections;

namespace day21test10
{
    class Program
    {
        /// <summary>
        /// BitArray 
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            //数组内全部以二进制的形式来存储数据
            /*Byte[] a = new byte[1];
            a[0] = 255;
            BitArray ary = new BitArray(a);

            foreach(var item in ary)
            {
                Console.WriteLine(item.ToString());
                Console.WriteLine(item.ToString().ToLower() == "false"?0:1);
            }
            Console.WriteLine("Hello World!");
            //位运算符
            //使用与（全1取1） 或（全0取0） 异或（相同取0，不同取1）二进制运算是一种高效率的运算方式
            int n1 = 100;
            int n2 = 100;
            if ((n1 | n2) == 0) { Console.WriteLine("相等"); }*/
            //Console.WriteLine();
            BitArray b1 = new BitArray(128);
            BitArray b2 = new BitArray(128);

            BitArray b3 = b1.Xor(b2);
            //if ((bool)b1.Xor(b2)) { }
            Console.Write(b3.ToString().ToLower() == "false"?0:1);

        }
    }
}

堆栈（Stack）

堆栈（Stack）代表了一个后进先出的对象集合。当您需要对各项进行后进先出的访问时，则使用堆栈。当您在列表中添加一项，称为推入元素，当您从列表中移除一项时，称为弹出元素。

Stack 类的方法和属性

下表列出了 Stack 类的一些常用的 属性：

属性	描述
Count	获取 Stack 中包含的元素个数。

下表列出了 Stack 类的一些常用的 方法：

序号	方法名 & 描述
1	public virtual void Clear(); 从 Stack 中移除所有的元素。
2	public virtual bool Contains( object obj ); 判断某个元素是否在 Stack 中。
3	public virtual object Peek(); 返回在 Stack 的顶部的对象，但不移除它。
4	public virtual object Pop(); 移除并返回在 Stack 的顶部的对象。
5	public virtual void Push( object obj ); 向 Stack 的顶部添加一个对象。
6	public virtual object[] ToArray(); 复制 Stack 到一个新的数组中。

using System;
using System.Collections;

namespace day21test08
{
    class Program
    {
        /// <summary>
        /// 堆栈，后进先出的集合类（最后进栈的最先出栈）
        /// 主要有入栈 出栈
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            Stack ss = new Stack();
            //压栈
            ss.Push(12);
            ss.Push(13);
            ss.Push(14);
            //出栈
            int c = (int)ss.Pop();
            Console.WriteLine(c);
            //查看当前要出栈的数据是
            int d = (int)ss.Peek();
            Console.WriteLine(d);
            Console.WriteLine("Hello World!");
        }
    }
}