java源码：
package com.test;
public class Recursion {
public static void main(String[] args) {
// 一维字符串数组
String[] ele = new String[] { "红色，黑色，黄色，紫色", "大，中，小", "金属，混合物，塑料",
"abc，使得双方的，ffff，sfefe" };
StringHandler(ele);
}
/**
*
* 将一维的字符串数组组合成为二维的数组
*
* @param ele
* @return
*/
public static String StringHandler(String[] ele) {
String res = "";
int len = ele.length;
String[] ts = ele[1].split("，");
String[][] abc = new String[len][ts.length];
for (int f = 0; f < ele.length; f++) {
String[] sub = ele[f].split("，");
abc[f] = sub;
}
String[][] ret = doExchange(abc);
String[] result = ret[0];
System.out.println("共有：" + result.length + "种组合！");
for (int i = 0; i < result.length; i++) {
System.out.println(result[i]);
}
return res;
}
/**
*
* 使用递归调用将二维数组中的值进行排列组合
*
* @param doubleArrays
* @return
*/
private static String[][] doExchange(String[][] doubleArrays) {
int len = doubleArrays.length;
if (len >= 2) {
int len1 = doubleArrays[0].length;
int len2 = doubleArrays[1].length;
int newlen = len1 * len2;
String[] temp = new String[newlen];
int index = 0;
for (int i = 0; i < len1; i++) {
for (int j = 0; j < len2; j++) {
temp[index] = doubleArrays[0][i] + " | "
+ doubleArrays[1][j];
index++;
}
}
String[][] newArray = new String[len - 1][];
for (int i = 2; i < len; i++) {
newArray[i - 1] = doubleArrays[i];
}
newArray[0] = temp;
return doExchange(newArray);
} else {
return doubleArrays;
}
}
}
输出结果：
共有：144种组合！
红色 | 大 | 金属 | abc
红色 | 大 | 金属 | 使得双方的
红色 | 大 | 金属 | ffff
红色 | 大 | 金属 | sfefe
红色 | 大 | 混合物 | abc
红色 | 大 | 混合物 | 使得双方的
红色 | 大 | 混合物 | ffff
红色 | 大 | 混合物 | sfefe
红色 | 大 | 塑料 | abc
红色 | 大 | 塑料 | 使得双方的
红色 | 大 | 塑料 | ffff
红色 | 大 | 塑料 | sfefe
红色 | 中 | 金属 | abc
红色 | 中 | 金属 | 使得双方的
红色 | 中 | 金属 | ffff
红色 | 中 | 金属 | sfefe
红色 | 中 | 混合物 | abc
红色 | 中 | 混合物 | 使得双方的
红色 | 中 | 混合物 | ffff
红色 | 中 | 混合物 | sfefe
红色 | 中 | 塑料 | abc
红色 | 中 | 塑料 | 使得双方的
红色 | 中 | 塑料 | ffff
红色 | 中 | 塑料 | sfefe
红色 | 小 | 金属 | abc
红色 | 小 | 金属 | 使得双方的
红色 | 小 | 金属 | ffff
红色 | 小 | 金属 | sfefe
红色 | 小 | 混合物 | abc
红色 | 小 | 混合物 | 使得双方的
红色 | 小 | 混合物 | ffff
红色 | 小 | 混合物 | sfefe
红色 | 小 | 塑料 | abc
红色 | 小 | 塑料 | 使得双方的
红色 | 小 | 塑料 | ffff
红色 | 小 | 塑料 | sfefe
黑色 | 大 | 金属 | abc
黑色 | 大 | 金属 | 使得双方的
黑色 | 大 | 金属 | ffff
黑色 | 大 | 金属 | sfefe
黑色 | 大 | 混合物 | abc
黑色 | 大 | 混合物 | 使得双方的
黑色 | 大 | 混合物 | ffff
黑色 | 大 | 混合物 | sfefe
黑色 | 大 | 塑料 | abc
黑色 | 大 | 塑料 | 使得双方的
黑色 | 大 | 塑料 | ffff
黑色 | 大 | 塑料 | sfefe
黑色 | 中 | 金属 | abc
黑色 | 中 | 金属 | 使得双方的
黑色 | 中 | 金属 | ffff
黑色 | 中 | 金属 | sfefe
黑色 | 中 | 混合物 | abc
黑色 | 中 | 混合物 | 使得双方的
黑色 | 中 | 混合物 | ffff
黑色 | 中 | 混合物 | sfefe
黑色 | 中 | 塑料 | abc
黑色 | 中 | 塑料 | 使得双方的
黑色 | 中 | 塑料 | ffff
黑色 | 中 | 塑料 | sfefe
黑色 | 小 | 金属 | abc
黑色 | 小 | 金属 | 使得双方的
黑色 | 小 | 金属 | ffff
黑色 | 小 | 金属 | sfefe
黑色 | 小 | 混合物 | abc
黑色 | 小 | 混合物 | 使得双方的
黑色 | 小 | 混合物 | ffff
黑色 | 小 | 混合物 | sfefe
黑色 | 小 | 塑料 | abc
黑色 | 小 | 塑料 | 使得双方的
黑色 | 小 | 塑料 | ffff
黑色 | 小 | 塑料 | sfefe
黄色 | 大 | 金属 | abc
黄色 | 大 | 金属 | 使得双方的
黄色 | 大 | 金属 | ffff
黄色 | 大 | 金属 | sfefe
黄色 | 大 | 混合物 | abc
黄色 | 大 | 混合物 | 使得双方的
黄色 | 大 | 混合物 | ffff
黄色 | 大 | 混合物 | sfefe
黄色 | 大 | 塑料 | abc
黄色 | 大 | 塑料 | 使得双方的
黄色 | 大 | 塑料 | ffff
黄色 | 大 | 塑料 | sfefe
黄色 | 中 | 金属 | abc
黄色 | 中 | 金属 | 使得双方的
黄色 | 中 | 金属 | ffff
黄色 | 中 | 金属 | sfefe
黄色 | 中 | 混合物 | abc
黄色 | 中 | 混合物 | 使得双方的
黄色 | 中 | 混合物 | ffff
黄色 | 中 | 混合物 | sfefe
黄色 | 中 | 塑料 | abc
黄色 | 中 | 塑料 | 使得双方的
黄色 | 中 | 塑料 | ffff
黄色 | 中 | 塑料 | sfefe
黄色 | 小 | 金属 | abc
黄色 | 小 | 金属 | 使得双方的
黄色 | 小 | 金属 | ffff
黄色 | 小 | 金属 | sfefe
黄色 | 小 | 混合物 | abc
黄色 | 小 | 混合物 | 使得双方的
黄色 | 小 | 混合物 | ffff
黄色 | 小 | 混合物 | sfefe
黄色 | 小 | 塑料 | abc
黄色 | 小 | 塑料 | 使得双方的
黄色 | 小 | 塑料 | ffff
黄色 | 小 | 塑料 | sfefe
紫色 | 大 | 金属 | abc
紫色 | 大 | 金属 | 使得双方的
紫色 | 大 | 金属 | ffff
紫色 | 大 | 金属 | sfefe
紫色 | 大 | 混合物 | abc
紫色 | 大 | 混合物 | 使得双方的
紫色 | 大 | 混合物 | ffff
紫色 | 大 | 混合物 | sfefe
紫色 | 大 | 塑料 | abc
紫色 | 大 | 塑料 | 使得双方的
紫色 | 大 | 塑料 | ffff
紫色 | 大 | 塑料 | sfefe
紫色 | 中 | 金属 | abc
紫色 | 中 | 金属 | 使得双方的
紫色 | 中 | 金属 | ffff
紫色 | 中 | 金属 | sfefe
紫色 | 中 | 混合物 | abc
紫色 | 中 | 混合物 | 使得双方的
紫色 | 中 | 混合物 | ffff
紫色 | 中 | 混合物 | sfefe
紫色 | 中 | 塑料 | abc
紫色 | 中 | 塑料 | 使得双方的
紫色 | 中 | 塑料 | ffff
紫色 | 中 | 塑料 | sfefe
紫色 | 小 | 金属 | abc
紫色 | 小 | 金属 | 使得双方的
紫色 | 小 | 金属 | ffff
紫色 | 小 | 金属 | sfefe
紫色 | 小 | 混合物 | abc
紫色 | 小 | 混合物 | 使得双方的
紫色 | 小 | 混合物 | ffff
紫色 | 小 | 混合物 | sfefe
紫色 | 小 | 塑料 | abc
紫色 | 小 | 塑料 | 使得双方的
紫色 | 小 | 塑料 | ffff
紫色 | 小 | 塑料 | sfefe
分享到：
相关推荐
在某些场景下，我们可能需要对二维数组进行特定的排序，例如顺时针排序或逆时针排序。顺时针排序意味着从数组的左上角开始，沿着顺时针方向依次访问元素；逆时针排序则是从左上角开始，沿着逆时针方向进行。这样的...
以类型int[][]声明一个叫matrix的二维数组变量，将矩阵初始化为一个5个元素的数组。 以下列方式为matrix的内部元素赋值：matrix从零开始循环到其长度值；例如索引为i，在每次迭代中，将matrix[i]指向一个新的整数数...
通过以上实验，我们不仅学习了数组排序和折半查找算法的基础知识，还掌握了如何使用一维数组实现栈，并利用栈来解决实际问题——将十进制数转换为二进制数。这些技能对于深入理解数据结构和算法非常有帮助，并且能够...
动态规划则能避免这个问题，通过一个二维数组存储已计算的组合值。 排列是指从n个不同元素中选取m个元素，并且考虑选取的顺序。排列的数量为P(n, m) = n! / (n-m)!。Java中实现排列可以使用回溯法或者迭代法。回溯...
虽然Java 5.0的`Arrays.sort()`方法不能直接用于多维数组，但可以通过递归或循环的方式，对二维数组的每一行进行单独排序。 四、`Collections.sort()`与`List` 除了`Arrays.sort()`，Java 5.0的`Collections.sort...
程序员可能会定义一个二维数组，其中每个元素表示杨辉三角的一行。数组的第一维表示行数，第二维表示行内的位置。初始化第一行为{1}，然后通过迭代每一行，根据上一行的值计算出当前行的值。这种方式直观且易于理解...
在实际编程中，还可以对这个程序进行优化，比如使用ArrayList动态增长数组，或者使用递归方法来生成每一行，进一步提高代码的灵活性和可读性。此外，为了使代码更易理解和复用，可以将生成杨辉三角的功能封装成一个...
在Java编程中，我们可以创建一个二维数组来表示这个结构，然后通过循环或递归来填充数组并打印出结果。 首先，我们需要理解杨辉三角形的规则。每一行的开头和结尾都是1，中间的数字由其上一行的相邻两个数字相加...
在Java编程语言中，递归遍历矩阵是一种常见的操作，特别是在处理二维数组或者图像数据时。这个压缩包“基于java的递归遍历矩阵源代码.zip”包含了一个名为“Matrix.java”的源文件，很可能是实现了矩阵的递归遍历...
在Java中，可以创建一个二维数组，并用两层循环来填充和打印乘法表的内容，这涉及到数组操作和嵌套循环的知识。这对于理解和处理表格型数据非常有帮助。 1.3章节的余弦曲线涉及到更复杂的数学和图形绘制。在Java中...
总的来说，Java实现奇数阶幻方涉及到数据结构（二维数组）、逻辑控制（填充算法）、数学计算（检查和调整）以及可视化展示（可能的图片输出）。这是一种很好的结合了编程和数学思维的练习，对于提升编程技巧和理解...
2. 二维数组中查找目标值：在Java中处理二维数组的问题，通常需要考虑如何遍历数组。解决这类问题时要注意边界条件的检查，以避免数组越界异常。 3. 替换字符串中的空格：这需要了解Java字符串不可变的特性，实际上...
在Java中，二维数组可以表示为一个矩阵。要计算反对角线的和，你需要遍历数组，同时检查元素是否位于从左上到右下的对角线上。可以用两个嵌套循环实现，外层循环遍历行，内层循环遍历列，对角线上的元素索引满足 `i...
我们可以创建一个二维数组dp[n+1][k+1]，初始化dp[0][0] = 1，并根据组合数的计算公式填充数组的其余部分。 在Java代码中，这可能看起来像这样： ```java public static int combination(int n, int k) { if (k =...
在Java中，可以通过创建一个二维数组并自底向上填充来生成。给出的代码使用了图形化界面（GUI）显示巴斯卡三角形，展示了每个位置的组合数。组合数可以用组合公式C(n, k) = n! / (k!(n-k)!）计算，其中n代表总项目数...
C语言以其简洁和高效著称，它的实现通常会利用二维数组来存储杨辉三角形的数据。程序可能会通过一个循环控制行数，再通过内部循环计算每行的每个元素。在C语言中，数组索引从0开始，因此在计算元素时需要注意边界...
4. 多维数组：Java支持多维数组，如二维数组`int[][] matrix = new int[3][4];`代表一个3行4列的矩阵。 在实际应用中，理解并熟练掌握数组的排序和查找是至关重要的，它们构成了许多高级算法的基础。通过深入学习...
在Java中实现，首先需要创建一个二维数组表示游戏地图，用数字0到8来标记周围的雷数。然后，通过随机函数确定雷的位置。游戏的核心在于点击和标记操作，这需要处理鼠标事件，更新显示区域，并检查是否赢得游戏或触发...