原文出处： 杨尚川
本文的目标有两个：
1、学会使用11大Java开源中文分词器
2、对比分析11大Java开源中文分词器的分词效果
本文给出了11大Java开源中文分词的使用方法以及分词结果对比代码，至于效果哪个好，那要用的人结合自己的应用场景自己来判断。
11大Java开源中文分词器，不同的分词器有不同的用法，定义的接口也不一样，我们先定义一个统一的接口：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/** * 获取文本的所有分词结果, 对比不同分词器结果
* @author 杨尚川
*/
public interface WordSegmenter {
/**
* 获取文本的所有分词结果
* @param text 文本
* @return 所有的分词结果，去除重复
*/
default public Set<String> seg(String text) {
return segMore(text).values().stream().collect(Collectors.toSet());
}
/**
* 获取文本的所有分词结果
* @param text 文本
* @return 所有的分词结果，KEY 为分词器模式，VALUE 为分词器结果
*/
public Map<String, String> segMore(String text);
} |
从上面的定义我们知道，在Java中，同样的方法名称和参数，但是返回值不同，这种情况不可以使用重载。
这两个方法的区别在于返回值，每一个分词器都可能有多种分词模式，每种模式的分词结果都可能不相同，第一个方法忽略分词器模式，返回所有模式的所有不重复分词结果，第二个方法返回每一种分词器模式及其对应的分词结果。
在这里，需要注意的是我们使用了Java8中的新特性默认方法，并使用stream把一个map的value转换为不重复的集合。
下面我们利用这11大分词器来实现这个接口：
1、word分词器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
@Overridepublic Map<String, String> segMore(String text) {
Map<String, String> map = new HashMap<>();
for(SegmentationAlgorithm segmentationAlgorithm : SegmentationAlgorithm.values()){
map.put(segmentationAlgorithm.getDes(), seg(text, segmentationAlgorithm));
}
return map;
}private static String seg(String text, SegmentationAlgorithm segmentationAlgorithm) {
StringBuilder result = new StringBuilder();
for(Word word : WordSegmenter.segWithStopWords(text, segmentationAlgorithm)){
result.append(word.getText()).append(" ");
}
return result.toString();
} |
2、Ansj分词器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
@Overridepublic Map<String, String> segMore(String text) {
Map<String, String> map = new HashMap<>();
StringBuilder result = new StringBuilder();
for(Term term : BaseAnalysis.parse(text)){
result.append(term.getName()).append(" ");
}
map.put("BaseAnalysis", result.toString());
result.setLength(0);
for(Term term : ToAnalysis.parse(text)){
result.append(term.getName()).append(" ");
}
map.put("ToAnalysis", result.toString());
result.setLength(0);
for(Term term : NlpAnalysis.parse(text)){
result.append(term.getName()).append(" ");
}
map.put("NlpAnalysis", result.toString());
result.setLength(0);
for(Term term : IndexAnalysis.parse(text)){
result.append(term.getName()).append(" ");
}
map.put("IndexAnalysis", result.toString());
return map;
} |
3、Stanford分词器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
private static final StanfordCoreNLP CTB = new StanfordCoreNLP("StanfordCoreNLP-chinese-ctb");
private static final StanfordCoreNLP PKU = new StanfordCoreNLP("StanfordCoreNLP-chinese-pku");
private static final PrintStream NULL_PRINT_STREAM = new PrintStream(new NullOutputStream(), false);
public Map<String, String> segMore(String text) {
Map<String, String> map = new HashMap<>();
map.put("Stanford Beijing University segmentation", seg(PKU, text));
map.put("Stanford Chinese Treebank segmentation", seg(CTB, text));
return map;
}private static String seg(StanfordCoreNLP stanfordCoreNLP, String text){
PrintStream err = System.err;
System.setErr(NULL_PRINT_STREAM);
Annotation document = new Annotation(text);
stanfordCoreNLP.annotate(document);
List<CoreMap> sentences = document.get(CoreAnnotations.SentencesAnnotation.class);
StringBuilder result = new StringBuilder();
for(CoreMap sentence: sentences) {
for (CoreLabel token: sentence.get(CoreAnnotations.TokensAnnotation.class)) {
String word = token.get(CoreAnnotations.TextAnnotation.class);;
result.append(word).append(" ");
}
}
System.setErr(err);
return result.toString();
} |
4、FudanNLP分词器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
private static CWSTagger tagger = null;
static{
try{
tagger = new CWSTagger("lib/fudannlp_seg.m");
tagger.setEnFilter(true);
}catch(Exception e){
e.printStackTrace();
}
}@Overridepublic Map<String, String> segMore(String text) {
Map<String, String> map = new HashMap<>();
map.put("FudanNLP", tagger.tag(text));
return map;
} |
5、Jieba分词器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
private static final JiebaSegmenter JIEBA_SEGMENTER = new JiebaSegmenter();
@Overridepublic Map<String, String> segMore(String text) {
Map<String, String> map = new HashMap<>();
map.put("INDEX", seg(text, SegMode.INDEX));
map.put("SEARCH", seg(text, SegMode.SEARCH));
return map;
}private static String seg(String text, SegMode segMode) {
StringBuilder result = new StringBuilder();
for(SegToken token : JIEBA_SEGMENTER.process(text, segMode)){
result.append(token.word.getToken()).append(" ");
}
return result.toString();
} |
6、Jcseg分词器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
private static final JcsegTaskConfig CONFIG = new JcsegTaskConfig();
private static final ADictionary DIC = DictionaryFactory.createDefaultDictionary(CONFIG);
static {
CONFIG.setLoadCJKSyn(false);
CONFIG.setLoadCJKPinyin(false);
}@Overridepublic Map<String, String> segMore(String text) {
Map<String, String> map = new HashMap<>();
map.put("复杂模式", segText(text, JcsegTaskConfig.COMPLEX_MODE));
map.put("简易模式", segText(text, JcsegTaskConfig.SIMPLE_MODE));
return map;
}private String segText(String text, int segMode) {
StringBuilder result = new StringBuilder();
try {
ISegment seg = SegmentFactory.createJcseg(segMode, new Object[]{new StringReader(text), CONFIG, DIC});
IWord word = null;
while((word=seg.next())!=null) {
result.append(word.getValue()).append(" ");
}
} catch (Exception ex) {
throw new RuntimeException(ex);
}
return result.toString();
} |
7、MMSeg4j分词器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
private static final Dictionary DIC = Dictionary.getInstance();
private static final SimpleSeg SIMPLE_SEG = new SimpleSeg(DIC);
private static final ComplexSeg COMPLEX_SEG = new ComplexSeg(DIC);
private static final MaxWordSeg MAX_WORD_SEG = new MaxWordSeg(DIC);
@Overridepublic Map<String, String> segMore(String text) {
Map<String, String> map = new HashMap<>();
map.put(SIMPLE_SEG.getClass().getSimpleName(), segText(text, SIMPLE_SEG));
map.put(COMPLEX_SEG.getClass().getSimpleName(), segText(text, COMPLEX_SEG));
map.put(MAX_WORD_SEG.getClass().getSimpleName(), segText(text, MAX_WORD_SEG));
return map;
}private String segText(String text, Seg seg) {
StringBuilder result = new StringBuilder();
MMSeg mmSeg = new MMSeg(new StringReader(text), seg);
try {
Word word = null;
while((word=mmSeg.next())!=null) {
result.append(word.getString()).append(" ");
}
} catch (IOException ex) {
throw new RuntimeException(ex);
}
return result.toString();
} |
8、IKAnalyzer分词器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
@Overridepublic Map<String, String> segMore(String text) {
Map<String, String> map = new HashMap<>();
map.put("智能切分", segText(text, true));
map.put("细粒度切分", segText(text, false));
return map;
}private String segText(String text, boolean useSmart) {
StringBuilder result = new StringBuilder();
IKSegmenter ik = new IKSegmenter(new StringReader(text), useSmart);
try {
Lexeme word = null;
while((word=ik.next())!=null) {
result.append(word.getLexemeText()).append(" ");
}
} catch (IOException ex) {
throw new RuntimeException(ex);
}
return result.toString();
} |
9、Paoding分词器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
private static final PaodingAnalyzer ANALYZER = new PaodingAnalyzer();
@Overridepublic Map<String, String> segMore(String text) {
Map<String, String> map = new HashMap<>();
map.put("MOST_WORDS_MODE", seg(text, PaodingAnalyzer.MOST_WORDS_MODE));
map.put("MAX_WORD_LENGTH_MODE", seg(text, PaodingAnalyzer.MAX_WORD_LENGTH_MODE));
return map;
}private static String seg(String text, int mode){
ANALYZER.setMode(mode);
StringBuilder result = new StringBuilder();
try {
Token reusableToken = new Token();
TokenStream stream = ANALYZER.tokenStream("", new StringReader(text));
Token token = null;
while((token = stream.next(reusableToken)) != null){
result.append(token.term()).append(" ");
}
} catch (Exception ex) {
throw new RuntimeException(ex);
}
return result.toString();
} |
10、smartcn分词器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
private static final SmartChineseAnalyzer SMART_CHINESE_ANALYZER = new SmartChineseAnalyzer();
@Overridepublic Map<String, String> segMore(String text) {
Map<String, String> map = new HashMap<>();
map.put("smartcn", segText(text));
return map;
}private static String segText(String text) {
StringBuilder result = new StringBuilder();
try {
TokenStream tokenStream = SMART_CHINESE_ANALYZER.tokenStream("text", new StringReader(text));
tokenStream.reset();
while (tokenStream.incrementToken()){
CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
result.append(charTermAttribute.toString()).append(" ");
}
tokenStream.close();
}catch (Exception e){
e.printStackTrace();
}
return result.toString();
} |
11、HanLP分词器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
private static final Segment N_SHORT_SEGMENT = new NShortSegment().enableCustomDictionary(false).enablePlaceRecognize(true).enableOrganizationRecognize(true);
private static final Segment DIJKSTRA_SEGMENT = new DijkstraSegment().enableCustomDictionary(false).enablePlaceRecognize(true).enableOrganizationRecognize(true);
@Overridepublic Map<String, String> segMore(String text) {
Map<String, String> map = new HashMap<>();
map.put("标准分词", standard(text));
map.put("NLP分词", nlp(text));
map.put("索引分词", index(text));
map.put("N-最短路径分词", nShort(text));
map.put("最短路径分词", shortest(text));
map.put("极速词典分词", speed(text));
return map;
}private static String standard(String text) {
StringBuilder result = new StringBuilder();
StandardTokenizer.segment(text).forEach(term->result.append(term.word).append(" "));
return result.toString();
}private static String nlp(String text) {
StringBuilder result = new StringBuilder();
NLPTokenizer.segment(text).forEach(term->result.append(term.word).append(" "));
return result.toString();
}private static String index(String text) {
StringBuilder result = new StringBuilder();
IndexTokenizer.segment(text).forEach(term->result.append(term.word).append(" "));
return result.toString();
}private static String speed(String text) {
StringBuilder result = new StringBuilder();
SpeedTokenizer.segment(text).forEach(term->result.append(term.word).append(" "));
return result.toString();
}private static String nShort(String text) {
StringBuilder result = new StringBuilder();
N_SHORT_SEGMENT.seg(text).forEach(term->result.append(term.word).append(" "));
return result.toString();
}private static String shortest(String text) {
StringBuilder result = new StringBuilder();
DIJKSTRA_SEGMENT.seg(text).forEach(term->result.append(term.word).append(" "));
return result.toString();
} |
现在我们已经实现了本文的第一个目的：学会使用11大Java开源中文分词器。
最后我们来实现本文的第二个目的：对比分析11大Java开源中文分词器的分词效果，程序如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
public static Map<String, Set<String>> contrast(String text){
Map<String, Set<String>> map = new LinkedHashMap<>();
map.put("word分词器", new WordEvaluation().seg(text));
map.put("Stanford分词器", new StanfordEvaluation().seg(text));
map.put("Ansj分词器", new AnsjEvaluation().seg(text));
map.put("HanLP分词器", new HanLPEvaluation().seg(text));
map.put("FudanNLP分词器", new FudanNLPEvaluation().seg(text));
map.put("Jieba分词器", new JiebaEvaluation().seg(text));
map.put("Jcseg分词器", new JcsegEvaluation().seg(text));
map.put("MMSeg4j分词器", new MMSeg4jEvaluation().seg(text));
map.put("IKAnalyzer分词器", new IKAnalyzerEvaluation().seg(text));
map.put("smartcn分词器", new SmartCNEvaluation().seg(text));
return map;
}public static Map<String, Map<String, String>> contrastMore(String text){
Map<String, Map<String, String>> map = new LinkedHashMap<>();
map.put("word分词器", new WordEvaluation().segMore(text));
map.put("Stanford分词器", new StanfordEvaluation().segMore(text));
map.put("Ansj分词器", new AnsjEvaluation().segMore(text));
map.put("HanLP分词器", new HanLPEvaluation().segMore(text));
map.put("FudanNLP分词器", new FudanNLPEvaluation().segMore(text));
map.put("Jieba分词器", new JiebaEvaluation().segMore(text));
map.put("Jcseg分词器", new JcsegEvaluation().segMore(text));
map.put("MMSeg4j分词器", new MMSeg4jEvaluation().segMore(text));
map.put("IKAnalyzer分词器", new IKAnalyzerEvaluation().segMore(text));
map.put("smartcn分词器", new SmartCNEvaluation().segMore(text));
return map;
}public static void show(Map<String, Set<String>> map){
map.keySet().forEach(k -> {
System.out.println(k + " 的分词结果：");
AtomicInteger i = new AtomicInteger();
map.get(k).forEach(v -> {
System.out.println("\t" + i.incrementAndGet() + " 、" + v);
});
});
}public static void showMore(Map<String, Map<String, String>> map){
map.keySet().forEach(k->{
System.out.println(k + " 的分词结果：");
AtomicInteger i = new AtomicInteger();
map.get(k).keySet().forEach(a -> {
System.out.println("\t" + i.incrementAndGet()+ " 、【" + a + "】\t" + map.get(k).get(a));
});
});
}public static void main(String[] args) {
show(contrast("我爱楚离陌"));
showMore(contrastMore("我爱楚离陌"));
} |
运行结果如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
********************************************word分词器 的分词结果： 1 、我 爱 楚离陌
Stanford分词器 的分词结果： 1 、我 爱 楚 离陌
2 、我 爱 楚离陌
Ansj分词器 的分词结果： 1 、我 爱 楚离 陌
2 、我 爱 楚 离 陌
HanLP分词器 的分词结果： 1 、我 爱 楚 离 陌
smartcn分词器 的分词结果： 1 、我 爱 楚 离 陌
FudanNLP分词器 的分词结果： 1 、我 爱楚离陌
Jieba分词器 的分词结果： 1 、我爱楚 离 陌
Jcseg分词器 的分词结果： 1 、我 爱 楚 离 陌
MMSeg4j分词器 的分词结果： 1 、我爱 楚 离 陌
IKAnalyzer分词器 的分词结果： 1 、我 爱 楚 离 陌
******************************************** |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
********************************************word分词器 的分词结果： 1 、【全切分算法】 我 爱 楚离陌
2 、【双向最大最小匹配算法】 我 爱 楚离陌
3 、【正向最大匹配算法】 我 爱 楚离陌
4 、【双向最大匹配算法】 我 爱 楚离陌
5 、【逆向最大匹配算法】 我 爱 楚离陌
6 、【正向最小匹配算法】 我 爱 楚离陌
7 、【双向最小匹配算法】 我 爱 楚离陌
8 、【逆向最小匹配算法】 我 爱 楚离陌
Stanford分词器 的分词结果： 1 、【Stanford Chinese Treebank segmentation】 我 爱 楚离陌
2 、【Stanford Beijing University segmentation】 我 爱 楚 离陌
Ansj分词器 的分词结果： 1 、【BaseAnalysis】 我 爱 楚 离 陌
2 、【IndexAnalysis】 我 爱 楚 离 陌
3 、【ToAnalysis】 我 爱 楚 离 陌
4 、【NlpAnalysis】 我 爱 楚离 陌
HanLP分词器 的分词结果： 1 、【NLP分词】 我 爱 楚 离 陌
2 、【标准分词】 我 爱 楚 离 陌
3 、【N-最短路径分词】 我 爱 楚 离 陌
4 、【索引分词】 我 爱 楚 离 陌
5 、【最短路径分词】 我 爱 楚 离 陌
6 、【极速词典分词】 我 爱 楚 离 陌
smartcn分词器 的分词结果： 1 、【smartcn】 我 爱 楚 离 陌
FudanNLP分词器 的分词结果： 1 、【FudanNLP】 我 爱楚离陌
Jieba分词器 的分词结果： 1 、【SEARCH】 我爱楚 离 陌
2 、【INDEX】 我爱楚 离 陌
Jcseg分词器 的分词结果： 1 、【简易模式】 我 爱 楚 离 陌
2 、【复杂模式】 我 爱 楚 离 陌
MMSeg4j分词器 的分词结果： 1 、【SimpleSeg】 我爱 楚 离 陌
2 、【ComplexSeg】 我爱 楚 离 陌
3 、【MaxWordSeg】 我爱 楚 离 陌
IKAnalyzer分词器 的分词结果： 1 、【智能切分】 我 爱 楚 离 陌
2 、【细粒度切分】 我 爱 楚 离 陌
******************************************** |
相关推荐
cws_evaluation是一个Java开源项目，专门用于评估和对比不同中文分词器的效果，帮助开发者选择最适合他们需求的工具。本文将深入探讨这个项目的核心概念、工作原理以及如何利用它进行分词器性能测试。 首先，中文...
IK Analyzer 是一个开源的，基于 java 语言开发的轻量级的中文分词工具包。从 2006年 12 月推出 1.0 版开始， IKAnalyzer 已经推出了 4 个大版本。最初，它是以开源项目Luence 为应用主体的，结合词典分词和文法分析...
Java开源项目cws-evaluation：中文分词器分词效果评估对比.zip
首先，ansj分词器是由李弄潮开发的一款开源分词工具，它具有强大的词典支持和自学习功能。ansj集成了词性标注、新词发现等功能，适用于新闻、博客等多种文本类型。其优点在于处理速度较快，但可能对某些专业词汇或...
setTitle("Mini分词器"); setDefaultCloseOperation(EXIT_ON_CLOSE); setJMenuBar(menuBar); JMenu fileMenu = new JMenu("文件"); JMenu algorithmMenu = new JMenu("分词算法"); JMenu ...
由于分词过程会增加CPU和内存的消耗，因此，在大规模数据处理时，可能需要对分词策略进行优化，例如选择合适的分词模式、使用缓存等方法。 **与其他分词器的对比** 除了IK，Elasticsearch还支持其他中文分词器，如...
Java的开源分词库如HanLP、jieba、IK Analyzer、Thulac等，因其高效稳定和易于集成的特点，受到了开发者的青睐。 3. **HanLP**：由百度公司前员工开发的高性能分词库，支持词性标注、命名实体识别等功能，广泛应用...
IK 分词器是针对中文文本进行分词处理的工具，通常用于提高搜索引擎对中文内容的索引和搜索效率。 **描述详解：** 描述中提到，这个分词器是为 Elasticsearch 2.2 版本设计的，意味着它与该版本的 Elasticsearch ...
例如，jieba分词库是Java领域一个著名的开源分词系统，它就采用了多种分词策略，并且支持自定义词典和在线学习，以适应不同场景的需求。 此外，为了提高分词性能，开发者可能会采用数据结构优化，如Trie树或AC...
jieba分词是中文处理领域的一个著名...综上所述，jieba分词Java版项目提供了一种在Java环境下进行中文分词的解决方案，通过Eclipse导入并运行测试，你可以快速了解和使用这个工具，为你的中文信息处理任务带来便利。
Solr中文分词器是Apache Solr搜索引擎系统中用于处理中文文本的核心组件，它使得Solr能够对中文文档进行有效的索引和搜索。在Solr中，分词器（Tokenizer）是分析器（Analyzer）的一部分，负责将输入的文本拆分成可被...
IKAnalyzer是一款针对中文的开源分词器，专为Java平台设计。它在处理中文文本时，能够有效地进行词语切分，提升文本分析的准确性和效率。这个工具在信息检索、自然语言处理、文本挖掘等领域有着广泛的应用。 1. **...
IK分词器（Intelligent Chinese Analyzer for Java）是一款针对中文文本处理的开源分词工具，专为Java平台设计。它致力于提供高效、灵活的中文分词解决方案，广泛应用于搜索引擎、信息检索、自然语言处理等领域。在...
ikanalyzer是基于Lucene的一个开源中文分词器，它对中文词汇进行了优化，支持词典扩展和自定义词典，可以有效地处理常见的中文词汇和短语。 ikanalyzer的设计理念是简单易用，它实现了Lucene的Analyzer接口，可以...
jieba分词器是一款在中文处理领域非常知名的开源工具，尤其在自然语言处理（NLP）和搜索引擎开发中广泛应用。它的主要功能是对中文文本进行精确、全模式、搜索引擎模式等多种方式的分词，以满足不同场景的需求。Java...
IK-Analyzer是一个开源的，基于java语言开发的轻量级的中文分词工具包，也就是可以将一串中文字符分割成一个个的词组或者字词 文件中包含分词工具 ikanalyzer-2012_u6.jar 中文分词配置 IKAnalyzer.cfg..xml
总的来说，选择和使用合适的Lucene中文分词器组件是实现高效、准确的中文搜索的关键。开发者需要根据项目需求、资源限制以及对分词效果的要求，综合评估后选择最适合的分词工具。同时，持续关注分词器的更新和改进，...
IK分词器是Java开发的一款高效、灵活的中文分词工具，主要应用于全文检索和自然语言处理领域。在Solr中，IK分词器作为重要的插件被广泛使用，用于对中文文本进行精确且高效的分词，从而提高搜索质量和效率。 标题中...
结巴分词（jieba）是一款广泛应用于中文文本处理的开源分词库，它能够高效地进行中文词语切分，为自然语言处理（NLP）提供了基础支持。NLP是计算机科学领域的一个分支，主要研究如何让计算机理解、生成和处理人类的...
分词是中文文本处理的基石，因为它能将连续的汉字序列划分为具有语义意义的单元，便于后续的分析和应用。 在"庖丁解牛"中，用户可以通过运行`analyzer.bat`程序来测试和查看分词结果。这是一个便捷的交互方式，允许...