「java数组对象递归」js递归处理一个多层对象数组
本篇文章给大家谈谈java数组对象递归，以及js递归处理一个多层对象数组对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
java 算法设计 多数组递归操作
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ArrayAssemble {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
Integer[] arrOfInt = { 1, 2, 3 };
@SuppressWarnings("unused")
Character[] arrOfChar1 = { 'a', 'b', 'c' };
@SuppressWarnings("unused")
Character[] arrOfChar2 = { '!', '@', '#' };
String[] arrOfStr = { "lmy", "lyb", "mz", "yx" };
System.out.println("以下是组合后的数组");
// List arrayList = assembleArraysToList(arrOfInt);
// for (int n = 0; n arrayList.size(); n++) {
// Object obj = arrayList.get(n);
// if (obj instanceof Object[]) {
// Object[] objArr = (Object[]) obj;
// System.out.println(Arrays.toString(objArr));
// } else {
// System.out.println(obj);
// }
//
// }
Object[][] objectsArrays = assembleArraysToPlanerArray(new Object[][] {
arrOfInt, arrOfChar1, arrOfChar2, arrOfStr });
for (Object[] objArrays : objectsArrays) {
System.out.println(Arrays.toString(objArrays));
}
}
// 方法一：使用可变参数方法返回数组类型的List
@SuppressWarnings("unchecked")
public static List assembleArraysToList(Object[]... objects) {
List arrayList = new ArrayList();
// 遍历方法的参数
for (int i = 0; i objects.length; i++) {
if (i == 0) {
// 对于第一个数组参数,先将其转变成List类型,以便能使用辅助方法进行处理
arrayList = Arrays.asList(objects[i]);
} else {
// 对从第二个参数开始的数组与前面组合过的列表进行组合
arrayList = assembleArrayToList(arrayList, objects[i]);
}
}
return arrayList;
}
// 方法一的辅助方法：将一个数组类型或对象类型的List与数组组合，并返回List
@SuppressWarnings("unchecked")
public static List assembleArrayToList(List aList, Object[] array) {
List arrList = new ArrayList();
// 遍历aList,将array与aList进行组合
for (int i = 0; i aList.size(); i++) {
Object obj = aList.get(i);
// 检查aList的元素是否是数组类型的，如果不是，则直接产生组合列表
if (obj instanceof Object[]) {
Object[] listArr = (Object[]) obj;
// 对数组类型的aList元素与array进行组合
for (int k = 0; k array.length; k++) {
Object[] newListArr = new Object[listArr.length + 1];
for (int j = 0; j listArr.length; j++) {
newListArr[j] = listArr[j];
}
newListArr[listArr.length] = array[k];
arrList.add(newListArr);
}
} else {
// 对非数组类型的aList元素与array进行组合
for (int j = 0; j array.length; j++) {
Object[] arrObj = { aList.get(i), array[j] };
arrList.add(arrObj);
}
}
}
return arrList;
}
// 方法二：使用二维数组参数方法返回组合的二维数组类型，并使用了递归
@SuppressWarnings("unchecked")
public static Object[][] assembleArraysToPlanerArray(Object[][] objectArrays) {
if (objectArrays.length == 2) {
Object[] assembledArray = objectArrays[0];
Object[] array = objectArrays[1];
return assembleArrayToArray(assembledArray, array);
} else if (objectArrays.length = 1) {
return objectArrays;
} else {
Object[] objArray = objectArrays[objectArrays.length - 1];
objectArrays = Arrays.copyOf(objectArrays, objectArrays.length - 1);
return assembleArrayToArray(
assembleArraysToPlanerArray(objectArrays), objArray);
}
}
// 方法二的辅助方法：将一个数组类型或二维数组类型与数组组合，并返回二维数组
public static Object[][] assembleArrayToArray(Object[] assembledArray,
Object[] array) {
int lenAssArray = assembledArray.length;
int lenArray = array.length;
Object[][] objArrays = new Object[lenAssArray * lenArray][];
for (int i = 0; i lenAssArray; i++) {
Object obj = assembledArray[i];
if (obj instanceof Object[]) {
Object[] objArr = (Object[]) obj;
int lenObjArr = objArr.length;
for (int k = 0; k lenArray; k++) {
// 复制objArr数组到newListArr数组，并将其长度加一
Object[] newListArr = Arrays.copyOf(objArr, lenObjArr + 1);
//将array数组的第k+1元素赋值给newListArr数组最后的元素,并将newListArr赋值给objArrays数组的第k+1个元素
newListArr[lenObjArr] = array[k];
objArrays[lenArray * i + k] = newListArr;
}
} else {
for (int j = 0; j lenArray; j++) {
Object[] newObjArray = { obj, array[j] };
objArrays[lenArray * i + j] = newObjArray;
}
}
}
return objArrays;
}
}
//我自己写的方法，用了一天的时间，希望能够采纳,对了，运行环境是JDK1.6
Java给定数组，用递归方法判定是否有序
public class Main {
public static void main(String[] args) {
int []A={1,2,3};
System.out.println(isArrayInSortedOrder(A,A.length));
}
//1.给定一个数组，用递归方法判定数组元素是否有序
static int isArrayInSortedOrder(int[] A, int index){
if (A.length==1) return 1;
return (A[index-1]=A[index-2])?0:isArrayInSortedOrder(A,index-1);
}
}
java中递归算法是什么怎么算的？
一、递归算法基本思路：
Java递归算法是基于Java语言实现的递归算法。递归算法是一种直接或者间接调用自身函数或者方法的算法。递归算法实质是把问题分解成规模缩小的同类问题的子问题，然后递归调用方法表示问题的解。递归往往能给我们带来非常简洁非常直观的代码形式，从而使我们的编码大大简化，然而递归的思维确实跟我们的常规思维相逆的，通常都是从上而下的思维问题，而递归趋势从下往上的进行思维。
二、递归算法解决问题的特点：
【1】递归就是方法里调用自身。
【2】在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。
【3】递归算法代码显得很简洁，但递归算法解题的运行效率较低。所以不提倡用递归设计程序。
【4】在递归调用的过程中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等，所以一般不提倡用递归算法设计程序。
【5】在做递归算法的时候，一定把握出口，也就是做递归算法必须要有一个明确的递归结束条件。这一点是非常重要的。其实这个出口就是一个条件，当满足了这个条件的时候我们就不再递归了。
三、代码示例：
public class Factorial {
//this is a recursive function
int fact(int n){
if (n==1) return 1;
return fact(n-1)*n;
}
}
public class TestFactorial {
public static void main(String[] args) {
// TODO Auto-generated method stub
Factorial factorial=new Factorial();
System.out.println("factorial(5)="+factorial.fact(5));
}
}
代码执行流程图如下：
此程序中n=5就是程序的出口。
java 递归替换复杂对象属性值
本示例中又三个对象嵌套：
UserBO：复杂对象，其中一个属性是ListAddressBO或者MapAddressBO
AddressBO：其中一个属性是SubAddressBO
SubAddressBO：包含目标属性addrId，且是string类型，查找addrId的值
任务：UserBO是一个复杂对象，该对象中肯定存在目标属性addrId（String类型,递归方法只能找string类型的属性，找其他类型自行修改代码），只是不知道addrId在哪个子属性中，如果UserBO存在多个addrId属性，那么只遍历出遇到的第一个addrId的值即可。
注意：（本例子在遍历复杂对象时，如果找到第一个目标属性，则退出，不在继续遍历，后面bolg有遍历复杂对象所有属性的文章）
1、本示例提供了两种方法来获取复杂对象中指定属性的值，一种是利用递归，另一种是直接把复杂对象转换成json串，再截取。
2、本示例对于复杂对象中不包含目标属性时，会返回空字符串。
3、目标属性可以存在于自定义类、list、map、数组中
4、复杂对象可以是复杂嵌套的BO/ListBO/MapObject,BO,目标属性存在于BO中
5、对于复杂对象是这种嵌套格式(ListListBO/ListMapObject,BO/MapObject,ListBO)的没有做测试
————————————————
版权声明：本文为CSDN博主「一路奔跑1314」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：
java数组对象递归的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于js递归处理一个多层对象数组、java数组对象递归的信息别忘了在本站进行查找喔。