javalist递归

1. java list 迭代（递归）

要用递归

public static void showList(List<Menu> allMenu) {
if (allMenu == null || allMenu.size() == 0 ) {
return ;
} else {
Iterator<Menu> iter = allMenu.iterator() ;
while(iter.hasNext()) {
Menu m = iter.next();
// 打印信息或将信息保存到一个公共集合中
System.out.println(m.getMenuId());
showList(m.getChilds());
}
}
}

public static void main(String[] args) {
// 把所有内容的集合传入
showList(all);
}

2. 使用java递归方法遍历指定目录下所有子目录和子文件

import java.io.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
* 读取目录及子目录下指定文件名的路径 并放到一个数组里面返回遍历
* @author zdz8207
*
*/
public class FileViewer {
public static void main(String[] args) {
//List arrayList = FileViewer.getListFiles("d:/com","html",true);

//读取d:/com下的以java 结尾的文件 如有子目录，包含之（后缀名为null则为所有文件）
//List arrayList = FileViewer.getListFiles("d:/com","java",true);

//经试验，后缀不能不填写，否则编译不通过，提示“FileViewer.java:17: 非法的表达式开始”。
//另外后缀为""时的情况需要 增加到IF 里去，否则 后缀为""时，不会显示所有文件
List arrayList = FileViewer.getListFiles("d:/com","",true);
if(arrayList.isEmpty())
{
System.out.println("没有符号要求的文件");
}
else
{
String message = "";
message += "符号要求的文件数：" + arrayList.size() + "\r\n";
System.out.println(message);

for (Iterator i = arrayList.iterator(); i.hasNext();)
{
String temp = (String) i.next();
System.out.println(temp);
message += temp + "\r\n";
}
//将显示的文件路径写到指定的文件里，若文件不存在，则提示IO异常
//java.io.FileNotFoundException: d:\ajax\menu.txt (系统找不到指定的路径。)
//如果 加个文件是否存在的判断，如不存在就在当前目录新建一个，则更好。
appendMethod("d:/menu.txt",message);
}
}
public static List<String> fileList = new ArrayList<String>();

/**
*
* @param path 文件路径
* @param suffix 后缀名
* @param isdepth 是否遍历子目录
* @return
*/
public static List getListFiles(String path, String suffix, boolean isdepth)
{
File file = new File(path);
return FileViewer.listFile(file ,suffix, isdepth);
}

public static List listFile(File f, String suffix, boolean isdepth)
{
//是目录，同时需要遍历子目录
if (f.isDirectory() && isdepth == true)
{
File[] t = f.listFiles();
for (int i = 0; i < t.length; i++)
{
listFile(t[i], suffix, isdepth);
}
}
else
{
String filePath = f.getAbsolutePath();

System.out.println("suffix = "+suffix);
if(suffix =="" || suffix == null)
{
//后缀名为null则为所有文件
System.out.println("----------------");
fileList.add(filePath);
}
else
{
int begIndex = filePath.lastIndexOf(".");//最后一个.(即后缀名前面的.)的索引
String tempsuffix = "";

if(begIndex != -1)//防止是文件但却没有后缀名结束的文件
{
tempsuffix = filePath.substring(begIndex + 1, filePath.length());
}

if(tempsuffix.equals(suffix))
{
fileList.add(filePath);
}
System.out.println("|||||||||||||||||||");
}

}

return fileList;
}

/**
* 方法追加文件：使用FileWriter
* @param fileName
* @param content
*/
public static void appendMethod(String fileName, String content)
{
try
{
//打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
FileWriter writer = new FileWriter(fileName, true);
writer.write(content + "\r\n");
writer.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}

3. Java递归遍历集合

首先把这张表的所有数据查询出来放到一个集合中（集合为List1），然后遍历这个集合，先根据集合List1中的父编号查询到一个集合 ，这样把list1遍历的对象和根据父编号查询到的集合构建问一个对象放到集合中就可以达到你的目的了，一下为代码说明：

import java.util.List;
public class dto1 {
private things thing;//当前编号得到的对象
private List list;//父编号查询到的集合
public things getThing() {
return thing;
}
public void setThing(things thing) {
this.thing = thing;
}
public List getList() {
return list;
}
public void setList(List list) {
this.list = list;
}
}
*********************************************************************************

public class things {

private int number;
private String name;
private int parentnumber;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getParentnumber() {
return parentnumber;
}
public void setParentnumber(int parentnumber) {
this.parentnumber = parentnumber;
}
}
**************************************************************************

import java.util.ArrayList;
import java.util.List;
public class action {

public static void main(String[] args) {

List getlist=new ArrayList();
List list=new ArrayList();//list为你根据编号查询出来的集合

for(int i=0;i<list.size();i++)
{
things thing=(things)list.get(i);

int parentbumber=thing.getParentnumber();//得到父编号
List li=new ArrayList();//此li为根据父编号parentbumber查询到的集合
dto1 dto=new dto1();
dto.setThing(thing);
dto.setList(li);
list.add(dto);//把当前编号的对象和父编号得到的集合构建成一个dto放到最终你要的list中
}

}
}

4. 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);
}
}

5. java 递归

花了将近一天时间才实现任意长度的字符串所有可能的排列，下面分享一下成果

里面最重要的思想是：假定已经将n-1个字符组成的字符所有可能的排列算好了，将它们放到List中存放着。在依次取出每个元素，那么将新增的字符插入这个元素的n个位置上，那么每个元素就会产生新的n个字符的排列了。

所以：总共产生的排列个数=List中已有元素个数 乘以 n

