Java 简易实现分词器功能_java 分词

前言：

搜索功能是具备数据库功能的系统的一大重要特性和功能，生活中常见的搜索功能基本上都具备了分词搜索功能。然而ES功能固然强大，但对于学生或小项目而言整合起来太费人力物力，这时候，若是写一个简易的分词器就会使项目锦上添花，使其不仅仅是只能“单关键词”搜索的系统。

业务需求：

生活中常见的搜索功能大概可分为以下几类：

• 单关键词。如“Notebook”
• 双关键词加空格。如“Super Notebook”
• 多关键词加多空格。如“Intel Super Notebook”

当然，还有四甚至五关键词，这些搜索场景在生活中可以用罕见来形容，不在我们的讨论范围。我们今天就以上三种生活中最常见的搜索形式进行探讨分析。业务需求也很简单，假设我们要完成一个搜索功能，业务层、持久层、控制层不在我们讨论的范围，仅讨论分词功能如何实现。

分析：

假设用户键入的搜索内容为以下内容：

Intel Super Notebook
1

我们可以利用Java中String强大而丰富的方法来慢慢拼凑一个小算法来达到目的。String中大多数方法的参数和返回值都与下标相关，那么，分析上述语句的下标，我们可发现如下内容：

上述内容红色是我们分词的关键内容。对于一个语句而言（不是语言学上通俗的语句，因为该句没有主谓宾），重要的就是各单词或词组的首字母下标与该单词或词组后面最近一个空格。我们发现，Intel这个单词首字母下标为0，距离该单词后面最近的一个空格下标为5；Super首字母下标为距离该单词前面最近的一个空格的下标加1，也就是6；Notebook首字母下标为距离该单词前面最近的一个空格的下标加1，也就是12；最后就是该语句的尾下标，也就是19。

当然，实际情况会有用户多输入了两个甚至三个空格在某两个单词之间，例如如下形式：

Intel  Super  Notebook
1

（注意这里的空格为每个单词之间为2个）

这个问题很容易解决，我们把两个或三个空格替换为一个空格即可（为什么不是四个或者更多？因为现实情况是用户不太可能在各个单词之间连按多个空格），如下：

sentence = sentence.replace("  ", " ");
sentence = sentence.replace("   ", " ");
1
2

这样以来语句中就只存在单个空格了。

经过分析我们得知，若想对一个语句进行分词，就必须知道各个单词的起始下标才行。起始下标可以由空格的下标得知，那我们该如何得知空格的下标？

很简单，我们写个方法，通过迭代语句的每个单词，判断其是否存在空格即可。方法如下：

private int firstPosition(){
	int first = 0;
	for(int i = 0; i < sentence.length(); i++){
		if(String.valueOf(sentence.charAt(i)).equals(" ")){
			first = i;
			return first;
		}	
	}
	return first;
}
1
2
3
4
5
6
7
8
9
10

这个方法的作用是判断一个语句中第一个空格的位置。既然有第一个了，肯定要有第二个了。要注意第一个内容是从0开始进行迭代，而第二个空格的判断方法要从第一个空格的位置加1开始，否则迭代的刚好还是第一个空格的位置。内容如下：

	private int secondPosition(){
		int second = 0;
		for(int i = (firstPosition() + 1); i < sentence.length(); i++){
			if(String.valueOf(sentence.charAt(i)).equals(" ")){
				second = i;
				return second;
			}	
		}
		return second;
	}
1
2
3
4
5
6
7
8
9
10

第三个为什么不迭代？因为第三个单词之后就没有空格了，就到结尾了。

找出每个空格的下标索引后，我们还需知道语句中含有多少个空格，是没有，还是1个或2个（连续的重复空格在上文已经被替换为单个空格了）。方法如下：

private int countBlank(String s){
	// Store single blank signal.
	int amount = 0;

	// If s contains single blank signal, and it will increse amount's value of 1 every loop times.
	for(int i = 0; i < s.length(); i++){
		if(String.valueOf(sentence.charAt(i)).equals(" ")){
			amount++;
		}
	}
	return amount;
}
1
2
3
4
5
6
7
8
9
10
11
12

拿到了空格的总个数及每个空格的下标，我们就可以写个方法进行分割了。由于我是采用了泛型集合作为数据源，这里的方法返回类型就为void。

我们先假设输入的仅有以下内容：

Intel
1

输入的仅有一个词组。我们先判断其空格的个数，发现为0，那么也不用进行什么操作了，直接添加其作为集合的数据。

	public void divide(){
		// Record every single blank signal's position.
		int position1 = firstPosition();
		int position2 = secondPosition();
		
		if(sentence.contains(" ")){

		} else{
        	words.add(sentence);
     	}
		
	}
1
2
3
4
5
6
7
8
9
10
11
12

