ICTCLAS用的字Lucene4.9捆绑

它一直喜欢的搜索方向，虽然无法做到。但仍保持了狂热的份额。记得那个夏天、这间实验室、这一群人，一切都随风而逝。踏上新征程。我以前没有自己。面对七三分技术的商业环境，我选择了沉淀。社会是一个大机器，我们只是一个小螺丝钉。我们不能容忍半点扭扭捏捏。

于一个时代的产物。也终将被时代所抛弃。言归正题，在lucene增加自己定义的分词器，须要继承Analyzer类。实现createComponents方法。同一时候定义Tokenzier类用于记录所需建立索引的词以及其在文章的位置，这里继承SegmentingTokenizerBase类，须要实现setNextSentence与incrementWord两个方法。当中。setNextSentence设置下一个句子，在多域（Filed）分词索引时，setNextSentence就是设置下一个域的内容，能够通过new
String(buffer, sentenceStart, sentenceEnd - sentenceStart)获取。而incrementWord方法则是记录每一个单词以及它的位置。须要注意一点就是要在前面加clearAttributes()，否则可能出现first position increment must be > 0...错误。以ICTCLAS分词器为例，以下贴上个人代码，希望能给大家带来帮助，不足之处，多多拍砖。

import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.Tokenizer;
import org.apache.lucene.analysis.core.LowerCaseFilter;
import org.apache.lucene.analysis.en.PorterStemFilter;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.util.Version;

/**
 * 中科院分词器 继承Analyzer类。实现其 tokenStream方法
 *
 * @author ckm
 *
 */
public class ICTCLASAnalyzer extends Analyzer {

	/**
	 * 该方法主要是将文档转变成lucene建立索 引所需的TokenStream对象
	 *
	 * @param fieldName
	 *            文件名称
	 * @param reader
	 *            文件的输入流
	 */
	@Override
	protected TokenStreamComponents createComponents(String fieldName, Reader reader) {
		try {
			System.out.println(fieldName);
		    final Tokenizer tokenizer = new ICTCLASTokenzier(reader);
		    TokenStream stream = new PorterStemFilter(tokenizer);
		    stream = new LowerCaseFilter(Version.LUCENE_4_9, stream);
		    stream = new PorterStemFilter(stream);
			return new TokenStreamComponents(tokenizer,stream);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;

	}

	public static void main(String[] args) throws Exception {
        Analyzer analyzer = new ICTCLASAnalyzer();
        String str = "黑客技术";
        TokenStream ts = analyzer.tokenStream("field", new StringReader(str));
        CharTermAttribute c = ts.addAttribute(CharTermAttribute.class);
        ts.reset();
        while (ts.incrementToken()) {
            System.out.println(c.toString());
        }  

        ts.end();
        ts.close();
    }  

}

import java.io.IOException;
import java.io.Reader;
import java.text.BreakIterator;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
import org.apache.lucene.analysis.util.SegmentingTokenizerBase;
import org.apache.lucene.util.AttributeFactory;

/**
 *
 * 继承lucene的SegmentingTokenizerBase,重载其setNextSentence与
 * incrementWord方 法，记录所需建立索引的词以及其在文章的位置
 *
 * @author ckm
 *
 */
public class ICTCLASTokenzier extends SegmentingTokenizerBase {

	private static final BreakIterator sentenceProto = BreakIterator.getSentenceInstance(Locale.ROOT);

	private final CharTermAttribute termAttr= addAttribute(CharTermAttribute.class);// 记录所需建立索引的词

	private final OffsetAttribute offAttr = addAttribute(OffsetAttribute.class);// 记录所需建立索引的词在文章中的位置

	private ICTCLASDelegate ictclas;// 分词系统的托付对象

	private Iterator<String> words;// 文章分词后形成的单词

	private int offSet= 0;// 记录最后一个词元的结束位置

	/**
	 * 构造函数
	 *
	 * @param segmented    分词后的结果
	 * @throws IOException
	 */
	protected ICTCLASTokenzier(Reader reader) throws IOException {
		this(DEFAULT_TOKEN_ATTRIBUTE_FACTORY, reader);
	}

	protected ICTCLASTokenzier(AttributeFactory factory, Reader reader) throws IOException {
		super(factory, reader,sentenceProto);
		ictclas = ICTCLASDelegate.getDelegate();

	}

