java递归怎么写
A. 用java递归方法实现
publicintfun(intn){
if(n==0||n==1)return1;
returnn*fun(n-1);
}
B. java的递归查询怎么写
原文在这里，写得不错，楼主可参考下，具体链接如下，我只是搬运工！
http://blog.csdn.net/u011627980/article/details/51454323
/**
*说明方法描述：将list转为树tree结构
*
*@paramallRrecords
*@return
*@time2016年5月10日下午6:00:35
*@authoryangdong
*/
publicList<Record>useListRecordToTree(List<Record>allRrecords){
List<Record>listParentRecord=newArrayList<Record>();
List<Record>listNotParentRecord=newArrayList<Record>();
//第一步：遍历allRrecords保存所有数据的uuid用于判断是不是根节点
Map<String,String>mapAllUuid=newHashMap<String,String>();
Map<String,Record>allRecordMap=newHashMap<String,Record>();
for(Recordrecord:allRrecords){
mapAllUuid.put(record.getStr("uuid"),record.getStr("uuid"));
allRecordMap.put(record.getStr("uuid"),record);
}
//第二步：遍历allRrecords找出所有的根节点和非根节点
if(allRrecords!=null&&allRrecords.size()>0){
for(Recordrecord:allRrecords){
if(StringUtil.isBlank(record.getStr("parent_uuid"))
||!mapAllUuid.containsKey(record.getStr("parent_uuid"))){
listParentRecord.add(record);
}else{
listNotParentRecord.add(record);
}
}
}
//第三步：递归获取所有子节点
if(listParentRecord.size()>0){
for(Recordrecord:listParentRecord){
//添加所有子级
record.set("childs",this.getTreeChildRecord(listNotParentRecord,record.getStr("uuid")));
}
}
returnlistParentRecord;
}
/**
*说明方法描述：使list转换为树并根据关键字和节点名称过滤
*
*@paramallRecords所有节点
*@paramkeywords要过滤的关键字
*@paramfilterFields要过滤的字段
*@return
*@time2016年5月19日下午3:27:32
*@authoryangdong
*/
publicList<Record>useListRecordToTreeByKeywords(List<Record>allRecords,Stringkeywords,String...filterFields){
List<Record>listRecord=newArrayList<Record>();
Map<String,Record>allRecordMap=newHashMap<String,Record>();
for(Recordrecord:allRecords){
allRecordMap.put(record.getStr("uuid"),record);
}
//遍历allRrecords找出所有的nodeName和关键字keywords相关的数据
if(allRecords!=null&&allRecords.size()>0){
if(filterFields.length>1){
for(Recordrecord:allRecords){
for(Stringfield:filterFields){
//比较
if(record.getStr(field).toLowerCase().indexOf(keywords.toLowerCase())!=-1){
listRecord.add(record);
}
}
}
}else{
for(Recordrecord:allRecords){
//比较
if(record.getStr(filterFields[0]).toLowerCase().indexOf(keywords.toLowerCase())!=-1){
listRecord.add(record);
}
}
}
}
//查找过滤出来的节点和他们的父节点
listRecord=this.getSelfAndTheirParentRecord(listRecord,newArrayList<Record>(),
newHashMap<String,Record>(),allRecordMap);
//将过滤出来的数据变成树tree结构
listRecord=this.useListRecordToTree(listRecord);
returnlistRecord;
}
/**
*说明方法描述：递归查询子节点
*
*@paramchildList子节点
*@paramparentUuid父节点id
*@return
*@time2016年5月10日下午3:29:35
*@authoryangdong
*/
privateList<Record>getTreeChildRecord(List<Record>childList,StringparentUuid){
List<Record>listParentRecord=newArrayList<Record>();
List<Record>listNotParentRecord=newArrayList<Record>();
//遍历tmpList，找出所有的根节点和非根节点
if(childList!=null&&childList.size()>0){
for(Recordrecord:childList){
//对比找出父节点
if(StringUtil.equals(record.getStr("parent_uuid"),parentUuid)){
listParentRecord.add(record);
}else{
listNotParentRecord.add(record);
}
}
}
//查询子节点
if(listParentRecord.size()>0){
for(Recordrecord:listParentRecord){
//递归查询子节点
record.set("childs",getTreeChildRecord(listNotParentRecord,record.getStr("uuid")));
}
}
returnlistParentRecord;
}
/**
*说明方法描述：递归找出本节点和他们的父节点
*
*@paramparentList根据关键字过滤出来的相关节点的父节点
*@paramresultList返回的过滤出来的节点
*@paramfilterRecordMap已经过滤出来的节点
*@paramallRecordMap所有节点
*@return
*@time2016年5月19日上午9:53:56
*@authoryangdong
*/
privateList<Record>getSelfAndTheirParentRecord(List<Record>parentList,List<Record>resultList,
Map<String,Record>filterRecordMap,
Map<String,Record>allRecordMap){
//当父节点为null或者节点数量为0时返回结果，退出递归
if(parentList==null||parentList.size()==0){
returnresultList;
}
//重新创建父节点集合
List<Record>listParentRecord=newArrayList<Record>();
//遍历已经过滤出来的节点
for(Recordrecord:parentList){
Stringuuid=record.getStr("uuid");
Stringparent_uuid=record.getStr("parent_uuid");
//如果已经过滤出来的节点不存在则添加到list中
if(!filterRecordMap.containsKey(uuid)){
listParentRecord.add(record);//添加到父节点中
filterRecordMap.put(uuid,record);//添加到已过滤的map中
allRecordMap.remove(uuid);//移除集合中相应的元素
resultList.add(record);//添加到结果集中
}
//找出本节点的父节点并添加到listParentRecord父节点集合中，并移除集合中相应的元素
if(StringUtil.isNotBlank(parent_uuid)){
RecordparentRecord=allRecordMap.get(parent_uuid);
if(parentRecord!=null){
listParentRecord.add(parentRecord);
allRecordMap.remove(parent_uuid);
}
}
}
//递归调用
getSelfAndTheirParentRecord(listParentRecord,resultList,filterRecordMap,allRecordMap);
returnresultList;
}
[java]viewplain
//示例
[java]viewplain
/**
*说明方法描述：递归查询所有权限
*
*@paramkeyword
*@paramis_deleted
*@return
*@time2016年5月10日下午3:47:50
*@authoryangdong
*/
publicList<Record>getRecordByKeywordRecursive(Stringkeyword,Stringis_deleted){
//第一步：查询所有的数据
StringBuffersql=newStringBuffer(
"selectpa.uuid,pa.parent_uuid,pa.author_code,pa.author_name,pa.is_menu,pa.sort_number,pa.is_enable,pa.menu_icon");
sql.append("froms_authorpa");
List<Object>params=newArrayList<Object>();
sql.append("wherepa.is_deleted=?");
params.add(is_deleted);
sql.append("orderbypa.sort_numberasc");
List<Record>allRrecords=Db.use(AppConst.DB_DATASOURCE_MAIN).find(sql.toString(),ParamUtil.listToArray(params));
[java]viewplain
//第二步：将list变为树tree结构
if(StringUtil.isNotBlank(keyword)){
returnsuper.useListRecordToTreeByKeywords(allRrecords,keyword,"author_name");
}else{
returnsuper.useListRecordToTree(allRrecords);
}
}
C. JAVA中的递归方法，求讲一下。
自己调用自己或几个方法相互调用。
最经典的是求正整数阶的算法：
int fact(int i){
if(i<=1)return 1;
return fact(i-1)*i;
}
多数递归方法可以转换成非递归方法。
一般同功能的非递归方法，执行效率要优于递归方法。但合理的使用递归方法，可以使代码结构更清晰，更有可读性，从而更方便维护。
D. 在JAVA中什么是递归有什么用
Java方法递归是指在一个方法的内部调用自身的过程，以此类推就是java方法递归的理解思想，具体来讲就是把规模大的问题转化为规模小的相似的子问题来解决。在函数实现时，因为解决大问题的方法和解决小问题的方法往往是同一个方法，所以就产生了函数调用它自身的情况。另外这个解决问题的函数必须有明显的结束条件，这样就不会产生无限递归的情况了。因此，java方法递归的两个条件就是，一通过递归调用来缩小问题规模，且新问题与原问题有着相同的形式；二存在一种简单情境，可以使递归在简单情境下退出。
E. Java递归写一个从10减到0的程序,怎么写
递归需要做到两个地方,第一明确应该在那个位置停止,第二:停止的条件是什么.不然就会成为死循环,
int a=0;
int b=mi(a);
System.out.println(b);
public static int mi(int aa){
int count=0;
if(aa==0){
return 0;
}
if(count<2){
int i=mi(aa-1);
}
return aa-i;
}
F. java中的递归方法是怎么样的请举例解析一下
自己调用自己或几个方法相互调用。
最经典的是求正整数阶的算法：
int fact(int i){
if(i<=1)return 1;
return fact(i-1)*i;
}
多数递归方法可以转换成非递归方法。
一般同功能的非递归方法，执行效率要优于递归方法。但合理的使用递归方法，可以使代码结构更清晰，更有可读性，从而更方便维护。
G. java递归怎么写31-32+33-34…+39
publicclassSpecialSum{
publicstaticvoidmain(String[]args){
System.out.println(sum(31,40));
}
publicstaticintsum(intstart,intend){
intsum=0;
if(start==end){
returnend%2==0?-1*end:end;
}
sum+=start%2==0?(-1*start):start;
returnsum+sum(start+1,end);
}
}
H. 求Java递归深入理解，比如循环里面写递归怎么写 求详细教程
递归实际上就是函数调用自己本身。
比如算一个整数的阶乘。传入参数4，求出4*3*2*1结果。代码如下：
public static int jiechen(int i)
{
if(i <= 1)
{
return 1;
}
else
{
return i*jiechen(i-1);
}
}
在这个函数中反复调用本身。
因为
jiechen(4) = 4*jiechen(3)
jiechen(3)=3*jiechen(2)
.....
递归的效率实际上并不高，不在不得已的情况下尽量不要递归
I. 什么是递归，用Java怎么实现
递归是函数调用自身，从而形成循环重复执行的现象。简单的示例名称为a的函数调用自身，a(){ a() } 。常见的用法比如处理树形结构数据，商品多级分类、多层级部门机构等
J. 怎么写 java 递归解决删除文件夹以及子文件
import java.util.Scanner;
import java.io.*;
public class Del {
/**
* @删除文件或文件夹 chsNight
*/
public static String adders;
public static void main(String[] args) throws IOException {
Scanner input = new Scanner(System.in);
System.out.print("请输入要删除的文件地址：");
adders = input.next();
System.out.print("确定删除？(Y/N)：");
String sfdel = input.next();
while (sfdel.equalsIgnoreCase("y")) {
del(adders);
break;
}
}
private static void del(String adders) {
File file = new File(adders);
if (file.isFile() == true) { // 如果是文件，直接删除
file.delete();
jg();
} else if (file.isDirectory() == true) { // 如果是文件夹
if (file.listFiles().length == 0) { // 如果是空文件夹
file.delete();
jg();
} else {
int zfiles = file.listFiles().length; // 子文件数量
File[] delfile = file.listFiles(); // 子文件路径
for (int i = 0; i < zfiles; i++) {
if (delfile[i].isDirectory()) {
del(delfile[i].getAbsolutePath()); // 递归调用del方法并取得子目录路径
}
System.out.println(delfile[i]);
delfile[i].delete();
}
file.delete();
jg();
}
} else {
System.out.println("删除失败：不存在该对象!");
}
}
public static void jg() {
System.out.println("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
System.out.println("\n" + adders + "删除成功！");
}
}