多个数组，每个有多个元素，彼此两两结合，怎么写比较优雅？

你想实现的操作，如果我没有理解错的话，在脚本语言或者函数式语言里叫做 zip。

[1, 2, 3, 4].zip([5, 6, 7, 8])
# => [[1, 5], [2, 6], [3, 7], [4, 8]]

Java 的话，可以看看 StackOverflow#3833814

@agagega 不太一样，我的意思不知道是不是应该叫“全结合”，就是排列组合里面的组合，15，16，17，18，25，26...这样，4*4 应该是 16 个结果。

看手写循环说的大概是排列组合？
function test(arys, states) {
if (arys.length) {

arys.forEach(

function test(arys, states) {
if (arys.length) {
for (const elmt of arys[0]) {
states.push(elmt);
test(arys.slice(1), states)
}
states.pop();
}
else {
console.log(states);
states.pop();
}
}

function biu() {
return Array.prototype.reduce.call(arguments, function(i, j) {
var result = [];
a.forEach(function(i) {
b.forEach(function(j) {
result.push(i.concat([j]))
})
});
return result;
}, [[]])
}

biu([1,2,3],[4,5,6],[7,8,9])

function biu() {
return Array.prototype.reduce.call(arguments, function(a, b) {
var result = [];
a.forEach(function(a) {
b.forEach(function(b) {
result.push(a.concat([b]))
})
});
return result;
}, [[]])
}

biu([1,2,3],[4,5,6],[7,8,9])
重发一次

$ zip [1..10] [20..30]
[(1,20) ...]

笛卡尔积？

>>> a = [1, 2, 3, 4]
>>> b = [5, 6, 7, 8]
>>> [(x, y) for x in a for y in b]
[(1, 5), (1, 6), (1, 7), (1, 8), (2, 5), (2, 6), (2, 7), (2, 8), (3, 5), (3, 6), (3, 7), (3, 8), (4, 5), (4, 6), (4, 7), (4, 8)]

Python 和 Haskell 的正常写法，算不上奇技淫巧吧
Java 的正常写法当然就是嵌套循环，我觉得足够优雅了

lz 是想要一个 generator 吧？

class XG{public X next();}

while (XG.next() != null) { test(X)}

@marcong95 对对，数学没学好话都说不清楚...

拿 numpy 或 pandas 处理一下？

不过我记得 collections 里面有一个方法可以实现，叫 com*什么来着想不起来了

python 的 itertools 就有 product

Ruby:

a.product(b)

既然是 Java，那就 N 个 for 就完事儿了

如果你想搞什么骚操作的话，有这么个思路：
设计一个类，表示 N 位、size-进制的数，就可以只用一个 for，遍历这个对象的值域，达到枚举的目的

用 python 预处理一遍，再用 Java 去取呗

不想用循环，那就递归嘛~~
def combine(pre, v2, idx):
if idx >= len(v2):
print pre
return
v1, idx = v2[idx], idx + 1
for c in v1:
combine(pre + str(c), v2, idx)

if __name__ == '__main__':
v2 = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 'a', 'b']]
combine('', v2, 0)
~

偷懒的办法：把数组元素插入到内存表里面，一个数组一个表，然后连表查询......

n 个数组，把迭代器都取出来. 做成一个列表，整数进位一样. 例如 n 为 4，迭代器数组指向的是 0,0,0,0，再一次就是 0,0,0,1 当低位，hasnext 到头了，就进位，下一个迭代器移动，并且把本迭代器回拨到 0. 最后整个封装成一个 generator

你这个直接说“ CrossJoin ”或者笛卡尔积就专业了。

具体实现上面都有，就不班门弄斧了。

电脑上补代码
```


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

public class Permutation {
interface Generator<T> {
T next();

boolean hasNext();
}

static class PermutationGenerator implements Generator<List<Integer>> {
final private int[] index;
final List<List<Integer>> nums;
private boolean hasNext = true;

public PermutationGenerator(List<List<Integer>> nums) {
this.nums = nums;
index = new int[nums.size()];
}

@Override
public List<Integer> next() {
List<Integer> ret = new ArrayList<>();
if (!hasNext)
return ret;

for (int i = 0; i < index.length; i++) {
ret.add(nums.get(i).get(index[i]));
}

int resetCount = 0;
for (int i = 0; i < index.length; i++) {
if (index[i] < nums.get(i).size() - 1) {
index[i]++;
break;
} else {
index[i] = 0;
resetCount++;
}
}

if (resetCount == index.length) {
hasNext = false;
}
return ret;
}

@Override
public boolean hasNext() {
return hasNext;
}
}


public static void main(String[] args) {
List<List<Integer>> data = Arrays.asList(Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6), Arrays.asList(7, 8, 9));
Generator<List<Integer>> gen = new PermutationGenerator(data);
while (gen.hasNext()) {
System.out.println(gen.next());
}
}
}

```

你可以参考 leetcode 17 题