Java-如何构建唯一的对象元组（n维）？_Java_Algorithm_Unique_Tuples_N Dimensional

Java-如何构建唯一的对象元组（n维）？

java algorithm

Java-如何构建唯一的对象元组（n维）？,java,algorithm,unique,tuples,n-dimensional,Java,Algorithm,Unique,Tuples,N Dimensional,我面临以下挑战，需要从对象列表中创建唯一的对象元组。这里的特殊挑战是如何处理动态列表大小（n维）？如果你有一个固定的尺寸，这很容易。我希望有人知道第三方API或有一些提示我如何才能做到这一点下面的示例显示了3个列表，因此更容易解释。我在一个列表中按类对对象进行排序，例如 lista = {a1,a2} listb = {b1,b2,b3} listc = {c1,c2} 我喜欢使用以下元组，以便每个对象彼此配对一次： tuple1 = {a1,b1,c1} tuple2 = {a1,b

我面临以下挑战，需要从对象列表中创建唯一的对象元组。这里的特殊挑战是如何处理动态列表大小（n维）？如果你有一个固定的尺寸，这很容易。我希望有人知道第三方API或有一些提示我如何才能做到这一点

下面的示例显示了3个列表，因此更容易解释。我在一个列表中按类对对象进行排序，例如

lista = {a1,a2}
listb = {b1,b2,b3}
listc = {c1,c2}

我喜欢使用以下元组，以便每个对象彼此配对一次：

tuple1  = {a1,b1,c1}
tuple2  = {a1,b1,c2}
tuple3  = {a1,b2,c1}
tuple4  = {a1,b2,c2}
tuple5  = {a1,b3,c1}
tuple6  = {a1,b3,c2}
tuple7  = {a2,b1,c1}
tuple8  = {a2,b1,c2}
tuple9  = {a2,b2,c1}
tuple10 = {a2,b2,c2}
tuple11 = {a2,b3,c1}
tuple12 = {a2,b3,c2}

在这种情况下，我如何才能做到这一点
-列表的数量是动态的
-列表的大小是动态变化的

有什么提示或想法吗？提前感谢您

我们可以建立以下解决方案。首先请注意，列表大小不同的情况在现代语言中从来都不是问题，因为现在几乎所有语言都支持可变大小的列表。更棘手的是当列表的数量变化时

下面是固定数量列表的Python示例：

lista = ["a1","a2"]
listb = ["b1","b2","b3"]
listc = ["c1","c2"]
[(a,b,c) for a in lista for b in listb for c in listc]

对于Java，也要做同样的事情。您将需要三个嵌套for循环：

List<String> lista = Arrays.asList("a1","a2");
List<String> listb = Arrays.asList("b1","b2","b3");
List<String> listc = Arrays.asList("c1","c2");

List<List<String>> result = new ArrayList<List<String>>();
for (String a: lista) {
    for (String b: listb) {
        for (String c: listc) {
            result.add(Arrays.asList(a, b, c));
        }
    }
}
System.out.println(result);

现在的诀窍是如何进行不确定数量的for循环？一种方法是使用递归

从0个列表（甚至1个）的基本情况开始，然后问问自己：当我添加一个新列表时，结果如何变化？然后你可以组合一个很好的小递归公式。你需要帮忙吗

（旁白：在Python中，我们有

itertools

来处理这类事情。我不知道有任何Java模拟，但谷歌搜索可能会发现一些东西。）

好的，让我们为无限数量的列表开发递归公式。如果你只有一张单子，说

a = ["a1", "a2"]

然后结果是

[[“a1”]，[“a2”]

。但现在让我们添加另一个列表：

a = ["b1", "b2"]

现在的答案是什么

[[a1, b1], [a1, b2], [a2, b1], [a2, b2]]

我们是怎么做到的？答案是我们获取新列表中的每个元素，并将其附加到结果中的每个元素。每次我们添加一个新的列表，我们都会这样做。假设现在我们添加

[“c1”、“c2”、“c3”]

。你知道我们会得到什么吗？如果是这样，您现在应该能够定义递归步骤了

完整代码

好吧，我无法抗拒！给你

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * An application requested by a SO user.
 */
public class ProductExample {

    /**
     * Returns a list containing all possible products of a list of lists of strings.
     */
    public static List<List<String>> product(List<List<String>> lists) {
        List<List<String>> result = new ArrayList<List<String>>();

        if (lists.isEmpty()) {
            result.add(new ArrayList<String>());
            return result;
        }

        List<List<String>> partial = product(lists.subList(0, lists.size() - 1));
        for (List<String> list: partial) {
            for (String s: lists.get(lists.size() - 1)) {
                List<String> listCopy = new ArrayList<String>(list);
                listCopy.add(s);
                result.add(listCopy);
            }
        }
        return result;
    }


    public static void main(String[] args) {
        System.out.println(product(
                Arrays.asList(
                        Arrays.asList("a1", "a2"),
                        Arrays.asList("b1", "b2", "b3"),
                        Arrays.asList("c1", "c2"),
                        Arrays.asList("d1", "d2"))));
    }
}

import java.util.ArrayList；
导入java.util.array；
导入java.util.List；
/**
*SO用户请求的应用程序。
*/
公共类产品示例{
/**
*返回一个列表，该列表包含字符串列表的所有可能产品。
*/
公共静态列表产品（列表）{
列表结果=新建ArrayList（）；
if（lists.isEmpty（））{
添加（新的ArrayList（））；
返回结果；
}
List partial=产品（lists.subList（0，lists.size（）-1））；
对于（列表：部分）{
for（字符串s:lists.get（lists.size（）-1））{
List listCopy=新阵列列表（列表）；
listCopy.add（s）；
结果。添加（列表副本）；
}
}
返回结果；
}
公共静态void main（字符串[]args）{
系统输出打印项次（产品）(
Arrays.asList(
数组。asList（“a1”、“a2”），
数组.asList（“b1”、“b2”、“b3”），
数组。asList（“c1”、“c2”），
数组.asList（“d1”、“d2”）；
}
}

兰特：这在Python中要容易得多。或红宝石。：）

我们可以建立如下解决方案。首先请注意，列表大小不同的情况在现代语言中从来都不是问题，因为现在几乎所有语言都支持可变大小的列表。更棘手的是当列表的数量变化时