这篇文章主要讲解了“java二进制多字段匹配的方法”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“java二进制多字段匹配的方法”吧！
package util;
/**
* <pre>
* 将多个int正整型合并为一个long型进行存储，并通过xor运算计算两组int是否匹配
* MultiEnumVal64 int正整数取值必须大于0，0值用于MultiVal64本身特殊计算使用，<=0表示不参与匹配计算。
* 如：业务中需要根据行人是否戴眼镜、是否戴帽子、衣服颜色来进行查询
* 是否戴眼镜取值： 1 未知 ; 2 戴眼镜 ; 3 不带眼镜 ;
* 是否戴帽子取值： 1 未知 ; 2 戴帽子 ; 3 不带帽子 ;
* 衣服的颜色取值： 1 未知 ; 2 红色 ; 3 绿色 ; 4 白色 ;
* </br>
* 假设某一个抓拍体型数据为：眼镜=2; 帽子=1; 颜色=4
* 1、构建MultiVal64数据
* <code>
* MultiEnumVal64 mv64 = new MultiEnumVal64(3,3,4); //创建MultiVal64对象，定义每一种属性的最大取值 ，定义的顺序为：眼镜、帽子、颜色
* mv64.build(2,1,4); //构造数据
* long longVal = mv64.getLong(); //获取long值，可存储于数据库
* </code>
* 2、java编码匹配MultiVal64数据 ，沿用1、的例子
* a、场景1查询条件是：戴着帽子且戴着眼镜
* <code>
* MultiEnumVal64 mv642 = new MultiEnumVal64(3,3,4); //创建MultiVal64对象，定义每一种属性的最大取值 ，定义的顺序为：眼镜、帽子、颜色
* mv642.build(2,2,-1); //构造数据，-1表示不参与匹配，原始数据不论取何值都可以匹配成功
* System.out.printl(mv642.xorTrue(mv64)); //匹配数据，该场景返回false，因为是否戴眼镜项匹配不成功
* </code>
* b、场景1查询条件是：戴着眼镜穿白色衣服
* <code>
* MultiEnumVal64 mv643 = new MultiEnumVal64(3,3,4); //创建MultiVal64对象，定义每一种属性的最大取值 ，定义的顺序为：眼镜、帽子、颜色
* mv643.build(2,-1,4); //构造数据，-1表示不参与匹配，原始数据不论取何值都可以匹配成功
* System.out.printl(mv643.xorTrue(mv64)); //匹配数据，该场景返回true
* </code>
* 3、数据库sql写法1，以场景2.->b为例
* <code>
* String sql = "";
* if(mv643.isHasIgnoreVal()) {
* sql = "select * from table where column_name (";
* for (int[] pos : mv643.getIgnorePos()) {
* if (pos[0] > 0 || pos[1] > 0) {
* for (int start = pos[1]; start <= pos[0]; start++) {
* sql + "& ~(1 << " + start + ")";
* }
* }
* }
* sql += ") ^ " + mv643.getLong() + " = 0;";
* } else {
* sql = "select * from table where column_name ^ " + mv643.getLong() + " =0;";
* }
* </code>
* 4、数据库sql写法2，以场景2.->b为例
* <code>
* String sql = "";
* if(mv643.isHasIgnoreVal()) {
* sql = "select * from table where (column_name & ~";
* sql += mv643.getComparVal();
* sql += ") ^ " + mv643.getLong() + " = 0;";
* } else {
* sql = "select * from table where column_name ^ " + mv643.getLong() + " =0;";
* }
* </code>
* </pre>
*
*/
public class MultiEnumVal64 {
/**
* 所有属性最大值二进制的长度容器
*/
private int[] config;
/**
* 忽略不参与匹配值的位置
*/
private int[][] ignorePos;
/**
* 二进制数值
*/
private long longVal;
/**
* 所有属性最大值二进制的长度综合
*/
private int length;
/**
* 是否有不参与匹配标识
*/
private boolean hasIgnoreVal = false;
/**
* 每一组int取值的最大值
*
* @param maxValConfig
*/
public MultiEnumVal64(int... maxValConfig) {
this.config = new int[maxValConfig.length];
this.ignorePos = new int[maxValConfig.length][2];
for (int index = 0; index < maxValConfig.length; index++) {
int maxVal = maxValConfig[index];
if (maxVal < 0) {
throw new IllegalArgumentException("value must be greater than 0");
}
int tempLength = Integer.toBinaryString(maxVal).length();
this.config[index] = tempLength;
length += tempLength;
}
if (length + 1 > 63) {
throw new IllegalArgumentException(length + " over the maximum digit 62");
}
}
/**
* 数值<=0 表示不参与计算
*
* values要把所有值按顺序传入，比如说总共有10个属性，只匹配一个属性，要把剩下9个属性补上，用不参与匹配-1或0补位
*
* @param values
* @return
*/
public MultiEnumVal64 build(int... values) {
if (values.length != this.config.length) {
throw new IllegalArgumentException("value array length and config mismatch, config length is " + this.config.length
+ " , but value array length is " + values.length);
}
/**
* 符号位最左边
*/
StringBuilder binaryStr = new StringBuilder("1");
/**
* 记录不参与匹配属性的下标
*/
int preLength = 1;
for (int i = 0; i < values.length; i++) {
int binaryLength = this.config[i];
int maxConfigVal = (1 << binaryLength);
int val = values[i];
/**
* 当前属性值不能大于初始所规定当前属性的最大值
*/
if (val > maxConfigVal) {
throw new IllegalArgumentException("the " + i + " value should be less than or equal to " + maxConfigVal);
}
/**
* 如果有不参与的属性标记为true，用0把最大占位补满
*/
if (val <= 0) {
hasIgnoreVal = true;
for (int j = 0; j < binaryLength; j++) {
binaryStr.append("0");
}
/**
* 记录不参与属性的位置
*/
ignorePos[i][0] = this.length - preLength;
ignorePos[i][1] = this.length - preLength - (this.config[i] - 1);
} else {
/**
* 以下全是参与的属性，十进制转换二进制
*/
String binaryVal = Integer.toBinaryString(val);
/**
* 如果当前二进制值长度比初始最大值小，那么用0补位
*/
for (int j = 0; j < binaryLength - binaryVal.length(); j++) {
binaryStr.append("0");
}
binaryStr.append(binaryVal);
/**
* 用-1表示该属性不被忽略，所以不需要记录被忽略的位置
*/
ignorePos[i][0] = -1;
ignorePos[i][1] = -1;
}
/**
* 实时追加下标才能准确计算到每个属性的在二进制中的位置
*/
preLength += binaryLength;
}
/**
* 将拼接成的二进制转换为十进制
*/
this.longVal = Long.parseLong(binaryStr.toString(), 2);
return this;
}
public MultiEnumVal64 build(long val) {
this.longVal = val;
build(getVals());
return this;
}
public long getLong() {
return longVal;
}
/**
* 将处理过的二进制通过字符截取还原成数组
* @return
*/
public int[] getVals() {
int[] values = new int[this.config.length];
String binary = Long.toBinaryString(getLong());
int binaryLength = binary.length();
int endIndex = binaryLength;
for (int i = this.config.length - 1; i >= 0; i--) {
int startIndex = endIndex - this.config[i];
if (startIndex < 1) {
if (endIndex > 1) {
startIndex = 1;
values[i] = Integer.parseInt(binary.substring(startIndex, endIndex), 2);
} else {
values[i] = -1;
}
} else {
values[i] = Integer.parseInt(binary.substring(startIndex, endIndex), 2);
}
if (values[i] == 0) {
values[i] = -1;
}
endIndex = startIndex;
}
return values;
}
public int[][] getIgnorePos() {
return ignorePos;
}
public int getLength() {
return length;
}
public long getComparVal() {
long m1 = 0L;
if (hasIgnoreVal) {
for (int[] pos : ignorePos) {
if (pos[0] > 0 || pos[1] > 0) {
for (int start = pos[1]; start <= pos[0]; start++) {
m1 = m1 ^ (1L << start);
}
}
}
}
return m1;
}
public long transform(long val) {
return val &~ getComparVal();
}
public long xor(long val) {
long v1 = transform(val);
return v1 ^ getLong();
}
public long xor(MultiEnumVal64 mv) {
return xor(mv.getLong());
}
public boolean xorTrue(long val) {
return xor(val) == 0;
}
public boolean xorTrue(MultiEnumVal64 mv) {
return xor(mv) == 0;
}
public boolean isHasIgnoreVal() {
return hasIgnoreVal;
}
}感谢各位的阅读，以上就是“java二进制多字段匹配的方法”的内容了，经过本文的学习后，相信大家对java二进制多字段匹配的方法这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是亿速云，小编将为大家推送更多相关知识点的文章，欢迎关注！
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
