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