笛卡尔积 可以用以二维数组么？集合可以的。数组用的就不行了 ，唉

笛卡尔积 可以用于二维数组么？？？集合可以的。数组用的就不行了 ，。。，唉
public static ArrayList Descartes(ArrayList argsList) {
ArrayList a0 = (ArrayList) argsList.get(0);
ArrayList resultList = new ArrayList();
for (int i = 1; i < argsList.size(); i++) {
ArrayList a1 = (ArrayList) argsList.get(i);
ArrayList temp = new ArrayList();
// 每次先计算两个集合的笛卡尔积，然后用其结果再与下一个计算
for (int j = 0; j < a0.size(); j++) {
for (int k = 0; k < a1.size(); k++) {
ArrayList cut = new ArrayList();
if (a0.get(j) instanceof ArrayList) {
cut.addAll((ArrayList) a0.get(j));
} else {
cut.add(a0.get(j));
}
if (a1.get(k) instanceof ArrayList) {
cut.addAll((ArrayList) a1.get(k));
} else {
cut.add(a1.get(k));
}
temp.add(cut);
}
}
a0 = temp;
if (i == argsList.size() - 1) {
resultList = temp;
}
}
return resultList;
}
这个是集合的计算的

下面是我根据计算集合的改写的计算数组的，好纠结，数组用的挺烦的

public static Object[][] DescartesArray(Object[][] argsList) {
Object[] a0=argsList[0];
Object[][] resultList=new Object[argsList.length][];
for(int i =0;i <argsList.length; i++) {
Object[] a1=argsList[i];
Object[][] temp=new Object[a1.length][];
// 每次先计算两个集合的笛卡尔积，然后用其结果再与下一个计算
for(int j =0;j < a0.length; j++) {
for(int k=0; k < a1.length;k++) {
Object[] cut=new Object[a0.length];
if(a0[j] instanceof Object[]) {
cut=a0;
} else {
cut[j]=a0[j];
}
if(a1[k] instanceof Object[]) {
cut=a1;
} else {
cut[j]=a1[k];
}
temp[j]=cut;
}
}
a0 = temp;
if (i == argsList.length- 1) {
resultList = temp;
}
}
return resultList;
}


数组添加元素  只能  是 Array[X]=X;  不像集合那样，直接 add(),纠结。。








------解决方案--------------------
楼主的判断写错了吧，Object[]应该是cut吧
------解决方案--------------------

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;



public class Test7 {


	public static void main(String[] args) {

		// TODO Auto-generated method stub

		List list1 = new ArrayList();

		list1.add("a");

		list1.add("b");

		List list2 = new ArrayList();

		list2.add("0");

		list2.add("1");

		list2.add("2");


		ArrayList list = new ArrayList();

		list.add(list1);

		list.add(list2);

		System.out.println(Descartes(list));



		//数组的形式开始

		Object[][] DescartesArray=new Object[2][];

		DescartesArray[0] = new Object[]{"a","b"};

		DescartesArray[1] = new Object[]{"0","1","2"};

		//调用参数为数组的方法

		Object[][] result=DescartesArray(DescartesArray);

		//打印结果

		for(int i=0;i<result.length;i++){

			System.out.print(Arrays.toString(result[i]));

		}



	}


	public static ArrayList Descartes(ArrayList argsList) {

		ArrayList a0 = (ArrayList) argsList.get(0);

		ArrayList resultList = new ArrayList();

		for (int i = 1; i < argsList.size(); i++) {

			ArrayList a1 = (ArrayList) argsList.get(i);

			ArrayList temp = new ArrayList();

			// 每次先计算两个集合的笛卡尔积，然后用其结果再与下一个计算

			for (int j = 0; j < a0.size(); j++) {

				for (int k = 0; k < a1.size(); k++) {

					ArrayList cut = new ArrayList();

					if (a0.get(j) instanceof ArrayList) {

						cut.addAll((ArrayList) a0.get(j));

					} else {

						cut.add(a0.get(j));

					}

					if (a1.get(k) instanceof ArrayList) {

						cut.addAll((ArrayList) a1.get(k));

					} else {

						cut.add(a1.get(k));

					}

					temp.add(cut);

				}

			}


			a0 = temp;

			if (i == argsList.size() - 1) {

				resultList = temp;

			}

		}

		return resultList;

	}


	public static Object[][] DescartesArray(Object[][] argsList) {

		ArrayList nextlist = new ArrayList();

		for(int i=0;i<argsList.length;i++){

			List innerList = new ArrayList();

			List nextList = Arrays.asList(argsList[i]);

			innerList.addAll(nextList);

			nextlist.add(innerList);

		}

		List list = Descartes(nextlist);