Java 从流中填充对象字段<；整数>；

我有课

@Data
Test{
  private int[] a;
  private int[] b;
}

我有一个私有的

Stream

，有1000000个整数

我怎样才能做到以下几点：

迭代流中的所有整数

创建新测试

如果

i=0

将

i

添加到

test.a

中，否则将

i

添加到

test.b

最后，我需要一个包含2个数组的测试对象，其中a包含所有非零元素，b包含所有零

---

我需要1个测试对象。

也许您可以使用2个流操作，并在测试的1个实例上为a和b使用setter

public class Foo {

    public static void main(String[] args) throws IOException {

        List<Integer> myList = new ArrayList<>();
        myList.add(1);
        myList.add(0);
        myList.add(1);
        Test t = new Test();
        t.setA(myList.stream().filter(x -> x != 0).mapToInt(x -> x).toArray());
        t.setB(myList.stream().filter(x -> x == 0).mapToInt(x -> x).toArray());
        System.out.println("t: " + t);

    }

}

class Test {
    private int[] a;
    private int[] b;

    public void setA(int[] array) {
        a = array;
    }

    public void setB(int[] array) {
        b = array;
    }

    @Override
    public String toString() {
        return "Test {a=" + Arrays.toString(a) + ", b=" + Arrays.toString(b) + "}";
    }

}

公共类Foo{
公共静态void main（字符串[]args）引发IOException{
List myList=new ArrayList（）；
添加（1）；
myList.add（0）；
添加（1）；
测试t=新测试（）；
t、 setA（myList.stream（）.filter（x->x！=0）.mapToInt（x->x.toArray（））；
t、 setB（myList.stream（）.filter（x->x==0）.mapToInt（x->x.toArray（））；
System.out.println（“t:+t”）；
}
}
课堂测试{
私人机构【】a；
私有int[]b；
公共void setA（int[]数组）{
a=阵列；
}
公共void setB（int[]数组）{
b=阵列；
}
@凌驾
公共字符串toString（）{
返回“Test{a=“+Arrays.toString（a）+”，b=“+Arrays.toString（b）+”}”；
}
}

下面是一个将流拆分为两个流的示例实现

public class Main {

static class Test {
    private int[] a;
    private int[] b;

    Test(int[] a, int[] b) {
        this.a = a;
        this.b = b;
    }
}

public static void main(String[] args) {
    IntStream.Builder zeroStreamBuilder = IntStream.builder();
    IntStream.Builder nonZeroStreamBuilder = IntStream.builder();

    IntStream intStream = IntStream.of(0, 0, 1, 2, 3, 4);
    intStream.forEach(value -> {
        if (value == 0)
            zeroStreamBuilder.add(value);
        else
            nonZeroStreamBuilder.add(value);
        }
    );

    int[] a = zeroStreamBuilder.build().toArray();
    int[] b = nonZeroStreamBuilder.build().toArray();
    Test result = new Test(a, b);
}
}

---

如果您愿意使用列表，则可以跳过从streams

.build（）.toArray（）

构建数组，因为您可以直接将值添加到结果列表中。

如果您事先知道有1000000个整数，则根本不需要收集零：

int[] a = stream.mapToInt(Integer::intValue).filter(i -> i!=0).toArray();
int[] b = new int[1_000_000 - a.length];
Test test = new Test(a, b);

---

到目前为止，您尝试了什么？您应该使用IntStream，而不是Stream，但我有1000 000个整数。如果我创建2个流，我需要进行2000次迭代