三、lucene3.5的分词语法[停用词扩展、同义词搜索等]

最新推荐文章于 2022-09-27 10:21:44 发布
最新推荐文章于 2022-09-27 10:21:44 发布
阅读量3.8k 收藏 2
点赞数 1
CC 4.0 BY-SA版权
分类专栏： lucene
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxwzy738/article/details/8832130
本文深入探讨了分词器在不同场景下的比较与测试，包括英文与中文分词，以及如何实现自定义停用词分词器。同时介绍了同义词处理方法，包括扩展同义词分词器和同义词过滤器，以及如何在Lucene环境中应用这些技术。文章最后展示了打印语汇单元信息的方法，帮助理解分词与同义词处理的详细过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1

、

2、语汇单元的结构解释


3、同义词的设计思路


4、分词器的比较和测试

package org.lucene.test;

import java.io.File;
import java.io.IOException;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.SimpleAnalyzer;
import org.apache.lucene.analysis.StopAnalyzer;
import org.apache.lucene.analysis.WhitespaceAnalyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.CorruptIndexException;
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.search.IndexSearcher;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.util.Version;
import org.junit.Test;
import org.lucene.util.AnalyzerUtils;
import org.lucene.util.MySameAnalyzer;
import org.lucene.util.MyStopAnalyzer;

import com.chenlb.mmseg4j.analysis.MMSegAnalyzer;

public class TestAnalyzer {
	/**
	 * 几种分词器在英文分词下面的比较
	 */
	@Test
	public void test01(){
		//标准分词器
		Analyzer a1 = new StandardAnalyzer(Version.LUCENE_35);
		//停用词分词器
		Analyzer a2 = new StopAnalyzer(Version.LUCENE_35);
		//简单分词器
		Analyzer a3 = new SimpleAnalyzer(Version.LUCENE_35);
		//空格分词器
		Analyzer a4 = new WhitespaceAnalyzer(Version.LUCENE_35);
		
		String txt = "this is my house,I am come from yunnang zhaotong," +
				"My email is ynkonghao@gmail.com,My QQ is 707807876";
		
		AnalyzerUtils.displayToken(txt, a1);
		//[my][house][i][am][come][from][yunnang][zhaotong][my][email][ynkonghao][gmail.com][my][qq][707807876]
		AnalyzerUtils.displayToken(txt, a2);
		//[my][house][i][am][come][from][yunnang][zhaotong][my][email][ynkonghao][gmail][com][my][qq]
		AnalyzerUtils.displayToken(txt, a3);
		//[this][is][my][house][i][am][come][from][yunnang][zhaotong][my][email][is][ynkonghao][gmail][com][my][qq][is]
		AnalyzerUtils.displayToken(txt, a4);
		//[this][is][my][house,I][am][come][from][yunnang][zhaotong,My][email][is][ynkonghao@gmail.com,My][QQ][is][707807876]
	}
	/**
	 * 几种分词器在中文分词下面的比较
	 */
	@Test
	public void test02(){
		//标准分词器
		Analyzer a1 = new StandardAnalyzer(Version.LUCENE_35);
		//停用词分词器
		Analyzer a2 = new StopAnalyzer(Version.LUCENE_35);
		//简单分词器
		Analyzer a3 = new SimpleAnalyzer(Version.LUCENE_35);
		//空格分词器
		Analyzer a4 = new WhitespaceAnalyzer(Version.LUCENE_35);
		
		String txt = "我来自云南昭通昭阳区师专";
		
		AnalyzerUtils.displayToken(txt, a1);
		//[我][来][自][云][南][昭][通][昭][阳][区][师][专]
		AnalyzerUtils.displayToken(txt, a2);
		//[我来自云南昭通昭阳区师专]
		AnalyzerUtils.displayToken(txt, a3);
		//[我来自云南昭通昭阳区师专]
		AnalyzerUtils.displayToken(txt, a4);
		//[我来自云南昭通昭阳区师专]
	}
	/**
	 * 打印分词的详细信息
	 */
	@Test
	public void test03(){
		//标准分词器
		Analyzer a1 = new StandardAnalyzer(Version.LUCENE_35);
		//停用词分词器
		Analyzer a2 = new StopAnalyzer(Version.LUCENE_35);
		//简单分词器
		Analyzer a3 = new SimpleAnalyzer(Version.LUCENE_35);
		//空格分词器
		Analyzer a4 = new WhitespaceAnalyzer(Version.LUCENE_35);
		
		String txt = "how are you thank you";
		
		AnalyzerUtils.displayAllToken(txt, a1);
		AnalyzerUtils.displayAllToken(txt, a2);
		AnalyzerUtils.displayAllToken(txt, a3);
		AnalyzerUtils.displayAllToken(txt, a4);
	}
	/**
	 * 停用词的测试
	 */
	@Test
	public void test04(){
		Analyzer a1 = new MyStopAnalyzer(new String[]{"I","you","hate"});
		Analyzer a2 = new StopAnalyzer(Version.LUCENE_35);
		String txt = "how are You thAnk's you I hate you";
		AnalyzerUtils.displayToken(txt, a1);
		AnalyzerUtils.displayToken(txt, a2);
	}
	/**
	 * 中文分词测试
	 * 使用词库分词，自己可扩展词库
	 */
	@Test
	public void test05(){
//		Analyzer a1 = new MMSegAnalyzer();//未加入该分词器自带的词库
		//[我][来][自][云][南][昭][通][昭][阳][区][师][专]
		//导入分词的词典便有词库
		Analyzer a1 = new MMSegAnalyzer(new File("D:\\Workspaces\\03_lucene_analyzer\\mmseg4j-1.8.4\\data"));
		//[我][来自][云南][昭][通][昭][阳][区][师专]
		//可以在data文件下面的words-my.dic扩展自己的词典，比如加了昭通，分词结果为：
		//[我][来自][云南][昭通][昭][阳][区][师专]
		
		String txt = "我来自云南昭通昭阳区师专";
		AnalyzerUtils.displayToken(txt, a1);
	}
	
