给定所需的最大布尔值数，生成可能的布尔组合的最优雅方法是什么？
前任：
bool(1) -> [false], [true]
bool(2) -> [false, false], [false, true], [true, false], [true, true]
...
这是我当前的实现：
public static List<Boolean[]> bool(int n) {
return IntStream.range(0, (int) Math.pow(2, n))
.mapToObj(i -> StringUtils.leftPad(Integer.toBinaryString(i), n, '0').chars().mapToObj(c -> c != '0').toArray(Boolean[]::new))
.collect(Collectors.toList());
}
但是，我对使用整数，然后映射到带有StringUtils.leftPad的二进制文件以及返回Boolean[]而不是boolean[]的map这一事实并不满意。
有没有更好的方法可以使用流 API 在单行中做到这一点？
试试这个：
boolean[] bitSetToArray(BitSet bs, int width) {
boolean[] result = new boolean[width]; // all false
bs.stream().forEach(i -> result[i] = true);
return result;
}
List<boolean[]> bool(int n) {
return IntStream.range(0, (int)Math.pow(2, n))
.mapToObj(i -> bitSetToArray(BitSet.valueOf(new long[] { i }), n))
.collect(toList());
}
关键是BitSet有一个stream()方法，该方法返回一位的索引流。这可用于将true值设置到boolean[]中。另请注意，（如Bubletan）可以有一个List<boolean[]>而不是List<Boolean[]>。也就是说，基元boolean值数组的列表，而不是盒装Boolean值数组的列表。（这是因为数组是引用类型，因此可以用作类型参数。
最后，感谢Bubletan，我通过添加bitSetToArray()来增强其解决方案。
更新
Srborlongan在评论中询问以下是否更好：
List<boolean[]> bool(int n) {
return IntStream.range(0, (int)Math.pow(2, n))
.mapToObj(i -> new long[] { i })
.map(BitSet::valueOf)
.map(bs -> bitSetToArray(bs, n))
.collect(toList());
}
它确实具有密度较低的优点。毕竟，这不是代码高尔夫，APL或Perl，其目标似乎是以最简洁的方式编写一些东西。密度较低的代码通常（但并非总是）更易于阅读和理解。
不过，我认为在这种情况下有一些细微差别。mapToObj级发出的"obj"是long[]，可以推断为BitSet::valueOf的参数类型。这反过来又会影响过载分辨率！除非您已经非常熟悉 BitSet API，否则您必须自己进行一些类型推断才能弄清楚这是在做什么。因此，在这种情况下，最好对BitSet.valueOf(long[])进行直接方法调用。
在性能方面 - 这并不总是重中之重 - 我认为直接方法调用可能比map操作链表现得更好。通过额外的流操作传递值可能涉及两个方法调用，以及 Lambda 元工厂调用额外 lambda 的开销。此外，与通过流传递值相比，直接方法调用可能更容易通过 JIT 和内联进行优化。但我还没有验证任何这些。
尝试了一些东西。不对所有内容使用 Stream API。虽然我认为不可能用它创建一个boolean[]。没有经常使用它，所以我可能是错的。
public static List<boolean[]> bool(int n) {
return IntStream.range(0, 1 << n)
.mapToObj(i -> BitSet.valueOf(new long[] {i}))
.map(bs -> {
boolean[] a = new boolean[n];
for (int i = 0; i < n; i++) {
a[n - i - 1] = bs.get(i);
}
return a;
})
.collect(Collectors.toList());
}
如果必须Stream s：
public static List<boolean[]> bool(int n) {
return IntStream.range(0, 1<<n).mapToObj(
i->IntStream.range(0, n)
.collect(()->new boolean[n], (ba,j)->ba[j]=((i>>>j)&1)!=0,
(x,y)->{throw new UnsupportedOperationException();})
).collect(Collectors.toList());
}
我省略了两个boolean[]数组未使用的合并函数，尽管可以提供这样的函数。但尤其是内部Stream代码与直接循环相比并不是一个很大的胜利：
public static List<boolean[]> bool(int n) {
return IntStream.range(0, 1<<n).mapToObj(i-> {
boolean[] ba=new boolean[n];
for(int j=0; j<n; j++) ba[j]=((i>>>j)&1)!=0;
return ba;
}).collect(Collectors.toList());
}
只是一种单行 - 它给你一个Iterator而不是一个List但它演示了计数的原则，并将计数的每个位呈现为boolean。
public static Iterator<Boolean[]> bool(final int n) {
return new Iterator<Boolean[]>() {
final BigInteger max = BigInteger.ONE.shiftLeft(n);
BigInteger next = BigInteger.ZERO;
@Override
public boolean hasNext() {
return next.compareTo(max) < 0;
}
@Override
public Boolean[] next() {
Boolean[] b = new Boolean[n];
for (int i = 0; i < n; i++) {
b[i] = next.testBit(i);
}
next = next.add(BigInteger.ONE);
return b;
}
};
}
OldCurmudgeon没有时间理会这些新奇的Stream东西。他们永远不会流行起来 - 这只是一种时尚......我的草坪！！:)
我对Stream解决方案的相当失败的尝试 - 我仍然没有摸索它们：
private static Boolean[] asBooleanArray(BigInteger n) {
int l = n.bitLength();
Boolean[] b = new Boolean[l];
for (int i = 0; i < l; i++) {
b[i] = n.testBit(i);
}
return b;
}
List<Boolean[]> bools =
Stream.<BigInteger>iterate(
BigInteger.ZERO,
i -> i.add(BigInteger.ONE))
.map(n -> asBooleanArray(n))
.collect(Collectors.toList());
我在终止 infnite Stream时遇到问题。