`
anyunbin
  • 浏览: 1083 次
  • 性别: Icon_minigender_2
最近访客 更多访客>>
社区版块
存档分类
最新评论

java

阅读更多
package com.chenlb.mmseg4j;


import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
* 词典类. 词库目录单例模式.<br/>
* 保存单字与其频率,还有词库.<br/>
* 有检测词典变更的接口,外部程序可以使用 {@link #wordsFileIsChange()} 和 {@link #reload()} 来完成检测与加载的工作.
*
* @author chenlb 2009-2-20 下午11:34:29
*/
public class Dictionary {

     private static final Logger log = Logger.getLogger(Dictionary.class.getName());

     private File dicPath;     //词库目录
     private volatile Map<Character, CharNode> dict;
     private volatile Map<Character, Object> unit;     //单个字的单位

     /** 记录 word 文件的最后修改时间 */
     private Map<File, Long> wordsLastTime = null;
     private long lastLoadTime = 0;

     /** 不要直接使用, 通过 {@link #getDefalutPath()} 使用*/
     private static File defalutPath = null;
     private static final ConcurrentHashMap<File, Dictionary> dics = new ConcurrentHashMap<File, Dictionary>();

     protected void finalize() throws Throwable {
          /*
          * 使 class reload 的时也可以释放词库
          */
          destroy();
     }

     /**
     * 从默认目录加载词库文件.<p/>
     * 查找默认目录顺序:
     *

         *
  1. 从系统属性mmseg.dic.path指定的目录中加载

  2.      *
  3. 从classpath/data目录

  4.      *
  5. 从user.dir/data目录

  6.      *

     * @see #getDefalutPath()
     */
     public static Dictionary getInstance() {
          File path = getDefalutPath();
          return getInstance(path);
     }

     /**
     * @param path 词典的目录
     */
     public static Dictionary getInstance(String path) {
          return getInstance(new File(path));
     }

     /**
     * @param path 词典的目录
     */
     public static Dictionary getInstance(File path) {
          log.info("try to load dir="+path);
          File normalizeDir = normalizeFile(path);
        System.out.println(normalizeDir);
          Dictionary dic = dics.get(normalizeDir);
          if(dic == null) {
               dic = new Dictionary(normalizeDir);
               dics.put(normalizeDir, dic);
          }
          return dic;
     }

     public static File normalizeFile(File file) {
          if(file == defalutPath) {
               return defalutPath;
          }
          try {
               return file.getCanonicalFile();
          } catch (IOException e) {
               throw new RuntimeException("normalize file=["+file+"] fail", e);
          }
     }

     /**
     * 销毁, 释放资源. 此后此对像不再可用.
     */
     void destroy() {
          clear(dicPath);

          dicPath = null;
          dict = null;
          unit = null;
     }

     /**
     * @see Dictionary#clear(File)
     */
     public static Dictionary clear(String path) {
          return clear(new File(path));
     }

     /**
     * 从单例缓存中去除
     * @param path
     * @return 没有返回 null
     */
     public static Dictionary clear(File path) {
          File normalizeDir = normalizeFile(path);
          return dics.remove(normalizeDir);
     }

     /**
     * 词典的目录
     */
     private Dictionary(File path) {
          init(path);
     }

     private void init(File path) {
          dicPath = path;
          wordsLastTime = new HashMap<File, Long>();

          reload();     //加载词典
     }

     private static long now() {
          return System.currentTimeMillis();
     }

     /**
     * 只要 wordsXXX.dic的文件
     * @return
     */
     protected File[] listWordsFiles() {
          return dicPath.listFiles(new FilenameFilter() {

               public boolean accept(File dir, String name) {

                    return name.startsWith("words") && name.endsWith(".dic");
               }

          });
     }

     private Map<Character, CharNode> loadDic(File wordsPath) throws IOException {
          InputStream charsIn = null;
          File charsFile = new File(wordsPath, "chars.dic");
          if(charsFile.exists()) {
               charsIn = new FileInputStream(charsFile);
               addLastTime(charsFile);     //chars.dic 也检测是否变更
          } else {     //从 jar 里加载
               charsIn = this.getClass().getResourceAsStream("/data/chars.dic");
               charsFile = new File(this.getClass().getResource("/data/chars.dic").getFile());     //only for log
          }
          final Map<Character, CharNode> dic = new HashMap<Character, CharNode>();
          int lineNum = 0;
          long s = now();
          long ss = s;
          lineNum = load(charsIn, new FileLoading() {     //单个字的

               public void row(String line, int n) {
                    if(line.length() < 1) {
                         return;
                    }
                    String[] w = line.split(" ");
                    CharNode cn = new CharNode();
                    switch(w.length) {
                    case 2:
                         try {
                              cn.setFreq((int)(Math.log(Integer.parseInt(w[1]))*100));//字频计算出自由度
                         } catch(NumberFormatException e) {
                              //eat...
                         }
                    case 1:

                         dic.put(w[0].charAt(0), cn);
                    }
               }
          });
          log.info("chars loaded time="+(now()-s)+"ms, line="+lineNum+", on file="+charsFile);

          //try load words.dic in jar
          InputStream wordsDicIn = this.getClass().getResourceAsStream("/data/words.dic");
          if(wordsDicIn != null) {
               File wordsDic = new File(this.getClass().getResource("/data/words.dic").getFile());
               loadWord(wordsDicIn, dic, wordsDic);
          }

          File[] words = listWordsFiles();     //只要 wordsXXX.dic的文件
          if(words != null) {     //扩展词库目录
               for(File wordsFile : words) {
                    loadWord(new FileInputStream(wordsFile), dic, wordsFile);

                    addLastTime(wordsFile);     //用于检测是否修改
               }
          }

          log.info("load all dic use time="+(now()-ss)+"ms");
          return dic;
     }

     /**
     * @param is 词库文件流
     * @param dic 加载的词保存在结构中
     * @param wordsFile     日志用
     * @throws IOException from {@link #load(InputStream, FileLoading)}
     */
     private void loadWord(InputStream is, Map<Character, CharNode> dic, File wordsFile) throws IOException {
          long s = now();
          int lineNum = load(is, new WordsFileLoading(dic)); //正常的词库
          log.info("words loaded time="+(now()-s)+"ms, line="+lineNum+", on file="+wordsFile);
     }

     private Map<Character, Object> loadUnit(File path) throws IOException {
          InputStream fin = null;
          File unitFile = new File(path, "units.dic");
          if(unitFile.exists()) {
               fin = new FileInputStream(unitFile);
               addLastTime(unitFile);
          } else {     //在jar包里的/data/unit.dic
               fin = Dictionary.class.getResourceAsStream("/data/units.dic");
               unitFile = new File(Dictionary.class.getResource("/data/units.dic").getFile());
          }

          final Map<Character, Object> unit = new HashMap<Character, Object>();

          long s = now();
          int lineNum = load(fin, new FileLoading() {

               public void row(String line, int n) {
                    if(line.length() != 1) {
                         return;
                    }
                    unit.put(line.charAt(0), Dictionary.class);
               }
          });
          log.info("unit loaded time="+(now()-s)+"ms, line="+lineNum+", on file="+unitFile);

          return unit;
     }

     /**
     * 加载 wordsXXX.dic 文件类。
     *
     * @author chenlb 2009-10-15 下午02:12:55
     */
     private static class WordsFileLoading implements FileLoading {
          final Map<Character, CharNode> dic;

          /**
          * @param dic 加载的词,保存在此结构中。
          */
          public WordsFileLoading(Map<Character, CharNode> dic) {
               this.dic = dic;
          }

          public void row(String line, int n) {
               if(line.length() < 2) {
                    return;
               }
               CharNode cn = dic.get(line.charAt(0));
               if(cn == null) {
                    cn = new CharNode();
                    dic.put(line.charAt(0), cn);
               }
               cn.addWordTail(tail(line));
          }
     }

     /**
     * 加载词文件的模板
     * @return 文件总行数
     */
     public static int load(InputStream fin, FileLoading loading) throws IOException {
          BufferedReader br = new BufferedReader(
                    new InputStreamReader(new BufferedInputStream(fin), "UTF-8"));
          String line = null;
          int n = 0;
          while((line = br.readLine()) != null) {
               if(line == null || line.startsWith("#")) {
                    continue;
               }
               n++;
               loading.row(line, n);
          }
          return n;
     }

     /**
     * 取得 str 除去第一个char的部分
     * @author chenlb 2009-3-3 下午10:05:26
     */
     private static char[] tail(String str) {
          char[] cs = new char[str.length()-1];
          str.getChars(1, str.length(), cs, 0);
          return cs;
     }

     public static interface FileLoading {
          /**
          * @param line 读出的一行
          * @param n 当前第几行
          * @author chenlb 2009-3-3 下午09:55:54
          */
          void row(String line, int n);
     }

     /**
     * 把 wordsFile 文件的最后更新时间加记录下来.
     * @param wordsFile 非 null
     */
     private synchronized void addLastTime(File wordsFile) {
          if(wordsFile != null) {
               wordsLastTime.put(wordsFile, wordsFile.lastModified());
          }
     }

     /**
     * 词典文件是否有修改过
     * @return
     */
     public synchronized boolean wordsFileIsChange() {
          //检查是否有修改文件,包括删除的
          for(Entry<File, Long> flt : wordsLastTime.entrySet()) {
               File words = flt.getKey();
               if(!words.canRead()) {     //可能是删除了
                    return true;
               }
               if(words.lastModified() > flt.getValue()) {     //更新了文件
                    return true;
               }
          }
          //检查是否有新文件
          File[] words = listWordsFiles();
          if(words != null) {
               for(File wordsFile : words) {
                    if(!wordsLastTime.containsKey(wordsFile)) {     //有新词典文件
                         return true;
                    }
               }
          }
          return false;
     }

     /**
     * 全新加载词库,没有成功加载会回滚。<P/>
     * 注意:重新加载时,务必有两倍的词库树结构的内存,默认词库是 50M/个 左右。否则抛出 OOM。
     * @return 是否成功加载
     */
     public synchronized boolean reload() {
          Map<File, Long> oldWordsLastTime = new HashMap<File, Long>(wordsLastTime);
          Map<Character, CharNode> oldDict = dict;
          Map<Character, Object> oldUnit = unit;

          try {
               wordsLastTime.clear();
               dict = loadDic(dicPath);
               unit = loadUnit(dicPath);
               lastLoadTime = System.currentTimeMillis();
          } catch (IOException e) {
               //rollback
               wordsLastTime.putAll(oldWordsLastTime);
               dict = oldDict;
               unit = oldUnit;

               if(log.isLoggable(Level.WARNING)) {
                    log.log(Level.WARNING, "reload dic error! dic="+dicPath+", and rollbacked.", e);
               }

               return false;
          }
          return true;
     }

     /**
     * word 能否在词库里找到
     * @author chenlb 2009-3-3 下午11:10:45
     */
     public boolean match(String word) {
          if(word == null || word.length() < 2) {
               return false;
          }
          CharNode cn = dict.get(word.charAt(0));
          return search(cn, word.toCharArray(), 0, word.length()-1) >= 0;
     }

     public CharNode head(char ch) {
          return dict.get(ch);
     }

     /**
     * sen[offset] 后 tailLen 长的词是否存在.
     * @see CharNode#indexOf(char[], int, int)
     * @author chenlb 2009-4-8 下午11:13:49
     */
     public int search(CharNode node, char[] sen, int offset, int tailLen) {
          if(node != null) {
               return node.indexOf(sen, offset, tailLen);
          }
          return -1;
     }

     public int maxMatch(char[] sen, int offset) {
          CharNode node = dict.get(sen[offset]);
          return maxMatch(node, sen, offset);
     }

     public int maxMatch(CharNode node, char[] sen, int offset) {
          if(node != null) {
               return node.maxMatch(sen, offset+1);
          }
          return 0;
     }

     public ArrayList<Integer> maxMatch(CharNode node, ArrayList<Integer> tailLens, char[] sen, int offset) {
          tailLens.clear();
          tailLens.add(0);
          if(node != null) {
               return node.maxMatch(tailLens, sen, offset+1);
          }
          return tailLens;
     }

     public boolean isUnit(Character ch) {
          return unit.containsKey(ch);
     }

     /**
     * 当 words.dic 是从 jar 里加载时, 可能 defalut 不存在
     */
     public static File getDefalutPath() {
          if(defalutPath == null) {
               String defPath = System.getProperty("mmseg.dic.path");
               log.info("look up in mmseg.dic.path="+defPath);
               if(defPath == null) {
                    URL url = Dictionary.class.getClassLoader().getResource("data");
                    if(url != null) {
                         defPath = url.getFile();
                         log.info("look up in classpath="+defPath);
                    } else {
                         defPath = System.getProperty("user.dir")+"/data";
                         log.info("look up in user.dir="+defPath);
                    }

               }

               defalutPath = new File(defPath);
               if(!defalutPath.exists()) {
                    log.warning("defalut dic path="+defalutPath+" not exist");
               }
          }
          return defalutPath;
     }

     /**
     * 仅仅用来观察词库.
     */
     public Map<Character, CharNode> getDict() {
          return dict;
     }

     /**
     * 注意:当 words.dic 是从 jar 里加载时,此时 File 可能是不存在的。
     */
     public File getDicPath() {
          return dicPath;
     }

     /** 最后加载词库的时间 */
     public long getLastLoadTime() {
          return lastLoadTime;
     }
}
0
3
分享到:
评论

相关推荐

    JAVA_API1.6文档(中文)

    java.lang.management 提供管理接口,用于监视和管理 Java 虚拟机以及 Java 虚拟机在其上运行的操作系统。 java.lang.ref 提供了引用对象类,支持在某种程度上与垃圾回收器之间的交互。 java.lang.reflect 提供类...

    java源码包---java 源码 大量 实例

    Applet钢琴模拟程序java源码 2个目标文件,提供基本的音乐编辑功能。编辑音乐软件的朋友,这款实例会对你有所帮助。 Calendar万年历 1个目标文件 EJB 模拟银行ATM流程及操作源代码 6个目标文件,EJB来模拟银行ATM...

    Java 面经手册·小傅哥.pdf

    这是一本以面试题为入口讲解 Java 核心内容的技术书籍,书中内容极力的向你证实代码是对数学逻辑的具体实现。当你仔细阅读书籍时,会发现Java中有大量的数学知识,包括:扰动函数、负载因子、拉链寻址、开放寻址、...

    Java OCR 图像智能字符识别技术,可识别中文

    Java OCR(Optical Character Recognition,光学字符识别)技术是一种计算机视觉领域的应用,它能将图像中的文字转换成可编辑的文本格式。这项技术在各种场景下都有广泛应用,比如文档扫描、车牌识别、发票处理等。...

    Java API文档 中文网页版

    Java API文档是Java开发者的重要参考资料,它包含了Java开发工具包(JDK)中的所有类、接口、方法和常量的详细说明。这份中文网页版的Java API文档为中国的开发者提供了便利,无需通过英文版本来学习和查找API信息,...

    java_011 java 人脸识别完整源代码

    java_011 java 人脸识别完整源代码java_011 java 人脸识别完整源代码java_011 java 人脸识别完整源代码java_011 java 人脸识别完整源代码java_011 java 人脸识别完整源代码java_011 java 人脸识别完整源代码java_011...

    java源码包2

    Applet钢琴模拟程序java源码 2个目标文件,提供基本的音乐编辑功能。编辑音乐软件的朋友,这款实例会对你有所帮助。 Calendar万年历 1个目标文件 EJB 模拟银行ATM流程及操作源代码 6个目标文件,EJB来模拟银行...

    java电商源代码 java电商源代码

    java电商源代码java电商源代码java电商源代码java电商源代码java电商源代码java电商源代码java电商源代码java电商源代码java电商源代码java电商源代码java电商源代码java电商源代码java电商源代码java电商源代码java...

    java源码包实例源码JAVA开发源码50个合集.zip

    java源码包实例源码JAVA开发源码50个合集: Ajax框架 ZK.rar Java图书馆管理系统源程序.rar Java图片倒影效果实例源码.rar Java图片翻折,将图像压扁.rar Java坦克大战网络对战版源代码.rar Java声音播放程序源代码....

    java api最新7.0

    JAVA开发人员最新版本7.0 api文档!本文档是 Java Platform Standard Edition 7 的 API !Java 1.7 API的中文帮助文档。 深圳电信培训中心 徐海蛟博士教学用api 7.0中文文档。支持全文检索,在线即时查询。 里面列...

    java单机小游戏.zip

    java单机小游戏java单机小游戏java单机小游戏java单机小游戏 java单机小游戏java单机小游戏java单机小游戏java单机小游戏 java单机小游戏java单机小游戏java单机小游戏java单机小游戏 java单机小游戏java单机小游戏...

    Java学习资料全套.zip

    最新全套Java学习资料打包 最新全套Java学习资料打包 最新全套Java学习资料打包 最新全套Java学习资料打包 最新全套Java学习资料打包 最新全套Java学习资料打包 最新全套Java学习资料打包 最新全套Java...

    JAVA上百实例源码以及开源项目源代码

    日历表格面板 [ConfigLine.java] 控制条类 [RoundBox.java] 限定选择控件 [MonthMaker.java] 月份表算法类 [Pallet.java] 调色板,统一配色类 Java扫雷源码 Java生成自定义控件源代码 2个目标文件 Java实现HTTP连接...

    java开源包5

    JoSQL(SQLforJavaObjects)为Java开发者提供运用SQL语句来操作Java对象集的能力.利用JoSQL可以像操作数据库中的数据一样对任何Java对象集进行查询,排序,分组。 搜索自动提示 Autotips AutoTips是为解决应用系统对于...

    Java算法集题大全.zip

    Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法...

    Java2Pas Java代码转pas代码

    Java2Pas是一个实用工具,主要用于将Java编程语言编写的源代码转换为Pascal语言的等效代码。这个工具对于那些需要在两种语言之间迁移代码或者理解不同编程语言语法的开发者来说非常有价值。Java和Pascal虽然都是面向...

    java错误处理:java.lang.OutOfMemoryError: Java heap space

    ### Java 错误处理:java.lang.OutOfMemoryError: Java heap space 在Java应用程序开发过程中,经常遇到的一个问题就是内存溢出错误,特别是在处理大量数据或长时间运行的应用时。其中,“java.lang....

    从Java菜鸟到专家的资料

    这份名为“从Java菜鸟到专家的资料”的压缩包文件包含了丰富的学习资源,旨在帮助初学者逐步成长为Java领域的专家。以下是对各个文件的详细解读: 1. **J2EE研究文集.chm**:这个文件专注于Java企业级应用开发,...

    Java文件管理系统源码.zip

    Java文件管理系统源码 Java文件管理系统源码 Java文件管理系统源码 Java文件管理系统源码 Java文件管理系统源码 Java文件管理系统源码 Java文件管理系统源码 Java文件管理系统源码 Java文件管理系统源码 ...

    Java基础 学习笔记 Markdownr版

    Java是一种广泛使用的面向对象的编程语言,其设计目标是具有高度的可移植性,灵活性和安全性。本学习笔记主要涵盖了Java的基础知识,包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面,...

Global site tag (gtag.js) - Google Analytics