精华内容
下载资源
问答
  • IKAnalyzer

    2018-09-07 11:35:51
    ikanalyzer-2012_u6中文分词器,Maven配置 清除IKAnalyzer2012_u6所依赖的Lucene4.7.2相关jar包 引入IKAnalyzer2012_u6所依赖的Lucene5.5.4相关jar包
  • IK Analyzer

    2015-09-29 14:21:13
    IKAnalyzer2012FF_u1.jar 支持lucene4/solr4 IKAnalyzer2012FF_u2.jar 支持lucene5/solr5
  • IK Analyzer 2012FF_hf1 和 IKAnalyzer2012_u6低分抢。
  • IKAnalyzer分词器版本 2012 兼容Lucene3.3以上版本 对solr1.4提供接口实现 使用IK分词器,应为该集群使用到的solr版本为4.10.3-cdh5.7.5,所以使用的 IK 包为IKAnalyzer2012FF_u1.jar,如果是3x的solr,使用IK...
  • 支持lucene5的 IKAnalyzer中文分词器 IKAnalyzer5.jar
  • ikanalyzer-2012_u6 和 IKAnalyzer2012FF_u1分词器两个版本的分词器,均有,Solr 3.x版本用u6,Solr 4.x版本用FF_u1
  • IKAnalyzer中文分词器的使用 IK-Analyzer是一个开源的,基于java语言开发的轻量级的中文分词工具包,也就是可以将一串中文字符分割成一个个的词组或者字词 安装 修改pom文件 <dependency> <groupId>...

    IKAnalyzer中文分词器的使用


    IK-Analyzer是一个开源的,基于java语言开发的轻量级的中文分词工具包,也就是可以将一串中文字符分割成一个个的词组或者字词

    • 安装
      修改pom文件
            <dependency>
                <groupId>com.janeluo</groupId>
                <artifactId>ikanalyzer</artifactId>
                <version>2012_u6</version>
            </dependency>
    
    • 使用测试
               StringReader sr = new StringReader("每个人都要走一条自己坚定了的路,就算是粉身碎骨。 ");
                IKSegmenter ik = new IKSegmenter(sr,true);
                Lexeme lex = null;
                while ((lex=ik.next())!=null){
                    System.out.print(lex.getLexemeText()+" ");
                }
    

    在这里插入图片描述

    • 配置暂停词和字典,暂停词也就是忽略词,字典也就是自定义组合词
      以下三个文件都在src目录下配置
      IKAnalyzer.cfg.xml文件
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
    <properties>
    	<comment>IK Analyzer 扩展配置</comment>
    	<!--用户可以在这里配置自己的扩展字典 -->
    	<entry key="ext_dict">test.dic;</entry>
    	<!--用户可以在这里配置自己的扩展停止词字典 -->
    	<entry key="ext_stopwords">teststop.dic;</entry>
    </properties>
    

    自己在俩个字典里面添加词组即可

    • 注意点:
      1、停用词词典必须是UTF-8编码
      2、这里非常多跟我一样的新手没办法成功的原因就是被无bom的UTF-8格式给折磨的,IK作者自己也这样说了
      3、假设你不知道啥叫无BOM,也不确定自己的文件是不是UTF-8无bom,那么请在第一行使用回车换行,从第二行開始加入停止词
      4、该配置文件以及停用词词典均存放在src文件夹以下就可以。

    • 我在test.dic里输入
      在这里插入图片描述
      teststop.dic输入
      在这里插入图片描述

    • 运行
      加了字典的
      在这里插入图片描述
      没加字典的
      在这里插入图片描述
      发现都要走三个字合起来了,的 路俩个字忽略了

    展开全文
  • IKAnalyzer IK分词器

    2017-11-13 16:51:55
    文件目录: doc IKAnalyzer2012FF_u1.jar IKAnalyzer.cfg.xml IKAnalyzer中文分词器V2012_FF使用手册.pdf LICENSE.txt NOTICE.txt
  • IKAnalyzer 2012

    2018-05-01 16:27:52
    文件列表: IKAnalyzer-3.1.0.jar IKAnalyzer中文分词器V2012_FF使用手册.pdf
  • IKAnalyzer2012_u3

    2017-12-05 15:33:38
    IK Analyzer 2012 IKAnalyzer2012_u3 IK Analyzer 2012 IKAnalyzer2012_u3 IK Analyzer 2012 IKAnalyzer2012_u3
  • Lucene使用IKAnalyzer分词实例 及 IKAnalyzer扩展词库

    方案一基于配置的词典扩充

    项目结构图如下:


    IK分词器还支持通过配置IKAnalyzer.cfg.xml文件来扩充您的专有词典。谷歌拼音词库下载http://ishare.iask.sina.com.cn/f/14446921.html?from=like
    在web项目的src目录下创建IKAnalyzer.cfg.xml文件,内容如下

    复制代码
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">  
    <properties>  
    
        <comment>IK Analyzer 扩展配置</comment>
        <!-- 用户可以在这里配置自己的扩展字典 -->
         <entry key="ext_dict">/dicdata/use.dic.dic;/dicdata/googlepy.dic</entry> 
         <!-- 用户可以在这里配置自己的扩展停止词字典    -->
        <entry key="ext_stopwords">/dicdata/ext_stopword.dic</entry> 
    
    </properties>
    复制代码

    词典文件的编辑与部署
    分词器的词典文件格式是无BOM 的UTF-8 编码的中文文本文件,文件扩展名不限。词典中,每个中文词汇独立占一行,使用\r\n 的DOS 方式换行。(注,如果您不了解什么是无BOM 的UTF-8 格式, 请保证您的词典使用UTF-8 存储,并在文件的头部添加一空行)。您可以参考分词器源码org.wltea.analyzer.dic 包下的.dic 文件。词典文件应部署在Java 的资源路径下,即ClassLoader 能够加载的路径中。(推荐同IKAnalyzer.cfg.xml 放在一起).

    方案二:基于API的词典扩充

    在IKAnalyzer的与词条相关的操作
    1.org.wltea.analyzer.cfg 
    2.org.wltea.analyzer.dic 

    复制代码
    org.wltea.analyzer.cfg下Configuration接口中的定义
      getExtDictionarys()  获取扩展字典配置路径
      getExtStopWordDictionarys() 获取扩展停止词典配置路径
      getMainDictionary() 获取主词典路径
      getQuantifierDicionary() 获取量词词典路径
    org.wltea.analyzer.cfg.DefualtConfig类是对Configuration接口的实现
    复制代码

    org.wltea.analyzer.dic下的Directory类中相关的方法

    public void addWords(java.util.Collection<java.lang.String> words)     批量加载新词条    参数:words - Collection词条列表
    public void disableWords(java.util.Collection<java.lang.String> words) 批量移除(屏蔽)词条

     

    Lucene中使用IKAnalyzer分词器实例演示
    业务实体

    复制代码
    package com.icrate.service.study.demo;
    /**
     * 
     *
     *  @version : 1.0
     *  
     *  @author  : 苏若年              <a href="mailto:DennisIT@163.com">发送邮件</a>
     *    
     *  @since   : 1.0        创建时间:    2013-4-7    下午01:52:49
     *     
     *  @function: TODO        
     *
     */
    public class Medicine {
    
        private Integer id;
        private String name;
        private String function;
        
        
        public Medicine() {
            
        }
        
        
        public Medicine(Integer id, String name, String function) {
            super();
            this.id = id;
            this.name = name;
            this.function = function;
        }
    
        //getter and setter()    
    
        public String toString(){
            return this.id + "," +this.name + "," + this.function;
        }
    }
    复制代码

    构建模拟数据

    复制代码
    package com.icrate.service.study.demo;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 
     *
     *  @version : 1.0
     *  
     *  @author  : 苏若年              <a href="mailto:DennisIT@163.com">发送邮件</a>
     *    
     *  @since   : 1.0        创建时间:    2013-4-7    下午01:54:34
     *     
     *  @function: TODO        
     *
     */
    public class DataFactory {
    
        
        private static DataFactory dataFactory = new DataFactory();
        
        private DataFactory(){
            
        }
        
        public List<Medicine> getData(){
            List<Medicine> list = new ArrayList<Medicine>();
            list.add(new Medicine(1,"银花 感冒颗粒","功能主治:银花感冒颗粒 ,头痛,清热,解表,利咽。"));
            list.add(new Medicine(2,"感冒 止咳糖浆","功能主治:感冒止咳糖浆,解表清热,止咳化痰。"));
            list.add(new Medicine(3,"感冒灵颗粒","功能主治:解热镇痛。头痛 ,清热。"));
            list.add(new Medicine(4,"感冒灵胶囊","功能主治:银花感冒颗粒 ,头痛,清热,解表,利咽。"));
            list.add(new Medicine(5,"仁和 感冒颗粒","功能主治:疏风清热,宣肺止咳,解表清热,止咳化痰。"));
            return list;
            
        }
        
        public static DataFactory getInstance(){
            return dataFactory;
        }
    }
    复制代码

    使用Lucene对模拟数据进行检索

    复制代码
    package com.icrate.service.study.demo;
    import java.io.File;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    import org.apache.lucene.analysis.Analyzer;
    import org.apache.lucene.document.Document;
    import org.apache.lucene.document.Field;
    import org.apache.lucene.index.IndexReader;
    import org.apache.lucene.index.IndexWriter;
    import org.apache.lucene.index.IndexWriterConfig;
    import org.apache.lucene.index.Term;
    import org.apache.lucene.queryParser.MultiFieldQueryParser;
    import org.apache.lucene.search.IndexSearcher;
    import org.apache.lucene.search.Query;
    import org.apache.lucene.search.ScoreDoc;
    import org.apache.lucene.search.TopDocs;
    import org.apache.lucene.search.highlight.Formatter;
    import org.apache.lucene.search.highlight.Fragmenter;
    import org.apache.lucene.search.highlight.Highlighter;
    import org.apache.lucene.search.highlight.QueryScorer;
    import org.apache.lucene.search.highlight.Scorer;
    import org.apache.lucene.search.highlight.SimpleFragmenter;
    import org.apache.lucene.search.highlight.SimpleHTMLFormatter;
    import org.apache.lucene.store.Directory;
    import org.apache.lucene.store.FSDirectory;
    import org.apache.lucene.util.Version;
    import org.wltea.analyzer.lucene.IKAnalyzer;
    
    /**
     *
     *  LuenceProcess.java  
     *
     *  @version : 1.1
     *  
     *  @author  : 苏若年    <a href="mailto:DennisIT@163.com">发送邮件</a>
     *    
     *  @since   : 1.0      创建时间:    Apr 3, 2013        11:48:11 AM
     *     
     *  TODO     : Luence中使用IK分词器
     *
     */
    
    public class LuceneIKUtil {
        
        private Directory directory ;
        private Analyzer analyzer ;
        
        /**
         * 带参数构造,参数用来指定索引文件目录
         * @param indexFilePath
         */
        public LuceneIKUtil(String indexFilePath){
            try {
                directory = FSDirectory.open(new File(indexFilePath));
                analyzer = new IKAnalyzer();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        /**
         * 默认构造,使用系统默认的路径作为索引
         */
        public LuceneIKUtil(){
            this("/luence/index");
        }
        
        
        /**
         * 创建索引
         * Description:
         * @author dennisit@163.com Apr 3, 2013
         * @throws Exception
         */
        public void createIndex()throws Exception{
            IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_35,analyzer);
            IndexWriter indexWriter = new IndexWriter(directory,indexWriterConfig);
            indexWriter.deleteAll();
            List<Medicine> list = DataFactory.getInstance().getData();
            for(int i=0; i<list.size(); i++){
                Medicine medicine = list.get(i);
                Document document = addDocument(medicine.getId(), medicine.getName(), medicine.getFunction());
                indexWriter.addDocument(document);
            }
            
            indexWriter.close();
        }
        
        /**
         * 
         * Description:
         * @author dennisit@163.com Apr 3, 2013
         * @param id
         * @param title
         * @param content
         * @return
         */
        public Document addDocument(Integer id, String name, String function){
            Document doc = new Document();
            //Field.Index.NO 表示不索引         
            //Field.Index.ANALYZED 表示分词且索引         
            //Field.Index.NOT_ANALYZED 表示不分词且索引
            doc.add(new Field("id",String.valueOf(id),Field.Store.YES,Field.Index.NOT_ANALYZED));
            doc.add(new Field("name",name,Field.Store.YES,Field.Index.ANALYZED));
            doc.add(new Field("function",function,Field.Store.YES,Field.Index.ANALYZED));
            return doc;
        }
        
        /**
         * 
         * Description: 更新索引
         * @author dennisit@163.com Apr 3, 2013
         * @param id
         * @param title
         * @param content
         */
        public void update(Integer id,String title, String content){
            try {
                IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_35,analyzer);
                IndexWriter indexWriter = new IndexWriter(directory,indexWriterConfig);
                Document document = addDocument(id, title, content);
                Term term = new Term("id",String.valueOf(id));
                indexWriter.updateDocument(term, document);
                indexWriter.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        /**
         * 
         * Description:按照ID进行索引
         * @author dennisit@163.com Apr 3, 2013
         * @param id
         */
        public void delete(Integer id){
            try {
                IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_35,analyzer);
                IndexWriter indexWriter = new IndexWriter(directory,indexWriterConfig);
                Term term = new Term("id",String.valueOf(id));
                indexWriter.deleteDocuments(term);
                indexWriter.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        /**
         * 
         * Description:查询
         * @author dennisit@163.com Apr 3, 2013
         * @param where 查询条件
         * @param scoreDoc 分页时用
         */
        public List<Medicine> search(String[] fields,String keyword){
            
            IndexSearcher indexSearcher = null;
            List<Medicine> result = new ArrayList<Medicine>();
            
            
            try {
                //创建索引搜索器,且只读
                IndexReader indexReader = IndexReader.open(directory,true);
                indexSearcher = new IndexSearcher(indexReader);
    
                MultiFieldQueryParser queryParser =new MultiFieldQueryParser(Version.LUCENE_35, fields,analyzer);
                Query query = queryParser.parse(keyword);
                
                //返回前number条记录
                TopDocs topDocs = indexSearcher.search(query, 10);
                //信息展示
                int totalCount = topDocs.totalHits;
                System.out.println("共检索出 "+totalCount+" 条记录");
                
                
                //高亮显示
                /*  
                      创建高亮器,使搜索的结果高亮显示
                    SimpleHTMLFormatter:用来控制你要加亮的关键字的高亮方式
                    此类有2个构造方法
                    1:SimpleHTMLFormatter()默认的构造方法.加亮方式:<B>关键字</B>
                    2:SimpleHTMLFormatter(String preTag, String postTag).加亮方式:preTag关键字postTag
                 */
                Formatter formatter = new SimpleHTMLFormatter("<font color='red'>","</font>");    
                /*
                     QueryScorer
                    QueryScorer 是内置的计分器。计分器的工作首先是将片段排序。QueryScorer使用的项是从用户输入的查询中得到的;
                    它会从原始输入的单词、词组和布尔查询中提取项,并且基于相应的加权因子(boost factor)给它们加权。
                    为了便于QueryScoere使用,还必须对查询的原始形式进行重写。
                    比如,带通配符查询、模糊查询、前缀查询以及范围查询 等,都被重写为BoolenaQuery中所使用的项。
                    在将Query实例传递到QueryScorer之前,可以调用Query.rewrite (IndexReader)方法来重写Query对象 
                 */
                Scorer fragmentScorer = new QueryScorer(query);
                Highlighter highlighter = new Highlighter(formatter,fragmentScorer);
                Fragmenter fragmenter = new SimpleFragmenter(100);
                /*    
                    Highlighter利用Fragmenter将原始文本分割成多个片段。
                          内置的SimpleFragmenter将原始文本分割成相同大小的片段,片段默认的大小为100个字符。这个大小是可控制的。
                 */
                highlighter.setTextFragmenter(fragmenter);
                
                ScoreDoc[] scoreDocs = topDocs.scoreDocs;
                
                for(ScoreDoc scDoc : scoreDocs){
                    Document  document = indexSearcher.doc(scDoc.doc);
                    Integer id = Integer.parseInt(document.get("id"));
                    String name = document.get("name");
                    String function = document.get("function");
                    //float score = scDoc.score; //相似度
                    
                    String lighterName = highlighter.getBestFragment(analyzer, "name", name);
                    if(null==lighterName){
                        lighterName = name;
                    }
                    
                    String lighterFunciton = highlighter.getBestFragment(analyzer, "function", function);
                    if(null==lighterFunciton){
                        lighterFunciton = function;
                    }
                    
                    Medicine medicine = new Medicine();
                    
                    medicine.setId(id);
                    medicine.setName(lighterName);
                    medicine.setFunction(lighterFunciton);
                    
                    result.add(medicine);
                                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                try {
                    indexSearcher.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        
            return result;
        }
        
        public static void main(String[] args) {
            LuceneIKUtil luceneProcess = new LuenceIKUtil("F:/index");
            try {
                luceneProcess.createIndex();
            } catch (Exception e) {
                e.printStackTrace();
            }
            //修改测试
            luceneProcess.update(2, "测试内容", "修改测试。。。");
            
            //查询测试
            String [] fields = {"name","function"};
            List<Medicine> list = luenceProcess.search(fields,"感冒");
            for(int i=0; i<list.size(); i++){
                Medicine medicine = list.get(i);
                System.out.println("("+medicine.getId()+")"+medicine.getName() + "\t" + medicine.getFunction());
            }
            //删除测试
            //luenceProcess.delete(1);
            
        }
    }
    复制代码

    程序运行结果

    复制代码
    加载扩展词典:/dicdata/use.dic.dic
    加载扩展词典:/dicdata/googlepy.dic
    加载扩展停止词典:/dicdata/ext_stopword.dic
    共检索出 4 条记录
    (1)银花 <font color='red'>感冒</font>颗粒    功能主治:银花<font color='red'>感冒</font>颗粒 ,头痛,清热,解表,利咽。
    (4)<font color='red'>感冒</font>灵胶囊    功能主治:银花<font color='red'>感冒</font>颗粒 ,头痛,清热,解表,利咽。
    (3)<font color='red'>感冒</font>灵颗粒    功能主治:解热镇痛。头痛 ,清热。
    (5)仁和 <font color='red'>感冒</font>颗粒    功能主治:疏风清热,宣肺止咳,解表清热,止咳化痰。
    复制代码

    如何判断索引是否存在

    复制代码
        /**
         * 判断是否已经存在索引文件
         * @param indexPath
         * @return
         */
        private  boolean isExistIndexFile(String indexPath) throws Exception{
            File file = new File(indexPath);
            if (!file.exists()) {
                file.mkdirs();
            }
            String indexSufix="/segments.gen";
             //根据索引文件segments.gen是否存在判断是否是第一次创建索引   
            File indexFile=new File(indexPath+indexSufix);
            return indexFile.exists();
        }
    复制代码

    附录: IK分词处理过程

    IK的整个分词处理过程首先,介绍一下IK的整个分词处理过程:

    1. Lucene的分词基类是Analyzer,所以IK提供了Analyzer的一个实现类IKAnalyzer。首先,我们要实例化一个IKAnalyzer,它有一个构造方法接收一个参数isMaxWordLength,这个参数是标识IK是否采用最大词长分词,还是采用最细粒度切分两种分词算法。实际两种算法的实现,最大词长切分是对最细粒度切分的一种后续处理,是对最细粒度切分结果的过滤,选择出最长的分词结果。

    2. IKAnalyzer类重写了Analyzer的tokenStream方法,这个方法接收两个参数,field name和输入流reader,其中filed name是Lucene的属性列,是对文本内容进行过分词处理和创建索引之后,索引对应的一个名称,类似数据库的列名。因为IK仅仅涉及分词处理,所以对field name没有进行任何处理,所以此处不做任何讨论。

    3. tokenStream方法在Lucene对文本输入流reader进行分词处理时被调用,在IKAnalyzer的tokenStream方法里面仅仅实例化了一个IKTokenizer类,该类继承了Lucene的Tokenizer类。并重写了incrementToken方法,该方法的作用是处理文本输入流生成token,也就是Lucene的最小词元term,在IK里面叫做Lexeme。

    4. 在IKtokenizer的构造方法里面实例化了IK里面最终要的分词类IKSegmentation,也称为主分词器。它的构造方法接收两个参数,reader和isMaxWordLength。

    5. IKsegmentation的构造方法里面,主要做了三个工作,创建上下文对象Context,加载词典,创建子分词器。

    6. Contex主要是存储分词结果集和记录分词处理的游标位置。

    7. 词典是作为一个单例被创建的,主要有量词词典、主词典和停词词典。词典是被存储在字典片段类DictSegment 这个字典核心类里面的。DictSegment有一个静态的存储结构charMap,是公共词典表,用来存储所有汉字,key和value都是一个中文汉字,目前IK里面的charMap大概有7100多的键值对。另外,DictSegment还有两个最重要的数据结构,是用来存储字典树的,一个是DictSegment的数组childrenArray,另一个是key为单个汉字(每个词条的第一个汉字),value是DictSegment的HashMap childrenMap。这两个数据结构二者取其一,用来存储字典树。

    8. 子分词器才是真正的分词类,IK里面有三个子分词器,量词分词器,CJK分词器(处理中文),停词分词器。主分词器IKSegmentation遍历这三个分词器对文本输入流进行分词处理。

    9. IKTokenizer的incrementToken方法调用了IKSegmentation的next方法,next的作用是获得下一个分词结果。next在第一次被调用的时候,需要加载文本输入流,并将其读入buffer,此时便遍历子分词器,对buffer种的文本内容进行分词处理,然后把分词结果添加到context的lexemeSet中。

    展开全文
  • IKAnalyzer分词器

    2018-07-20 21:36:22
    ikanalyzer-2012_u6.jar IKAnalyzer2012FF_u1.jar IKAnalyzer2012FF_u2.jar
  • IKAnalyzer3.2.8 source,IKAnalyzer中文分词器V3.2.0使用手册
  • 这里还是使用搜狗的扩展词库扩展词典添加搜狗词库:词条大小392790个13737KB先直接用java.lang.Runtime类中的freeMemory(),total...加上IKAnalyzer默认加载的这两个词典:org/wltea/analyzer/dic/main2012.dic 275...

    这里还是使用搜狗的扩展词库

    扩展词典添加搜狗词库:

    词条

    大小

    392790个

    13737KB

    先直接用java.lang.Runtime类中的freeMemory(),totalMemory(),maxMemory ()这几个方法

    进行计算。

    先把这92790个放入到ext.dic文件中。

    加上IKAnalyzer默认加载的这两个词典:

    org/wltea/analyzer/dic/main2012.dic 275713个

    org/wltea/analyzer/dic/quantifier.dic 316个

    总格的词条是66W多。

    执行如下代码:

    public static void main(String[] args){

    calculateMem();

    }

    public static void calculateMem(){

    System.out.println("初始化内存");

    System.out.println("空闲内存:" + Runtime.getRuntime().freeMemory());

    System.out.println("已获取到的内存:" + Runtime.getRuntime().totalMemory());

    System.out.println("能够获得的最大内存:" +Runtime.getRuntime().maxMemory());

    System.gc();

    Dictionary.initial(DefaultConfig.getInstance());

    long total = Runtime.getRuntime().totalMemory(); // 返回总的内存数

    long size = Runtime.getRuntime().freeMemory(); // 返回当前的剩余内存数

    System.out.println("Memory used: " + (total - size));

    }

    执行结果如下:

    初始化内存

    空闲内存:15965080

    已获取到的内存:16252928

    能够获得的最大内存:518979584

    加载扩展词典:ext.dic

    加载扩展停止词典:stopword.dic

    Memory used: 95027120B

    结果是90.62M

    接下来使用Instrumentation的getObjectSize方法进行计算下:

    public class CalculateDictionarySize {

    public static void main(String[] args){

    Dictionary.initial(DefaultConfig.getInstance());

    System.out.print(SizeOfAgent.fullSizeOf(Dictionary.getSingleton()) + "B");

    }

    }

    编写MANIFEST.MF文件:

    Manifest-Version: 1.0

    Ant-Version: Apache Ant 1.6.1

    Created-By: 1.5.0_06-b05 (Sun Microsystems Inc.)

    Main-Class: com.itzhai.test.CalculateDictionarySize

    Class-Path: lib/IKAnalyzer2012_u6.jar

    Premain-Class: com.itzhai.test.SizeOfAgent

    Boot-Class-Path:

    Can-Redefine-Classes: false

    包结构如下:

    458a84343125c4ec47d3ea8e92b617f0.png

    SizeOfAgent的写法参考这里:

    打包成Jar文件之后,到命令行中执行:

    java -javaagent:sizeOfAgent.jar com.itzhai.test.CalculateDictionarySize

    结果如下:

    506adee3288231a696dddcf43ed5c214.png

    73.48M

    也就是说66W多个字条占用了73.48M的内存。

    IKAnalyzer的存储结构:

    IKAnalyzer是以字典树的方式把字典载入内存中的:

    词典管理类为Dictionary,有三种词典:主词典,停用词词典,量词词典,这三种词典都是对应为一个DictSegment对象的,而DictSegment对象时树形结构的,每一个子节点又可以是一个DictSegment对象。

    节点的存储方式:以数组(DictSegment[])或者Map(Map

    如果子节点数量小于等于ARRAY_LENGTH_LIMIT,则采用数组存储

    如果子节点数量大于ARRAY_LENGTH_LIMIT,则采用Map存储。

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,588
精华内容 1,435
关键字:

ikanalyzer