论坛首页 → Java企业应用论坛 →

原创中文分词代码分享（1.1）——词典接口

浏览 3129 次
锁定老帖子 主题：原创中文分词代码分享（1.1）——词典接口
精华帖 (0) :: 良好帖 (0) :: 新手帖 (0) :: 隐藏帖 (0)
作者 正文
  • billgmh
  • 等级: 初级会员
  • 性别:
  • 文章: 44
  • 积分: 52
  • 来自: 广东广州
   发表时间：2006-12-26  
目前为止，已实现了1、一维线性表 2、首字Hash 3、双Hash 三种词典的存储结构与表现形式。

首先来看一下词典结构的接口Interface：
java 代码
  1. /* 
  2.  * @作者:Hades , 创建日期:2006-11-17 
  3.  * 
  4.  * 汕头大学03计算机本科 
  5.  *  
  6.  */  
  7. package edu.stu.cn.segment.matching.dictionary;  
  8.   
  9. import java.io.PrintStream;  
  10.   
  11. /** 
  12.  * @author Hades Guan 词典操作接口 
  13.  */  
  14. public interface DictionaryImpl  
  15. {  
  16.   
  17.     /** 
  18.      * 删除词典中的词word 
  19.      *  
  20.      * @param word 
  21.      *            待删除的词汇 
  22.      */  
  23.     public void deleteWord(String word);  
  24.   
  25.     /** 
  26.      * 将词汇word插入到词典文件中 
  27.      *  
  28.      * @param word 
  29.      *            待插入的词汇 
  30.      */  
  31.     public void insertWord(String word);  
  32.   
  33.     /** 
  34.      * 载入以文本格式存储的词典 
  35.      *  
  36.      * @param fileName 
  37.      *            词典的文件名 
  38.      */  
  39.     @SuppressWarnings("unchecked")  
  40.     public void loadDictionary(String fileName);  
  41.   
  42.     /** 
  43.      * 判断输入的字符串是否在词典中 
  44.      *  
  45.      * @param word 
  46.      *            待判断字符串 
  47.      * @return 判断结果 
  48.      */  
  49.     public boolean match(String word);  
  50.   
  51.     /** 
  52.      * 输出已载入内存中所有词汇 
  53.      *  
  54.      * @param out 
  55.      *            输出流 
  56.      */  
  57.     public void print(PrintStream out);  
  58.   
  59. }  
接口中定义了插入词汇、删除词汇、词汇查询、从txt文本文件中载入词典、将已载入的词典输出 五个操作。

