基于Java分词的ikanalyzer工具_java ikanalyzer

1.Maven依赖

<dependency>
      <groupId>org.apache.opennlp</groupId>
      <artifactId>opennlp-tools</artifactId>
      <version>1.9.1</version>
    </dependency>
1
2
3
4
5

2. 自定义词典

IKanalyzer可通过配置Ikanalyzer.cfg.xml进行自定义词库，
 *  但有时需要在程序中根据不同的文章动态调用不同的词库进行分词，
 *  这就需要自定义Configuration类来实现。
1
2
3

首先，拷贝Ikanalyzer源码中的DefaultConfig.java，改为MyConfiguration.java,然后做如下改写：

package com.xhq.DOG.config;

/**
 *  IKanalyzer可通过配置Ikanalyzer.cfg.xml进行自定义词库，
 *  但有时需要在程序中根据不同的文章动态调用不同的词库进行分词，
 *  这就需要自定义Configuration类来实现。
 * 
 * 
 */
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.InvalidPropertiesFormatException;
import java.util.List;
import java.util.Properties;

import org.wltea.analyzer.cfg.Configuration;

/**
 * Configuration 默认实现
 * 2012-5-8
 *
 */
public class myDefaultConfig implements Configuration {

  /*
   * 分词器默认字典路径
   */
  private String PATH_DIC_MAIN = "org/wltea/analyzer/dic/main2012.dic";
  private static final String PATH_DIC_QUANTIFIER = "org/wltea/analyzer/dic/quantifier.dic";

  /*
   * 分词器配置文件路径
   */
  private static final String FILE_NAME = "IKAnalyzer.cfg.xml";
  // 配置属性——扩展字典
  private static final String EXT_DICT = "ext_dict";
  // 配置属性——扩展停止词典
  private static final String EXT_STOP = "ext_stopwords";

  private Properties props;
  /*
   * 是否使用smart方式分词
   */
  private boolean useSmart;

  /**
   * 返回单例
   * @return Configuration单例
   */
  public static Configuration getInstance() {
    return new myDefaultConfig();
  }

  /*
   * 初始化配置文件
   */
  public myDefaultConfig() {
    props = new Properties();

    InputStream input = this.getClass().getClassLoader().getResourceAsStream(FILE_NAME);
    if (input != null) {
      try {
        props.loadFromXML(input);
      } catch (InvalidPropertiesFormatException e) {
        e.printStackTrace();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }

  /**
   * 返回useSmart标志位
   * useSmart =true ，分词器使用智能切分策略， =false则使用细粒度切分
   * @return useSmart
   */
  public boolean useSmart() {
    return useSmart;
  }

  /**
   * 设置useSmart标志位
   * useSmart =true ，分词器使用智能切分策略， =false则使用细粒度切分
   * @param useSmart
   */
  public void setUseSmart(boolean useSmart) {
    this.useSmart = useSmart;
  }

  /**
   * 获取主词典路径
   * 
   * @return String 主词典路径
   */
  public String getMainDictionary() {
    return PATH_DIC_MAIN;
  }
  /**
   * 设置主词典路径（2019-06-05 新加的）
   * 
   * @return String 主词典路径
   */
  public void setMainDictionary(String path) {
    this.PATH_DIC_MAIN = path;
  }
  /**
   * 获取量词词典路径
   * @return String 量词词典路径
   */
  public String getQuantifierDicionary() {
    return PATH_DIC_QUANTIFIER;
  }

  /**
   * 获取扩展字典配置路径
   * @return List<String> 相对类加载器的路径
   */
  public List<String> getExtDictionarys() {
    List<String> extDictFiles = new ArrayList<String>(2);
    String extDictCfg = props.getProperty(EXT_DICT);
    if (extDictCfg != null) {
      // 使用;分割多个扩展字典配置
      String[] filePaths = extDictCfg.split(";");
      if (filePaths != null) {
        for (String filePath : filePaths) {
          if (filePath != null && !"".equals(filePath.trim())) {
            extDictFiles.add(filePath.trim());
          }
        }
      }
    }
    return extDictFiles;
  }

  /**
   * 获取扩展停止词典配置路径
   * @return List<String> 相对类加载器的路径
   */
  public List<String> getExtStopWordDictionarys() {
    List<String> extStopWordDictFiles = new ArrayList<String>(2);
    String extStopWordDictCfg = props.getProperty(EXT_STOP);
    if (extStopWordDictCfg != null) {
      // 使用;分割多个扩展字典配置
      String[] filePaths = extStopWordDictCfg.split(";");
      if (filePaths != null) {
        for (String filePath : filePaths) {
          if (filePath != null && !"".equals(filePath.trim())) {
            extStopWordDictFiles.add(filePath.trim());
          }
        }
      }
    }
    return extStopWordDictFiles;
  }

}


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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

3.调用方法

public static void main(String[] args) throws Exception{
		List<String> wordList = new ArrayList<>();
		//定义自己的词库
		myDefaultConfig cfg = new myDefaultConfig();
		cfg.setUseSmart(true); //智能切分
		//动态设置自定义的词库
		cfg.setMainDictionary("com/xhq/DOG/config/mydict.dic"); 

		
		String content = "100% POLYESTER MAGGIE 20PC COMFORTER SET,SOLID PINSONIC QUILT SET,DREAM HAVEN COMFORTER";
		byte[] bt = content.getBytes();
        InputStream ip = new ByteArrayInputStream(bt);
        Reader read = new InputStreamReader(ip); 
		IKSegmenter iks = new IKSegmenter(read, cfg);
		Lexeme t;
		while((t = iks.next()) != null){
			wordList.add(t.getLexemeText());
		}
        System.out.print(wordList);
        
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21