优化前代码如下：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
*
* @author chenhui
*
*/
public class TestArrayABC {

/**
* @param str 字符串str中每个字符都不相同
* @return 字符串str所有可能的排列
*/
public List<String> doCompute(String str)
{
List<String> list = new ArrayList<String>();
List<String> temp = new ArrayList<String>();
temp.addAll(list);
list.removeAll(null);
if(str.length() == 1)
{
list.add(str);
return list;
}
else
{
char ch = str.charAt(0);
temp = doCompute(str.substring(1));
for(int j = 0; j < temp.size(); j++)
{
String s = temp.get(j);
char[] charArray = s.toCharArray();
char[] tempArray = new char[s.length() + 1];
//将ch分别放到charArray.length + 1个位置
for(int k = 0; k < charArray.length + 1; k++)
{
for(int i = 0; i < charArray.length + 1; i++)
{
if(i < k)
{
tempArray[i] = charArray[i];
}
else if(i == k)
{
tempArray[i] = ch;
}
else
{
tempArray[i] = charArray[i - 1];
}
}
list.add(j, new String(tempArray));
}
}
return list;
}
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

TestArrayABC abc = new TestArrayABC();
List<String> list = abc.doCompute(

6. java 递归 linked list 求 相同元素 不同元素 还有两个LIST是否相等

这是搞哪样？
不但大费周章，而且容易错……

先equalSets吧，
private static boolean equalSets(LinkedList list1, LinkedList list2){
return subset(list1,list2)&&subset(list2,list1);// 集合的内容，两集合互为子集就是相等了
}

然后difference，
private static LinkedList difference(LinkedList list1, LinkedList list2){
while(isNull(list2)){
if(isMember(first(list2),list1))
list1=deleteAll(first(list2),list1);// 将重复元素去除
else
list1=add(first(list2),list1);// 非重复元素存入list1
list2=rest(list2);
}
return list1;
}

最后intersect，
private static LinkedList intersect(LinkedList list1, LinkedList list2){
list2=difference(list1,list2);// 得到两集合不同的元素
while(isNull(list2)){
if(isMember(first(list2),list1))
;// 元素重复，什么也不干
else
list1=deleteAll(first(list2),list1);// 非重复元素删除
list2=rest(list2);
}
return list1;
}

7. java中对List数据递归筛选

这个很好写，无非就是list读写麻烦点，写一个递归方法
public list<t> findavg() {
for(int i=0;list){
sum += list[i];
}

avg=sum/list.size();
for(int i=0;list){
avg*(1-0.2)<=list[i]<=avg*(1+0.2)
list2.add(list[i]);

}
return list2;
}

8. 求Java List 递归算法..

无需JAVA递归取！

从设计角度看，表结构设计已经有问题了！
即使是树状结构，为何表结构没有体现？这也构成了为何楼主需要想办法来应对非树状结构数据的树状显示问题。

先进一步来说，表加一个grade字段，来表明当前记录处于第几级。那么直接一个SQL就可以取出来：
select lpad(' ',a.grade,'-')||a.name from myList a
这样就可以按楼主需要的结构取出数据；

但还存在一个问题，就是顺序问题，这样取出的数据是无序的！

那么我们再进一步看，我在做这种数据结构的表设计时，往往会给每个结点增加两个字段，left/right，分别代表其在树中的左右值。

这样就可以在上面SQL后增加order by a.left以保证取出数据的顺序。

9. java中递归算法是什么怎么算的

一、递归算法基本思路：

Java递归算法是基于Java语言实现的递归算法。递归算法是一种直接或者间接调用自身函数或者方法的算法。递归算法实质是把问题分解成规模缩小的同类问题的子问题，然后递归调用方法表示问题的解。递归往往能给我们带来非常简洁非常直观的代码形式，从而使我们的编码大大简化，然而递归的思维确实跟我们的常规思维相逆的，通常都是从上而下的思维问题，而递归趋势从下往上的进行思维。

二、递归算法解决问题的特点：

【1】递归就是方法里调用自身。

【2】在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。

【3】递归算法代码显得很简洁，但递归算法解题的运行效率较低。所以不提倡用递归设计程序。

【4】在递归调用的过程中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等，所以一般不提倡用递归算法设计程序。

【5】在做递归算法的时候，一定把握出口，也就是做递归算法必须要有一个明确的递归结束条件。这一点是非常重要的。其实这个出口就是一个条件，当满足了这个条件的时候我们就不再递归了。

三、代码示例：

publicclassFactorial{

//thisisarecursivefunction

intfact(intn){

if(n==1)return1;

returnfact(n-1)*n;

}}

publicclassTestFactorial{publicstaticvoidmain(String[]args){

//TODOAuto-generatedmethodstub

Factorialfactorial=newFactorial();

System.out.println("factorial(5)="+factorial.fact(5));

}
}

代码执行流程图如下：

此程序中n=5就是程序的出口。

10. java中的List递归

/*
* 读取XML文档
*/
public void ReadDocument(){
SAXReader reader = new SAXReader(); //创建SAXReader对象
try {
Document document = reader.read(new File("student.xml")); //获取文档对象
Element root = document.getRootElement(); //获取根节点
this.ReadNode(root);
} catch (DocumentException e) {
e.printStackTrace();
}
}

/*
* 读取节点 输出节点中的值
*/
public void ReadNode(Element element){
List list = element.elements(); //获得子节点
if(list.size()==0){
String str = element.getText(); //获取节点中的文本
System.out.println(element.getName()+": "+str);
}else{
for (int i = 0; i < list.size(); i++) {
Element ele = (Element)list.get(i); //获取节点对象
ReadNode(ele);
}
}
}