java的递归查询怎么写

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

>/ 

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

     @param allRrecords 

     @return 

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

     @author yangdong 

    /  

   public List<Record> useListRecordToTree(List<Record> allRrecords) {  

       List<Record> listParentRecord = new ArrayList<Record>();  

       List<Record> listNotParentRecord = new ArrayList<Record>();  

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

       Map<String, String> mapAllUuid = new HashMap<String, String>();  

       Map<String, Record> allRecordMap = new HashMap<String, Record>();  

       for (Record record : allRrecords) {  

           mapAllUuidput(recordgetStr("uuid"), recordgetStr("uuid"));  

           allRecordMapput(recordgetStr("uuid"), record);  

       }  

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

       if (allRrecords != null && allRrecordssize() > 0) {  

           for (Record record : allRrecords) {  

               if (StringUtilisBlank(recordgetStr("parent_uuid"))  

                   || !mapAllUuidcontainsKey(recordgetStr("parent_uuid"))) {  

                   listParentRecordadd(record);  

               } else {  

                   listNotParentRecordadd(record);  

               }  

           }  

       }  

       // 第三步： 递归获取所有子节点  

       if (listParentRecordsize() > 0) {  

           for (Record record : listParentRecord) {  

               // 添加所有子级  

               recordset("childs", thisgetTreeChildRecord(listNotParentRecord, recordgetStr("uuid")));  

           }  

       }  

       return listParentRecord;  

   }  

   / 

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

     @param allRecords 所有节点 

     @param keywords 要过滤的关键字 

     @param filterFields 要过滤的字段 

     @return 

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

     @author yangdong 

    /  

   public List<Record> useListRecordToTreeByKeywords(List<Record> allRecords, String keywords, String filterFields) {  

       List<Record> listRecord = new ArrayList<Record>();  

       Map<String, Record> allRecordMap = new HashMap<String, Record>();  

       for (Record record : allRecords) {  

           allRecordMapput(recordgetStr("uuid"), record);  

       }  

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

       if (allRecords != null && allRecordssize() > 0) {  

           if (filterFieldslength > 1) {  

               for (Record record : allRecords) {  

                   for (String field : filterFields) {  

                       // 比较  

                       if (recordgetStr(field)toLowerCase()indexOf(keywordstoLowerCase()) != -1) {  

                           listRecordadd(record);  

                       }  

                   }  

               }  

           } else {  

               for (Record record : allRecords) {  

                   // 比较  

                   if (recordgetStr(filterFields[0])toLowerCase()indexOf(keywordstoLowerCase()) != -1) {  

                       listRecordadd(record);  

                   }  

               }  

           }  

       }  

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

       listRecord = thisgetSelfAndTheirParentRecord(listRecord, new ArrayList<Record>(),  

                                                     new HashMap<String, Record>(), allRecordMap);  

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

       listRecord = thisuseListRecordToTree(listRecord);  

       return listRecord;  

   }  

   / 

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

     @param childList 子节点 

     @param parentUuid 父节点id 

     @return 

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

     @author yangdong 

    /  

   private List<Record> getTreeChildRecord(List<Record> childList, String parentUuid) {  

       List<Record> listParentRecord = new ArrayList<Record>();  

       List<Record> listNotParentRecord = new ArrayList<Record>();  

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

       if (childList != null && childListsize() > 0) {  

           for (Record record : childList) {  

               // 对比找出父节点  

               if (StringUtilequals(recordgetStr("parent_uuid"), parentUuid)) {  

                   listParentRecordadd(record);  

               } else {  

                   listNotParentRecordadd(record);  

               }  

           }  

       }  

       // 查询子节点  

       if (listParentRecordsize() > 0) {  

           for (Record record : listParentRecord) {  

               // 递归查询子节点  

               recordset("childs", getTreeChildRecord(listNotParentRecord, recordgetStr("uuid")));  

           }  

       }  

       return listParentRecord;  

   }  

   / 

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

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

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

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

     @param allRecordMap 所有节点 

     @return 

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

     @author yangdong 

    /  

   private List<Record> getSelfAndTheirParentRecord(List<Record> parentList, List<Record> resultList,  

                                                    Map<String, Record> filterRecordMap,  

                                                    Map<String, Record> allRecordMap) {  

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

       if (parentList == null || parentListsize() == 0) {  

           return resultList;  

       }  

       // 重新创建父节点集合  

       List<Record> listParentRecord = new ArrayList<Record>();  

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

       for (Record record : parentList) {  

           String uuid = recordgetStr("uuid");  

           String parent_uuid = recordgetStr("parent_uuid");  

           // 如果已经过滤出来的节点不存在则添加到list中  

           if (!filterRecordMapcontainsKey(uuid)) {  

               listParentRecordadd(record);// 添加到父节点中  

               filterRecordMapput(uuid, record);// 添加到已过滤的map中  

               allRecordMapremove(uuid);// 移除集合中相应的元素  

               resultListadd(record);// 添加到结果集中  

           }  

           // 找出本节点的父节点并添加到listParentRecord父节点集合中，并移除集合中相应的元素  

           if (StringUtilisNotBlank(parent_uuid)) {  

               Record parentRecord = allRecordMapget(parent_uuid);  

               if (parentRecord != null) {  

                   listParentRecordadd(parentRecord);  

                   allRecordMapremove(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 List<Record> getRecordByKeywordRecursive(String keyword, String is_deleted) {  

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

        StringBuffer sql = new StringBuffer(  

                                            " select pauuid,paparent_uuid,paauthor_code,paauthor_name,pais_menu,pasort_number,pais_enable,pamenu_icon ");  

        sqlappend("  from s_author pa");  

        List<Object> params = new ArrayList<Object>();  

        sqlappend(" where  pais_deleted= ");  

        paramsadd(is_deleted);  

        sqlappend(" order by pasort_number asc ");  

        List<Record> allRrecords = Dbuse(AppConstDB_DATASOURCE_MAIN)find(sqltoString(), ParamUtillistToArray(params));  

[java] view plain copy

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

        if (StringUtilisNotBlank(keyword)) {  

            return superuseListRecordToTreeByKeywords(allRrecords, keyword, "author_name");  

        } else {  

            return superuseListRecordToTree(allRrecords);  

        }  

    }

Jquery的遍历，其实就当前位置的元素相对于其他元素的位置的关系进行查找或选取HTML元素。以某项选择开始，并沿着这条线进行移动，或向上（父级）、或向下（子级）、或水平（同级），直到找到目标元素为止，这种移动也被成为对DOM进行遍历。

其实对于DOM来说，这个不陌生，Jquery的遍历也就是在DOM树上上蹿下跳，当然这种上蹿下跳不是没有规则的，胡乱的找是让人鄙视的。通俗的说，在一颗树上（你也在树上，已经爬上去了，哈哈），以你所在的位置为起点，以树上有个桃子为目的地，你的这个起点也就是当前 this ,去移动去摘桃子的过程就是Jquery遍历，所以相对应的Jquery所衍生出的遍历方法可以分为三大类，即Jquery遍历之父级（祖先）、同级（同胞）和子级（后代）三种。

某一节点下的所有子节点function getChildren(id/节点ID/)

{    var $tree = $('#tree');    var node = $treetree

('find',id);    var childrenNodes = $treetree

('getChildren',nodetarget);    return childrenNodes;}//某节点的一级节点

function getSubChildren(id){    var $tree = $('#tree');    var node = $treetree

('find',id);    var subNodes = [];    $(nodetarget)    next()children()children

("divtree-node")each(function(){           subNodespush($treetree

('getNode',this));    });   return subNodes;}

子节点是塔的若干部件的汇合点。

所属学科：

电力（一级学科）；输电线路（二级学科）。

定义2：

在一对相啮合的齿轮上，其两节圆的切点。

所属学科：

机械工程（一级学科）；传动（二级学科）；齿轮传动（三级学科）。

定义3：

在网络拓扑中，网络任何支路的终端或网络中两个或更多支路的互连公共点。

所属学科：

通信科技（一级学科）；通信原理与基本技术（二级学科）。

Parent的话，我个人觉得，将其转化为对应的接口，接口下会有对应的Get方法，比如说交点，将其转化为CATIGSMInterstct接口，其下会有GetFirstElement等方法，有高手说用CATIAncestry 接口，但是我木有用过，你可以试试~~~Children的话，你试试CATIDescendents接口~~~

// using nodejs

let path = require('path');

let fs = require('fs');

const tree = ($path)=>fsreaddir($path,(err,files)=>{

filesforEach(f => {

let file_path = pathjoin($path,f);

let state = fslstatSync(file_path);

if(stateisDirectory()){

tree(file_path);

}else if(stateisFile()){

consolelog(file_path);

}

});

});

tree(pathjoin(__dirname,'/'));

这个就涉及到层,我告诉你具体做法

增加两个字段叫layer(层数)和layerorder(层次序)

id为A且在第一层的layer=1,layerorder=000A(看你ID的位数而定）

id为B且在第二层parentid为A的,layer=2,layerorder=000A000B

id为C且在第三层parentid为B的,layer=3,layerorder=000A000B000C

依次类推

如果知道某部门ID想搜索子部门，那只需要

select id ,name from XX where layerorder like 某部门ID+"%"

这样就可以把子部门全搜索出来，还可以加上layer作为搜索条件限制只要第几层的，具体实现你可以自己摸索下~~

//某一节点下的所有子节点

function getChildren(id/节点ID/){

    var $tree = $('#tree');

    var node = $treetree('find',id);

    var childrenNodes = $treetree('getChildren',nodetarget);

    return childrenNodes;

}

//某节点的一级节点

function getSubChildren(id){

    var $tree = $('#tree');

    var node = $treetree('find',id);

    var subNodes = [];

    $(nodetarget)

    next()children()children("divtree-node")each(function(){   

        subNodespush($treetree('getNode',this));

    });

   return subNodes;

}

以上就是关于java的递归查询怎么写全部的内容，包括:java的递归查询怎么写、js中如何获取div下的二级子元素、如何获取jquery easyui Tree的所有子节点等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！