接下来看一下一维线性表结构的词典接口实现类SimpleDictionary：
java 代码
  1. /* 
  2.  * @作者:Hades , 创建日期:2006-11-18 
  3.  * 
  4.  * 汕头大学03计算机本科 
  5.  *  
  6.  */  
  7. package edu.stu.cn.segment.matching.dictionary;  
  8.   
  9. import java.io.BufferedReader;  
  10. import java.io.FileReader;  
  11. import java.io.IOException;  
  12. import java.io.PrintStream;  
  13. import java.io.Serializable;  
  14. import java.util.ArrayList;  
  15. import java.util.Collections;  
  16.   
  17. /** 
  18.  * @author Hades Guan 简单顺序词典接口 
  19.  */  
  20. public class SimpleDictionary implements Serializable, DictionaryImpl  
  21. {  
  22.     /** 
  23.      * serialVersionUID 的注释 
  24.      */  
  25.     private static final long serialVersionUID = -6631832710612755332L;  
  26.   
  27.     /** 
  28.      * 词典容器 
  29.      */  
  30.     private ArrayList<string> dic = </string>new ArrayList<string>();  </string>
  31.   
  32.     /** 
  33.      * 删除词典中的词word 
  34.      *  
  35.      * @param word 
  36.      *            待删除的词汇 
  37.      */  
  38.     public void deleteWord(String word)  
  39.     {  
  40.         if (word == null)  
  41.             return;  
  42.         int pos;  
  43.         // 判断原词典中是否已有该词汇  
  44.         if ((pos = Collections.binarySearch(dic, word)) < 0)  
  45.             return;  
  46.         else  
  47.             dic.remove(pos);  
  48.     }  
  49.   
  50.     /** 
  51.      * 将词汇word插入到词典文件中 
  52.      *  
  53.      * @param word 
  54.      *            待插入的词汇 
  55.      */  
  56.     public void insertWord(String word)  
  57.     {  
  58.         if (word == null)  
  59.             return;  
  60.         // 判断原词典中是否已有该词汇  
  61.         if (Collections.binarySearch(dic, word) < 0)  
  62.             dic.add(word);  
  63.         // 插入后重新排序  
  64.         Collections.sort(dic);  
  65.     }  
  66.   
  67.     /** 
  68.      * 载入以文本格式存储的词典 
  69.      *  
  70.      * @param fileName 
  71.      *            词典的文件名 
  72.      */  
  73.     public void loadDictionary(String fileName)  
  74.     {  
  75.         try  
  76.         {  
  77.             // 初始化输入流  
  78.             BufferedReader in = new BufferedReader(new FileReader(fileName));  
  79.             String word = null;  
  80.   
  81.             // 读取词典  
  82.             while ((word = in.readLine()) != null)  
  83.             {  
  84.                 dic.add(word);  
  85.             }  
  86.             // 词典排序  
  87.             Collections.sort(dic);  
  88.             // 关闭输入  
  89.             in.close();  
  90.         }  
  91.         catch (IOException e)  
  92.         {  
  93.             // TODO 自动生成 catch 块  
  94.             e.printStackTrace();  
  95.         }  
  96.     }  
  97.   
  98.     /** 
  99.      * 判断输入的字符串是否在词典中 
  100.      *  
  101.      * @param word 
  102.      *            待判断字符串 
  103.      * @return 判断结果 
  104.      */  
  105.     public boolean match(String word)  
  106.     {  
  107.         int pos = Collections.binarySearch(dic, word);  
  108.         if (pos >= 0)  
  109.             return true;  
  110.         else  
  111.             return false;  
  112.     }  
  113.   
  114.     /** 
  115.      * 输出已载入内存中所有词汇 
  116.      *  
  117.      * @param out 
  118.      *            输出流 
  119.      */  
  120.     public void print(PrintStream out)  
  121.     {  
  122.         for (int i = 0; i < this.dic.size(); i++)  
  123.         {  
  124.             out.println(dic.get(i));  
  125.         }  
  126.         out.flush();  
  127.     }  
  128.   
  129. }  
SimpleDictionary类实现了自定义的DictionaryImpl接口外还实现了序列化，这样做的目的是希望能把从原始文本资料中载入的词汇排序整理后以序列化的形式写成文件，以后需要使用时直接从文件中载入就可以使用了，省去了不少初始化的麻烦。后面提到的词典实现类也都实现了序列化。

