java根据中文包含词和中文排除词,匹配文章中的命中的词组规则-创新互联
文章:"小学生刚刚步入校园生活，还在适应期，虽然坐在教室，但是思绪不知道飘到哪里去了，这也是他们想象力如此丰富的原因";
+代表与,|代码或,整个规则必须用()括起来
当排除词的规则命中其中一个时，整篇文章视为不匹配,返回false
包含词规则:"(小学生|(思绪|想象力+适应期))"
排除词规则:"(小x生)"
源码：WordMatcher.java
类文件 BoolParse.java在 我以前发布的文章《java 求字符串形式bool表达式的值》中:
import org.apache.commons.lang3.StringUtils;
import java.util.*;
import java.util.function.Function;
public class WordMatcher {
private final ListincludeExprList;
private final ListexcludeExprList;
private final MapwordMapId = new HashMap<>();
private final MapidMapWord = new HashMap<>();
private final Tree tree = new Tree();
private SethitExpr = null;
public WordMatcher(String includeExpr, String excludeExpr) {
if (StringUtils.isBlank(includeExpr)) throw new RuntimeException("包含词不能为空");
Function>function = (expr) ->{
ListexprList = new ArrayList<>();
StringBuilder newExpr = new StringBuilder();
StringBuilder word = new StringBuilder();
int level = 0;
for (char aChar : expr.toCharArray()) {
switch (aChar) {
case ' ':
continue;
case '(':
level++;
if (level == 1) continue;
if (level >1) newExpr.append(aChar);
continue;
case ')':
level--;
break;
case '|':
break;
case '+':
aChar = '&';
break;
default:
word.append(aChar);
continue;
}
String s = word.toString();
if (s.isEmpty()) {
if( level == 0) break;
throw new RuntimeException("表达式语法错误:" + expr);
}
tree.insert(s);
char id;
if (!wordMapId.containsKey(s)) {
char c = (char) (wordMapId.size() + 256);
wordMapId.put(s, c);
idMapWord.put(c, s);
id = c;
} else {
id = wordMapId.get(s);
}
word = new StringBuilder();
newExpr.append(id);
if (level >1 || (level == 1 && aChar != '|')) newExpr.append(aChar);
if (level == 1&& aChar == '|') {
exprList.add(newExpr.toString());
newExpr = new StringBuilder();
}
}
if (level != 0 || word.length() != 0) throw new RuntimeException("表达式语法错误:" + expr);
if (newExpr.length() != 0) {
exprList.add(newExpr.toString());
}
return exprList;
};
this.includeExprList = function.apply(includeExpr);
if (includeExprList.isEmpty()) throw new RuntimeException("包含词表达式不能为空");
if (StringUtils.isBlank(excludeExpr)) this.excludeExprList = new ArrayList<>();
else this.excludeExprList = function.apply(excludeExpr);
}
public boolean match(String content) {
Objects.requireNonNull(content);
if (content.isEmpty()) throw new RuntimeException("empty string");
SetexistWords = new HashSet<>();
Listbuilders = new ArrayList<>();
for (char c : content.toCharArray()) {
{
for (StringBuilder builder : builders) {
builder.append(c);
}
String str = c + "";
boolean b = tree.containsTheWord(str);
if (b) {
builders.add(new StringBuilder(str));
}
if (tree.existTheWord(str)) {
existWords.add(str);
}
}
builders.removeIf(builder ->{
if (builder.length() == 1) return false;
String str = builder.toString();
boolean b = tree.containsTheWord(str);
if (!b) return true;
boolean exist = tree.existTheWord(str);
if (exist) {
existWords.add(str);
}
return false;
});
}
for (String exclude : excludeExprList) {
for (String word : wordMapId.keySet()) {
String id = wordMapId.get(word) + "";
if (existWords.contains(word)) {
exclude = exclude.replaceAll(id + "", "T");
} else {
exclude = exclude.replaceAll(id + "", "F");
}
}
if (BoolParser.parse(exclude)) {
hitExpr = new HashSet<>();
return false;
}
}
SetexprSet = new HashSet<>();
boolean result = false;
for (String include : includeExprList) {
String includeTemp = include;
for (String word : wordMapId.keySet()) {
String id = wordMapId.get(word) + "";
if (existWords.contains(word)) {
include = include.replaceAll(id + "", "T");
} else {
include = include.replaceAll(id + "", "F");
}
}
boolean parse = BoolParser.parse(include);
if (parse) {
for (Character id : idMapWord.keySet()) {
String word = idMapWord.get(id);
includeTemp = includeTemp.replaceAll(id + "", word);
}
exprSet.add(includeTemp.replaceAll("&", "+"));
}
if (!result) result = BoolParser.parse(include);
}
hitExpr = exprSet;
return result;
}
public SethitExpr() {
if (hitExpr == null) throw new RuntimeException("请先匹配文章");
return hitExpr;
}
//字典树
private static class Tree {
private final Mapnodes = new HashMap<>();
public Tree() {
}
public void insert(String word) {
Objects.requireNonNull(word);
if (word.isEmpty()) return;
char[] chars = word.toCharArray();
Node head = nodes.computeIfAbsent(chars[0], Node::new);
for (int i = 1; i< chars.length; i++) {
char aChar = chars[i];
head = head.putChild(aChar);
}
}
public boolean containsTheWord(String word) {
Objects.requireNonNull(word);
if (word.isEmpty()) throw new RuntimeException("empty string");
char[] chars = word.toCharArray();
if (!nodes.containsKey(chars[0])) return false;
Node node = nodes.get(chars[0]);
for (int i = 1; i< chars.length; i++) {
char aChar = chars[i];
Node child = node.getChild(aChar);
if (child == null) return false;
node = child;
}
return true;
}
public boolean existTheWord(String word) {
Objects.requireNonNull(word);
if (word.isEmpty()) throw new RuntimeException("empty string");
char[] chars = word.toCharArray();
if (!nodes.containsKey(chars[0])) return false;
Node node = nodes.get(chars[0]);
for (int i = 1; i< chars.length; i++) {
char aChar = chars[i];
Node child = node.getChild(aChar);
if (child == null) return false;
node = child;
}
return node.isEnd();
}
}
private static class Node {
protected final char value;
private final MapchildNodes = new HashMap<>();
public Node(char value) {
this.value = value;
}
public Node putChild(char value) {
return childNodes.computeIfAbsent(value, Node::new);
}
public Node getChild(char value) {
return childNodes.get(value);
}
public boolean containsNode(char value) {
return childNodes.containsKey(value);
}
public boolean isEnd() {
return childNodes.isEmpty();
}
}
} 使用示例1
public static void main(String[] args) {
WordMatcher matcher = new WordMatcher("(小学生|(思绪|想象力+适应a))", "(小x生)");
boolean result = matcher.match("小学生刚刚步入校园生活，还在适应期，虽然坐在教室，但是思绪不知道飘到哪里去了，这也是他们想象力如此丰富的原因");
System.out.println(result);//false
System.out.println(matcher.hitExpr());//[]
}使用示例2
public static void main(String[] args) {
WordMatcher matcher = new WordMatcher("(小学生|(思绪|想象力+适应期))", "");
boolean result = matcher.match("小学生刚刚步入校园生活，还在适应期，虽然坐在教室，但是思绪不知道飘到哪里去了，这也是他们想象力如此丰富的原因");
System.out.println(result);//true
System.out.println(matcher.hitExpr());//[(思绪|想象力+适应期), 小学生]
}你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
分享名称：java根据中文包含词和中文排除词,匹配文章中的命中的词组规则-创新互联
本文URL：http://scyanting.com/article/igdgd.html
