java递归查询方法代码 java递归查找文件

java的递归查询怎么写

原文在这里，写得不错，楼主可参考下，具体链接如下，我只是搬运工！

十载的青田网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。成都全网营销的优势是能够根据用户设备显示端的尺寸不同，自动调整青田建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。成都创新互联从事“青田网站设计”,“青田网站推广”以来，每个客户项目都认真落实执行。

/** 

* 说明方法描述：将list转为树tree结构 

*  

* @param allRrecords 

* @return 

* @time 2016年5月10日 下午6:00:35 

* @author yangdong 

*/  

public ListRecord useListRecordToTree(ListRecord allRrecords) {  

ListRecord listParentRecord = new ArrayListRecord();  

ListRecord listNotParentRecord = new ArrayListRecord();  

// 第一步：遍历allRrecords保存所有数据的uuid用于判断是不是根节点  

MapString, String mapAllUuid = new HashMapString, String();  

MapString, Record allRecordMap = new HashMapString, Record();  

for (Record record : allRrecords) {  

mapAllUuid.put(record.getStr("uuid"), record.getStr("uuid"));  

allRecordMap.put(record.getStr("uuid"), record);  

}  

// 第二步：遍历allRrecords找出所有的根节点和非根节点  

if (allRrecords != null  allRrecords.size()  0) {  

for (Record record : 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 (Record record : listParentRecord) {  

// 添加所有子级  

record.set("childs", this.getTreeChildRecord(listNotParentRecord, record.getStr("uuid")));  

}  

}  

return listParentRecord;  

}  

/** 

* 说明方法描述：使list转换为树并根据关键字和节点名称过滤 

*  

* @param allRecords 所有节点 

* @param keywords 要过滤的关键字 

* @param filterFields 要过滤的字段 

* @return 

* @time 2016年5月19日 下午3:27:32 

* @author yangdong 

*/  

public ListRecord useListRecordToTreeByKeywords(ListRecord allRecords, String keywords, String... filterFields) {  

ListRecord listRecord = new ArrayListRecord();  

MapString, Record allRecordMap = new HashMapString, Record();  

for (Record record : allRecords) {  

allRecordMap.put(record.getStr("uuid"), record);  

}  

// 遍历allRrecords找出所有的nodeName和关键字keywords相关的数据  

if (allRecords != null  allRecords.size()  0) {  

if (filterFields.length  1) {  

for (Record record : allRecords) {  

for (String field : filterFields) {  

// 比较  

if (record.getStr(field).toLowerCase().indexOf(keywords.toLowerCase()) != -1) {  

listRecord.add(record);  

}  

}  

}  

} else {  

for (Record record : allRecords) {  

// 比较  

if (record.getStr(filterFields[0]).toLowerCase().indexOf(keywords.toLowerCase()) != -1) {  

listRecord.add(record);  

}  

}  

}  

}  

// 查找过滤出来的节点和他们的父节点  

listRecord = this.getSelfAndTheirParentRecord(listRecord, new ArrayListRecord(),  

new HashMapString, Record(), allRecordMap);  

// 将过滤出来的数据变成树tree结构  

listRecord = this.useListRecordToTree(listRecord);  

return listRecord;  

}  

/** 

* 说明方法描述：递归查询子节点 

*  

* @param childList 子节点 

* @param parentUuid 父节点id 

* @return 

* @time 2016年5月10日 下午3:29:35 

* @author yangdong 

*/  

private ListRecord getTreeChildRecord(ListRecord childList, String parentUuid) {  

ListRecord listParentRecord = new ArrayListRecord();  

ListRecord listNotParentRecord = new ArrayListRecord();  

// 遍历tmpList，找出所有的根节点和非根节点  

if (childList != null  childList.size()  0) {  

for (Record record : childList) {  

// 对比找出父节点  

if (StringUtil.equals(record.getStr("parent_uuid"), parentUuid)) {  

listParentRecord.add(record);  

} else {  

listNotParentRecord.add(record);  

}  

}  

}  

// 查询子节点  

if (listParentRecord.size()  0) {  

for (Record record : listParentRecord) {  

// 递归查询子节点  

record.set("childs", getTreeChildRecord(listNotParentRecord, record.getStr("uuid")));  

}  

}  

return listParentRecord;  

}  

/** 

* 说明方法描述：递归找出本节点和他们的父节点 

*  

* @param parentList 根据关键字过滤出来的相关节点的父节点 

* @param resultList 返回的过滤出来的节点 

* @param filterRecordMap 已经过滤出来的节点 

* @param allRecordMap 所有节点 

* @return 

* @time 2016年5月19日 上午9:53:56 

* @author yangdong 

*/  

private ListRecord getSelfAndTheirParentRecord(ListRecord parentList, ListRecord resultList,  

MapString, Record filterRecordMap,  

MapString, Record allRecordMap) {  

// 当父节点为null或者节点数量为0时返回结果，退出递归  

if (parentList == null || parentList.size() == 0) {  

return resultList;  

}  

// 重新创建父节点集合  

ListRecord listParentRecord = new ArrayListRecord();  

// 遍历已经过滤出来的节点  

for (Record record : parentList) {  

String uuid = record.getStr("uuid");  

String parent_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)) {  

Record parentRecord = allRecordMap.get(parent_uuid);  

if (parentRecord != null) {  

listParentRecord.add(parentRecord);  

allRecordMap.remove(parent_uuid);  

}  

}  

}  

// 递归调用  

getSelfAndTheirParentRecord(listParentRecord, resultList, filterRecordMap, allRecordMap);  

