C#中HashTable简介和使用用法

一 简介

名词介绍 散列表（Hash table 也叫哈希表） 是根据关键码值(Key value)而直接进行访问的数据结构 也就是说 它通过把关键码值映射到表中一个位置来访问记录 以加快查找的速度 这个映射函数叫做散列函数 存放记录的数组叫做散列表

HashTable 表的优点 HashTable是System Collections命名空间提供的一个容器 HashTable中的key/value均为object类型 所以HashTable可以支持任何类型的key/value键/值对

HashTable的优点就在于其索引的方式 速度非常快

二 哈希表的简单 *** 作

在哈希表中添加一个keyvalue键值对 HashtableObject Add(key value);

在哈希表中去除某个keyvalue键值对 HashtableObject Remove(key);

从哈希表中移除所有元素 HashtableObject Clear();

判断哈希表是否包含特定键key HashtableObject Contains(key);

下面控制台程序将包含以上所有 *** 作

using System;

using System Collections;       //file使用Hashtable时 必须引入这个命名空间

class hashtable

{

public static void Main()

{

Hashtable ht=new Hashtable();  //file创建一个Hashtable实例

ht Add(E e);                   //添加keyvalue键值对

ht Add(A a);

ht Add(C c);

ht Add(B b);

string s=(string)ht[A];

if(ht Contains(E))             //file判断哈希表是否包含特定键 其返回值为true或false

Console WriteLine(the E keyexist);

ht Remove(C);                 //移除一个keyvalue键值对

Console WriteLine(ht[A]);     //此处输出a

ht Clear();                   //移除所有元素

Console WriteLine(ht[A]);     //file此处将不会有任何输出

}

}

三 遍历哈希表

遍历哈希表需要用到DictionaryEntry Object 代码如下

for(DictionaryEntry de in ht) // fileht为一个Hashtable实例

{

Console WriteLine(de Key);   //de Key对应于keyvalue键值对key

Console WriteLine(de Value); //de Key对应于keyvalue键值对value

}

四 对哈希表进行排序

对哈希表进行排序在这里的定义是对keyvalue键值对中的key按一定规则重新排列 但是实际上这个定义是不能实现的 因为我们无法直接在Hashtable进行对key进行重新排列 如果需要Hashtable提供某种规则的输出 可以采用一种变通的做法

ArrayList akeys=new ArrayList(ht Keys);  // file别忘了导入System Collections

akeys Sort();                           // file按字母顺序进行排序

for(string skey in akeys)

