Java-8：要流的布尔基元数组？

在一条语句中将给定的

boolean[]foo

数组转换为Java-8中的流没有好方法，或者我遗漏了什么

（我不会问为什么，但这确实令人费解：为什么不为所有基本类型添加流支持？）

---

提示：

数组。流（foo）

将不起作用，对于

布尔[]

类型没有此类方法。

给定

布尔[]foo

使用

Stream<Boolean> stream = IntStream.range(0, foo.length)
                                  .mapToObj(idx -> foo[idx]);

Stream=IntStream.range（0，foo.length）
.mapToObj（idx->foo[idx]）；

请注意，每个布尔值都将被装箱，但这通常不是什么大问题，因为布尔值装箱不会分配额外的内存（只使用预定义值之一--

boolean.TRUE

或

boolean.FALSE

）。

您可以使用：

Stream=Booleans.asList（foo.Stream（）；

这是一种非常有效的方法，因为

Booleans.asList

返回数组的包装，并且不进行任何复制。

当然，您可以直接创建流

---

浏览最新版本的早期访问JavaDoc（即module），仍然没有一种简单的方法使原始布尔数组与流API一起很好地工作。API中没有处理原始布尔数组的新功能

请注意，存在表示原始布尔序列变化的和，但没有类似于

BooleanStream

。

Stream

的重载方法还有and，但不是

Stream:：mapToBoolean

返回这样一个假设的

BooleanStream

甲骨文似乎一直遵循这一模式，这也可以在中找到。对

float

原语也没有这样的支持（而是对

double

原语）。在我看来，与

float

不同，

boolean

支持的实现是有意义的

回到代码。。。如果您有一个装箱布尔数组（即，

boolean[]array

），事情会变得更简单：

Boolean[] array = ...
Stream<Boolean> streamOfBoxedBoolean1 = Arrays.stream(array);
Stream<Boolean> streamOfBoxedBoolean2 = Stream.of(array);

---

事实上，Java 8只为

int

、

long

和

double

以及

数组提供专门的原语流。流

不接受

布尔[]

。我想你必须把它框起来。在这里使用数组而不是数组会有好处吗？@Fildor:是的，你可以在一个位集上进行流操作。但是，结果可能会不同，因为您正在对位（即它们的位置号）进行流式传输。令人惊讶的是，障碍在另一边：没有简明的方法将

布尔[]

数组转换为

位集。希望链接的Q&a仍然有用。创建
BooleanStream
还意味着创建
boolean
基本迭代器、
OptionalBoolean
、
booleansfunction
、
booleanspredicate
（或者我们是否滥用了
booleanuaryfunction
）、
booleanbaryOperator
、
booleantoffunction
，
BooleanToLongFunction
，
BooleanToDoubleFunction
，
BooleanConsumer
，（出于未知原因，
BooleanSupplier
存在），
ObjBooleanConsumer
，
BooleanSummaryStatistics
，等等。@Holger，BooleanSupplier完成
的矩阵（对象| int | long | double | void）->（Object | int | long | double | void | boolean）
函数：这30个函数实际上都存在于JDK中，而且似乎没有提供其他一个/零参数函数。因此
BooleanSupplier
看起来很合理。在您看来，可以安全地推断“轻量级”函数吗
boolean
s上的装箱操作可能是
boolean
s没有专门的原始流的原因？好的一个+1，让我们看看，可能会有其他想法进入人们的脑海：）@Mena，有多个原因。其中之一是代码膨胀：每个基本流都会添加大量专门化的代码，更不用说添加
IntStream.mapToBoolean
、
BooleanStream.mapToDouble
等时会增加二次API。所以他们不得不停在某个地方。他们认为
int
、
long
和
double
是最有用的原始类型，因此这是一个合理的权衡。希望Java10能给我们带来泛型专门化，
Stream
将开箱即用。我想，尽可能接近。但是“好”是不一样的——伊姆霍。（+1）@TagirValeev他们本可以在。。。所有的原语，没有那么多（8个原语+1个参考）。很好！请注意，除非定义了自定义拆分器，否则不会调整结果流的大小（它是。这可能会影响某些操作的性能，如
toArray（）
。此外，它也不会并行化（如果有人关心）。@Tagir Valeev:“reports spliterator.SIZED and spliterator.ORDERED”…@TagirValeev我刚刚检查了Booleans.asList（）

返回的拆分器的特性，它看起来有一个大小字符。@Holger，对不起，我的错。那么唯一的问题是并行性。尽管在Java-9中也是如此。@ZhekaKozlov，不，拆分器

trySplit（）

方法必须正确实现。默认值为“穷人并行”它通过迭代器将列表顺序遍历到中间缓冲区，这是三个顶级语句+三个语句表达式，在

中，对于
，\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuu，@Andrey，我没有另一种说法。Direct的意思是手动一块一块地组合在一起。我希望您喜欢第二个解决方案。
Stream.Builder<Boolean> builder = Stream.builder();
for (int i = 0; i < foo.length; i++)
  builder.add(foo[i]);
Stream<Boolean> stream = builder.build();

Stream<Boolean> stream = new AbstractList<Boolean>() {
  public Boolean get(int index) {return (foo[index]);}
  public int size() {return foo.length;}
}.stream();

Boolean[] array = ...
Stream<Boolean> streamOfBoxedBoolean1 = Arrays.stream(array);
Stream<Boolean> streamOfBoxedBoolean2 = Stream.of(array);

boolean[] array = ...

Stream<Boolean> stream = StreamSupport.stream(
        Spliterators.spliteratorUnknownSize(
                new Iterator<>() {
                    int index = 0;
                    @Override public boolean hasNext() { return index < array.length; }
                    @Override public Boolean next() { return array[index++]; }
                }, 0), false);