基于逻辑表达式的集合运算

课题：基于逻辑表达式的集合运算

需求：

实际项目开发中，我们可能会有这样的需求，有A、B、C、D四个集合，需要对这四个集合进行一定的逻辑运算，从而得到经过该表达式运算之后的最终的集合情况。

实例：

1、假设现在有四个集合元素分别为：

A集合：20，50，60

B集合：70，80

C集合：90，100

D集合：30，70，80

2、运算表达式为：（A∪B）∩（C∪D）

3、我们想要的最终集合为：70，80.

A∪B = 20，50，60，70，80

C∪D = 90，100，70，80，30

（A∪B）∩（C∪D）= 70，80

步骤：

1、建立操作模型。

逻辑表达式的解析，一般思路就是依据运算符号（包括括号）优先级下坠，构建成树状结构。所以我们建立的模型如下：

LogicExpression｛

LogicExpression left;//左分支

LogicExpression right;//右分支

Collection data;//数据集合

｝

2、解析逻辑表达式，根据表达式初始化操作模型的树状结构。

3、根据集合索引，向树状结构的操作模型中各个节点分发数据集合。

4、根据树模型的中序遍历规则，将各个节点的左右俩分支的数据集合进行运算。

5、最后得到根节点的数据集合，即为所求。

源码：

package tools;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

/**
* 逻辑表达式或数值表达式的解析成表达式树结构
*
* @author 高伟
* @date May 29, 2012 8:51:49 AM
* @description:
*/
public class LogicExpression {

private String separators = "∩∪()";
private String[] operators = { "∩", "∪" };

/*
* 树节点数据
*/
private String data = null;
/*
* 树节点左分支
*/
private LogicExpression left = null;
/*
* 树节点右分支
*/
private LogicExpression right = null;
/*
* 树节点集合数据
*/
private Collection<Object> dataList = new ArrayList<Object>();

private String exp = "";
private List<String> parts = new ArrayList<String>();
private int numOperators = 0;

public LogicExpression(String exp) throws RuntimeException {
this(exp, "∩∪()", new String[]{ "∩", "∪" });
}

private LogicExpression(String exp, String separators, String[] operators) throws RuntimeException {
this.separators = separators;
this.operators = operators;
this.exp = exp;
splitExpression(exp);
parseSyntax();
}

/**
* 打印解析后表达式树结构，按照前序遍历。
*
* printTree
* 高伟
* May 29, 2012 8:59:43 AM
*/
public void printTree()
{
System.out.println(data);
if ( left !=null ) left.printTree();
if ( right != null ) right.printTree();
}

/**
* 将集合Map分发到树的每个节点
*
* walkMap
* @param map
* 高伟
* May 29, 2012 9:00:26 AM
*/
public void walkMap(Map<String, Collection<Object>> map)
{
if ( left != null ) left.walkMap(map);
if("∩".equals(data) || "∪".equals(data) || "(".equals(data) || ")".equals(data)){
}else{
dataList = map.get(data);
}
if ( right != null ) right.walkMap(map);
}

/**
* 按照先左后右的顺序合并所有节点的集合
*
* combin
* 高伟
* May 29, 2012 9:00:55 AM
*/
public void combin()
{
if(left != null ){
left.combin();
dataList.addAll(left.dataList);
}
if(right != null ){
right.combin();
if("∩".equals(data)){
dataList.retainAll(right.dataList);
}else if("∪".equals(data)){
dataList.addAll(right.dataList);
}
}
}

/**
* 分隔表达式
*
* splitExpression
* @param Expression
* 高伟
* May 29, 2012 9:03:55 AM
*/
private void splitExpression(String Expression) {
StringTokenizer statements = new StringTokenizer(Expression, separators, true);
String tempToken;

parts.clear();
numOperators = 0;

while (statements.hasMoreElements()) {
tempToken = (String) statements.nextElement();

for (int i = 0; i < operators.length; i++)
if (tempToken.equals(operators[i]))
numOperators++;

parts.add(tempToken);
}
}

/**
* 解析表达式为树结构
*
* parseSyntax
* @throws RuntimeException
* 高伟
* May 29, 2012 9:04:07 AM
*/
private void parseSyntax() throws RuntimeException {
String actToken = "";
int level = 0;
int foundPriority = Integer.MAX_VALUE;
int foundLevel = Integer.MAX_VALUE;
int foundPosition = -1;
String foundOperator = "";

if (numOperators == 0) {
setData((String) parts.get(0));
return;
}

for (int position = 0; position < parts.size(); position++) {
actToken = (String) parts.get(position);

if (actToken.equals("(")) {
level++;
continue;
}
if (actToken.equals(")")) {
level--;
continue;
}

for (int prior = 0; prior < operators.length; prior++)
if (actToken.equals(operators[prior]))
if (level < foundLevel || (level == foundLevel && prior < foundPriority)) {
foundLevel = level;
foundPriority = prior;
foundPosition = position;
foundOperator = actToken;
break;
}
}

if (level != 0)
throw new RuntimeException("parseSyntax error");

if (foundLevel != Integer.MAX_VALUE && foundLevel > 0) {
if (!((String) parts.get(0)).equals("(") || !((String) parts.get(parts.size() - 1)).equals(")"))
throw new RuntimeException("parseSyntax error");

exp = exp.substring(1, exp.length() - 1);

splitExpression(exp);
parseSyntax();

return;
}

String leftPart = "";
String rightPart = "";

for (int i = 0; i < parts.size(); i++)
if (i < foundPosition)
leftPart = leftPart.concat((String) parts.get(i));
else if (i != foundPosition)
rightPart = rightPart.concat((String) parts.get(i));

setData(foundOperator);

if (leftPart.equals("") && !foundOperator.equals("")) {
setRight(new LogicExpression(rightPart));
} else {
setLeft(new LogicExpression(leftPart));
setRight(new LogicExpression(rightPart));
}
}

//get set method

public String getData() {
return data;
}

public void setData(String data) {
this.data = data;
}

public LogicExpression getLeft() {
return left;
}

public void setLeft(LogicExpression left) {
this.left = left;
}

public LogicExpression getRight() {
return right;
}

public void setRight(LogicExpression right) {
this.right = right;
}

public Collection<Object> getDataList() {
return dataList;
}

public void setDataList(Collection<Object> dataList) {
this.dataList = dataList;
}

@Override
public String toString() {
return data;
}
}