return resultList;  

}  

[java] view plain copy

//示例  

[java] view plain copy

/** 

* 说明方法描述：递归查询所有权限 

*  

* @param keyword 

* @param is_deleted 

* @return 

* @time 2016年5月10日 下午3:47:50 

* @author yangdong 

*/  

public ListRecord getRecordByKeywordRecursive(String keyword, String is_deleted) {  

// 第一步：查询所有的数据  

StringBuffer sql = new StringBuffer(  

" select pa.uuid,pa.parent_uuid,pa.author_code,pa.author_name,pa.is_menu,pa.sort_number,pa.is_enable,pa.menu_icon ");  

sql.append("  from s_author pa");  

ListObject params = new ArrayListObject();  

sql.append(" where  pa.is_deleted=? ");  

params.add(is_deleted);  

sql.append(" order by pa.sort_number asc ");  

ListRecord allRrecords = Db.use(AppConst.DB_DATASOURCE_MAIN).find(sql.toString(), ParamUtil.listToArray(params));  

[java] view plain copy

//第二步：将list变为树tree结构  

if (StringUtil.isNotBlank(keyword)) {  

return super.useListRecordToTreeByKeywords(allRrecords, keyword, "author_name");  

} else {  

return super.useListRecordToTree(allRrecords);  

}  

}

JAVA的递归查询指定后缀名文件的问题

你的程序只打印指定目录下的“.java”文件,是因为dir.listFiles(new FilenameFilter());只返回过滤后的文件列表,所以返回的是指定目录下的“.java”文件

你的程序我帮你改好了,你看看吧

import java.io.*;

class test2

{

public static void main(String[] args) 

{

File fi=new File("D:\\BD\\java2016");   //指定查找目录

showdir(fi);

}

public static void showdir(File dir) //定义一个返回目录中所有文件的方法showdir

{

if(dir.isDirectory())

{        //判断是否目录，

File[] files=dir.listFiles(new FilenameFilter()   //定义过滤器，过滤文件类型为.java的文件

{

public boolean accept(File dir,String name)

{

return name.endsWith(".java");

}

});

for(int x=0;xfiles.length;x++)        //打印以.java结尾的文件名

{

System.out.println(files[x]); 

}

File[] files1=dir.listFiles();   //定义没有过滤器的文件列表

for(int x=0;xfiles1.length;x++)        

{

if(files1[x].isDirectory())   //如果是目录则递归调用showdir方法,不是目录则忽略

showdir(files1[x]);  

}

}

} 

}

java递归方法

一般递归只实现一个方向的逻辑，把两个方向的逻辑放到一方法里并不好，不容易控制，实现也很麻烦，考虑到维护时的难度请不要在实际项目中使用。

搞了好一会，搞出个这样的输出2N-1行星号，中间最长的一行不重复，如果楼主希望重复中间一行，可以对代码做一点点改动。

/**

* 入口，传入N

*/

public static void printStar(int number){

printStar2(number, number, 1);

}

/**

*

* @param number 给定的N

* @param oldNumber 给定的N

* @param direction 递归时的方向

*/

public static void printStar2(int number,int oldNumber, int direction){

if(number==0)direction++;

String s="";

int i = number;

if(direction==1){

for(;ioldNumber;i++){

s+="*";

}

number--;

}else{

for(;ioldNumber;i++){

s+="*";

}

number++;

if(numberoldNumber){

return;

}

}

printStar2(number,oldNumber,direction);

System.out.println(s);

}

-----------------------------------------------------------------------------------------

运行效果：

printStar(5);

*

**

***

****

*****

****

***

**

*

java递归:查询e盘下所有文件夹及其子文件夹里名为s的文件并打印,s为从控制台输入的需要查询的文件名

public static void main(String[] args) throws Exception {

System.out.print("请输入检索的盘符:");

Scanner input = new Scanner(System.in);

String pf = input.next();

System.out.print("请输入检索的字符串:");

String s = input.next();

File file = new File(pf + ":/");

if (!file.isDirectory()) {

System.out.println("盘符不存在,或没有内容!");

return;

}

js(file, s);

}

public static void js(File file, String s) throws Exception {

if (file == null)

return;

if (file.isFile()) {// 判断是否是文件

String name = file.getName();// 取得文件的名字

// 文件的名字没有去掉后缀，这段代码你自己写吧。

name = name == null ? "" : name.trim();

String path = file.getPath();// 取得文件路径

if (name.equalsIgnoreCase(s))// 如果文件名于录入的字符串相等打印文件路径

System.out.println(path);

}

File[] files = file.listFiles();// 取得文件夹中包含的文件及文件夹

if (files == null || files.length = 0)

return;// 如果没有其中没有文件或文件夹，返回

for (File file2 : files) {// 循环其下所有文件及文件夹

js(file2, s);// 递归

}

}

大体上是这样的。

一段JAVA的递归代码

下面递归写了一段递归累加到100，每加20个就换行输出。

package zhidao;

public class Digui {

public static int add(int num){

int sum = 0;

StringBuffer sb = new StringBuffer();

if (num = 0) {

return 0;

}else{

if (num == 1) {

sum = sum+1;

}else {

sum = add(num-1)+num;

}

if (num % 20 == 0) {

System.out.println("[index = "+num+" sum = "+sum+"]");

}else {

System.out.print("[index = "+num+" sum = "+sum+"],");

}

}

return sum;

}

public static void main(String[] args) {

add(100);

}

}

java 递归查询数据库

这个就是个树形结构，数据结构里的东西。查询后构建一个树就行了。稍后给你一个代码。