{

Console Write(skey + );

Console WriteLine(ht[skey]);            // 排序后输出

lishixinzhi/Article/program/net/201311/12422

HashTable在SystemCollections的命名空间下。

是个根据object索引键访问object值的集合。

没有泛型，使用的时候只能进行强制转换。

Dictionary只能通过string类来定义键值，

如Dictionary d;d["wang"]="王"；

CollectionBase只能通过数字索引来访问，

如CollectionBase col;col[0]="好";

HashTable比起上述两种类型来说有更强的访问能力。如：

HastTable hs=new HashTable();

hs["wang"]="王";

hs[0]="好";

然而上述两个集合类有泛型类的实现Dictionary<>和List<>，可以实现强类型化。（返回的是自己定制的类型）

HashTable没有泛型类，返回的都是object类型。使用的时候必须进行强制转化。

开始学HashTable，HashMap和TreeMap的时候比较晕，觉得作用差不多，但是到实际运用的时候又发现有许多差别的。需要大家注意，在实际开发中以需求而定。

java为数据结构中的映射定义了一个接口javautilMap，而HashMap Hashtable和TreeMap就是它的实现类。Map是将键映射到值的对象，一个映射不能包含重复的键；每个键最多只能映射一个一个值。

Hashmap 是一个最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为Null;允许多条记录的值为Null;HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步，可以用Collections的synchronizedMap方法使HashMap具有同步的能力

Hashtable 与 HashMap类似,但是主要有6点不同。

1HashTable的方法是同步的，HashMap未经同步，所以在多线程场合要手动同步HashMap这个区别就像Vector和ArrayList一样。

2HashTable不允许null值，key和value都不可以,HashMap允许null值，key和value都可以。HashMap允许key值只能由一个null值，因为hashmap如果key值相同，新的key, value将替代旧的。

3HashTable有一个contains(Object value)功能和containsValue(Object value)功能一样。

4HashTable使用Enumeration，HashMap使用Iterator。

5HashTable中hash数组默认大小是11，增加的方式是 old2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。

6哈希值的使用不同，HashTable直接使用对象的hashCode。

TreeMap能够把它保存的记录根据键排序,默认是按升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。

下面是HashTable，HashMap和TreeMap总结的一个经典例子。

package comtaobaoluxiaoting;

import javautilMap;

import javautilHashMap;

import javautilSet;

import javautilHashSet;

import javautilIterator;

import javautilHashtable;

import javautilTreeMap;

class HashMaps

{

public static void main(String[] args)

{

Map map=new HashMap();

mapput(“a”, “aaa”);

mapput(“b”, “bbb”);

mapput(“c”, “ccc”);

mapput(“d”, “ddd”);

Iterator iterator = mapkeySet()iterator();

while (iteratorhasNext()) {

Object key = iteratornext();

Systemoutprintln(“mapget(key) is :”+mapget(key));

}

Hashtable tab=new Hashtable();

tabput(“a”, “aaa”);

tabput(“b”, “bbb”);

tabput(“c”, “ccc”);

tabput(“d”, “ddd”);

Iterator iterator_1 = tabkeySet()iterator();

while (iterator_1hasNext()) {

Object key = iterator_1next();

Systemoutprintln(“tabget(key) is :”+tabget(key));

}

TreeMap tmp=new TreeMap();

tmpput(“a”, “aaa”);

tmpput(“b”, “bbb”);

tmpput(“c”, “ccc”);

tmpput(“d”, “ddd”);

Iterator iterator_2 = tmpkeySet()iterator();

while (iterator_2hasNext()) {

Object key = iterator_2next();

Systemoutprintln(“tmpget(key) is :”+tmpget(key));

}

}

}

结果:

=========map=========

mapget(key) is :ddd

mapget(key) is :bbb

mapget(key) is :ccc

mapget(key) is :aaa

=========Hashtable=========

tabget(key) is :bbb

tabget(key) is :aaa

tabget(key) is :ddd

tabget(key) is :ccc

=========TreeMap=========

tmpget(key) is :aaa

tmpget(key) is :bbb

tmpget(key) is :ccc

tmpget(key) is :ddd

Hashtable-哈希表类\x0d\\x0d\以哈希表的形式存储数据,数据的形式是键值对\x0d\特点:\x0d\查找速度快,遍历相对慢\x0d\键值不能有空指针和重复数据\x0d\\x0d\创建\x0d\Hashtable ht=new \x0d\Hashtable();\x0d\\x0d\添值\x0d\\x0d\htput(1,"Andy");\x0d\htput(2,"Bill");\x0d\htput(3,"Cindy");\x0d\htput(4,"Dell");\x0d\htput(5,"Felex");\x0d\htput(6,"Edinburg");\x0d\htput(7,"Green");\x0d\\x0d\取值\x0d\\x0d\String str=htget(1);\x0d\Systemoutprintln(str);// Andy\x0d\\x0d\对键进行遍历\x0d\\x0d\Iterator it = htkeySet()iterator();\x0d\\x0d\while (ithasNext()) {\x0d\ Integer key = (Integer)itnext();\x0d\ \x0d\Systemoutprintln(key);\x0d\}\x0d\\x0d\对值进行遍历\x0d\\x0d\Iterator it = htvalues()iterator();\x0d\\x0d\while (ithasNext()) {\x0d\ String value =(String) itnext();\x0d\ \x0d\Systemoutprintln(value);\x0d\}\x0d\\x0d\取Hashtable记录数\x0d\\x0d\Hashtable ht=new Hashtable();\x0d\\x0d\htput(1,"Andy");\x0d\htput(2,"Bill");\x0d\htput(3,"Cindy");\x0d\htput(4,"Dell");\x0d\htput(5,"Felex");\x0d\htput(6,"Edinburg");\x0d\htput(7,"Green");\x0d\\x0d\int i=htsize();// 7\x0d\\x0d\删除元素\x0d\\x0d\Hashtable ht=new Hashtable();\x0d\\x0d\htput(1,"Andy");\x0d\htput(2,"Bill");\x0d\htput(3,"Cindy");\x0d\htput(4,"Dell");\x0d\htput(5,"Felex");\x0d\htput(6,"Edinburg");\x0d\htput(7,"Green");\x0d\\x0d\htremove(1);\x0d\htremove(2);\x0d\htremove(3);\x0d\htremove(4);\x0d\\x0d\Systemoutprintln(htsize());// 3\x0d\\x0d\Iterator it = htvalues()iterator();\x0d\\x0d\while (ithasNext()) {\x0d\ // Get value\x0d\ String value =(String) \x0d\itnext();\x0d\ Systemoutprintln(value);\x0d\}

刚好自己遇到了这个问题，经过一番研究，和大家分享一下。

Vector <Hashtable<String, Object>> v= dbselect("SELECT FROM lct_t_articles ORDER BY id DESC LIMIT 10");

Hashtable<String, Object> articl=null;

for(int i=0;i<vsize();i++){

Hashtable table=vget(i);

Systemoutprintln(tableget("title"));

}

Java为数据结构中的映射定义了一个接口javautilMap，

它有四个实现类，分别是HashMap、HashTable、LinkedHashMap和TreeMap。

这里介绍这4中实例的用法和区别。

关键技术剖析：

Map用于存储键值对，根据键得到值，因此不允许键重复，值可以重复。

l  （1）HashMap是一个最常用的Map，它根据键的hashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为null，不允许多条记录的值为null。HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap，可能会导致数据的不一致。如果需要同步，可以用CollectionssynchronizedMap(HashMap map)方法使HashMap具有同步的能力。

l  （2）Hashtable与HashMap类似，不同的是：它不允许记录的键或者值为空；它支持线程的同步，即任一时刻只有一个线程能写Hashtable，然而，这也导致了Hashtable在写入时会比较慢。

l  （3）LinkedHashMap保存了记录的插入顺序，在用Iteraor遍历LinkedHashMap时，先得到的记录肯定是先插入的。在遍历的时候会比HashMap慢。有HashMap的全部特性。

l  （4）TreeMap能够把它保存的记录根据键排序，默认是按升序排序，也可以指定排序的比较器。当用Iteraor遍历TreeMap时，得到的记录是排过序的。TreeMap的键和值都不能为空。

  

import javautilHashMap;

import javautilHashtable;

import javautilIterator;

import javautilLinkedHashMap;

import javautilMap;

import javautilTreeMap;

 

 

public class TestMap {

  

  

   public static void init(Map map){

      if (map != null){

         String key = null;

         for (int i=5; i>0; i--){

            key = new Integer(i)toString() + "0";

            mapput(key, keytoString());

            //Map中的键是不重复的，如果插入两个键值一样的记录，

            //那么后插入的记录会覆盖先插入的记录

            mapput(key, keytoString() + "0");         }

      }

   }

  

   public static void output(Map map){

      if (map != null){

         Object key = null;

         Object value = null;

         //使用迭代器遍历Map的键，根据键取值

         Iterator it = mapkeySet()iterator();

         while (ithasNext()){

            key = itnext();

            value = mapget(key);

            Systemoutprintln("key: " + key + "; value: " + value );

         }

         //或者使用迭代器遍历Map的记录MapEntry

         MapEntry entry = null;

         it = mapentrySet()iterator();

         while (ithasNext()){

            //一个MapEntry代表一条记录

            entry = (MapEntry)itnext();

            //通过entry可以获得记录的键和值

            //Systemoutprintln("key: " + entrygetKey() + "; value: " + entrygetValue());

         }

      }

   }

  

   public static boolean containsKey(Map map, Object key){

      if (map != null){

         return mapcontainsKey(key);

      }

      return false;

   }

  

   public static boolean containsValue(Map map, Object value){

      if (map != null){

         return mapcontainsValue(value);

      }

      return false;

   }

  

   public static void testHashMap(){

      Map myMap = new HashMap();

      init(myMap);

      //HashMap的键可以为null

      myMapput(null,"ddd");

      //HashMap的值可以为null

      myMapput("aaa", null);

      output(myMap);

   }

  

   public static void testHashtable(){

      Map myMap = new Hashtable();

      init(myMap);

      //Hashtable的键不能为null

      //myMapput(null,"ddd");

      //Hashtable的值不能为null

      //myMapput("aaa", null);

      output(myMap);

   }

  

   public static void testLinkedHashMap(){

      Map myMap = new LinkedHashMap();

      init(myMap);

      //LinkedHashMap的键可以为null

      myMapput(null,"ddd");

      myMapput(null,"aaa");

      //LinkedHashMap的值可以为null

      myMapput("aaa", null);

      output(myMap);

   }

  

   public static void testTreeMap(){

      Map myMap = new TreeMap();

      init(myMap);

      //TreeMap的键不能为null

      //myMapput(null,"ddd");

      //TreeMap的值不能为null

      //myMapput("aaa", null);

      output(myMap);

   }

 

   public static void main(String[] args) {

      Systemoutprintln("采用HashMap");

      TestMaptestHashMap();

      Systemoutprintln("采用Hashtable");

      TestMaptestHashtable();

      Systemoutprintln("采用LinkedHashMap");

      TestMaptestLinkedHashMap();

      Systemoutprintln("采用TreeMap");

      TestMaptestTreeMap();

     

      Map myMap = new HashMap();

      TestMapinit(myMap);

      Systemoutprintln("新初始化一个Map: myMap");

      TestMapoutput(myMap);

      //清空Map

      myMapclear();

      Systemoutprintln("将myMap clear后，myMap空了么  " + myMapisEmpty());

      TestMapoutput(myMap);

      myMapput("aaa", "aaaa");

      myMapput("bbb", "bbbb");

      //判断Map是否包含某键或者某值

      Systemoutprintln("myMap包含键aaa  "+ TestMapcontainsKey(myMap, "aaa"));

      Systemoutprintln("myMap包含值aaaa  "+ TestMapcontainsValue(myMap, "aaaa"));

      //根据键删除Map中的记录

      myMapremove("aaa");

      Systemoutprintln("删除键aaa后，myMap包含键aaa  "+ TestMapcontainsKey(myMap, "aaa"));

      //获取Map的记录数

      Systemoutprintln("myMap包含的记录数:  " + myMapsize());

   }

}

输出结果：

采用HashMap

key: null; value: ddd

key: 30; value: 300

key: aaa; value: null

key: 40; value: 400

key: 10; value: 100

key: 50; value: 500

key: 20; value: 200

采用Hashtable

key: 40; value: 400

key: 10; value: 100

key: 30; value: 300

key: 50; value: 500

key: 20; value: 200

采用LinkedHashMap

key: 50; value: 500

key: 40; value: 400

key: 30; value: 300

key: 20; value: 200

key: 10; value: 100

key: null; value: aaa

key: aaa; value: null

采用TreeMap

key: 10; value: 100

key: 20; value: 200

key: 30; value: 300

key: 40; value: 400

key: 50; value: 500

新初始化一个Map: myMap

key: 30; value: 300

key: 40; value: 400

key: 10; value: 100

key: 50; value: 500

key: 20; value: 200

将myMap clear后，myMap空了么  true

myMap包含键aaa  true

myMap包含值aaaa  true

删除键aaa后，myMap包含键aaa  false

myMap包含的记录数:  1

源码分析：

遍历Map有两种方法：

（1）map的keySet()方法获得键的集合，再调用键集合的iterator方法获得键的迭代器，以此迭代地取出Map中的键，用get方法获得键对应的值，便完成了Map的遍历。代码如下所示：

//使用迭代器遍历Map的键，根据键取值

       Iterator it = mapkeySet()iterator();

       while (ithasNext()){

          key = itnext();

          value = mapget(key);

          Systemoutprintln("key: " + key + "; value: " + value );

       }

（2）使用Map的entrySet方法获得Map中记录的集合，每条对象都是一个MapEntry对象，使用其getKey方法获得记录的键，使用其getValue方法获得记录的值。代码如下所示：

       //或者使用迭代器遍历Map的记录MapEntry

       MapEntry entry = null;

       it = mapentrySet()iterator();

       while (ithasNext()){

          //一个MapEntry代表一条记录

          entry = (MapEntry)itnext();

          //通过entry可以获得记录的键和值

          //Systemoutprintln("key: " + entrygetKey() + "; value: " + entrygetValue());

以上就是关于C#中HashTable简介和使用用法全部的内容，包括:C#中HashTable简介和使用用法、c#中如何使用hashtable、hashmap和 hashtable以及treemap的区别等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！