测试：

public static void main(String[] args) {
{//多层次测试
LogicExpression logExp = new LogicExpression("(A∪B)∩(C∪D)");//1、建立操作模型。2、解析逻辑表达式
logExp.printTree();//打印操作模型。
Map<String, Collection<Object>> map = new HashMap<String, Collection<Object>>();
{
List<Object> list = new ArrayList<Object>();
list.add(new Integer(20));
list.add(new Integer(50));
list.add(new Integer(60));
map.put("A", list);
}
{
List<Object> list = new ArrayList<Object>();
list.add(new Integer(70));
list.add(new Integer(80));
map.put("B", list);
}
{
List<Object> list = new ArrayList<Object>();
list.add(new Integer(90));
list.add(new Integer(100));
map.put("C", list);
}
{
List<Object> list = new ArrayList<Object>();
list.add(new Integer(30));
list.add(new Integer(70));
list.add(new Integer(80));
map.put("D", list);
}
logExp.walkMap(map);//3、根据集合索引，向树状结构的操作模型中各个节点分发数据集合。
logExp.combin();//4、根据树模型的中序遍历规则，将各个节点的左右俩分支的数据集合进行运算。
Collection<Object> list = logExp.getDataList();//5、最后得到根节点的数据集合，即为所求。
for (Object obj : list) {
System.out.println(obj);
}
}
}

结果：

70
80

总结：

godway

com.gaowei@msn.com

2012-07-04