Java 如何创建类似于三个不同类型列表的笛卡尔乘积的数据结构？

我想创建一个数据结构，它类似于三个列表的笛卡尔乘积。 我还参考了建议使用flatMap的现有答案。我也试过那样做。但我有一个条件，

filterValue

list在

types

list中。所以flatMap在这里不起作用。As

FilterValue

可以是

0或更多

。因此，根据笛卡尔积（我们可以称之为组合）的变化

对于每个列表，

度量值、类型和筛选值的大小可以不同。
如果
measure
列表为空。然后，组合将仅为
类型和过滤值
（并且
度量值
将设置为
空
。我在
if else
块的注释中添加了这些不同的场景

我有以下类型的列表：

列出度量值
列表类型
列出过滤器值
例如，输入结构是：

{
  "measures": [
    "m1",
    "m2",
    "m3"
  ],
  "types": [
    {
      "type": "type-1",
      //some more fields
      "filterValues": [
        //no filter values present
      ]
    },
    {
      "type": "type-2",
      //some more fields
      "filterValues": [
        {
          "filterValue": "t2f1"
          //some more fields
        },
        {
          "filterValue": "t2f2"
          //some more fields
        }
      ]
    }
  ]
}

在上面的例子中，我期望的输出数据结构是

m1  type-1 null
m1  type-2 t2f1 
m1  type-2 t2f2 

m2  type-1 null
m2  type-2 t2f1 
m2  type-2 t2f2 

m3  type-1 null
m3  type-2 t2f1 
m3  type-2 t2f2 

然后将上述相同的值设置为以下类：

类搜索区域{
弦长；
字符串类型；
TypeCombi型文件管理器；
//度量和类型的构造函数
//所有三个的构造函数
//接球手和接球手
}
类型组合类{
字符串类型；
字符串名称；//它与filterValue映射
//上述两个字段的构造函数
//接球手和接球手
}

类
类型
和
过滤器值
如下所示

类类型{
字符串类型；
列出filterValues；
//更多的领域
//接球手和接球手
}
类FilterValue{
字符串filterValue；
//更多的领域
//接球手和接球手
}

我可以使用下面的
getSearchAreas
函数实现预期的输出。但是在这种情况下，我对
循环使用了多（两）个
。是否可以使用
stream/flatmap
而不是两个
循环来清除此代码块？
还有什么更好的方法来处理多个if/else块吗？（我已经在每个if/else块上面添加了注释，用于它的场景）

私有列表getSearchAreas（列表度量、列表类型）{
List searchAreas=new ArrayList（）；
//度量值和类型均为空
if（（measures==null | | measures.isEmpty（））
&&（types==null | | types.isEmpty（））
返回集合。emptyList（）；
//一个或多个度量值和零类型
else if（measures！=null&&！measures.isEmpty（）
&&（types==null | | types.isEmpty（））{
搜索区域=度量
.stream（）
.map（度量值->新搜索区域（度量值，空））
.collect（Collectors.toList（））；
返回搜索区；
}
//零度量值和一个或多个类型
else if（（measures==null | | measures.isEmpty（））{
对于（类型：类型）{
if（type.getFilterValues（）==null
||类型。getFilterValues（）.isEmpty（））{
添加（新的SearchArea（null，type.getType（））；
}否则{
searchAreas.addAll（type.getFilterValues（）
.stream（）
.map（filterValue->newsearcharea（null，
type.getType（），
新类型组合（type.getType（），
filterValue.getFilterValue（））
.collect（Collectors.toList（））；
}
}
返回搜索区；
}
//一个或多个度量值和一个或多个类型
否则{
for（字符串度量值：度量值）{
对于（类型：类型）{
if（type.getFilterValues（）==null
||类型。getFilterValues（）.isEmpty（））{
添加（新的SearchArea（measure，type.getType（））；
}否则{
searchAreas.addAll（type.getFilterValues（）
.stream（）
.map（filterValue->newsearcharea（度量、，
type.getType（），
新类型组合（type.getType（），
filterValue.getFilterValue（））
.collect（Collectors.toList（））；
}
}
}
返回搜索区；
}
}

如果有人能帮助我以更干净的方式重组上述内容，那就太好了。
我想这就是你想要的。请注意，不使用流有时更干净

public static void main(String[] args) throws Exception {
    List<String> strings = Collections.emptyList();
    List<Integer> ints = Arrays.asList(1, 2, 3);

    if (strings == null || strings.isEmpty()) {
        strings = Collections.singletonList(null);
    }

    if (ints == null || ints.isEmpty()) {
        ints = Collections.singletonList(null);
    }

    for (String str : strings) {
        for (Integer integer : ints) {
            // In your code doubles comes from a property of integer.
            List<Double> doubles = integer == null ? Collections.emptyList() : Arrays.asList(1.0d, 2.0d, 3.0d);

            if (doubles == null || doubles.isEmpty()) {
                doubles = Collections.singletonList(null);
            }

            for (Double doubler : doubles) {
                // Create your object here.
                System.out.format(Locale.US, "    str = %s, int = %d, double = %f %n", str, integer, doubler);
            }
        }
    }
}

您可以获得三个或更多不同类型列表的笛卡尔积，并将其存储到对象列表中
list

公共静态列表卡特尔产品（列表…列表）{
//传入数据不正确
if（lists==null）返回Collections.emptyList（）；
返回数组.stream（列表）
//非空和非空列表
.filter（list->list！=null&&list.size（）>0）
//将每个列表元素表示为SingletonList
.map（list->list.stream（）.map（Collections:：singletonList）
//溪流
.collect（收集器.toList（））
//内部列表对的求和
.reduce（（list1，list2）->list1.stream（）
//内部列表的组合
.flatMap（inner1->list2.stream（）
//将两个内部列表合并为一个
.map（inner2->Stream.of（inner1，inner2）
.flatMap（列表：：流）
.collect（收集器.toList（）））
//组合列表
.collect（收集器.toList（））
//返回列表，否则返回空列表
.
str = null, int = 1, double = 1.000000 
str = null, int = 1, double = 2.000000
str = null, int = 1, double = 3.000000
str = null, int = 2, double = 1.000000
str = null, int = 2, double = 2.000000 
str = null, int = 2, double = 3.000000
str = null, int = 3, double = 1.000000
str = null, int = 3, double = 2.000000
str = null, int = 3, double = 3.000000