	/**
	 * 同义词测试
	 * @throws IOException 
	 * @throws CorruptIndexException 
	 */
	@Test
	public void test06() throws CorruptIndexException, IOException{
		Analyzer a1 = new MySameAnalyzer();
		String txt = "我来自中国云南昭通昭阳区师专";
		AnalyzerUtils.displayAllToken(txt, a1);
		
		String keyword = "俺";
		Directory dire = new RAMDirectory();
		IndexWriter indexWriter = new IndexWriter(dire,new IndexWriterConfig(Version.LUCENE_35, a1));
		Document doc = new Document();
		doc.add(new Field("content",txt,Field.Store.YES,Field.Index.ANALYZED));
		indexWriter.addDocument(doc);
		indexWriter.close();
		
		IndexSearcher search = new IndexSearcher(IndexReader.open(dire));
		TopDocs topDoc = search.search(new TermQuery(new Term("content",keyword)),10);
		ScoreDoc[] scoreDoc = topDoc.scoreDocs;
		for(ScoreDoc score : scoreDoc){
			Document doc1 = search.doc(score.doc);
			System.out.println(doc1.get("content"));
		}
		
	}
}

5、扩展自己的停用词分词器 

package org.lucene.util;

import java.io.IOException;
import java.io.Reader;
import java.util.Set;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.LetterTokenizer;
import org.apache.lucene.analysis.LowerCaseFilter;
import org.apache.lucene.analysis.StopAnalyzer;
import org.apache.lucene.analysis.StopFilter;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.Tokenizer;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.util.Version;

/**
 * 扩展自己的停用词分词器
 * @author user
 *
 */
public class MyStopAnalyzer extends Analyzer{

	private Set stops;
	public MyStopAnalyzer(String[] sws){
		//会自动将字符串数组转化为Set
		stops = StopFilter.makeStopSet(Version.LUCENE_35, sws, true);
		//把原来的停用词给加进来
		stops.addAll(StopAnalyzer.ENGLISH_STOP_WORDS_SET);
	}
	public MyStopAnalyzer(){
		//获取原有的停用词
		stops.addAll(StopAnalyzer.ENGLISH_STOP_WORDS_SET);
	}
	
