我有一个遗留应用程序，它接受整数、将其转换为二进制字符串，反转该字符串，然后获取位（一）的位置作为整数列表。例如：
6 -> "110" -> "011" -> (2,3)
7 -> "111" -> "111" -> (1,2,3)
8 -> "1000" -> "0001" -> (4)
在现代Java中，没有使用String操作，如何简洁明了地完成这个任务？将其转换为String然后再转回来似乎很浪费，而且我知道没有简单的方法来翻转一个字符串（没有String.reverse()）。
依次检查每一位：
List<Integer> bits(int num) {
List<Integer> setBits = new ArrayList<>();
for (int i = 1; num != 0; ++i, num >>>= 1) {
if ((num & 1) != 0) setBits.add(i);
}
return setBits;
}
6 [2, 3]
7 [1, 2, 3]
8 [4]
num & (1<<i) 或其他东西更有效，同时也使位编号在初始化 i 方面是任意的。 - Peter Cordes你可以直接测试比特位，而无需将整数转换为字符串：
List<Integer> onePositions(int input) {
List<Integer> onePositions = new ArrayList<>();
for (int bit = 0; bit < 32; bit++) {
if (input & (1 << bit) != 0) {
onePositions.add(bit + 1); // One-based, for better or worse.
}
}
return onePositions;
}
比特通常从右向左计数，最右边的比特为第0位。操作1<<bit会给你一个int，其中编号为bit的比特位被设置为1（其余位为0）。然后使用&（按位与）检查此比特位在input中是否被设置，并且如果是，则记录输出数组中的位置。
maxBit = Integer.highestOneBit(input)，然后将bit <= maxBit用作循环保护（并从bit = Integer.lowestOneBit(input)开始，就此而言）。 - Andy Turnerinput & (1 << bit) 周围加上括号，因为 != 的优先级高于 &。（在我看来，这是 Java 中的一个错误，因为它没有任何用处）。我认为这个答案是最好的，因为它最易读。你可以像 Matthieu 的答案中所做的那样，将 Integer.bitCount(input) 传递给 ArrayList 的构造函数，以稍微提高性能。 - user427231，将被测试的数字右移更好。首先，它避免了任何变量计数移位，这可能具有优势（例如，在现代英特尔 CPU 上，如果 JIT 编译器没有将其优化为 bt 指令，则需要 3 个 uops 而不是 1）。其次，当 input >>>= 1 变为 0 时，它可以免费提供早期退出。在循环传递依赖链中使用右移作为一部分是可以的；现代 CPU 具有单周期延迟移位。 - Peter Cordes我可以提出一个纯位运算的解决方案吗？
static List<Integer> onesPositions(int input)
{
List<Integer> result = new ArrayList<Integer>(Integer.bitCount(input));
while (input != 0)
{
int one = Integer.lowestOneBit(input);
input = input - one;
result.add(Integer.numberOfTrailingZeros(one));
}
return result;
}
这种解决方案在算法上是最优的:
Integer.bitCount 来预先适当地调整 ArrayList 的大小。
- 循环迭代的次数最少，每组一次1。
内部循环非常简单：
Integer.lowestOneBit 返回一个只有输入中最低位的 int 。input - one 取消设置输入的此位，以用于下一次迭代。 Integer.numberOfTrailingZeros 计算二进制下的末尾零的数量，有效地给出了最低 1 位的索引。
1 值得注意的是，一旦编译，这可能不是最优的方式，并且相反，基于 bitCount 的显式 0..n 循环更容易为 JIT 展开。
add CTZ（input）/ blsr input，即使用input＆= input-1;清除最低位。即使JITter不使用x86 BMI2 [blsr]（https://www.felixcloutier.com/x86/blsr），也很容易使用几个指令实现。或者如果JIT仍然无法使用LEA孔洞优化，则为3，并且最终的AND根据“input”设置FLAGS，从而为循环分支节省了cmp / test。除非HotSpot JIT也搞砸了。希望HotSpot知道“tzcnt”或“bsf”具有输出依赖性... - Peter Cordesblsr 是 BMI1 指令，而非 BMI2。 - Peter CordesInteger.lowestOneBit(…) 已经被实现为 return i & -i;。无论 JIT 是否理解这个习惯用法，调用这个方法永远不会比手动执行 input&=input-1; 更糟糕。 - Holgerinput = input - one;。这缩短了循环依赖链的延迟时间。(如果使用BMI1 blsr而不是blsi / sub，或者只有1个周期，如果JIT不那么聪明)。 - Peter Cordesi & -i;可能比i & (i-1)更糟糕，这取决于JIT编译器。例如，可以使用lea eax，[rdi-1]将i-1计算到一个单独的寄存器中，但是计算-i而不破坏原始的i通常需要mov+neg，或者使用异或零寄存器来从中减去sub。（x86-64没有任何地址模式可以从任何东西中减去一个寄存器）。因此，对于可以使用LEA的编译器而言，如果没有BMI1 peepholes（并且它是否可用），则i & (i-1)的计算成本可能更低。（我不知道当前的JVM是否这样做）。 - Peter Cordes既然你提到“现代Java”，那么以下是使用流（Java 8或更高版本）的实现方式：
final int num = 7;
List<Integer> digits = IntStream.range(0,31).filter(i-> ((num & 1<<i) != 0))
.map(i -> i+1).boxed().collect(Collectors.toList());
这张地图仅在你从1开始计数而不是从0开始计数时才需要。
然后
System.out.println(digits);
打印
[1, 2, 3]
BitSet.valueOf(new long[] { num }).stream().map(i -> i + 1) - Holger我个人肯定更倾向于安迪的回答，尽管一开始它似乎有些神秘。但由于这里没有人给出使用流(streams)的答案（即使它们在这里完全不合适）:
我个人肯定更喜欢安迪的答案，即使一开始它看起来有点难懂。但是由于这里还没有人给出流(streams)方面的答案（即使它们在这里完全不适用）：
public List<Integer> getList(int x) {
String str = Integer.toBinaryString(x);
final String reversed = new StringBuilder(str).reverse().toString();
return IntStream.range(1, str.length()+1)
.filter(i -> reversed.charAt(i-1)=='1')
.boxed()
.collect(Collectors.toList());
}
IntStream.rangeClosed(1, str.length()) 对我来说更整洁。 - Andy Turner一个愚蠢的答案，只是为了增加趣味性：
BitSet bs = BitSet.valueOf(new long[] {0xFFFFFFFFL & input});
List<Integer> setBits = new ArrayList<>();
for (int next = -1; (next = bs.nextSetBit(next + 1)) != -1;) {
setBits.add(next + 1);
}
(感谢pero_hero指出需要对WJS的答案进行掩蔽)
给定原始整数，返回一个包含每个二进制位的位置的列表。
static List<Integer> bitPositions(int v) {
return BitSet.valueOf(new long[]{v&0xFF_FF_FF_FFL})
.stream()
.mapToObj(b->b+1)
.collect(Collectors.toList());
}
或者，如果您想进行位移操作。
static List<Integer> bitPositions(int v ) {
List<Integer> bits = new ArrayList<>();
int pos = 1;
while (v != 0) {
if ((v & 1) == 1) {
bits.add(pos);
}
pos++;
v >>>= 1;
}
return bits;
}
String str = Integer.toBinaryString(num);
int len = str.length();
List<Integer> list = new ArrayList<>();
for (int i=0; i < len; i ++) {
if (str.charAt(i) == '1') list.add(len - 1 - i);
}
Pattern one = Pattern.compile("1");
List<Integer> collect = one.matcher(
new StringBuilder(Integer.toBinaryString(value)).reverse())
.results()
.map(m -> m.start() + 1)
.collect(Collectors.toList());
System.out.println(collect);
List<Integer> list = IntStream.iterate(value, (v) -> v != 0, (v) -> v & (v - 1))
.mapToObj(val -> Integer.numberOfTrailingZeros(val) + 1)
.collect(toList());
new StringBuilder(s).reverse().toString()可以用来翻转字符串 s。 - David Conrad