Java-数组列表中数组列表中对象的排列

Question

我是Java和Stack Overflow的新手，我有一个关于排列的问题。

方法：我使用ArrayList中的对象生成ArrayList。每个ArrayList的大小从1（可能最小为1）到无限，并包含具有唯一名称属性的自定义生成对象。

问题：现在我的问题是如何在我的外部ArrayList（y轴）中获得从第一个数组列表到最后一个数组列表的所有可能对象组合的排列（我想我们可以说这是x轴）？

我试着举一个简单的例子:

1. ArrayList： 1.1|1.2|1.3
2. ArrayList： 2.1
3. ArrayList： 3.1|3.2

这里，这些ArrayList位于外部ArrayList中（因为对象中可能存在的

结果：我想得到这样的结果：

1. 组合：1.1 | 2.1 | 3.1
2. 组合：1.1 | 2.1 | 3.2
3. 组合：1.2 | 2.1 | 3.1
4. 组合：1.2 | 2.1 | 3.2
5. 组合：1.3 | 2.1 | 3.1
6. 组合：1.3 | 2.1 | 3.2

编辑：这里的分隔符“|”代表例如ArrayList中的插槽。不应在控制台中写入组合，因为我需要单独访问排列的每个对象。

最好的情况是，如果我可以在一个接一个地获取每个组合，因为我想检查每个组合的几个条件，并且只保护进一步的 ArrayList 或 .txt 文件中的某些组合。

到目前为止我得到的：我找到了一个代码片段，它将ArrayList与ArrayList中的字符串进行排列，并返回一个带有组合字符串的ArrayList。

public static ArrayList<String> combineAllCases(ArrayList<ArrayList<String>> totalList)
{
ArrayList<String> result = new ArrayList<String>(totalList.get(0));

    for(int index = 1; index < totalList.size() ; index++)
    {
        result = (ArrayList<String>) combineTwoLists(result, totalList.get(index));
    }
    return result;
}

和

    private static ArrayList<String> combineTwoLists(ArrayList<String> list1, ArrayList<String>   list2)
{
ArrayList<String> result = new ArrayList<String>();
    StringBuilder sb = new StringBuilder();
    for(String s1 : list1)
    {
        for(String s2: list2)
        {
            sb.setLength(0);
            sb.append(s1).append("#").append(s2);
            result.add(sb.toString());
        }
    }
    return result;
}

想法是：使用这个方法，我可以使用＜code＞String＜/code＞拆分来获得每个组合的每个对象名称，并可以在旧的＜code＞ArrayLists＜/code>中搜索该名称以获取对象。

问题：此方法仅适用于ArrayList中的少量ArrayList（例如，如上例）。如果外部ArrayList中有例如16个大小为7的ArrayList，我得到"MemoryOutOfSpace"的错误。

因此，如前所述，最好的情况是获得一个又一个的组合，并单独决定是否要保留组合（我想我会将每个组合保存在一个.txt文件中，因为它可能是，我想保留每个组合 -

简短摘要：包含对象的内部数组列表（大小从 1 到未知大小）。具有 inner-ArrayLists（大小未知）的 Outer-ArrayList。所需输出：从上到下的所有对象组合。

提前谢谢。

Answer 1

编辑：我理解错了问题。这不是一个正确的解决方案。

据我了解您的问题，您只需要遍历所有三个列表，获取所有元素并将它们加在一起。

下面是一个简单的例子，有三个字符串类型的列表:

List<String> l1 = new ArrayList<String>();
l1.add("1.1");
l1.add("1.2");
l1.add("1.3");

List<String> l2 = new ArrayList<String>();
l2.add("2.1");

List<String> l3 = new ArrayList<String>();
l3.add("3.1");
l3.add("3.2");

for (String s1 : l1)
{
    for (String s2 : l2)
    {
        for (String s3 : l3)
        {
            System.out.println(s1 + " | " + s2 + " | " + s3);
        }
    }
}

