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