# How to get Cartesian product from multiple lists?

Say I have several `List<T>`s, I will put them into another list or other collections, so I don’t know how many `list<T>` I have until I call `List<List<T>>.size()`

Take below `List<Integer>` as an example:

```list1=[1,2]
list2=[3,4]
list3=[5,6]
....
listn=[2*n-1,2n];
```

How can I get the result of `list1*list2*list3*...listn` as a Cartesian product?

For example:

```list1*list2*list3
```

should be:

```[1,3,5],[1,3,6],[1,4,5],[1,4,6],[2,3,5],[2,3,6],[2,4,5],[2,4,6]
```

You can use recursion to achieve it, your base case of recursion is when input is empty then return empty list, else process the remaining elements. E.g.

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

public class CartesianProduct {
public static <T> List<List<T>> calculate(List<List<T>> input) {
List<List<T>> res = new ArrayList<>();
if (input.isEmpty()) { // if no more elements to process
return res;
} else {
// we need to calculate the cartesian product
// of input and store it in res variable
process(input, res);
}
return res; // method completes , return result
}

private static <T> void process(List<List<T>> lists, List<List<T>> res) {
//take first element of the list
//invoke calculate on remaining element, here is recursion
List<List<T>> tail = calculate(lists.subList(1, lists.size()));

for (List<T> t : tail) { //iterate over the tail
List<T> tmp = new ArrayList<>(t.size());
tmp.addAll(t); // and current tail element
}
}
}

public static void main(String[] args) {
//we invoke the calculate method
System.out.println(calculate(Arrays.asList(
Arrays.asList(1, 2),
Arrays.asList(3, 4),
Arrays.asList(5, 6))));
}
}
```

Output

```[[1,3,5],[1,3,6],[1,4,5],[1,4,6],[2,3,5],[2,3,6],[2,4,5],[2,4,6]]
```