于Lucene的中文字典分词模块的设计与实现
Lucene开发实例：Lucene中文分词（转载）
Lucene开发实例：Lucene中⽂分词（转载）2、从Oracle数据库中取数据创建索引（使⽤IK分词）1package lucene.util;23import org.apache.lucene.index.IndexWriter;4import org.apache.lucene.index.IndexWriterConfig;5import org.apache.lucene.index.CorruptIndexException;6import org.apache.lucene.store.FSDirectory;7import org.apache.lucene.store.Directory;8import org.apache.lucene.analysis.Analyzer;9import org.apache.lucene.analysis.standard.StandardAnalyzer;10import org.apache.lucene.util.Version;11import org.apache.lucene.document.Document;12import org.apache.lucene.document.Field;13import org.wltea.analyzer.lucene.IKAnalyzer;1415import java.sql.Connection;16import java.io.File;17import java.io.IOException;18import java.util.ArrayList;19import java.util.Date;2021import modules.gk.Gk_info;22import modules.gk.Gk_infoSub;23import web.sys.Globals;24import web.db.DBConnector;25import web.db.ObjectCtl;26import web.util.StringUtil;27//28public class LuceneIndex {29 IndexWriter writer = null;30 FSDirectory dir = null;31boolean create = true;3233public void init() {34long a1 = System.currentTimeMillis();35 System.out.println("[Lucene 开始执⾏：" + new Date() + "]");36 Connection con = DBConnector.getconecttion(); //取得⼀个数据库连接37try {38final File docDir = new File(Globals.SYS_COM_CONFIG.get("sys.index.path").toString());//E:\lucene39if (!docDir.exists()) {40 docDir.mkdirs();41 }42 String cr = Globals.SYS_COM_CONFIG.get("sys.index.create").toString();//true or false43if ("false".equals(cr.toLowerCase())) {44 create = false;45 }46 Directory dir = FSDirectory.open(docDir);47// Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_36);48 Analyzer analyzer = new IKAnalyzer(true);49 IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_36, analyzer);50if (create) {51// Create a new index in the directory, removing any52// previously indexed documents:53 iwc.setOpenMode(IndexWriterConfig.OpenMode.CREATE);54 } else {55// Add new documents to an existing index:56 iwc.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);57 }58 IndexWriter writer = new IndexWriter(dir, iwc);59 String sql = "SELECT indexno,title,describes,pdate,keywords FROM TABLEA WHERE STATE=1 AND SSTAG<>1 ";60int rowCount = ObjectCtl.getRowCount(con, sql);61int pageSize = StringUtil.StringToInt(Globals.SYS_COM_CONFIG.get("sys.index.size").toString()); //每页记录数62int pages = (rowCount - 1) / pageSize + 1; //计算总页数63 ArrayList list = null;64 Gk_infoSub gk = null;65for (int i = 1; i < pages+1; i++) {66long a = System.currentTimeMillis();67 list = ObjectCtl.listPage(con, sql, i, pageSize, new Gk_infoSub());68for (int j = 0; j < list.size(); j++) {69 gk = (Gk_infoSub) list.get(j);70 Document doc = new Document();71 doc.add(new Field("indexno", StringUtil.null2String(gk.getIndexno()), Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));//主键不分词72 doc.add(new Field("title", StringUtil.null2String(gk.getTitle()), Field.Store.YES, Field.Index.ANALYZED));73 doc.add(new Field("describes", StringUtil.null2String(gk.getDescribes()), Field.Store.YES, Field.Index.ANALYZED));74 doc.add(new Field("pdate", StringUtil.null2String(gk.getPdate()), Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));//⽇期不分词75 doc.add(new Field("keywords", StringUtil.null2String(gk.getKeywords()), Field.Store.YES, Field.Index.ANALYZED));76 writer.addDocument(doc);77 ObjectCtl.executeUpdateBySql(con,"UPDATE TABLEA SET SSTAG=1 WHERE indexno='"+gk.getIndexno()+"'");//更新已索引状态78 }80long b = System.currentTimeMillis();81long c = b - a;82 System.out.println("[Lucene " + rowCount + "条，" + pages + "页，第" + i + "页花费时间：" + c + "毫秒]");83 }84 mit();8586 } catch (Exception e) {87 e.printStackTrace();88 } finally {89 DBConnector.freecon(con); //释放数据库连接90try {91if (writer != null) {92 writer.close();93 }94 } catch (CorruptIndexException e) {95 e.printStackTrace();96 } catch (IOException e) {97 e.printStackTrace();98 } finally {99try {100if (dir != null && IndexWriter.isLocked(dir)) {101 IndexWriter.unlock(dir);//注意解锁102 }103 } catch (IOException e) {104 e.printStackTrace();105 }106 }107 }108long b1 = System.currentTimeMillis();109long c1 = b1 - a1;110 System.out.println("[Lucene 执⾏完毕，花费时间：" + c1 + "毫秒，完成时间：" + new Date() + "]");111 }112 }3、单字段查询以及多字段分页查询⾼亮显⽰1package lucene.util;23import org.apache.lucene.store.FSDirectory;4import org.apache.lucene.store.Directory;5import org.apache.lucene.search.*;6import org.apache.lucene.search.highlight.SimpleHTMLFormatter;7import org.apache.lucene.search.highlight.Highlighter;8import org.apache.lucene.search.highlight.SimpleFragmenter;9import org.apache.lucene.search.highlight.QueryScorer;10import org.apache.lucene.queryParser.QueryParser;11import org.apache.lucene.queryParser.MultiFieldQueryParser;12import org.apache.lucene.analysis.TokenStream;13import org.apache.lucene.analysis.Analyzer;14import org.apache.lucene.analysis.KeywordAnalyzer;15import org.apache.lucene.document.Document;16import org.apache.lucene.index.IndexReader;17import org.apache.lucene.index.Term;18import org.apache.lucene.util.Version;19import modules.gk.Gk_infoSub;2021import java.util.ArrayList;22import java.io.File;23import java.io.StringReader;24import ng.reflect.Constructor;2526import web.util.StringUtil;27import web.sys.Globals;28import org.wltea.analyzer.lucene.IKAnalyzer;29//30public class LuceneQuery {31private static String indexPath;// 索引⽣成的⽬录32private int rowCount;// 记录数33private int pages;// 总页数34private int currentPage;// 当前页数35private int pageSize; //每页记录数3637public LuceneQuery() {38this.indexPath = Globals.SYS_COM_CONFIG.get("sys.index.path").toString();39 }4041public int getRowCount() {42return rowCount;43 }4445public int getPages() {46return pages;47 }49public int getPageSize() {50return pageSize;51 }5253public int getCurrentPage() {54return currentPage;55 }5657/**58 * 函数功能:根据字段查询索引59*/60public ArrayList queryIndexTitle(String keyWord, int curpage, int pageSize) {61 ArrayList list = new ArrayList();62try {63if (curpage <= 0) {64 curpage = 1;65 }66if (pageSize <= 0) {67 pageSize = 20;68 }69this.pageSize = pageSize; //每页记录数70this.currentPage = curpage; //当前页71int start = (curpage - 1) * pageSize;72 Directory dir = FSDirectory.open(new File(indexPath));73 IndexReader reader = IndexReader.open(dir);74 IndexSearcher searcher = new IndexSearcher(reader);75 Analyzer analyzer = new IKAnalyzer(true);76 QueryParser queryParser = new QueryParser(Version.LUCENE_36, "title", analyzer);77 queryParser.setDefaultOperator(QueryParser.AND_OPERATOR);78 Query query = queryParser.parse(keyWord);79int hm = start + pageSize;80 TopScoreDocCollector res = TopScoreDocCollector.create(hm, false);81 searcher.search(query, res);8283 SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter("<span style='color:red'>", "</span>");84 Highlighter highlighter = new Highlighter(simpleHTMLFormatter, new QueryScorer(query));85this.rowCount = res.getTotalHits();86this.pages = (rowCount - 1) / pageSize + 1; //计算总页数87 TopDocs tds = res.topDocs(start, pageSize);88 ScoreDoc[] sd = tds.scoreDocs;89for (int i = 0; i < sd.length; i++) {90 Document hitDoc = reader.document(sd[i].doc);91 list.add(createObj(hitDoc, analyzer, highlighter));92 }9394 } catch (Exception e) {95 e.printStackTrace();96 }9798return list;99100 }101/**102 * 函数功能:根据字段查询索引103*/104public ArrayList queryIndexFields(String allkeyword, String onekeyword, String nokeyword, int curpage, int pageSize) {105 ArrayList list = new ArrayList();106try {107if (curpage <= 0) {108 curpage = 1;109 }110if (pageSize <= 0) {111 pageSize = 20;112 }113this.pageSize = pageSize; //每页记录数114this.currentPage = curpage; //当前页115int start = (curpage - 1) * pageSize;116 Directory dir = FSDirectory.open(new File(indexPath));117 IndexReader reader = IndexReader.open(dir);118 IndexSearcher searcher = new IndexSearcher(reader);119 BooleanQuery bQuery = new BooleanQuery(); //组合查询120if (!"".equals(allkeyword)) {//包含全部关键词121 KeywordAnalyzer analyzer = new KeywordAnalyzer();122 BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD};//AND 123 Query query = MultiFieldQueryParser.parse(Version.LUCENE_36, allkeyword, new String[]{"title", "describes", "keywords"}, flags, analyzer); 124 bQuery.add(query, BooleanClause.Occur.MUST); //AND125 }126if (!"".equals(onekeyword)) { //包含任意关键词127 Analyzer analyzer = new IKAnalyzer(true);128 BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD};//OR 129 Query query = MultiFieldQueryParser.parse(Version.LUCENE_36, onekeyword, new String[]{"title", "describes", "keywords"}, flags, analyzer); 130 bQuery.add(query, BooleanClause.Occur.MUST); //AND131 }132if (!"".equals(nokeyword)) { //排除关键词133 Analyzer analyzer = new IKAnalyzer(true);134 BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD};//NOT 135 Query query = MultiFieldQueryParser.parse(Version.LUCENE_36, nokeyword, new String[]{"title", "describes", "keywords"}, flags, analyzer); 136 bQuery.add(query, BooleanClause.Occur.MUST_NOT); //AND137138 }139int hm = start + pageSize;140 TopScoreDocCollector res = TopScoreDocCollector.create(hm, false);141 searcher.search(bQuery, res);142 SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter("<span style='color:red'>", "</span>");143 Highlighter highlighter = new Highlighter(simpleHTMLFormatter, new QueryScorer(bQuery));144this.rowCount = res.getTotalHits();145this.pages = (rowCount - 1) / pageSize + 1; //计算总页数146 System.out.println("rowCount:" + rowCount);147 TopDocs tds = res.topDocs(start, pageSize);148 ScoreDoc[] sd = tds.scoreDocs;149 Analyzer analyzer = new IKAnalyzer();150for (int i = 0; i < sd.length; i++) {151 Document hitDoc = reader.document(sd[i].doc);152 list.add(createObj(hitDoc, analyzer, highlighter));153 }154155 } catch (Exception e) {156 e.printStackTrace();157 }158159return list;160161 }162163/**164 * 创建返回对象（⾼亮）165*/166167private synchronized static Object createObj(Document doc, Analyzer analyzer, Highlighter highlighter) {168169 Gk_infoSub gk = new Gk_infoSub();170try {171172if (doc != null) {173 gk.setIndexno(StringUtil.null2String(doc.get("indexno")));174 gk.setPdate(StringUtil.null2String(doc.get("pdate")));175 String title = StringUtil.null2String(doc.get("title"));176 gk.setTitle(title);177if (!"".equals(title)) {178 highlighter.setTextFragmenter(new SimpleFragmenter(title.length()));179 TokenStream tk = analyzer.tokenStream("title", new StringReader(title));180 String htext = StringUtil.null2String(highlighter.getBestFragment(tk, title));181if (!"".equals(htext)) {182 gk.setTitle(htext);183 }184 }185 String keywords = StringUtil.null2String(doc.get("keywords"));186 gk.setKeywords(keywords);187if (!"".equals(keywords)) {188 highlighter.setTextFragmenter(new SimpleFragmenter(keywords.length()));189 TokenStream tk = analyzer.tokenStream("keywords", new StringReader(keywords));190 String htext = StringUtil.null2String(highlighter.getBestFragment(tk, keywords));191if (!"".equals(htext)) {192 gk.setKeywords(htext);193 }194 }195 String describes = StringUtil.null2String(doc.get("describes"));196 gk.setDescribes(describes);197if (!"".equals(describes)) {198 highlighter.setTextFragmenter(new SimpleFragmenter(describes.length()));199 TokenStream tk = analyzer.tokenStream("keywords", new StringReader(describes));200 String htext = StringUtil.null2String(highlighter.getBestFragment(tk, describes));201if (!"".equals(htext)) {202 gk.setDescribes(htext);203 }204 }205206 }207return gk;208 }209catch (Exception e) {210211 e.printStackTrace();212return null;213 }214finally {215 gk = null;216 }217218 }219220private synchronized static Object createObj(Document doc) {221222 Gk_infoSub gk = new Gk_infoSub();223try {224225if (doc != null) {226 gk.setIndexno(StringUtil.null2String(doc.get("indexno")));227 gk.setPdate(StringUtil.null2String(doc.get("pdate")));228 gk.setTitle(StringUtil.null2String(doc.get("title")));229 gk.setKeywords(StringUtil.null2String(doc.get("keywords")));230 gk.setDescribes(StringUtil.null2String(doc.get("describes")));231 }232return gk;233 }234catch (Exception e) {235236 e.printStackTrace();237return null;238 }239finally {240 gk = null;241 }242243 }244 }单字段查询：1long a = System.currentTimeMillis();2try {3int curpage = StringUtil.StringToInt(StringUtil.null2String(form.get("curpage")));4int pagesize = StringUtil.StringToInt(StringUtil.null2String(form.get("pagesize")));5 String title = StringUtil.replaceLuceneStr(StringUtil.null2String(form.get("title")));6 LuceneQuery lu = new LuceneQuery();7 form.addResult("list", lu.queryIndexTitle(title, curpage, pagesize));8 form.addResult("curPage", lu.getCurrentPage());9 form.addResult("pageSize", lu.getPageSize());10 form.addResult("rowCount", lu.getRowCount());11 form.addResult("pageCount", lu.getPages());12 } catch (Exception e) {13 e.printStackTrace();14 }15long b = System.currentTimeMillis();16long c = b - a;17 System.out.println("[搜索信息花费时间：" + c + "毫秒]");多字段查询：1long a = System.currentTimeMillis();2try {3int curpage = StringUtil.StringToInt(StringUtil.null2String(form.get("curpage")));4int pagesize = StringUtil.StringToInt(StringUtil.null2String(form.get("pagesize")));5 String allkeyword = StringUtil.replaceLuceneStr(StringUtil.null2String(form.get("allkeyword")));6 String onekeyword = StringUtil.replaceLuceneStr(StringUtil.null2String(form.get("onekeyword")));7 String nokeyword = StringUtil.replaceLuceneStr(StringUtil.null2String(form.get("nokeyword")));8 LuceneQuery lu = new LuceneQuery();9 form.addResult("list", lu.queryIndexFields(allkeyword,onekeyword,nokeyword, curpage, pagesize));10 form.addResult("curPage", lu.getCurrentPage());11 form.addResult("pageSize", lu.getPageSize());12 form.addResult("rowCount", lu.getRowCount());13 form.addResult("pageCount", lu.getPages());14 } catch (Exception e) {15 e.printStackTrace();16 }17long b = System.currentTimeMillis();18long c = b - a;19 System.out.println("[⾼级检索花费时间：" + c + "毫秒]");4、Lucene通配符查询1 BooleanQuery bQuery = new BooleanQuery(); //组合查询2if (!"".equals(title)) {3 WildcardQuery w1 = new WildcardQuery(new Term("title", title+ "*"));4 bQuery.add(w1, BooleanClause.Occur.MUST); //AND5 }6int hm = start + pageSize;7 TopScoreDocCollector res = TopScoreDocCollector.create(hm, false);8 searcher.search(bQuery, res);5、Lucene嵌套查询实现SQL：(unitid like 'unitid%' and idml like 'id2%') or (tounitid like 'unitid%' and tomlid like 'id2%' and tostate=1)1 BooleanQuery bQuery = new BooleanQuery();2 BooleanQuery b1 = new BooleanQuery();3 WildcardQuery w1 = new WildcardQuery(new Term("unitid", unitid + "*"));4 WildcardQuery w2 = new WildcardQuery(new Term("idml", id2 + "*"));5 b1.add(w1, BooleanClause.Occur.MUST);//AND6 b1.add(w2, BooleanClause.Occur.MUST);//AND7 bQuery.add(b1, BooleanClause.Occur.SHOULD);//OR8 BooleanQuery b2 = new BooleanQuery();9 WildcardQuery w3 = new WildcardQuery(new Term("tounitid", unitid + "*"));10 WildcardQuery w4 = new WildcardQuery(new Term("tomlid", id2 + "*"));11 WildcardQuery w5 = new WildcardQuery(new Term("tostate", "1"));12 b2.add(w3, BooleanClause.Occur.MUST);//AND13 b2.add(w4, BooleanClause.Occur.MUST);//AND14 b2.add(w5, BooleanClause.Occur.MUST);//AND15 bQuery.add(b2, BooleanClause.Occur.SHOULD);//OR6、Lucene先根据时间排序后分页1int hm = start + pageSize;2 Sort sort = new Sort(new SortField("pdate", SortField.STRING, true));3 TopScoreDocCollector res = TopScoreDocCollector.create(pageSize, false);4 searcher.search(bQuery, res);5this.rowCount = res.getTotalHits();6this.pages = (rowCount - 1) / pageSize + 1; //计算总页数7 TopDocs tds =searcher.search(bQuery,rowCount,sort);// res.topDocs(start, pageSize);8 ScoreDoc[] sd = tds.scoreDocs;9 System.out.println("rowCount:" + rowCount);10int i=0;11for (ScoreDoc scoreDoc : sd) {12 i++;13if(i<start){14continue;15 }16if(i>hm){17break;18 }19 Document doc = searcher.doc(scoreDoc.doc);20 list.add(createObj(doc));21 }这个效率不⾼，正常的做法是创建索引的时候进⾏排序，之后使⽤分页⽅法，不要这样进⾏2次查询。
基于Lucene的中文分词器的改进与实现
基于Lucene的中文分词器的改进与实现罗惠峰;郭淑琴【摘要】Lucene是一个高效的全文检索工具包,本文主要研究了Lucene的体系架构及其在中文检索上的应用.通过对基于最大匹配算法的中文分词器的设计与改进,并引入文本解析器与构建同义词词库引擎,使得Lucene对中文的检索更加个性化.通过检索结果的对比表明,改进后的中文分词器对检索功能的扩展有了极大的提高.并最终构建出了一个高效的中文全文检索系统.【期刊名称】《微型机与应用》【年(卷),期】2015(034)011【总页数】4页(P76-78,82)【关键词】全文检索;中文分词器;文本解析器;最大匹配算法(MMSEG)【作者】罗惠峰;郭淑琴【作者单位】浙江工业大学信息工程学院,浙江杭州310023;浙江工业大学信息工程学院,浙江杭州310023【正文语种】中文【中图分类】TP390 引言随着网络的发展和数据存储技术的成熟，如何在大量的数据中快速、准确地获取到我们所需要的信息成为一个亟待解决的问题，也是信息检索技术的核心问题。
信息检索的核心是全文检索技术，全文检索是指以各种计算机数据诸如文字、声音、图像等为处理对象，提供按照数据资料的内容而不是外在特征来实现的信息检索手段。
当前对全文数据的检索主要有两种方法：顺序扫描法（Serial Scanning）和倒排索引法（Inverted Index）。
前者较为原始，对于小数量的数据是最直接和最方便的方法；但随着数据量的增多，倒排索引法具有更快的检索速度和更全的应用范围[1]。
Lucene并不是一个完整的搜索引擎应用，而是一个开放源代码的高性能、可伸缩的信息搜索库，可以方便地嵌入到各种应用中，实现针对应用的全文索引/检索功能，并且已经在许多搜索项目中得到了广泛的应用[2]。
中文分词技术作为信息检索的核心技术之一，它的研究与发展促进了全文检索技术的应用。
本文主要研究了中文分词的最大匹配算法，并通过该算法对原始中文分词器进行了改进，改进后的分词器更加适用于中文条件下的搜索。
基于Lucene的中文分词器的设计与实现
基于Lucene的中文分词器的设计与实现彭焕峰【摘要】According to the low efficiency of the Chinese words segmentation machines of Lucene, this paper designs a new word segmentation machine based on all-Hash segmentation mechanism according to binary-seek-by-word by analyzing many old dictionary mechanisms. The new mechanism uses the word＇s Hash value to reduce the number of string findings. The maintenance of dictionary file is convenient, and the developers can customize the dictionary based on different application to improve search efficiency.%针对Lucene自带中文分词器分词效果差的缺点，在分析现有分词词典机制的基础上，设计了基于全哈希整词二分算法的分词器，并集成到Lucene中，算法通过对整词进行哈希，减少词条匹配次数，提高分词效率。
该分词器词典文件维护方便，可以根据不同应用的要求进行定制，从而提高了检索效率。
【期刊名称】《微型机与应用》【年(卷),期】2011(030)018【总页数】3页(P62-64)【关键词】Lucene;哈希;整词二分;最大匹配【作者】彭焕峰【作者单位】南京工程学院计算机工程学院,江苏南京211167【正文语种】中文【中图分类】TP391.1信息技术的发展，形成了海量的电子信息数据，人们对信息检索的要求越来越高，搜索引擎技术也得到了快速发展，并逐渐地被应用到越来越多的领域。
Lucene入门+实现
Lucene⼊门+实现Lucene简介详情见：（）lucene实现原理其实⽹上很多资料表明了，lucene底层实现原理就是倒排索引（invertedindex）。
那么究竟什么是倒排索引呢？经过Lucene分词之后，它会维护⼀个类似于“词条--⽂档ID”的对应关系，当我们进⾏搜索某个词条的时候，就会得到相应的⽂档ID。
不同于传统的顺排索引根据⼀个词，知道有哪⼏篇⽂章有这个词。
图解：Lucene在搜索前⾃⾏⽣成倒排索引，相⽐数据库中like的模糊搜索效率更⾼！Lucene 核⼼API索引过程中的核⼼类1. Document⽂档：他是承载数据的实体（他可以集合信息域Field），是⼀个抽象的概念，⼀条记录经过索引之后，就是以⼀个Document的形式存储在索引⽂件中的。
2. Field：Field 索引中的每⼀个Document对象都包含⼀个或者多个不同的域(Field),域是由域名(name)和域值(value)对组成，每⼀个域都包含⼀段相应的数据信息。
3. IndexWriter：索引过程的核⼼组件。
这个类⽤于创建⼀个新的索引并且把⽂档加到已有的索引中去，也就是写⼊操作。
4. Directroy：是索引的存放位置，是个抽象类。
具体的⼦类提供特定的存储索引的地址。
（FSDirectory 将索引存放在指定的磁盘中，RAMDirectory ·将索引存放在内存中。
）5. Analyzer：分词器，在⽂本被索引之前，需要经过分词器处理，他负责从将被索引的⽂档中提取词汇单元，并剔除剩下的⽆⽤信息（停⽌词汇），分词器⼗分关键，因为不同的分词器，解析相同的⽂档结果会有很⼤的不同。
Analyzer是⼀个抽象类，是所有分词器的基类。
搜索过程中的核⼼类1. IndexSearcher ：IndexSearcher 调⽤它的search⽅法，⽤于搜索IndexWriter 所创建的索引。
2. Term ：Term 使⽤于搜索的⼀个基本单元。
基于Lucene的中文文本分词
法分析法 等．
１ １ ３ 人 工智 能法 ． 称理 解分 词法 ． 工智 能是 对信 息进 行 智能 化处 理 的 ． 种模 式 ， ．． 又 人 一 主要 有两 种处
关键词： 中文文本分词 ； 文本检索；ｕｅｅ Ｌｃ ｎ
中图 分类号 ： Ｐ １．１ 文献 标识 码 ： Ｔ ３１１ Ａ
０ 引 言
伴 随着 文本挖掘 技 术 的发展 ， 文本 分词 技术 作为 文本 挖掘技 术 的一个 重要 研 究分支 ， 也得 到了迅速 的发 展． 本 分词 技 术为 大 多数 文 本 挖掘 技术 （ 文 如文 本分 类 技 术 ， 本 聚类 技 术 等 ） 供文 本 预处理 工 文 提 作， 分词 效果 的好坏 会直 接影 响到 后续 的处理 过 程 ， 因此文本 分词 技术 是文 本 挖掘过 程 中的一个关 键环 节． 目前 ， 文本 挖掘领 域 的一 项重 要 成果 —— Ａｐ ｃ ｅＪｋ ｒａ的开源 工 程 Ｌ ｃ ｎ （ ａｈ ａ ａｔ ｕ ｅ ｅ 一种 基于 Ｊ ＡＶＡ语 言 的文本 检索工 具包 ） 已经 得到 了广 泛 的应用 和发 展． 国际上很 多 的大公 司都 以 Ｌ ｃｎ ｕ ｅ ｅ作为开 发平 台 ， 例 如 目前搜 索弓Ｉ 擎业 的 巨头 Ｇ ｏ ｌ 司 也在其 系统 中引入 了 Ｌ ｃｎ 平 台 ， 在其 基础 上进行 深入 的开 ｏ ｇｅ公 ｕｅ ｅ 并
维普资讯
内蒙古 工 业大 学学 报
ｊ ｏＵＲＮＡＬ ＯＦ ３期
ＵＮＩ ＶＥＲＳＩ ＴＹ ＯＦ ＴＥＣＨＮＯＬＯＧＹ
文 章 编 号 ：０ １ ５ ６ （０ ７ ０。 １ ５０ １ ０ — １ ７２ ０ ）３０ ８ —４
基于Lucene的中文分词技术研究
向或逆 向最大匹配 的方法来分 词。例如 ，假设词 典包括 如下
的 词语 ：
今天 ／ 很好” 。
天
天气
很
好
很好
输入 “ 今天天气很好 ” ，最后 的分词结 果为 “ 今天 ， 天气
正 向最大匹配 和逆向最大 匹配 的实 现大 同小 异 ，最 大的 区别 就是正 向最 大匹配是 正向扫描字符 串 ，逆 向最大 匹配是
除 了这 两种 ，另外 一种最 少切分 的方法是使 每一句 中切 出的词数最小 。 ２２ 基于统计 的分词方法 ．
所周 知 ，英 语等西方 语言是使 用空格 和标 点来分 隔单词 。但 是在 汉语等 亚洲语种 中 ，一 般使用 表意文 字 ，而 不是使 用 由
字母 组成 的单词 。所 以相对 于西方语 言 ，Ｌ ｃ ｎ 中文 分词 ｕｅ ｅ对
ａ ｃ ａ ｙ ｃ ｕｒ ｃ ・
Ｋｅ ｒ ｓ ｈ ｎ ｓ ｅ ｍｅ ｔ ｔ ｎ； ｕ ｅ ｅ； ｘｍａ ｔ ｈ ｎ ｍａ ｉ ｍ ｒｂ ｂ ｌ ｙ ｙ ｗｏ ｄ ：Ｃ ｉ ｅ ｅ ｓ ｇ ｎ ａｉ ｏ Ｌ ｃ ｎ ｍａ ｉ ｌｍａ ｃ ｉ ｇ； ｘ ｍｕ ｐ ａ ｉ ｔ ｏ ｉ
１ 引 言
的效果并不是很好 。Ｌ ｃｎ 处理 中文分词常用方法有 ３种 ： ｕｅ ｅ （）单字方式 ： 【 【 【 【 ［ 【 。 １ 咬】 死】 猎】 人】 的】 狗］
（） 二元覆 盖方式 ： 【 ２ 咬死】 ［ 死猎】 ［ 人１ 【 的１ 猎 人 【 的狗】 。
ｗ ｒ ｅ ｅ ｔ ｔ ｎ ｍｅｈ ｄ ａ ｄ ｍａ ｉ ｍ ｒ ｂ ｂ ｌ ｙ ｐ ｒｉｉ ｌ ｔ ｏ ｉ ｈ ｉ ｔ ｏｖ ｈ ｒ ｂ ｅ ｏ ｎ ｅ ｕ ｔ ｏ ｏ ｄ ｓ ｇ ｎ ａ ｉ ｔ ｏ ｎ ｘ ｍｕ ｐ ｏ ａ ｉ ｔ ａ ｔ ｐ ｅ ｍｅ ｄ ｗｈ ｃ ｓ ｏ ｓ ｌｅ ｔ ｅ ｐ ｏ ｌ ｍ ｆ ｍａ ｙ ｒ ｓ ｌ ｆ ｍ ｏ ｉ ｃ ｈ ｓ
lucene中文分词组件和分析器KTDictSeg
V1.3.01
1、 修改字典格式，提高字典加载速度
2、 增加对英文专业名词的支持 如C++,C#等只要加入字典就可以被分出来
3、 增加词频判断功能，在无法取舍时根据词频取舍
4、 增加优先优先词频选项，通过这个选项动态决定分词粒度 需打开 FreqFirst
5、 增加中文人名前后缀统计和根据该统计定位人名的功能
7、 1.4版本新加了 KTDictSegTokenizer默认构造，没有全面考虑到锁的问题。导致多线程查询是会出错，已经更改这出错误。
使用KTDictSeg的lucene分词分析器
1. using System;
2. using System.Collections.Generic;
13、提供一个新闻搜索的简单例子，采用+KTDictSegAnalyzer+KTDictSeg,项目名为Demo.KTDictSegAnalyzer
14、将所有ArrayList 改为List<>
V1.4.01
1、 增加对的支持
2、 增加多元分词
3、 配置文件中增加对相对路径的支持(winform 和 )
36. {
37. m_SimpleDictSeg = null;
38. throw e1;
39. }
40. }
14. {
15. dictPath = _dictPath;
16. }
17ห้องสมุดไป่ตู้
18. public override TokenStream TokenStream(string fieldName, TextReader reader)
基于lucene4.6的SmartChineseAnalyzer中文切词源码
基于SmartChineseAnalyzer的中文分词Date:2014.1.1在搜索引擎的构建中，分词器是索引器和搜索器中重要的一部分。
分词器的好坏直接影响着搜索效果的优劣。
SmartChineseAnalyzer是lucene自带的中文分词器。
Lucene是apache软件基金会jakarta项目组的一个子项目，是一个开放源代码的全文检索引擎工具包。
Lucene4.6是当前的最新版本。
作为最新版本的lucene，其自带的中文分词器效果也相当不错。
其分词测试代码如下：package com.lm.IndexTxt;import java.io.IOException;import java.util.ArrayList;import java.util.List;import org.apache.lucene.analysis.Analyzer;import org.apache.lucene.analysis.TokenStream;import .smart.SmartChineseAnalyzer;import org.apache.lucene.analysis.tokenattributes.CharTermAttribute; import org.apache.lucene.util.Version;/***中文切词*@author lm*/public class AnalyzerCN_LM {// 分析器类型基本介绍// WhitespaceAnalyzer 以空格作为切词标准，不对语汇单元进行其他规范化处理// SimpleAnalyzer 以非字母符来分割文本信息，并将语汇单元统一为小写形式，并去掉数字类型的字符// StopAnalyzer 该分析器会去除一些常有a,the,an等等，也可以自定义禁用词// StandardAnalyzer Lucene内置的标准分析器，会将语汇单元转成小写形式，并去除停用词及标点符号// CJKAnalyzer 能对中，日，韩语言进行分析的分词器，对中文支持效果一般。
基于Lucene的自定义中文分词器的设计与实现
基于Lucene的自定义中文分词器的设计与实现王桐;王韵婷【期刊名称】《电脑知识与技术》【年(卷),期】2014(000)002【摘要】该文设计了一个基于复杂形式最大匹配算法(MMSeg_Complex)的自定义中文分词器，该分词器采用四种歧义消除规则，并实现了用户自定义词库、自定义同义词和停用词的功能，可方便地集成到Lucene中，从而有效地提高了Lucene的中文处理能力。
通过实验测试表明，该分词器的分词性能跟Lucene自带的中文分词器相比有了极大的提高，并最终构建出了一个高效的中文全文检索系统。
%This paper designed a custom Chinese word analyzer that based on a complex form of maximum matching algorithm (MMSEG_Complex). This analyzer use four kinds of disambiguation rules, and has achieved user-defined thesaurus、custom func-tion of synonyms and stop words , which can be easily integrated into Lucene, thus effectively improving the Chinese processing capabilities of Lucene. Through experiments we found that this analyzer's performance of Chinese word segmentation has been greatly improved compared to the Chinese word analyzer which built-in Lucene, and then we can eventually build an effective Chinese full-text retrieval system.【总页数】4页(P430-433)【作者】王桐;王韵婷【作者单位】哈尔滨工程大学信息与通信工程学院，黑龙江哈尔滨 150001;哈尔滨工程大学信息与通信工程学院，黑龙江哈尔滨 150001【正文语种】中文【中图分类】TP393【相关文献】1.基于Lucene和MMSEG算法的中文分词器研究 [J], 邓晓枫;蒋廷耀2.基于Lucene的中文分词器的改进与实现 [J], 罗惠峰;郭淑琴3.基于Lucene的中文分词器的设计与实现 [J], 彭焕峰4.基于Lucene的中文是非问答系统的设计与实现 [J], 罗东霞;卿粼波;吴晓红5.基于Lucene的中文是非问答系统的设计与实现 [J], 罗东霞;卿粼波;吴晓红因版权原因，仅展示原文概要，查看原文内容请购买。
中文分词及其在基于Lucene的全文检索中的应用的开题报告
中文分词及其在基于Lucene的全文检索中的应用的开题报告一、研究背景随着搜索引擎技术的快速发展，全文检索成为了信息检索领域的主流技术之一，对于处理大量文本数据时更加高效。
在全文检索中，中文分词是非常重要的一环，在处理中文文本时需要将文本按照一定规则分成若干个词语或短语，以便进行后续的检索和处理。
二、研究目的和意义中文分词是中文信息处理和文本数据挖掘中的一个核心问题，其准确性和效率对于文本处理的质量和速度至关重要。
因此，本文旨在对中文分词的相关技术进行研究与分析，并探讨其在基于Lucene的全文检索中的应用，从而提高中文文本检索的准确性和效率。
三、研究内容1. 中文分词技术的研究与分析本文将对中文分词的基本概念、传统方法和现有技术进行详细的研究与分析，包括基于规则、基于词典和基于统计的分词方法，以及近年来兴起的深度学习分词技术等。
2. 基于Lucene的全文检索系统的设计与实现本文将以基于Lucene的全文检索系统为例进行设计和实现，并结合中文分词技术，探讨如何在全文检索系统中实现中文文本的准确分词和快速检索。
具体包括索引的建立、查询的处理和结果的排序等核心技术。
四、研究方法本文采用文献调研、理论分析、案例分析和实践操作等方法，对中文分词技术的相关文献进行搜集和分析，对全文检索系统的设计和实现进行思考和探讨，通过实践操作来验证理论分析的正确性。
五、预期成果1. 理论成果：详细介绍中文分词的相关技术特点和优缺点，分析其在全文检索中的应用和发展趋势。
2. 实践成果：设计和实现基于Lucene的全文检索系统，并结合中文分词技术来实现中文文本的准确分词和快速检索。
3. 经济效益：提高中文文本检索的准确性和效率，为企业和组织提供更加快速和准确的文本搜索服务，从而提高工作效率和经济效益。
六、论文结构全文分为五个部分，分别是绪论、中文分词技术的研究与分析、基于Lucene的全文检索系统的设计与实现、实验结果分析及总结与展望。
搜索引擎中文分词原理与实现
while (ts.i ncreme ntToke n()) {//取得下一个词搜索引擎中文分词原理与实现因为中文文本中，词和词之间不像英文一样存在边界， 所以中文分词是一个专业处理中文信息的搜索引擎首先面对的问题，需要靠程序来切分出词。
一、LUCene 中的中文分词LUCene 在中处理中文的常用方法有三种，以 皎死猎人的狗"为例说明之：单 字:【咬】【死】 【猎】 【人】 【的】 【狗】二元覆盖：【咬死】 【死猎】 【猎人】 【人的】 【的狗】分词：【咬】 【死】 【猎人】 【的】【狗】LUCene 中的StandardTokenizer 采用单子分词方式， CJKTokenize 采用二元覆盖方式。
1、LUCene 切分原理LUCene 中负责语言处理的部分在 org.apache.Iucene.analysis 包，其中， TokenStream 类 用来进行基本的分词工作， Analyzer 类是TokenStream 的包装类，负责整个解析工作，Analyzer 类接收整段文本，解析出有意义的词语。
通常不需要直接调用分词的处理类 analysis ,而是由LUCene 内存内部来调用，其中：(1) 在索引阶段，调用 addDocument (doc )时，LUCene 内部使用 Analyzer 来处理每 个需要索引的列，具体如下图：图1 LUCene 对索引文本的处理In dexWriter in dex = new In dexWriter(i ndexDirectory, new CnAn alyzer(), //用于支持分词的分析器 !in Creme ntal,In dexWriter.MaxFieldLe ngth.UNLIMITED);(2) 在搜索阶段，调用QUeryParSer.parse (queryText )来解析查询串时， QUeryParSer 会调用Analyzer 来拆分查询字符串，但是对于通配符等查询不会调用 Analyzer 。
基于lucene4.6的SmartChineseAnalyzer中文切词源码
基于SmartChineseAnalyzer的中文分词Date:2014.1.1在搜索引擎的构建中，分词器是索引器和搜索器中重要的一部分。
分词器的好坏直接影响着搜索效果的优劣。
SmartChineseAnalyzer是lucene自带的中文分词器。
Lucene是apache软件基金会jakarta项目组的一个子项目，是一个开放源代码的全文检索引擎工具包。
Lucene4.6是当前的最新版本。
作为最新版本的lucene，其自带的中文分词器效果也相当不错。
其分词测试代码如下：package com.lm.IndexTxt;import java.io.IOException;import java.util.ArrayList;import java.util.List;import org.apache.lucene.analysis.Analyzer;import org.apache.lucene.analysis.TokenStream;import .smart.SmartChineseAnalyzer;import org.apache.lucene.analysis.tokenattributes.CharTermAttribute; import org.apache.lucene.util.Version;/***中文切词*@author lm*/public class AnalyzerCN_LM {// 分析器类型基本介绍// WhitespaceAnalyzer 以空格作为切词标准，不对语汇单元进行其他规范化处理// SimpleAnalyzer 以非字母符来分割文本信息，并将语汇单元统一为小写形式，并去掉数字类型的字符// StopAnalyzer 该分析器会去除一些常有a,the,an等等，也可以自定义禁用词// StandardAnalyzer Lucene内置的标准分析器，会将语汇单元转成小写形式，并去除停用词及标点符号// CJKAnalyzer 能对中，日，韩语言进行分析的分词器，对中文支持效果一般。
lucene中文分词给Lucene添加中文分词
lucene中文分词:给Lucene添加中文分词疯狂代码 / ĵ:http://DeveloperUtil/Article54083.htmlThe tokenizer compose of two part. The code in a jar file and a dictinary information(chinese language model) ,which is compressed in a zip file, you can uncompress it to a path. Make a CnAnalyzer to test it:import java.io.Reader;import org.apache.lucene.analysis.Analyzer;import org.apache.lucene.analysis.LowerCaseFilter;import org.apache.lucene.analysis.TokenStream;import Tokenizer;import seg.result.PlaceFilter;/*** The Analyzer to demo CnTokenizer.**/public CnAnalyzer extends Analyzer {//~ Constructors -----------------------------------------------------------public CnAnalyzer {}//~ Methods ----------------------------------------------------------------/*** get token stream from input** @param fieldName lucene field name* @param reader input reader** @ TokenStream*/public final TokenStream tokenStream(String fieldName, Reader reader) { TokenStream result = CnTokenizer(reader); result = LowerCaseFilter(result); //还加入了地名过滤 result = PlaceFilter(result); result;}}Use a test to test CnAnalyzer:public void testCnAnalyzer throws Exception { long startTime; long endTime; StringReader input; CnTokenizer.makeTag= false; String sentence="其中包括兴安至全州、桂林至兴安、全州至黄沙河、阳朔至平乐、桂林至阳朔、桂林市国道过境线灵川至3塘段、平乐至钟山、桂林至 3江高速公路"; input = java.io.StringReader(sentence); startTime = .currentTimeMillis; TokenStream tokenizer = Tokenizer(input); endTime = .currentTimeMillis; .out.prln("seg time cost:" + ( endTime - startTime)); for (Token t = tokenizer.next; t != null; t = tokenizer.next) { .out.prln(t.termText + " " + t.startOff + " " + t.endOff + " "+t.type); }}To run it , please add a java property value "dic.dir" to java command line. For example:"-Ddic.dir=D:/lg/work/SSeg/Data"It also have the function of auto learn words from corpus ,such as:java -Xmx512m "-Ddic.dir=/home/lg/SSeg/Data" -cp seg.jar:je.jar:libsvm.jar:lucene-1.4.3.jarseg.train.FindNewWords -p/home/lg/segtest/db -v -c ../0/2009-1-15 22:31:02疯狂代码 /。
一种基于LUCENE的中文分词算法研究
１ １ Ｌ Ｃ Ｎ 系 统 架 构 ． Ｕ Ｅ Ｅ
Ｌ ｃｎ ｕ ｅ ｅ系统 架构有 着 明显 的 面向对 象特 点 ， 将 系统 核 心 功 能部 分 设 计 为抽 象 类 ， 体 的实 现 部 分设 它 具 计 为抽 象类 的实 现 ， 计一 种 与平 台无关 的索 引格 式类 ， 设 与平 台相关 操 作也 设 计 为抽 象 类 ， 过层 层 面 向对 通 象设 计 ， Ｌ ｃ ｎ 成 为一 个 高 内聚 、 使 ｕｅｅ 低耦 合 、 易 进 行 二次 开 发 的检索 引擎 。Ｌ ｃｎ 系 统 架 构 主要 由基本 容 ｕｅ ｅ 封装 结构 、 引核 心 和外部 接 口三部 分组 成 ， 中索引核 心是 Ｌ ｃｎ 架 构 的关键 部 分 。Ｌ ｃｎ 索 其 ｕｅｅ ｕ ｅ ｅ系统 架 构如
Ｖｏ ． ４ ＮＯ ３ １２ ．
Ａ ｕｇ ２ ０ １ １ ．
文 章 编 号 ： ０ ６ ０ ７ ２ １ ） ３— ０ ３—０ １ ０ —１ ３ （ ０ １ ０ ０ ５ ６
ｄｉ１ ． ９ ９ｊｉ ｎ １０ ｏ ： ０ ３ ６ ／．ｓ ． ０ ６—１ ３ ． ０ １ ０ ． １ ｓ ０７２１．８０２
器 。该算 法基 于字 符 串匹 配原 理 ， 现 了正 向 和逆 向相 结 合 的最 大 增 字 匹配 分 词 算 法 。 实 通过 实验 仿真 ， 比较 改进 后 的分 析器 与 Ｌ ｃｎ ｕ ｅ ｅ自带 的两 种分 析器 在分 词效 果 和效率 上 的 差异 。结 果显示 ， 进后 的分 析器 分词 效 果 明显 优 于 Ｌ ｃｎ 改 ｕ ｅ ｅ自带 的 两种 分 析 器 ， 高 了 提 全文 检索 系统 的 中文处 理能 力 ， 系统 的查 全率 和查 准率都 达 到用 户 的需 求 。 关键 词 ：全文 检 索 ；Ｌ ｃｎ ；中文分 词 ｕ ｅｅ
lucene 中文分词方法
lucene 中文分词方法Lucene 中文分词方法Lucene是一款开源的全文检索引擎库，支持中文分词。
中文分词是指将中文文本按照一定规则切分成一个个词语的过程，是中文文本处理的核心环节之一。
在Lucene中，中文分词方法采用了一种被称为“最大正向匹配”（Maximum Matching）的算法来实现。
最大正向匹配算法是一种基于词典的分词算法，其基本思想是从左到右遍历待分词文本，找出最长的匹配词，然后将其切分出来。
具体步骤如下：1. 构建词典：首先需要构建一个中文词典，词典中包含了常用的中文词语。
词典可以手动创建，也可以通过自动分词算法生成。
2. 正向匹配：对于待分词文本，从左到右遍历每个字符，依次匹配词典中的词语。
当匹配到一个词语时，将其切分出来，并将指针移动到下一个位置继续匹配。
3. 最长匹配：在匹配过程中，选择最长的匹配词语进行切分。
这样可以避免将一个词语切分成多个部分，提高分词的准确性。
4. 重复匹配：如果一个词语可以匹配多个词典中的词语，选择其中最长的词语进行切分。
这样可以避免将一个长词切分成多个短词，提高分词的准确性。
5. 后处理：对于一些特殊情况，例如未登录词（未在词典中出现的词语）或者歧义词（一个词语有多个意思），可以通过后处理来进行处理，例如利用统计信息或者上下文信息进行判断。
Lucene中的中文分词方法通过上述算法实现了对中文文本的分词。
在使用Lucene进行中文分词时，可以通过调用相关API来实现，具体步骤如下：1. 创建分词器：首先需要创建一个中文分词器，例如使用Lucene 中提供的SmartChineseAnalyzer分词器。
2. 分词：将待分词的中文文本传入分词器的分词方法，即可获取到分词结果。
分词结果是一个词语列表，包含了文本中的所有词语。
3. 处理分词结果：可以对分词结果进行一些后处理，例如去除停用词（常用但无实际意义的词语）或者对词语进行统计分析。
通过使用Lucene中的中文分词方法，可以有效地对中文文本进行分词处理，提高中文文本处理的效果。
基于Lucene的中文分词全文搜索引擎设计与实现
Ｃ ｏ ｍｐ ｕ ｔ ｅ ｒ Ｋ ｎ ｏ ｗ ｌ ｅ ｄ ｇ ｅ ａ ｎ ｄ Ｔ ｅ ｃ ｈ ｎ ｏ ｌ ｏ ｇ ｙ电脑知识与技术
Ｖｏ １ ． １ Ｉ ， Ｎｏ ． １ ３ ， Ｍａ ｙ ２ ０ １ ５
基于 Ｌ ｕ ｃ ｅ ｎ ｅ 的 中文分 词 全文 搜 索 引擎设 计 与 实现
Ｌ Ｉ Ｂｉ ｎ ｇ － ｌ ｉ ａ ｎ
（ Ｚ ｈ ｕ ｈ ａ ｉ Ｃ ｉ ｔ ｙ Ｐ ｏ ｌ ｙ ｔ ｅ ｃ ｈ ｎ ｉ ｃ Ｃ ｏ ｌ ｌ ｅ ｇ ｅ， Ｚ ｈ ｕ ｈ ａ ｉ ５ １ ９ ０ ９ ０ ， Ｃ ｈ ｉ ｎ ａ ）
Ａｂ ｓ ｔ ｒ ａ ｃ ｔ ： Ｔ ｈ ｉ ｓ ｐ ａ ｐ ｅ ｒ ｄ ｅ ｓ ｉ ｇ ｎ ａ ｎ ｄ ｉ ｍｐ ｌ ｅ ｍｅ ｎ ｔ ａ ｎ ｅ ｆ ｆ ｉ ｃ ｉ ｅ ｎ ｔ Ｃ ｈ ｉ ｎ ｅ ｓ ｅ ｓ ｅ ｇ ｍｅ ｎ ｔ ａ ｔ ｉ ｏ ｎ ｓ ｅ ａ ｒ ｃ ｈ ｅ ｎ ｇ ｉ ｎ ｅ ｂ ａ ｓ ｅ ｄ ｏ ｎ Ｌ ｕ ｃ ｅ ｎ ｅ ａ ｎ ｄ Ｐ ａ ｏ ｄ ｉ ｎ ｇ Ａｎ ａ ｌ ｙ ｚ — ｅ ｒ ， ｗｈ ｉ ｃ ｈ ｍａ ｉ ｎ ｌ ｙ ｆ ｏ ｒ ｄ ｅ ａ ｌ ｉ ｎ ｇ ｗｉ ｔ ｈ Ｃ ｈ ｉ ｎ ｅ ｓ ｅ ｗ ｏ ｒ ｄ ｓ ｔ ｏ ｉ ｍｐ ｒ ｏ ｖ ｅ ｔ ｈ ｅ ａ ｂ ｉ ｌ ｉ ｔ ｙ ｏ ｆ ｆ ｕ ｌ ｌ ｔ ｅ ｘ ｔ ｓ ｅ ａ ｒ ｃ ｈ ｓ ｙ ｓ ｔ ｅ ｍ．
关键词： 全文搜索 ； 中文分词 ； 搜 索引擎 ； Ｌ ｕ ｃ ｅ ｎ ｅ
中图 分 类 号 ： Ｔ Ｐ ３ １ １ 文献标识码 ： Ａ 文 章编 号 ： １ ０ ０ ９ － ３ ０ ４ ４ （ ２ ０ １ ５ ） １ ３ － ０ ２ ３ ６ － ０ ２
一种基于Lucene的中文分词的设计与测试
（ ｏｌ ｅｏ Ｉｆｒ ｔ ｎＳｃ ｒ ｙ Ｓ ａ ｇ Ｍ ｉｏｏ ｇＵ ｉｅｓｙ Ｓ ａ ｇ ａ ００ ０ Ｃ ｉａ Ｃ ｌｇ ｆ ｎｏｍａ ｏ ｅｕ ｉ ，ｂ ｎ ｈ Ｊａｔｎ ｎｖｒｉ ，ｈ ｎ ｈ ｉ ０ ３ ， ｈｎ ） ｅ ｉ ｔ ｔ ２
ｓ ａｃ ｉ ｇ ｓ ｓｅ ． ｅ ｈ ｎ ｙ ｔｍ ｒ
Ｋｅ ｒ ｓ： Ｃｈ ｎ ｓ ｒ ｅ ｅ ｔ ｔ ｎ； ｓ ａ ｃ ｎ ｉ ｙ ｗｏ ｄ ｉ ｅ ｅ ｗｏ ｄ ｓห้องสมุดไป่ตู้ｇ ｎ ａ ｉ ｍ ｏ ｅ ｒ ｈ ｅ ｇｎｅ； Ｌ ｃ ｎ ｕ ｅ ｅ；ｆ ｒ ａ ｄ ｘ ｍｕ ｍａｃ ｇ ｒｔｍ ｏ ｗ ｒ ｓｍａ ｉ ｍ ｔ ｈ ａ ｏ ｉ ｌ ｈ
和 效率上 的差异。对 于如何构 建一 个高效 的 中文检 索 系统 ，提 出了一种 实现 方案 。 关键词 ：中文分词 ；搜索 引擎 ；Ｌｃｎ ；正 向最大匹 配算法 ｕｅｅ
Ａ ｅ ｉ ｎ ａ ｄ ｔ ｓ ｆ Ｃｈ ｎ ｓ ｒ ｅ ｍ ｅ ｔ ｔｏ ａ ｅ ｎ Ｌｕ ｅ ｅ ｄ ｓｇ ｎ ｅ ｔｏ ｉ ｅ ｅ ｗｏ ｄ ｓ ｇ ｎ ａ ｉ ｎ ｂ ｓ ｄ ｏ ｃ ｎ
ｗｉｅｙ ｕ ｅ ｒ ｈ ｔｃｕ ｅ Ｌ ｃ ｎ ｎ ｄ ｃ ｍｂ ｎ ｓｔ ｅ ｍａ ｉ ｍ ｔｈ ｎ ｌ ｏ ｔｍ ｎ ｐ ｉ ｚ ｄ Ｃ ｉ ｅ ｅ ｄ ｌ ｓ ｄ ａ ｃ ｉ ｔｒ ｕ ｅ ｅ，ａ ｏ ｉｅ ｘ ｍｕ ｍａｃ ｉｇ ａ ｇ ｒ ｈ ａ ｄ ｏ ｔ ｅ ｈ ｎ ｓ ｅ ｈ ｉ ｍｉ ｗ ｒ ｓ ｄ ｃｉｎ ｒ ｏａ ｈ ｅ ｅ ａｈ ｇ ｆ ｃｅ ｃ ｎ ｃ ｕ ａ ｙ ｏ ｈ ｎ ｓ ｏ ｄ ｅ ｅ ｔ ｔ ｎ ｈ ｅｐ ｐ ｒａｓ ｏ ｄ ｉｔ ａｙ ｔ ｃ ｉ ｖ ｉｈ ｅ ｉｉｎ ｙ ａ ｄ ａ ｃ ｒ ｃ ｆＣ ｉ ｅ ｅ ｗ ｒ ｓｓ ｇ ｎａ ｉ ．Ｔ ａ ｅ ｌｏ ｏ ｍ ｏ ｃ ｍｐ ｒ ｓ ｈ ｍｏ ｕ ｅ ｉ ｔ Ｓ ａ ｄ ｒ Ａｎ ｙ ｅ ｎ Ｃ Ｋ ａ ｙ ｅ ｉ ｆ ｎ ｔ ｎ ｎ ｅ ｉｉｎ ｙ ｙ ｌ ｏ ａｅ ｔ ｅ ｄ ｌ ｗ ｈ ｔ ａ ｄ ａ ｚ ａ ｄ Ｊ Ａｎ ｌｚ ｒ ｎ ｕ ｃ ｉ ａ ｄ ｆ ｃｅ ｃ ｂ ｔ ｅ ｎ ｌ ｏ １
CLucene 中文分词
//是字母或数字或空格
rd.UnGet();
// wprintf(_T("[%s]"),str);
return new Token(str.getBuffer(), start, rd.Column(), tokenImage[lucene::analysis::chinese::CHINESE] );
}
}
else
{
//非汉字
// ch是汉字
if(((char_t)ch>>8)&&(char_t)ch>=0xa0)
{
// wprintf(_T("[%s]"),str);
rd.UnGet();
return new Token(str.getBuffer(), start, rd.Column(), tokenImage[lucene::analysis::chinese::CHINESE] );
if( isSpace((char_t)ch)!=0 )
{
continue;
}
// Read for Alpha-Nums and Chinese
if( isAlNum((char_t)ch)!=0 )
{
start = rd.Column();
return ReadChinese(ch);
{
//是数学或英语就读到下一个空格.或下一个汉字
//是汉字.就读下一个汉字组成词组,或读到空格或英文结束
if(isChinese)
{
//汉字,并且ch是汉字
if(((char_t)ch>>8)&&(char_t)ch>=0xa0)
ApacheLucene（全文检索引擎）—分词器
ApacheLucene（全⽂检索引擎）—分词器⽬录1.分词器的作⽤ a. 在创建索引的时候需要⽤到分词器，在使⽤字符串搜索的时候也会⽤到分词器，并且这两个地⽅要使⽤同⼀个分词器，否则可能会搜索不出来结果。
b. 分词器(Analyzer)的作⽤是把⼀段⽂本中的词按规则取出所包含的所有词，对应的是Analyzer类，这是⼀个抽象类(public abstract class org.apache.lucene.analysis.Analyzer)，切分词的具体规则是由⼦类实现的，所以对于不同的语⾔规则，要有不同的分词器。
2.英⽂分词器的原理 a.英⽂的处理流程为：输⼊⽂本，词汇切分，词汇过滤(去除停⽤词)，词⼲提取(形态还原)、⼤写转⼩写，结果输出。
b. 何为形态还原，意思是：去除单词词尾的形态变化，将其还原为词的原形，这样做可以搜索出更多有意义的结果，⽐如在搜索student的时候，同事也可以搜索出students的结果。
c. 任何⼀个分词法对英⽂的⽀持都是还可以的。
3.中⽂分词器的原理 a.中⽂分词⽐较复杂，并没有英⽂分词那么简单，这主要是因为中⽂的词与词之间并不是像英⽂那样⽤空格来隔开，因为不是⼀个字就是⼀个词，⽽且⼀个词在另外⼀个地⽅就可能不是⼀个词，如："我们是中国⼈"，"是中"就不是⼀个词，对于中⽂分词，通常有三种⽅式：单字分词、⼆分法分词、词典分词。
a.1 单字分词：就是按照中⽂⼀个字⼀个字的进⾏分词，⽐如:"我们是中国⼈"，分词的效果就是"我"，"们"，"是"，"中"，"国"，"⼈"，StandardAnalyzer分词法就是单字分词。
a.2 ⼆分法分词：按照两个字进⾏切分，⽐如："我们是中国⼈"，分词的效果就是："我们"，"们是"，"是中"，"中国"，"国⼈"，CJKAnalyzer分词法就是⼆分法分词 a.3 词库分词：按照某种算法构造词，然后去匹配已建好的词库集合，如果匹配到就切分出来成为词语，通常词库分词被认为是最好的中⽂分词算法，如："我们是中国⼈"，分词的效果就是:"我们"，"中国⼈"，极易分词MMAnalyzer、庖丁分词、IkAnalyzer等分词法就是属于词库分词。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
３．１ 中文分词技术简介 针对中文语言所具有的特点，许多专家及学者对中
文词语进行深入研究后，主要提出了３种中文分词方 案［引。
（１）基于字符串匹配的分词方法：先构建词表，词表中要 尽可能包含可能出现的所有词。然后对待分文本按照一定的 算法进行匹配，从而实现分词。按照扫描方向的不同，主要包 括：最大匹配法、逆向最大匹配法、逐词遍历法、最佳匹配法、 二次扫描法、双向扫描法、部件词典法等。
顺序排列，而其对应的值是一个内层哈希表，此内层哈希 表的键为字符串，值为该字符串被插入的次数。对每一 个词语，如果该词语有ｎ个字，则将该词语的１，１～２，１～
３……１～ｎ个字的长度对应外层哈希表的键，再将该词语 的１，１～２，ｌ～３……１～ｎ个字作为键插入其各自对应的
内层哈希表的键中，而若内层哈希表中的同一个键被重 复插入，则其对应的值递增。具体结构如表１所示。
Ⅺａｎｇ Ｈｌｌｉｌ Ｇｕｏ Ｙｉｐｉｎ９２ Ｗａｎｇ Ｌｉａｎ９１ 。（Ｄｅｐ口厅胱眦矿ＣＤｎ加Ｚ｜Ｓｃ如ｗｅ ｏｎｄ Ｅｎｇｉｎ∞＾ｎｇ，舰岔施。愕‰溉瑙妙矿
＆ｉｅｎ∞ｏ以死砒∞ｆｏ删，耽眈ｎ ４３Ｄ０刀，仍ｉｍ）
２（肌口加Ｄｎｇ胁｝ｉ钾珊ｉ纱矿＆ｉｅｎｃｅ ｏｎｄ死如ｎｏＺＤｇｙ￡ｉ６ｒ口可，Ｗ亿＾。ｎ ４３ＤＤ刀，Ｃｈ饥口）
万方数据
是最小的索引概念单位，它直接代表了一个字符串以及 其在文件中的位置、出现次数等信息。这也就是说，项就 是Ｌｕｃｅｎｅ中语言分析器Ａｎａｌｙｚｅｒ处理源文件所得到的字 段，只不过在Ａｎａｌｙｚｅｒ中，项是以Ｔ０ｋｅｎ结构出现的。换 句话说，Ｔｏｋｅｎ就是语言分析器Ａｎａｌｙｚｅｒ分析源文件后返 回给索引器的ｊｉｅｇｕｏ，其记录了每一个索引字段的必需的 信息，其数据结构如下：
ｐｒｉｖａｔｅ ｉｎｔ ｐｏｓｉｔｉｏｎＩｎｃｒｅｍｅｎｔ ＝ １；
ｐｕｂＩｉｃ Ｔｏｋｅｎ（ｓｔｒｉｎｇ ｔｅｘｔ，ｉｍ ｓｔａＩｔ，ｉｎｔ ｅｎｄ，Ｓｔｒｉｎｇ ｔｙｐｅ）
因此，本文所设计的中文字典分词程序模块Ｌｕｃｅｎｅ． Ｎｅｔ．ａＩｌａｌｙｓｉｓ．ｃＪＩ（２也要能够将源文件经分析处理成为一 个个独立的Ｔｏｋｅｎ。
收稿日期：２００６—０５—１９ ·４６·
万方数据
现基于Ｌｕｃｅｎｅ的中文字典分词模块。
２ Ｌｕｃｅｎｅ全文检索引擎
２．１ Ｌｕｃｅｎｅ简介 Ｌｕｃｅｎｅ【１，２ Ｊ不是一个完整的全文检索系统，而是一个
用Ｊａｖａ写的全文索引引擎工具包，它提供了灵活的ＡＰＩ函 数和可以定制的数据存储结构，可以方便地嵌入到各种应 用中实现具体的全文检索系统。Ｌｕｃｅｎｅ本身只是一个组 件，而非一个完整的应用，所以在集成到应用程序中时，须 根据应用程序的需要设计索引数据结构，调用Ｌｕｃｅｎｅ提供 的各种接口实现全文检索的功能。Ｌｕｃｅｎｅ．Ｎｅｔ是Ｌｕｃｅｎｅ 系统移植到Ｎｅｔ平台下的全文检索引擎，提供了标准的ｃ｝｝ ＡＰＩ接口，具有良好的拓展和扩展性。本文所设计及实现 的中文字典分词模块就嵌入在Ｌｕｃｅｎｅ．Ｎｅｔ中。 ２．２ Ｌｕｃｅｎｅ．Ｎｅｔ系统功能介绍
现能够在基于Ｌｕｃｅｎｅ的搜索引擎中处理中文信息的中文分词模块。
【关键词】 搜索引擎Ｌｕｃｅｎｅ中文分词正向最大匹配算法
【分类号】 Ｇ２５４
Ｄｅｓｉｇｎ ａｎｄ Ｉｍｐｌｅｍｅｎｔａｔｉｏｎ ０ｆ Ｃｌｌｉｎｅｓｅ Ｗｏｒｄｓ Ｄｉｃｔｉｏｎａｒｙ
Ｓｅ霉擎ｍｅｎｔａｔｉｏｎ Ｔ讧ｏｄｕｌｅ Ｂａｓｅｄ ｏｎ Ｌｕｃｅｎｅ
１ 引言
当搜索引擎技术应用于中文信息资源处理时，由于中 文语言与英文语言在体系及结构方面的不同，比如：英文单 词以空格切分，中文词语由单个汉字按一定的规则组成；中 文汉字与英文字母在标准编码规则上有所不同；英文单词 基本上形式固定，中文词语的组成却随着不同的情况而变 化等等，因此，搜索引擎需要采用一种与处理英文信息所不 同的处理方式即中文分词技术来处理中文信息，而其对中 文信息的处理结果直接影响其搜索结果及效率。也正因为 如此，关于中文分词的处理技术便成了中文搜索引擎中的 关键技术之一。而Ｌｕｃｅｎｅ作为目前世界上最流行的开源 全文索引系统，已经在许多搜索引擎技术项目中得到了广 泛且深入的应用和研究，而其中的语言分析器已经能够支 持世界上大多数语言，当然也包括中文汉字。但目前Ｌｕ－ ｃｅｎｅ中已有中文处理只提供中文单字和双字分词机制，而 这两种中文分词模块并不能较好支持Ｌｕｃｅｎｅ中文分析处 理。为此，本文采用中文正向最大匹配分词算法及其所适 用的词表，再根据Ｌｕｃｅｎｅ中语言分析器的结构，设计并实
信息检索技术
总第１４０期
（２）Ｌｕｃｅｎｅ．Ｎｅｔ．ｉｎｄｅｘ，索引管理，包括索引的建立、更新、 删除等等；
（３）Ｌｕｃｅｎｅ．Ｎｅｔ．ｑｕｅｒｙＰａｒｓｅｒ，查询分析器，实现查询关键 词间的运算，如与、或、非等；
（４）Ｌｕｃｅｎｅ．Ｎｅｔ．ｓｅａｒｃｈ，检索管理，根据查询条件，检索得 到结果。
图１是Ｌｕｃｅｎｅ全文索引及检索过程示意图。
Ｌｕｃｅｎｅ．Ｎｅｔ源码中共包括７个子包，每个包各自完 成其特定的功能，其中最重要的４个子包为：
（１）Ｌｕｃｅｎｅ．Ｎｅｔ．ａｎａｌｙｓｉｓ，语言分析器，主要用于各种语言 的切词，本文所设计及实现的中文字典分词模块就是在Ｌｕ— ｃｅｎｅ．Ｎｅｔ．ａＩｌａｌｙｓｉｓ语言分析器的基础上扩展生成的；
《现代图书情报技术》２００６年第８期
Ｃｈｉｎｅｓｅ ｉｎｆｂ珊ａｔｉｏｎ ｗｅｌｌ ａｎｄ ｅｆＥｉｃｉｅｎⅡｙ ｉｎ ｔｈｅ ｓｅａｒｃｈ ｅｎｇｉｎｅ ｂａｓｅｄ ｏｎ Ｉｍｃｅｎｅ．
【Ｋｅｙｗｏｒｄｓ】 ｓｅａｒｃｈ ｅｎｇｉｎｅ Ｌｕｃｅｎｅ ｃｈｉｎｅｓｅ ｗｏｒｄｓ ｓｅｇｍｅｎｔａｔｉｏｎ Ｆｏｒｗａｒｄｓ ｍａｘｉｍｕｍ ｍａｔｃｈ ａｌｇｏｆｉｔｈｍ
最大匹配法【４ Ｊ分词需要一个词表（即字典），分词过 程中用文本中的候选词与词表中的词进行匹配，如果匹 配成功，则认为候选词是词，予以切分；否则就认为不是 词。所谓最大匹配，就是尽可能地用最长的词来匹配句 子中的汉字串。而中文分词的正向最大匹配法就是：对 一个字符串ｓ，从前到后扫描，对扫描的每个字，从词表中 寻找最长匹配。例如，假设ｓ＝“我是中华人民共和国公 民”，词表中有“中华人民共和国”，“中华”，“公民”，“人 民”，“共和国”……等词。当扫描到“中”字，就从“中”字 开始，向后分别取１、２、３……８个字（“中”，“中华”，“中 华人”，“中华人民”，“中华人民共”，“中华人民共和”， “中华人民共和国”，“中华人民共和国公”），词表中的最 长匹配字符串就是“中华人民共和国”，那么，就此切分 开，扫描器推进到“公”字。假设对Ｓ＝Ｃ１Ｃ２ｃ３Ｃ４……进 行正向最大匹配分词，其算法可描述如下：
Ｌｕｃｅｎｅ是一个全文索引检索系统，其工作原理可以 概括为：建立和检索索引文件。由此可知，索引文件是 Ｌｕｃｅｎｅ的关键。Ｌｕｃｅｎｅ索引由若干段（ｓｅｇｍｅｎｔ）组成，每 一段由若干的文档（Ｄｏｃｕｍｅｎｔ）组成，每一个文档由若干 的域（Ｆｉｅｌｄ）组成，每一个域由若干的项（Ｔｅ珊）组成。项
·４８．
３．３词表描述及其数据结构 词表数据结构使用的是哈希表。字典使用的是一般
文本词库，内容形式如下所示：
词（ｔａｂ）ｎ 阿爸４ 阿比让４ 阿波罗４ 阿布卡兹语４ 阿布扎比４ 阿爹４ 阿斗４ 阿尔巴尼亚４ 阿尔巴尼亚人４
·４７·
《现代图书情报技术》２００６年第８期
信息检索技术
总第１４０期
词表的数据结构采用两层哈希表结构Ｌ５ Ｊ。外层哈希 表的键为数字，存储的是字典中出现的词的各种长度且
（１）取一字ｃ，，在词表中查找ｃ。并保存是否成词标记； （２）再取一字ｃ：，判断词表中是否有以ｃ。ｃ２为前缀的 词； （３）不存在，则ｃ，为单字，一次分词结束； （４）存在，判断ｃ。ｃ：是否为词，并取以ｃ，ｃ：为首的多字 词的个数ｎ； （５）如ｎ为０，一次分词结束； （６）否则再取一字Ｃ；，判断词表中是否有以Ｃ。Ｃ：…Ｃ；为 前缀的词； （７）若不存在，则返回最近一次能够成词的Ｃ。Ｃ：…ｃ；一。； （８）否则转（６）； （９）从字Ｃｉ开始下一次分词。
为此，Ｌｕｃｅｎｅ．Ｎｅｔ．ａＩｌａｌｙｓｉｓ．ｃＪＩ（２包括５个文件： ｃＪＫ２Ａｎａｌｙｚｅｒ．ｃｓ中文分词器定义文件，ｃＪＫ２Ｔｏｋｅｎｉｚｅｒ．ｃｓ 中文分词Ｔｏｋｅｎ处理文件，ｃｈｉｎｅｓｅｗｏｒｄｓＨａｓｈｃｏｕｎｔｓｅｔ．ｃｓ 中文词表初始化文件，Ｃｈｉｎｅｓｅｗｏｒｄｕｎｉｔ．ｃｓ中文词表中词 结构文件，ｃｈｉｎｅｓｅＰａｒｓｅ．ｃｓ正向最大匹配分词程序文件。 其中，中文词表与正向最大匹配算法前文已介绍，这里就 不再描述。ＣＪＩ（２Ａｎａｌｙｚｅｒ继承于Ａｎａｌｙｚｅｒ虚拟基类分析 器，在初始化ｃＪｌ＜２Ａｎａｌｙｚｅｒ分析器的同时，对中文词表进 行初始化，在分析处理源文件时重载基类方法Ｔｏｋｅｎ— Ｓ溉ａｍ（），并在初始化ｃＪＩ（２Ｔｏｋｅｎｉｚｅｒ之后经过Ｓｔ叩Ｆｉｌｔｅｒ （）处理返回Ｔｏｋｅｎ流。
（２）基于理解分词方法：在分词的同时进行语法语义的 分析，利用句法和语义信息来处理歧义现象，一般它包括３个 部分：分词子系统、句法语义子系统和总控部分。在总控部分 的指示下，分词子系统进行分词，句法子系统对分词歧义性进 行判断，它模拟了人对句子的理解过程。主要包括：基于期望 分词方法、联想回溯法、邻接约束法、邻接知识约束法、扩充转 移网络分词方法、语境相关法、自动词典切词、基于规则分词 法、专家系统分词法。
表１词表数据结构示意
键
值
键
值
由
３
ｌ
阿
４
中华１中国２ Nhomakorabea２
阿拉
２
中华人
１
３
阿拉伯
２
中华人民
ｌ
４
阿拉伯联
１
４ Ｌｕｃｅｎｅ中文字典分词模块的设计与实现
Ｌｕｃｅｎｅ缺省提供了两个比较通用的分析器Ｓｉｍ— ｐｌｅＡｎａｌｙｚｅｒ和ｓｔａｎｄａｒＡｎａｌｙｚｅｒ，但这两个分析器缺省都不 支持中文，因此需要加入中文分词程序。Ｌｕｃｅｎｅ．Ｎｅｔ．ａ— ｎａｌｙｓｉｓ是Ｌｕｃｅｎｅ缺省的语言分析器子包，目前，Ｌｕｃｅｎｅ 中已有中文处理模块即中文单字和双字分词程序模块。 Ｌｕｃｅｎｅ．Ｎｅｔ．ａｎａｌｙｓｉｓ．ＣＪＫ中的中文语言分词器ＣＪＫＡｎａ－ ｌｙｚｅｒ就是基于此子包中的基类语言分析器Ａｎａｌｙｚｅｒ的继 承实现。而我们的任务就是设计实现一个新的继承于 ＡｎａＪｙｚｅｒ的中文字典分词程序模块Ｌｕｃｅｎｅ．Ｎｅｔ．ａｎａｌｙｓｉｓ． ＣＪＫ２。