打印

1.1 | 2.1 | 3.1
1.1 | 2.1 | 3.2
1.2 | 2.1 | 3.1
1.2 | 2.1 | 3.2
1.3 | 2.1 | 3.1
1.3 | 2.1 | 3.2

它所做的很简单:首先我们用你想要排列的值填充我们的三个数组。

然后我们真的可以阅读代码：对于列表l1中的每个字符串s1，我们获取l2中的每个字符串s2。对于这些组合，我们获取l3中的每个字符串s3。然后我们打印出组合

所以它在内部做的是:

s1  | s2  | s3
1.1 |     |
1.1 | 2.1 |
1.1 | 2.1 | 3.1 -> print
1.1 | 2.1 | 3.2 -> print
1.2 |     |
1.2 | 2.1 | 3.1 -> print
1.2 | 2.1 | 3.2 -> print
1.3 |     |
1.3 | 2.1 | 3.1 -> print
1.3 | 2.1 | 3.2 -> print

Answer 2

我认为你必须递归地做它。在Java 8中使用流是可能的，但是我(还)不太熟悉它们。下面是使用递归时的样子:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

public class ArrayLists {

    ArrayList<List<String>> outer = new ArrayList(5);
    List<String> helper = new ArrayList<String>();

    public static void main(String[] args) {
        ArrayLists arrayLists = new ArrayLists();
        arrayLists.displayPermutations();
    }

    private void displayPermutations() {
        List<String> l1 = new ArrayList<String>();
        l1.add("1.1");
        l1.add("1.2");
        l1.add("1.3");

        List<String> l2 = new ArrayList<String>();
        l2.add("2.1");
        l2.add("2.2");

        List<String> l3 = new ArrayList<String>();
        l3.add("3.1");
        l3.add("3.2");
        l3.add("3.3");

        outer.add(l1);
        outer.add(l2);
        outer.add(l3);

        initHelper();
        recursion(l1);
    }

    private void initHelper() {
        for(int i = 0; i < outer.size(); i++) {
            helper.add(i, outer.get(i).get(0));
        }
    }

     void recursion(List<String> listToIncrement) {
         int helperIndex = outer.indexOf(listToIncrement);
         for(int i = 0; i < listToIncrement.size(); i++) {
             helper.set(helperIndex, listToIncrement.get(i));
             if(helperIndex < outer.size() - 1) {
                 recursion(outer.get(helperIndex + 1));
             }
            else{
                 System.out.println(helper);
             }

         }

    }
}

当然，您可以摆脱initHelper方法，它不是最干净的代码……

Answer 3

我认为你问题的关键词是笛卡尔乘积而不是排列。你可以尝试这样的事情：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.BinaryOperator;
import java.util.function.Supplier;
import java.util.stream.Stream;

class Test{
    public static void main(String[] args){
        List<List<String>> totalList = new ArrayList<>();
        totalList.add(Arrays.asList("1.1","1.2","1.3"));
        totalList.add(Arrays.asList("2.1"));
        totalList.add(Arrays.asList("3.1","3.2"));
        Supplier<Stream<String>>[] sup = new Supplier[totalList.size()];

        for(int i = 0; i<totalList.size();i++){
            final int j = i;
            sup[i]= () -> totalList.get(j).stream();
        }

        Stream<String> result = cartesian((a, b) -> a+"|"+b, sup);
        result.forEach(System.out::println);
    }

    private static <T> Stream<T> cartesian(BinaryOperator<T> aggregator, Supplier<Stream<T>>... streams) {
    return Arrays.stream(streams)
        .reduce((s1, s2) -> 
            () -> s1.get().flatMap(t1 -> s2.get().map(t2 -> aggregator.apply(t1, t2))))
        .orElse(Stream::empty).get();
    }
}

有关更多信息，请参阅其他 SO 问题：Java 8 中流作为流的笛卡尔乘积（仅使用流）

Java中任意集合的笛卡尔积