理解需求：整数到二进制布尔数组的转换
在java编程中，有时我们需要将一个整数的二进制表示形式转换为布尔数组，其中 true 代表二进制位 1，false 代表二进制位 0。这个过程涉及两个关键点：
- 位序问题： 二进制表示可以是从低位到高位（LSB-first，即数组索引0对应最低位），也可以是从高位到低位（MSB-first，即数组索引0对应最高位）。实际应用中，MSB-first更符合直观阅读习惯。
- 固定长度： 有时需要生成的布尔数组具有特定的长度，这意味着可能需要用前导 false（即 0）进行填充。
例如，整数 12 的二进制是 1100。
- 如果期望输出 {True, True, False, False}，这表示 MSB-first。
- 如果期望输出 {False, False, True, True}，这表示 LSB-first。
对于整数 15 (二进制 1111)，如果要求固定长度为 6，则期望输出 {False, False, True, True, True, True} (即 001111)。
使用 java.util.BitSet 进行转换
java.util.BitSet 是Java中一个强大的工具类，专门用于处理位向量。它提供了一种高效且内存友好的方式来存储和操作一系列布尔值（位）。
1. BitSet 的基本用法
BitSet.valueOf(long[] longs) 方法可以将一个或多个 long 值转换为 BitSet。对于单个 int，我们可以将其转换为 long 数组再传入。
立即学习“Java免费学习笔记（深入）”；
示例代码 1：将整数转换为 BitSet
import java.util.BitSet;
public class IntegerToBitSet {
public static void main(String[] args) {
int input1 = 12;
BitSet bitSet1 = BitSet.valueOf(new long[]{input1});
System.out.println("Input: " + input1 + ", BitSet: " + bitSet1);
// 输出: Input: 12, BitSet: {2, 3} (表示位索引2和3被设置)
int input2 = 15;
BitSet bitSet2 = BitSet.valueOf(new long[]{input2});
System.out.println("Input: " + input2 + ", BitSet: " + bitSet2);
// 输出: Input: 15, BitSet: {0, 1, 2, 3} (表示位索引0,1,2,3被设置)
}
}注意事项：
- BitSet 默认采用 LSB-first 的方式存储位。索引 0 对应最低有效位（LSB）。
- BitSet.toString() 方法输出的是所有被设置为 true 的位的索引列表。
2. 从 BitSet 到 MSB-first 布尔数组（动态长度）
由于 BitSet 默认是 LSB-first，而我们通常期望 MSB-first 的布尔数组，因此需要进行转换。我们可以通过迭代 BitSet 的位并反向填充布尔数组来实现。
示例代码 2：从 BitSet 生成 MSB-first 布尔数组（动态长度）
import java.util.BitSet;
import java.util.Arrays;
public class BitSetToBooleanArray {
/**
* 将BitSet转换为MSB-first的布尔数组。
* 数组的长度由BitSet的实际长度决定。
* @param bitSet 要转换的BitSet
* @return MSB-first的布尔数组
*/
public static boolean[] toMsbFirstBooleanArray(BitSet bitSet) {
int len = bitSet.length(); // 获取BitSet中最高设置位的索引+1
if (len == 0 && bitSet.isEmpty()) { // 如果BitSet为空，例如0
return new boolean[]{false}; // 至少返回一个false
}
boolean[] result = new boolean[len];
for (int i = 0; i < len; i++) {
// BitSet.get(i) 获取的是第i位的值 (LSB-first)
// 我们需要将其映射到MSB-first数组的相应位置
result[len - 1 - i] = bitSet.get(i);
}
return result;
}
public static void main(String[] args) {
int input1 = 12; // 二进制 1100
BitSet bitSet1 = BitSet.valueOf(new long[]{input1});
boolean[] arr1 = toMsbFirstBooleanArray(bitSet1);
System.out.println("Input: " + input1 + ", MSB-first Boolean Array: " + Arrays.toString(arr1));
// 期望输出: {true, true, false, false}
int input2 = 15; // 二进制 1111
BitSet bitSet2 = BitSet.valueOf(new long[]{input2});
boolean[] arr2 = toMsbFirstBooleanArray(bitSet2);
System.out.println("Input: " + input2 + ", MSB-first Boolean Array: " + Arrays.toString(arr2));
// 期望输出: {true, true, true, true}
int input3 = 0; // 二进制 0
BitSet bitSet3 = BitSet.valueOf(new long[]{input3});
boolean[] arr3 = toMsbFirstBooleanArray(bitSet3);
System.out.println("Input: " + input3 + ", MSB-first Boolean Array: " + Arrays.toString(arr3));
// 期望输出: {false}
}
}3. 生成固定长度的 MSB-first 布尔数组
当需要指定布尔数组的长度时，我们需要在转换过程中进行填充。这通常意味着在最高有效位之前添加 false。
示例代码 3：生成固定长度的 MSB-first 布尔数组
import java.util.BitSet;
import java.util.Arrays;
public class FixedLengthBooleanArray {
/**
* 将整数转换为指定长度的MSB-first布尔数组。
* 如果整数的二进制表示短于指定长度，则用false进行前导填充。
* @param value 待转换的整数
* @param length 期望的布尔数组长度
* @return 固定长度的MSB-first布尔数组
* @throws IllegalArgumentException 如果指定长度小于表示该整数所需的最小位数
*/
public static boolean[] toFixedLengthMsbFirstBooleanArray(int value, int length) {
if (length < 0) {
throw new IllegalArgumentException("Length cannot be negative.");
}
// 对于负数，Java的BitSet.valueOf(long[])会将其解释为无符号数，
// 行为可能与预期不符。本例主要针对非负整数。
if (value < 0) {
// 负数处理可能需要更复杂的逻辑，例如补码表示
// 这里简化为抛出异常或根据需求处理
throw new IllegalArgumentException("Negative integers are not directly supported in this simplified example for fixed-length MSB conversion.");
}
BitSet bitSet = BitSet.valueOf(new long[]{value});
int actualBitsNeeded = bitSet.length(); // 实际需要的位数 (最高设置位索引+1)
// 如果输入是0，bitSet.length()为0，但我们至少需要一个位来表示0
if (value == 0 && actualBitsNeeded == 0) {
actualBitsNeeded = 1;
}
if (length < actualBitsNeeded) {
throw new IllegalArgumentException("Specified length (" + length +
") is too short to represent the integer " + value +
" (needs at least " + actualBitsNeeded + " bits).");
}
boolean[] result = new boolean[length];
// 默认情况下，boolean数组元素初始化为false，这正好用于前导填充
for (int i = 0; i < actualBitsNeeded; i++) {
// 将BitSet的LSB-first位映射到结果数组的MSB-first位置
// 结果数组的最后一个元素对应BitSet的第0位 (LSB)
// 结果数组的倒数第二个元素对应BitSet的第1位，以此类推
result[length - 1 - i] = bitSet.get(i);
}
return result;
}
public static void main(String[] args) {
int input1 = 12; // 二进制 1100
int length1 = 4;
boolean[] arr1 = toFixedLengthMsbFirstBooleanArray(input1, length1);
System.out.println("Input: " + input1 + ", Length: " + length1 +
", MSB-first Boolean Array: " + Arrays.toString(arr1));
// 期望输出: {true, true, false, false}
int input2 = 15; // 二进制 1111
int length2 = 6;
boolean[] arr2 = toFixedLengthMsbFirstBooleanArray(input2, length2);
System.out.println("Input: " + input2 + ", Length: " + length2 +
", MSB-first Boolean Array: " + Arrays.toString(arr2));
// 期望输出: {false, false, true, true, true, true}
int input3 = 5; // 二进制 101
int length3 = 8;
boolean[] arr3 = toFixedLengthMsbFirstBooleanArray(input3, length3);
System.out.println("Input: " + input3 + ", Length: " + length3 +
", MSB-first Boolean Array: " + Arrays.toString(arr3));
// 期望输出: {false, false, false, false, false, true, false, true}
int input4 = 0; // 二进制 0
int length4 = 3;
boolean[] arr4 = toFixedLengthMsbFirstBooleanArray(input4, length4);
System.out.println("Input: " + input4 + ", Length: " + length4 +
", MSB-first Boolean Array: " + Arrays.toString(arr4));
// 期望输出: {false, false, false}
// 尝试非法长度
try {
toFixedLengthMsbFirstBooleanArray(12, 3); // 12需要4位，指定3位会报错
} catch (IllegalArgumentException e) {
System.err.println("Error: " + e.getMessage());
}
}
}替代方案：位运算符
对于不涉及复杂位操作且性能要求极致的场景，或者当 BitSet 显得过于重量级时，可以直接使用位运算符 (>> 右移, & 按位与, 1 掩码) 来实现整数到布尔数组的转换。这种方法通常更直接，但需要手动管理位序和长度。
示例代码 4：使用位运算符生成固定长度的 MSB-first 布尔数组
import java.util.Arrays;
public class BitwiseOperatorToBooleanArray {
/**
* 使用位运算符将整数转换为指定长度的MSB-first布尔数组。
* @param value 待转换的整数
* @param length 期望的布尔数组长度
* @return 固定长度的MSB-first布尔数组
* @throws IllegalArgumentException 如果指定长度小于表示该整数所需的最小位数
*/
public static boolean[] toFixedLengthMsbFirstBooleanArrayBitwise(int value, int length) {
if (length < 0) {
throw new IllegalArgumentException("Length cannot be negative.");
}
// 对于负数，Java的右移(>>)会进行符号位扩展。
// 如果需要处理负数的补码表示，需要更复杂的逻辑，例如使用 >>> 无符号右移。
// 本例主要针对非负整数的二进制表示。
if (value < 0) {
throw new IllegalArgumentException("Negative integers are not directly supported in this simplified example for fixed-length MSB conversion.");
}
// 计算实际需要的位数
int actualBitsNeeded = (value == 0) ? 1 : (Integer.SIZE - Integer.numberOfLeadingZeros(value));
if (length < actualBitsNeeded) {
throw new IllegalArgumentException("Specified length (" + length +
") is too short to represent the integer " + value +
" (needs at least " + actualBitsNeeded + " bits).");
}
boolean[] result = new boolean[length];
// 数组默认填充false，用于前导0
for (int i = 0; i < length; i++) {
// 从最高位开始遍历
// (value >> (length - 1 - i)) 将当前要检查的位移动到最低位
// & 1 用于检查最低位是否为1
result[i] = ((value >> (length - 1 - i)) & 1) == 1;
}
return result;
}
public static void main(String[] args) {
int input1 = 12; // 二进制 1100
int length1 = 4;
boolean[] arr1 = toFixedLengthMsbFirstBooleanArrayBitwise(input1, length1);
System.out.println("Input: " + input1 + ", Length: " + length1 +
", MSB-first Boolean Array (Bitwise): " + Arrays.toString(arr1));
// 期望输出: {true, true, false, false}
int input2 = 15; // 二进制 1111
int length2 = 6;
boolean[] arr2 = toFixedLengthMsbFirstBooleanArrayBitwise(input2, length2);
System.out.println("Input: " + input2 + ", Length: " + length2 +
", MSB-first Boolean Array (Bitwise): " + Arrays.toString(arr2));
// 期望输出: {false, false, true, true, true, true}
int input3 = 5; // 二进制 101
int length3 = 8;
boolean[] arr3 = toFixedLengthMsbFirstBooleanArrayBitwise(input3, length3);
System.out.println("Input: " + input3 + ", Length: " + length3 +
", MSB-first Boolean Array (Bitwise): " + Arrays.toString(arr3));
// 期望输出: {false, false, false, false, false, true, false, true}
int input4 = 0; // 二进制 0
int length4 = 3;
boolean[] arr4 = toFixedLengthMsbFirstBooleanArrayBitwise(input4, length4);
System.out.println("Input: " + input4 + ", Length: " + length4 +
", MSB-first Boolean Array (Bitwise): " + Arrays.toString(arr4));
// 期望输出: {false, false, false}
// 尝试非法长度
try {
toFixedLengthMsbFirstBooleanArrayBitwise(12, 3);
} catch (IllegalArgumentException e) {
System.err.println("Error: " + e.getMessage());
}
}
}注意事项与性能考量
- BitSet 的优势： BitSet 在处理大量位（例如，超过 int 或 long 的范围）、需要进行复杂位操作（如 AND, OR, XOR, NOT）或动态增长的位序列时表现出色。它的内部实现通常比 boolean[] 更节省内存，因为它将多个布尔值打包存储在一个 long 中。
- 位运算符的优势： 对于简单的整数到布尔数组转换，尤其是在已知固定长度