	@Override
	public TokenStream tokenStream(String fieldName, Reader reader) {
		System.out.println("//------------------------------------");
		Tokenizer tokenizer = new LetterTokenizer(Version.LUCENE_35,reader);
//		Tokenizer tokenizer = new StandardTokenizer(Version.LUCENE_35,reader);
		CharTermAttribute cta = tokenizer.addAttribute(CharTermAttribute.class);
		try {
			while(tokenizer.incrementToken()){
				System.out.println(cta);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println("------------------------------------\\");
		//为这个分词器设定过滤链和Tokenizer
		return new StopFilter(Version.LUCENE_35, 
				new LowerCaseFilter(Version.LUCENE_35, 
				new LetterTokenizer(Version.LUCENE_35, reader)), 
				stops);
	}

}
6、分词器的扩展，同义词分词器 
package org.lucene.util;

import java.io.Reader;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import com.chenlb.mmseg4j.Dictionary;
import com.chenlb.mmseg4j.MaxWordSeg;
import com.chenlb.mmseg4j.analysis.MMSegTokenizer;

/**
 * 分词器的扩展，同义词分词器
 * @author user
 *
 */
public class MySameAnalyzer extends Analyzer{

	@Override
	public TokenStream tokenStream(String fieldName, Reader reader) {
		Dictionary dic = Dictionary.getInstance("D:\\Workspaces\\03_lucene_analyzer\\mmseg4j-1.8.4\\data");
		
		return new MySameTokenFilter(new MMSegTokenizer(new MaxWordSeg(dic), reader));
	}
	
}

7、同义词过滤器的扩展 

package org.lucene.util;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;
import org.apache.lucene.analysis.TokenFilter;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
import org.apache.lucene.util.AttributeSource;

/**
 * 同义词过滤器的扩展
 * @author user
 *
 */
public class MySameTokenFilter extends TokenFilter{

	private CharTermAttribute cta = null;
	private PositionIncrementAttribute pia = null;
	private AttributeSource.State current = null;
	private Stack<String> sames = null;
	
	protected MySameTokenFilter(TokenStream input) {
		super(input);
		cta = this.addAttribute(CharTermAttribute.class);
		pia = this.addAttribute(PositionIncrementAttribute.class);
		sames = new Stack<String>();
	}

	/**
	 * 思想如下：
	 * 其实每个同义词都要放在CharTermAttribute里面，但是如果直接cta.append("大陆");的话
	 * 那会直接把原来的词和同义词连接在同一个语汇单元里面[中国大陆]，这样是不行的
	 * 要的是这样的效果[中国][大陆]
	 * 那么就要在遇到同义词的时候把当前的状态保存一份，并把同义词的数组放入栈中，
	 * 这样在下一个语汇单元的时候判断同义词数组是否为空，不为空的话把之前的保存的一份状态
	 * 还原，然后在修改之前状态的值cta.setEmpty(),然后在把同义词的值加入cta.append("大陆")
	 * 再把位置增量设为0，pia.setPositionIncrement(0)，这样的话就表示是同义词，
	 * 接着把该同义词的语汇单元返回
	 */
	@Override
	public boolean incrementToken() throws IOException {
		while(sames.size() > 0){
			//将元素出栈，并获取这个同义词
			String str = sames.pop();
			//还原状态
			restoreState(current);
			cta.setEmpty();
			cta.append(str);
			//设置位置
			pia.setPositionIncrement(0);
			return true;
		}
		if(!input.incrementToken()) return false;
		if(getSameWords(cta.toString())){
			//如果有同义词将当前状态先保存
			current = captureState();
		}
		return true;
	}
/*	
 * 使用这种方式是不行的，这种会把的结果是[中国]替换成了[大陆]
 * 而不是变成了[中国][大陆]
	@Override
	public boolean incrementToken() throws IOException {
		if(!input.incrementToken()) return false;
		if(cta.toString().equals("中国")){
			cta.setEmpty();
			cta.append("大陆");
		}
		return true;
	}
*/
	private boolean getSameWords(String name){
		Map<String,String[]> maps = new HashMap<String,String[]>();
		maps.put("中国", new String[]{"大陆","天朝"});
		maps.put("我", new String[]{"咱","俺"});
		String[] sws = maps.get(name);
		if(sws != null){
			for(String s : sws){
				sames.push(s);
			}
			return true;
		}
		return false;
	}
}

8、打印语汇单元的信息 

package org.lucene.util;
import java.io.IOException;
import java.io.StringReader;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
import org.apache.lucene.analysis.tokenattributes.TypeAttribute;

/**
 * 打印语汇单元的信息
 * @author user
 *
 */
public class AnalyzerUtils {
	public static void displayToken(String str,Analyzer a){
		TokenStream stream = a.tokenStream("content", new StringReader(str));
		/*
		 * TokenStream相当于一条流
		 * CharTermAttribute相当于一个碗
		 * 然后把碗丢进流里面，当碗得到一个元素后，碗又会自动流到了下
		 * 一个元素进行取值
		 * 这是一种设计模式：创建一个属性，这个属性会添加流中，
		 * 随着这个TokenStream增加
		 */
		CharTermAttribute cta = stream.addAttribute(CharTermAttribute.class);
		try {
			while(stream.incrementToken()){
				System.out.print("["+cta+"]");
//				System.out.println(stream);
				//如果直接打印Stream的话,toString打印如下：
				//(来,startOffset=1,endOffset=2,positionIncrement=1,type=<IDEOGRAPHIC>)
			}
			System.out.println();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	/**
	 * 打印详细信息的语汇单元
	 * @param str
	 * @param a
	 */
	public static void displayAllToken(String str,Analyzer a){
		TokenStream stream = a.tokenStream("content", new StringReader(str));
		//位置增量
		PositionIncrementAttribute pia = stream.addAttribute(PositionIncrementAttribute.class);
		//偏移量
		OffsetAttribute oa = stream.addAttribute(OffsetAttribute.class);
		//词元
		CharTermAttribute cta = stream.addAttribute(CharTermAttribute.class);
		//分词的类型
		TypeAttribute ta = stream.addAttribute(TypeAttribute.class);
		try {
			while(stream.incrementToken()){
				System.out.print(pia.getPositionIncrement()+":");
				System.out.print(cta+"["+oa.startOffset()+"-"+
						oa.endOffset()+"-"+ta.type());
				System.out.println();
			}
			System.out.println();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

工程下载路径： http://download.csdn.net/detail/wxwzy738/5284705


Lucene分词原理与代码实例讲解
AI天才研究院
07-25 357
Lucene分词原理与代码实例讲解 1. 背景介绍 1.1 问题的由来 在信息检索和自然语言处理领域中,分词(Tokenization)是一个基础且关键的预处理步骤。分词的目的是将连续的文本流拆分为一个个有意义的词元(Token),以便后续的
es5.3.2使用热词、停用词、同义词词典.rar
04-27
es5.3.2热词、停用词、同义词词典，包括插件压缩包，插件源码，远程词典服务端示例，配置说明等
关于lucene的分词（三）
老浣熊
04-02 136
到此为止这个简单的但是功能强大的分词器就写完了,下面咱们可以尝试写一个功能更强大的分词器. 如何DIY一个功能更加强大Analyzer 譬如你有词典,然后你根据正向最大匹配法或者逆向最大匹配法写了一个分词方法,却想在Lucene中应用,很简单 你只要把他们包装成Lucene的TokenStream就好了.下边我以调用中科院写的ICTCLAS接口为例,进行演示.你去中科院 网站可以拿到此接口...
Lucene分词器实现停用词，常用词
weixin_46422238的博客
09-27 459
在resources文件夹下创建IKAnalyzer.cfg.xml来声明停用词，常用词 创建utf-8格式的 ext_dict.txt 和 ext_stopword.txt 放在与IKAnalyzer.cfg.xml同一目录下 如果格式不对可以使用记事本打开然后另存为UTF-8格式
lucene 进行去除停用词和词干提取
march_on的专栏
05-16 9249
简单的示例代码如下，从文件中读取内容进行去除停用词和词干提取，结果保存在result中。 Version matchVersion = Version.LUCENE_43; BufferedReader stopwordsReader = new BufferedReader( new FileReader("a.txt")); Analyzer analyzer = new Standar
Lucene修改停用分词器添加新的需要停用的单词
庸医2048的博客
12-24 1223
代码： 第一步：创建自己的分词器 public final class MyStopAnalyzer extends Analyzer { //继承Analyzer这个类 private Set stops; public MyStopAnalyzer(String[] sws) { //构造方法 stops=StopFilter.makeStopSe
IKAnalyzer: Lucene中文分词工具深度剖析
还有同义词扩展功能，可以增加特定词汇的同义词，从而在搜索时能够扩大搜索范围，提高搜索的相关性。 IKAnalyzer作为一个开源项目，拥有活跃的社区和完善的文档，这使得其更容易为开发者所掌握和使用。同时，作为...
Solr 5.3.1搜索引擎搭建全攻略：集成MySQL、中文分词与同义词
"这篇教程详细介绍了如何搭建Solr 5.3.1搜索引擎，并涵盖了与MySQL的集成、中文分词的添加、同义词的处理以及查询语法等内容。" Solr是一个开源的企业级搜索平台，它允许用户快速构建强大、灵活且可扩展的搜索应用...
lucene.net+盘古分词
01-25
《深入探索：Lucene.NET与盘古分词在全文搜索中的应用》 ...在实际项目中，根据具体需求，还可以进一步探索如近义词扩展、同义词库支持、停用词处理等高级特性，以增强搜索引擎的智能性和实用性。
Lucene扩展停用词字典与自定义词库
1.02^365=1377.41
02-04 6898
介绍如何在Lucene 6.0中扩展停用词，如何通过自定义字典把"厉害了我的哥"分成一个词
lucene3.5 IKAnalyzer3.2.5 实例中文分词通过
02-14
lucene3.5 IKAnalyzer3.2.5 实例中文分词通过，目前在网上找的lucene 和IKAnalyzer 的最新版本测试通过。内含：示例代码，以及最新jar包。 lucene lucene3.5 IKAnalyzer IKAnalyzer3.2.5 jar 中文 分词
Lucene分词器，使用中文分词器，扩展词库，停用词
xiaomin1991222的专栏
11-10 541
停止词：lucene的停止词是无功能意义的词，比如is 、a 、are 、”的”，“得”，“我” 等，这些词会在句子中多次出现却无意义，所以在分词的时候需要把这些词过滤掉。   扩展词库：就是不想让哪些词被分开，让他们分成一个词。     同义词：假设有一个电子商务系统，销售书籍，提供了一个搜索引擎，一天，市场部的人要求客户在搜索书籍时，同义词就是比如输入“电子”，除了展示电子相关的...
Lucene学习之——停用词
weixin_33725270的博客
02-18 316
        做中文文本聚类，研究中科院的imdict-chinese-analyzer分词器时，我自己加载的停用词表一直都跑不出正确的结果，于是，就追踪lucene是怎么加载自己的停用词表的。在源代码的WordListLoader.java类中，发现了这样的代码： public static HashSet getWordSet(Reader reader) throws IOExcepti...
lucene3.5实现自定义同义词分词器
西楚小羽的专栏
04-01 1268
最近一直在学Lucene3.5，感觉里面的知识真的很棒。今天就和大家一起分享一下我们自己来实现一个同义词的分词器。 一个分词器由多个Tokenizer和TokenFilter组成，这篇文章讲解的就是我们利用这两个特性实现自己的一个简单的同义词分词器，不妥之处请大家指出。 一、设计思路 什么叫同义词搜索呢？比如我们在搜 ”中国“ 这个词的时候，我们也可以搜索 ”大陆“ 这个词，后者搜索的要
Lucene（3.5） 的几个查询
java
04-11 3435
几个查询用法如下代码： 其中 数字范围查询：索引时字段保存为 new NumericField(name,  Field.Store.YES(NO), true(false).setIntValue( num ); Query numericRangeQuery = NumericRangeQuery.newIntRange("size", 20, 150, true, true);
NLP分词中的2750个停用词和9995个同义词
给我一点温度
09-04 2174
停用词： 在信息检索中，为节省存储空间和提高搜索效率，在处理自然语言数据（或文本）之前或之后会自动过滤掉某些字或词，这些字或词即被称为Stop Words(停用词)。 这些停用词都是人工输入、非自动化生成的，生成后的停用词会形成一个停用词表。但是，并没有一个明确的停用词表能够适用于所有的工具，甚至有一些工具是明确地避免使用停用词来支持短语搜索的。 对于一个给定的目的，任何一类的词语都可以被选...
同义词挖掘的一些常用方法
腾讯云搜的博客
07-16 1万+
在用户使用搜索引擎的过程中，由于地区差异、文化水平等差异，用户所输入的query很多时候和资料中的描述不一致。这种情况下，为了能够召回更多的文档向用户展示，搜索引擎需要对用户的输入做同义词、纠错、归一化等操作。在进行这些操作的过程中，同义词的挖掘是一个基础工作。下面简单介绍一下几个简单实用的算法。
Lucene+分词器精确提取用户自定义关键词(Lucene版本3.6)
热门推荐
EchoYY的博客
10-20 1万+
Lucene+分词器精确提取用户自定义关键词
中文检索(分词、同义词、权重)
wudiyong22的专栏
09-08 7008
1、首先导入Lucene相关包： lucene-analyzers-common-4.7.1.jar lucene-core-4.7.1.jar lucene-facet-4.7.1.jar lucene-highlighter-4.7.1.jar lucene-queries-4.7.1.jar lucene-queryparser-4.7.1.jar 2、然后把分词源码I
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值