接着是首字Hash结构词典实现类HashDictionary：
java 代码
  1. /* 
  2.  * @作者:Hades , 创建日期:2006-11-19 
  3.  * 
  4.  * 汕头大学03计算机本科 
  5.  *  
  6.  */  
  7. package edu.stu.cn.segment.matching.dictionary;  
  8.   
  9. import java.io.BufferedReader;  
  10. import java.io.FileReader;  
  11. import java.io.IOException;  
  12. import java.io.PrintStream;  
  13. import java.io.Serializable;  
  14. import java.util.ArrayList;  
  15. import java.util.Collections;  
  16. import java.util.Hashtable;  
  17.   
  18. /** 
  19.  * @author Hades Guan 单层哈希字典操作类 
  20.  */  
  21. public class HashDictionary implements DictionaryImpl, Serializable  
  22. {  
  23.     /** 
  24.      * serialVersionUID 的注释 
  25.      */  
  26.     private static final long serialVersionUID = -436844886894530829L;  
  27.   
  28.     /** 
  29.      * 词典 
  30.      */  
  31.     private Hashtablenew Hashtable
  32.   
  33.     /** 
  34.      * 删除词典中的词word 
  35.      *  
  36.      * @param word 
  37.      *            待删除的词汇 
  38.      */  
  39.     public void deleteWord(String word)  
  40.     {  
  41.         if (word == null)  
  42.             return;  
  43.         // 截取首字  
  44.         String fch = word.substring(0, 1);  
  45.         if (dic.containsKey(fch))  
  46.         {  
  47.             // 获取词汇表  
  48.             ArrayList<string> wal = dic.get(fch);  </string>
  49.             // 截取词汇剩余部分  
  50.             String leftWord = word.substring(1);  
  51.             // 查找该词汇是否存在于词汇表中  
  52.             int pos = Collections.binarySearch(wal, leftWord);  
  53.             // 存在时删除  
  54.             if (pos >= 0)  
  55.             {  
  56.                 wal.remove(pos);  
  57.                 dic.put(fch, wal);  
  58.             }  
  59.         }  
  60.     }  
  61.   
  62.     /** 
  63.      * 将词汇word插入到词典文件中 
  64.      *  
  65.      * @param word 
  66.      *            待插入的词汇 
  67.      */  
  68.     public void insertWord(String word)  
  69.     {  
  70.         if (word == null)  
  71.             return;  
  72.         // 截取首字  
  73.         String fch = word.substring(0, 1);  
  74.         // 词汇表  
  75.         ArrayList<string> wal = null;  </string>
  76.         if (dic.containsKey(fch))  
  77.             wal = dic.get(fch);  
  78.         else  
  79.             wal = new ArrayList<string>();  </string>
  80.         // 截取词汇剩余部分  
  81.         String leftWord = word.substring(1);  
  82.         // 判断词汇表中是否已有该词汇  
  83.         if (Collections.binarySearch(wal, leftWord) < 0)  
  84.         {  
  85.             wal.add(leftWord);  
  86.             Collections.sort(wal);  
  87.             dic.put(fch, wal);  
  88.         }  
  89.     }  
  90.   
  91.     /** 
  92.      * 载入以文本格式存储的词典 
  93.      *  
  94.      * @param fileName 
  95.      *            词典的文件名 
  96.      */  
  97.     public void loadDictionary(String fileName)  
  98.     {  
  99.         try  
  100.         {  
  101.             // 初始化输入流  
  102.             BufferedReader in = new BufferedReader(new FileReader(fileName));  
  103.             String word = null;  
  104.   
  105.             // 读取词典  
  106.             while ((word = in.readLine()) != null)  
  107.             {  
  108.                 // 插入词汇  
  109.                 this.insertWord(word.trim());  
  110.             }  
  111.         }  
  112.         catch (IOException e)  
  113.         {  
  114.             // TODO 自动生成 catch 块  
  115.             e.printStackTrace();  
  116.         }  
  117.     }  
  118.   
  119.     /** 
  120.      * 判断输入的字符串是否在词典中 
  121.      *  
  122.      * @param word 
  123.      *            待判断字符串 
  124.      * @return 判断结果 
  125.      */  
  126.     public boolean match(String word)  
  127.     {  
  128.         if (word == null)  
  129.             return false;  
  130.         // 截取首字  
  131.         String fch = word.substring(0, 1);  
  132.         // 判断词汇表是否有此首字  
  133.         if (!dic.containsKey(fch))  
  134.             return false;  
  135.         // 获取词汇表  
  136.         ArrayList<string> wal = dic.get(fch);  </string>
  137.         // 截取词汇剩余部分  
  138.         String leftWord = word.substring(1);  
  139.   
  140.         // 折半查找  
  141.         int pos = Collections.binarySearch(wal, leftWord);  
  142.   
  143.         return (pos >= 0);  
  144.     }  
  145.   
  146.     /** 
  147.      * 输出已载入内存中所有词汇 
  148.      *  
  149.      * @param out 
  150.      *            输出流 
  151.      */  
  152.     public void print(PrintStream out)  
  153.     {  
  154.         // 获取首字集合  
  155.         for (String fch : dic.keySet())  
  156.         {  
  157.             out.println("首字:" + fch);  
  158.             for (String w : dic.get(fch))  
  159.                 out.println("\t" + w);  
  160.         }  
  161.         out.flush();  
  162.     }  
  163.   
  164. }  
首字Hash结构中是使用Hashtable类作为基础，其中key为词汇的首字，如：“关心”中的“关”字，而value则是ArrayList类型的一维线性表，存储的是相同首字的词汇列表。
基于这种结构，查询时先把字符串的首个字符作为key，若Hashtable中不包含这个key则返回false，否则取出改线性表value后使用折半查找的方法查询。
返回顶楼
         
论坛首页 → Java企业应用版

跳转论坛:
Global site tag (gtag.js) - Google Analytics