现在情况变为输入的内容如下：

Intel Super
1

我们知道了这个语句共有一个空格，下标为5，长度为11，那可以这样判断：是否包含空格，如果是，那就判断其空格数是否大于等于0，如果为真，就添加到数据源。接着判断其空格数是否大于等于1，如果真，进入下一层判断其空格数是否大于等于1其小于2，如果真，就添加到数据源。内容如下：

	public void divide(){
		// Record every single blank signal's position.
		int position1 = firstPosition();
		int position2 = secondPosition();
		
		if(sentence.contains(" ")){
			int blankAmount = countBlank(sentence);
			if (blankAmount >= 0) {
				words.add(sentence.substring(0, position1));
				if (blankAmount >= 1) {
					if(blankAmount >= 1 && blankAmount < 2)));
						words.add(sentence.substring(position1, sentence.length()));
					} else {

					}
	
				} 
				
			}
		} else{
        	words.add(sentence);
     	}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

下面就是较为全面的情况了：

Intel Super Notebook
1

我们判断完两个情况就看第三个情况。第三个单词其获取是通过第二个空格下标与语句长度得来。但第二个单词就要改为第一个空格下标加1与第二个空格下标加1了。那么至此分割方法也就完成了：

public String divide(){
	// Record every single blank signal's position.
	int position1 = firstPosition();
	int position2 = secondPosition();
	
	if(sentence.contains(" ")){
		int blankAmount = countBlank(sentence);
		if (blankAmount >= 0) {
			words.add(sentence.substring(0, position1));
			if (blankAmount >= 1) {
				if(blankAmount >= 1 && blankAmount < 2){
					words.add(sentence.substring(position1, sentence.length()));
				} else {
					words.add(sentence.substring(position1, position2));
					if (blankAmount >= 2) {
						words.add(sentence.substring(position2, sentence.length()));
					}
				}

			} 
			
		}
	} else{
        	words.add(sentence);
     	}
	
}
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

测试：

Intel Super Notebook
1

SIZE:3
POSITION(0): Intel
POSITION(1): Super
POSITION(2): Notebook

Intel   Super   Notebook
1

(注这里有重复且连续的空格)
SIZE:3
POSITION(0): Intel
POSITION(1): Super
POSITION(2): Notebook

英特尔 超级  笔记本
1

SIZE:3
POSITION(0): 英特尔
POSITION(1): 超级
POSITION(2): 笔记本

华为
1

SIZE:1
POSITION(0): 华为

完整代码：

class DivideWord{
	
	private String sentence;
	private List<String> words = new ArrayList<String>();

	public DivideWord(String sentence) {
		// Replace two or three blank signal that connected into single blank signal.
		sentence = sentence.replace("  ", " ");
		sentence = sentence.replace("   ", " ");
		this.sentence = sentence;
	}
	
	private int countBlank(String s){
		// Store single blank signal.
		int amount = 0;

		// If s contains single blank signal, and it will increse amount's value of 1 every loop times.
		for(int i = 0; i < s.length(); i++){
			if(String.valueOf(sentence.charAt(i)).equals(" ")){
				amount++;
			}
		}
		return amount;
	}
	
	private int firstPosition(){
		int first = 0;
		for(int i = 0; i < sentence.length(); i++){
			if(String.valueOf(sentence.charAt(i)).equals(" ")){
				first = i;
				return first;
			}	
		}
		return first;
	}
	
	private int secondPosition(){
		int second = 0;
		for(int i = (firstPosition() + 1); i < sentence.length(); i++){
			if(String.valueOf(sentence.charAt(i)).equals(" ")){
				second = i;
				return second;
			}	
		}
		return second;
	}
	
	public String divide(){
		// Record every single blank signal's position.
		int position1 = firstPosition();
		int position2 = secondPosition();
		
		if(sentence.contains(" ")){
			int blankAmount = countBlank(sentence);
			if (blankAmount >= 0) {
				words.add(sentence.substring(0, position1));
				if (blankAmount >= 1) {
					if(blankAmount >= 1 && blankAmount < 2){
						words.add(sentence.substring(position1, sentence.length()));
					} else {
						words.add(sentence.substring(position1, position2));
						if (blankAmount >= 2) {
							words.add(sentence.substring(position2, sentence.length()));
						}
					}
	
				} 
				
			}
		} else{
        	words.add(sentence);
     	}
	}
	
	public int getSize(){
		return words.size();
	}
	
	public String getWord(int position){
		return words.get(position);
	}
}

public class DateGet {
	public static void main(String[] args){
		DivideWord divideWord = new DivideWord("英特尔");
		divideWord.divide();
		System.out.println("SIZE:" + divideWord.getSize());
		System.out.println("POSITION :" + divideWord.getWord(0));
		
	}
}
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