本文目录一览：
Java里的递归方法是不是一定要是静态方法啊？
java常用递归代码
//Top代表树的的根节点
private void showNodeList(CollectionNode topList){
for(Node top:topList)
{
//显示顶点
System.out.println(top.getName());
//显示子树
showNodeList(top.getChildren())
}
}
所谓递归就是循环，就是调用你本身的循环体，需要一个出口，不然就是死循环。
请看一个简单的例子
说明：此方法就是调用了递归，recursion(car,i)自已调用了自已的方法。从此方法中，可以先对它进行了传递参数，分别是car(值)，i（对递归次数的控制）,car=2*(car-3000)这是对car第一次的计算，用if判断是否结束，在这个if判断中把每次递归都放入car，进行计算的值返回。这个递归直到12次，计算car的值都放入了car中，打印出car的总和，结束（出口）
缺点：由此可见递归就是调用自已的，方法与方法之间，类与类之间都可以。当然那我们在使用其的时候，要声明一个操作的终结点（出口）。递归调用会增加内存负担，因为每次调用一回方法都要开辟一段栈空间（先进后出），知道该方法满足条件后才释放。有结束条件了，是非常好的，否则你的递归程序会因为栈空间不足而中止的。
坏处：因为递归需要你的操作系统中的堆和栈，所以空间消耗上要比非递归代码要大的多，而且递归深度太大了，可能系统支撑不了。
用一个方法就可以取到下面所有的子树的集合但方法中传递的时候传递的参数必须是集合，然后遍历此集合，让每一元素通过select * from Id=??去那其下面的子集合，然后遍历出来的子集合直接作为一个参数传递你写的这个方法中，也就是再此调用下此方法，这样最后就可以把每一个分支中的集合都传递过来，最后拿到每个分支中的最后一个分支对象传递过来后，就发现这就是要For循环得到的对象。
Java程序调用自身叫做递归,所以不是一定要静态。
java 递归
/**
* Given a String, return true if the following types of brackets are
* balanced and properly nested. () {} []
*
* @param str
* String
* @return true if bracket match success
*/
public static boolean bracketMatch(String str) {
if (str == null || "".equals(str))
return true;
str = str.replaceAll("[^\\[\\]\\(\\)\\{\\}]", "");
int len = str.length();
if (len == 0)
return true;
if (len % 2 != 0) {
return false;
}
StringBuilder prev = new StringBuilder(len);
StringBuilder back = new StringBuilder(len);
prev.append(str.charAt(0));
back.append(str.substring(1, str.length()));
return bracketMatch(prev, back, len);
}
/**
* like public bracketMatch
*
* @param prev
* The front half of the string
* @param back
* The back half of the string
* @param len
* length of String
* @return true if bracket match success
*/
private static boolean bracketMatch(StringBuilder prev, StringBuilder back,
int len) {
if (prev.length() len / 2)
return false;
// the first char in the back half of the string
char backFirst = back.charAt(0);
//the last char in the front half of the string
char prevLast = prev.charAt(prev.length() - 1);
// match ok
if ((backFirst == ']' prevLast == '[')
|| (backFirst == ')' prevLast == '(')
|| (backFirst == '}' prevLast == '{')
|| (backFirst == '' prevLast == '')) {
//delete two chars matched
prev.deleteCharAt(prev.length() - 1);
back.deleteCharAt(0);
len -= 2;
} else {
//move backFirst to the end of prev
prev.append(backFirst);
//delete the first char in the back
back.deleteCharAt(0);
}
if (back.length() == 0) {
if (prev.length() == 0) {
return true;
} else {
return false;
}
} else {
return bracketMatch(prev, back, len);
}
}
用java递归方法实现
1、递归做为一种算法在程序设计语言中广泛使用，是指函数/过程/子程序在运行过程中直接或间接调用自身而产生的重入现象。
2、递归算法一般用于解决三类问题：
1）数据的定义是按递归定义的。（Fibonacci（斐波那契）的函数）
2）问题解法按递归算法实现。（回溯）
3）数据的结构形式是按递归定义的。（树的遍历，图的搜索）
java递归的优点缺点
递归好处：代码更简洁清晰，可读性更好
递归可读性好这一点，对于初学者可能会反对。实际上递归的代码更清晰，但是从学习的角度要理解递归真正发生的什么，是如何调用的，调用层次和路线，调用堆栈中保存了什么，可能是不容易。但是不可否认递归的代码更简洁。一般来说，一个人可能很容易的写出前中后序的二叉树遍历的递归算法，要写出相应的非递归算法就比较考验水平了，恐怕至少一半的人搞不定。所以说递归代码更简洁明了。
递归坏处：由于递归需要系统堆栈，所以空间消耗要比非递归代码要大很多。而且，如果递归深度太大，可能系统撑不住。
个人觉得：非必要时不递归
JAVA中的递归方法，求讲一下。
方法递归和循环语句差不多，打个比喻。方法递归是小明上楼拿东西，一楼，二楼，三楼……楼顶。在楼顶拿到想要的东西以后，你总不能直接跳下来吧。你得一层一层的返回下来。循环就是驴拉磨，你转多少圈都是在原地。变化的只是盘子里的东西有变化。方法递归不会进入死循环，但陷的太深系统会崩溃。
答得不好抱歉
java递归问题
用map，key就是你的a1,a2,a3,value就是你的值
递归写的时候就可以取key和value了
