从数组列表的元素中检索所有组合

Question

I want to know a procedure have combinations from Arraylists. Scenario is as follows. Lets say there are 3 different Arraylists like below.

ex:

1. [Silver, White, Grey, Purple]
2. [Petrol, Hybrid]
3. [Toyota, Micro]

combinations can be created like given below, out of the above three Arraylists.

ex:

1. Silver Petrol Toyota
2. Silver Petrol Micro
3. Silver Hybrid Toyota
4. Silver Hybrid Micro
5. White Petrol Toyota
6. White Petrol Micro
7. White Hybrid Toyota
8. White Hybrid Micro
9. Grey Petrol Toyota
10. Grey Petrol Micro
11. Grey Hybrid Toyota
12. Grey Hybrid Micro
13. Purple Petrol Toyota
14. Purple Petrol Micro
15. Purple Hybrid Toyota
16. Purple Hybrid Micro

In my case the number of arraylists are dynamic. The size of one arraylist is also dynamic. In the scenario like that I want to know the method to implement using Java. Can anyone please suggest me a way to this using Java?

Thanks

Answer 1

You can put all the List you have to a totalList, whose type is List>. Combine 2 lists at a time to populate all of the combination cases.

Below is an exmaple for your reference, and it will print the information as you want.

Note: It supports dynamic number of Lists and dynamic size of List .

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

public class Test {

    public static void main(String[] args) {

        List<String> listOne = Arrays.asList("Silver", "White", "Grey",
                "Purple");
        List<String> listTwo = Arrays.asList("Petrol", "Hybrid");
        List<String> listThree = Arrays.asList("Toyota", "Micro");
        List<List<String>> totalList =  Arrays.asList(listOne,listTwo,listThree);

        new Test().printAllCases(totalList);
    }

    public void printAllCases(List<List<String>> totalList) {
        List<String> result = new ArrayList<String>(totalList.get(0));

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

        /* print */
        int count = 0;
        for(String s: result) {
            System.out.printf("%d. %s\n", ++count, s);
        }
    }

    private List<String> combineTwoLists(List<String> list1, List<String>   list2) {
        List<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;
    }
}

Answer 2

If you're not opposed to outside libraries, guava-libraries provides a very nice Sets.cartesianProduct method that can do precisely this. Of course, you'd wind up converting your lists over...

Set<String> colors = ImmutableSet.of("Silver", "White", "Grey", "Purple");
Set<String> fuelTypes = ImmutableSet.of("Petrol", "Hybrid");
Set<String> brands = ImmutableSet.of("Toyota", "Micro");

Set<List<String>> result = Sets.cartesianProduct(colors, fuelTypes, brands);
System.out.println(result);

Answer 3

Well think of this pseudo code:

for (i for size of array1) {
    for (j for size of array2) {
        for (k for size of array3) {
            print array1[i] + array2[j] + array3[k]
        }
    }
}

In Java something like this:

int i, j, k;
int count = 0;
for (i = 0; array1.size(); i++) {
    for (j = 0; array2.size(); j++) {
        for (k = 0; array3.size(); k++) {
            count++;
            System.out.println(count + ". " +array1.get(i) + array2.get(j) + array3.get(k));
        }
    }
}