	@Override
	protected void setNextSentence(int sentenceStart, int sentenceEnd) {
		// TODO Auto-generated method stub
		String sentence = new String(buffer, sentenceStart, sentenceEnd - sentenceStart);
		String result=ictclas.process(sentence);
		String[] array = result.split("\\s");
		if(array!=null){
			List<String> list = Arrays.asList(array);
			words=list.iterator();
		}
		offSet= 0;
	}

	@Override
	protected boolean incrementWord() {
		// TODO Auto-generated method stub
		if (words == null || !words.hasNext()) {
		    return false;
		} else {
			String t = words.next();
			while(t.equals("")||StopWordFilter.filter(t)){ //这里主要是为了过滤空白字符以及停用词
				                                          //StopWordFilter为自己定义停用词过滤类
				if (t.length() == 0)
					offSet++;
				else
					offSet+= t.length();
				t =words.next();
			}
			if (!t.equals("") && !StopWordFilter.filter(t)) {
				clearAttributes();
				termAttr.copyBuffer(t.toCharArray(), 0, t.length());
				offAttr.setOffset(correctOffset(offSet), correctOffset(offSet=offSet+ t.length()));
				return true;
			}
			return false;
		}
	}

	/**
	 * 重置
	 */
	public void reset() throws IOException {
		super.reset();
		offSet= 0;
	}

	public static void main(String[] args) throws IOException {
		String content = "宝剑锋从磨砺出，梅花香自苦寒来！

";
		String seg = ICTCLASDelegate.getDelegate().process(content);
		//ICTCLASTokenzier test = new ICTCLASTokenzier(seg);
		//while (test.incrementToken());
	}

}

import java.io.File;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import ICTCLAS.I3S.AC.ICTCLAS50;

/**
 * 中科院分词系统代理类
 *
 * @author ckm
 *
 */
public class ICTCLASDelegate {

	private static final String userDict = "userDict.txt";// 用户词典

	private final static Charset charset = Charset.forName("gb2312");// 默认的编码格式

	private static String ictclasPath =System.getProperty("user.dir");

	private static String dirConfigurate = "ICTCLASConf";// 配置文件所在文件夹名

	private static String configurate = ictclasPath + File.separator+ dirConfigurate;// 配置文件所在文件夹的绝对路径

	private static int wordLabel = 2;// 词性标注类型（北大二级标注集）

	private static ICTCLAS50 ictclas;// 中科院分词系统的jni接口对象

	private static ICTCLASDelegate instance = null;

	private ICTCLASDelegate(){ }

	/**
	 * 初始化ICTCLAS50对象
	 *
	 * @return ICTCLAS50对象初始化化是否成功
	 */
	public boolean init() {
		ictclas = new ICTCLAS50();
		boolean bool = ictclas.ICTCLAS_Init(configurate
				.getBytes(charset));
		if (bool == false) {
			System.out.println("Init Fail!");
			return false;
		}
		// 设置词性标注集(0 计算所二级标注集。1 计算所一级标注集，2 北大二级标注集，3 北大一级标注集)
		ictclas.ICTCLAS_SetPOSmap(wordLabel);
		importUserDictFile(configurate + File.separator + userDict);// 导入用户词典
		ictclas.ICTCLAS_SaveTheUsrDic();// 保存用户字典
		return true;
	}

	/**
	 * 将编码格式转换为分词系统识别的类型
	 *
	 * @param charset
	 *            编码格式
	 * @return 编码格式相应的数字
	 **/
	public static int getECode(Charset charset) {
		String name = charset.name();
		if (name.equalsIgnoreCase("ascii"))
			return 1;
		if (name.equalsIgnoreCase("gb2312"))
			return 2;
		if (name.equalsIgnoreCase("gbk"))
			return 2;
		if (name.equalsIgnoreCase("utf8"))
			return 3;
		if (name.equalsIgnoreCase("utf-8"))
			return 3;
		if (name.equalsIgnoreCase("big5"))
			return 4;
		return 0;
	}

	/**
	 * 该方法的作用是导入用户字典
	 *
	 * @param path
	 *            用户词典的绝对路径
	 * @return 返回导入的词典的单词个数
	 */
	public int importUserDictFile(String path) {
		System.out.println("导入用户词典");
		return ictclas.ICTCLAS_ImportUserDictFile(
				path.getBytes(charset), getECode(charset));
	}

