如何使用Java流合并和排列数组？

以下代码按预期工作：

私有静态无效实验（）{
最终UUID[]UUID=新UUID[]{null，UUID.randomUUID（）}；
最终字符串[]名称=新字符串[]{null，“，”，“\t”，“someName”}；
最终字符串[]descrs=新字符串[]{null，“，”，“\t”，“someDescr”}；
最终列表allArguments=new ArrayList（）；
Arrays.stream（uuids）
.forEach（uuid->Arrays.stream（名称）
.forEach（名称->数组.stream（描述）
.forEach（说明->所有论证）
.add（Arguments.of（uuid，name，descr‘‘‘‘‘））；
}

allArguments

以以下内容结束（准编码），由50个元素组成：

{
 {null, null, null},
 {null, null, ""},
 ...
 {68dc3afc-a13e-405f-a761-12169e73ecf6, "someName", "someDescr"}
}

但是，我希望有两个变化：

我想要源值的

n

数组，而不是硬编码的三个数组（uuid、name、descr）

我希望通过以下方式使用流解决此问题：

final Collection allArguments=
...
.收集（）；

有人能对这个问题提出建议吗？

试试这个

static Function<List<Object>, Stream<List<Object>>> add(Object[] a) {
    return list -> Arrays.stream(a).map(y -> {
        List<Object> n = new ArrayList<>(list);
        n.add(y);
        return n;
    });
}


static void experiment() {
    UUID[] a = {null, UUID.randomUUID()};
    String[] b = {null, "b"};
    Integer[] c = {100, 200};
    String[] d = {"X", "Y"};
    List<List<Object>> s = Stream.of(Arrays.asList())
        .flatMap(add(a))
        .flatMap(add(b))
        .flatMap(add(c))
        .flatMap(add(d))
        .collect(Collectors.toList());
    for (List<Object> e : s)
        System.out.println(e);
}

或者你也可以这样做

static List<List<Object>> cartesianProduct(Object[]... arrays) {
    return Arrays.stream(arrays)
        .map(a -> add(a))
        .reduce(Stream.of(Arrays.asList()),
            (s, p) -> s.flatMap(p), (a, b) -> Stream.concat(a, b))
        .collect(Collectors.toList());
}

静态列表卡特尔产品（对象[]…数组）{
返回Arrays.stream（数组）
.map（a->add（a））
.reduce（Stream.of（Arrays.asList（）），
（s，p）->s.flatMap（p），（a，b）->Stream.concat（a，b））
.collect（Collectors.toList（））；
}

及

UUID[]a={null，UUID.randomUUID（）}；
字符串[]b={null，“b”}；
整数[]c={100200}；
字符串[]d={“X”，“Y”}；
对于（列表：卡特尔产品（a、b、c、d））
系统输出打印项次（列表）；

试试这个

static Function<List<Object>, Stream<List<Object>>> add(Object[] a) {
    return list -> Arrays.stream(a).map(y -> {
        List<Object> n = new ArrayList<>(list);
        n.add(y);
        return n;
    });
}


static void experiment() {
    UUID[] a = {null, UUID.randomUUID()};
    String[] b = {null, "b"};
    Integer[] c = {100, 200};
    String[] d = {"X", "Y"};
    List<List<Object>> s = Stream.of(Arrays.asList())
        .flatMap(add(a))
        .flatMap(add(b))
        .flatMap(add(c))
        .flatMap(add(d))
        .collect(Collectors.toList());
    for (List<Object> e : s)
        System.out.println(e);
}

或者你也可以这样做

static List<List<Object>> cartesianProduct(Object[]... arrays) {
    return Arrays.stream(arrays)
        .map(a -> add(a))
        .reduce(Stream.of(Arrays.asList()),
            (s, p) -> s.flatMap(p), (a, b) -> Stream.concat(a, b))
        .collect(Collectors.toList());
}

静态列表卡特尔产品（对象[]…数组）{
返回Arrays.stream（数组）
.map（a->add（a））
.reduce（Stream.of（Arrays.asList（）），
（s，p）->s.flatMap（p），（a，b）->Stream.concat（a，b））
.collect（Collectors.toList（））；
}

及

UUID[]a={null，UUID.randomUUID（）}；
字符串[]b={null，“b”}；
整数[]c={100200}；
字符串[]d={“X”，“Y”}；
对于（列表：卡特尔产品（a、b、c、d））
系统输出打印项次（列表）；

使用流，您可以首先将每个数组表示为二维数组，假设数组的长度相同，然后获得二维数组流，然后将该流表示为单个二维数组

publicstaticvoidmain（字符串[]args）{
字符串[]uuids={null，”，“68dc3afc”，“112b1030”}；
字符串[]名称={null，”，“someName”，“anotherName”}；
字符串[]descrs={null，”，“someDesrc”，“anotherDesrc”}；
字符串[][]arr2d=mergeAndPermute（uuid、name、descr）；
//输出
Arrays.stream（arr2d）.map（Arrays:：toString）.forEach（System.out:：println）；
//[零，零，零]
//[, ]
//[68dc3afc，someName，someDesrc]
//[112b1030，另一个名称，另一个DESRC]
}

publicstaticstring[]mergeAndPermute（String[]…数组）{
//假设数组的长度相同
返回数组
//溪流
.stream（数组）
//将每个阵列表示为二维阵列
//溪流
.map（arr->Arrays.stream（arr）
.map（str->newstring[]{str}）
.toArray（字符串[][]：：新建））
//将二维阵列流减少为单个二维阵列
//通过顺序连接二维数组的行
.reduce（（arr2d1，arr2d2）->IntStream
//迭代二维数组的索引
.范围（0，arr2d1.长度）
//连接二维数组的行
.mapToObj（i->Stream
.concat（Arrays.stream（arr2d1[i]），
Arrays.stream（arr2d2[i]））
.toArray（字符串[]：：新建））
//返回单个二维数组
.toArray（字符串[][]：：新建））
.orElse（空）；
}

---

另见：
•
•

使用流，您可以首先将每个阵列表示为二维阵列，假设阵列的长度相同，然后获得二维阵列流，然后将该流转换为单个二维阵列

publicstaticvoidmain（字符串[]args）{
字符串[]uuids={null，”，“68dc3afc”，“112b1030”}；
字符串[]名称={null，”，“someName”，“anotherName”}；
字符串[]descrs={null，”，“someDesrc”，“anotherDesrc”}；
字符串[][]arr2d=mergeAndPermute（uuid、name、descr）；
//输出
Arrays.stream（arr2d）.map（Arrays:：toString）.forEach（System.out:：println）；
//[零，零，零]
//[, ]
//[68dc3afc，someName，someDesrc]
//[112b1030，另一个名称，另一个DESRC]
}

publicstaticstring[]mergeAndPermute（String[]…数组）{
//假设数组的长度相同
返回数组
//溪流
.stream（数组）
//将每个阵列表示为二维阵列
//溪流
.map（arr->Arrays.stream（arr）
.map（str->newstring[]{str}）
.toArray（字符串[][]：：新建））
//将二维阵列流减少为单个二维阵列
//通过顺序连接二维数组的行
.reduce（（arr2d1，arr2d2）->IntStream
//迭代二维数组的索引
.范围（0，arr2d1.长度）
//连接二维数组的行
.mapToObj（i->Stream
.concat（Arrays.stream（arr2d1[i]），
Arrays.stream（arr2d2[i]））
.toArray（字符串[]：：新建））
//返回单个二维数组
.toArray（字符串[][]：：新建））
.orElse（空）；
}

---

另见：
•

---

•

如果您甚至可以在