	/**
	 * 该方法的作用是对字符串进行分词
	 *
	 * @param source
	 *            所要分词的源数据
	 * @return 分词后的结果
	 */
	public String process(String source) {
		return process(source.getBytes(charset));
	}

	public String process(char[] chars){
	   CharBuffer cb = CharBuffer.allocate (chars.length);
	   cb.put (chars);
	   cb.flip ();
	   ByteBuffer bb = charset.encode (cb);
	   return process(bb.array());

	}

	public String process(byte[] bytes){
		if(bytes==null||bytes.length<1)
			return null;
		byte nativeBytes[] = ictclas.ICTCLAS_ParagraphProcess(bytes, 2, 0);
		String nativeStr = new String(nativeBytes, 0,
				nativeBytes.length-1, charset);
		return nativeStr;
	}

	/**
	 * 获取分词系统代理对象
	 *
	 * @return 分词系统代理对象
	 */
	public static ICTCLASDelegate getDelegate() {
		if (instance == null) {
			synchronized (ICTCLASDelegate.class) {
				instance = new ICTCLASDelegate();
				instance.init();
			}
		}
		return instance;
	}

	/**
	 * 退出分词系统
	 *
	 * @return 返回操作是否成功
	 */
	public boolean exit() {
		return ictclas.ICTCLAS_Exit();
	}

	public static void main(String[] args) {
		String str="结婚的和尚未结婚的";
		ICTCLASDelegate id = ICTCLASDelegate.getDelegate();
		String result = id.process(str.toCharArray());
		System.out.println(result.replaceAll(" ", "-"));
	}

}

import java.util.Iterator;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 停用词过滤器
 *
 * @author ckm
 *
 */
public class StopWordFilter {

	private static Set<String> chineseStopWords = null;// 中文停用词集
	private static Set<String> englishStopWords = null;// 英文停用词集
	static {
		init();
	}

	/**
	 * 初始化中英文停用词集
	 */
	public static void init() {
		LoadStopWords lsw = new LoadStopWords();
		chineseStopWords = lsw.getChineseStopWords();
		englishStopWords = lsw.getEnglishStopWords();
	}

	/**
	 * 推断keyword的类型以及推断其是否为停用词 注意：临时仅仅考虑中文，英文。中英混合， 中数混合，英数混合这五种类型。当中中英 混合，
	 * 中数混合，英数混合还没特定的停用 词库或语法规则对其进行判别
	 *
	 * @param word
	 *            keyword
	 * @return true表示是停用词
	 */
	public static boolean filter(String word) {
		Pattern chinese = Pattern.compile("^[\u4e00-\u9fa5]+$");// 中文匹配
		Matcher m1 = chinese.matcher(word);
		if (m1.find())
			return chineseFilter(word);
		Pattern english = Pattern.compile("^[A-Za-z]+$");// 英文匹配
		Matcher m2 = english.matcher(word);
		if (m2.find())
			return englishFilter(word);
		Pattern chineseDigit = Pattern.compile("^[\u4e00-\u9fa50-9]+$");// 中数匹配
		Matcher m3 = chineseDigit.matcher(word);
		if (m3.find())
			return chineseDigitFilter(word);
		Pattern englishDigit = Pattern.compile("^[A-Za-z0-9]+$");// 英数匹配
		Matcher m4 = englishDigit.matcher(word);
		if (m4.find())
			return englishDigitFilter(word);
		Pattern englishChinese = Pattern.compile("^[A-Za-z\u4e00-\u9fa5]+$");// 中英匹配,这个必须在中文匹配与英文匹配之后
		Matcher m5 = englishChinese.matcher(word);
		if (m5.find())
			return englishChineseFilter(word);
		return true;
	}

	/**
	 * 推断keyword是否为中文停用词
	 *
	 * @param word
	 *            keyword
	 * @return true表示是停用词
	 */
	public static boolean chineseFilter(String word) {
		// System.out.println("中文停用词推断");
		if (chineseStopWords == null || chineseStopWords.size() == 0)
			return false;
		Iterator<String> iterator = chineseStopWords.iterator();
		while (iterator.hasNext()) {
			if (iterator.next().equals(word))
				return true;
		}
		return false;
	}

	/**
	 * 推断keyword是否为英文停用词
	 *
	 * @param word
	 *            keyword
	 * @return true表示是停用词
	 */
	public static boolean englishFilter(String word) {
		// System.out.println("英文停用词推断");
		if (word.length() <= 2)
			return true;
		if (englishStopWords == null || englishStopWords.size() == 0)
			return false;
		Iterator<String> iterator = englishStopWords.iterator();
		while (iterator.hasNext()) {
			if (iterator.next().equals(word))
				return true;
		}
		return false;
	}

	/**
	 * 推断keyword是否为英数停用词
	 *
	 * @param word
	 *            keyword
	 * @return true表示是停用词
	 */
	public static boolean englishDigitFilter(String word) {
		return false;

	}

	/**
	 * 推断keyword是否为中数停用词
	 *
	 * @param word
	 *            keyword
	 * @return true表示是停用词
	 */
	public static boolean chineseDigitFilter(String word) {
		return false;

	}

	/**
	 * 推断keyword是否为英中停用词
	 *
	 * @param word
	 *            keyword
	 * @return true表示是停用词
	 */
	public static boolean englishChineseFilter(String word) {
		return false;

	}

	public static void main(String[] args) {
		/*
		 * Iterator<String> iterator=
		 * StopWordFilter.chineseStopWords.iterator(); int n=0;
		 * while(iterator.hasNext()){ System.out.println(iterator.next()); n++;
		 * } System.out.println("总单词量："+n);
		 */
		boolean bool = StopWordFilter.filter("宝剑");
		System.out.println(bool);
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/**
 * 载入停用词文件
 *
 * @author ckm
 *
 */

public class LoadStopWords {

	private Set<String> chineseStopWords = null;// 中文停用词集

	private Set<String> englishStopWords = null;// 英文停用词集

	/**
	 * 获取中文停用词集
	 *
	 * @return 中文停用词集Set<String>类型
	 */
	public Set<String> getChineseStopWords() {
		return chineseStopWords;
	}

	/**
	 * 设置中文停用词集
	 *
	 * @param chineseStopWords
	 *            中文停用词集Set<String>类型
	 */
	public void setChineseStopWords(Set<String> chineseStopWords) {
		this.chineseStopWords = chineseStopWords;
	}

	/**
	 * 获取英文停用词集
	 *
	 * @return 英文停用词集Set<String>类型
	 */
	public Set<String> getEnglishStopWords() {
		return englishStopWords;
	}

	/**
	 * 设置英文停用词集
	 *
	 * @param englishStopWords
	 *            英文停用词集Set<String>类型
	 */
	public void setEnglishStopWords(Set<String> englishStopWords) {
		this.englishStopWords = englishStopWords;
	}

	/**
	 * 载入停用词库
	 */
	public LoadStopWords() {
		chineseStopWords = loadStopWords(this.getClass().getResourceAsStream(
				"ChineseStopWords.txt"));
		englishStopWords = loadStopWords(this.getClass().getResourceAsStream(
				"EnglishStopWords.txt"));
	}

	/**
	 * 从停用词文件里载入停用词， 停用词文件是普通GBK编码的文本文件， 每一行 是一个停用词。凝视利用“//”， 停用词中包含中文标点符号，
	 * 中文空格， 以及使用率太高而对索引意义不大的词。
	 *
	 * @param input
	 *            停用词文件流
	 * @return 停用词组成的HashSet
	 */
	public static Set<String> loadStopWords(InputStream input) {
		String line;
		Set<String> stopWords = new HashSet<String>();
		try {
			BufferedReader br = new BufferedReader(new InputStreamReader(input,
					"GBK"));
			while ((line = br.readLine()) != null) {
				if (line.indexOf("//") != -1) {
					line = line.substring(0, line.indexOf("//"));
				}
				line = line.trim();
				if (line.length() != 0)
					stopWords.add(line.toLowerCase());
			}
			br.close();
		} catch (IOException e) {
			System.err.println("不能打开停用词库！。");
		}
		return stopWords;
	}

	public static void main(String[] args) {
		LoadStopWords lsw = new LoadStopWords();
		Iterator<String> iterator = lsw.getEnglishStopWords().iterator();
		int n = 0;
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
			n++;
		}
		System.out.println("总单词量：" + n);
	}

}

这里须要ChineseStopWords.txt 与EnglishStopWords.txt中国和英国都存储停用词，在这里，我们不知道如何上传，有ICTCLAS基本的文件。

下载完整的项目：http://download.csdn.net/detail/km1218/7754907