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

        }  

    }

用String 包下的indexOf()方法

代码如下：

public class Test {

public static void main(String[] args) {

String str="asdjavahnaskjavajdasjdasjjavafdlsafhdsaduhvcjavadsanclsajhdqlwijavadcwaduasjavadhua";

String strIndex = "java";

//StringindexOf()是String包下的方法，返回指定子字符串在此字符串中第一次出现处的索引。

//下面输出3

Systemoutprintln(strindexOf(strIndex));

Systemoutprintln("用递归方法找到java的个数是" + new Test()javaDiGui(str,strIndex) );

Systemoutprintln("用循环方法找到java的个数是" + new Test()javaXunHuan(str,strIndex) );

}

//str为要查找的长字符串,strIndex为短字符串从main传过过来的"java"

//这里采用递归方法

//方法是找到第一次出现的位置，总个数=1+余下子串中java个数

public int javaDiGui(String str,String strIndex){

int i=strindexOf(strIndex);

//i==-1则表示找不到

if(i == -1){

return 0;

}

else return 1+javaDiGui(strsubstring(i+strIndexlength()),strIndex);

//subString(int beginIndex)返回一个新的字符串，它是此字符串的一个子字符串。该子字符串从指定索引处的字符开始，直到此字符串末尾。

}

//str为要查找的长字符串,strIndex为短字符串从main传过过来的"java"

//这里采用递归方法

//方法是找到第一次出现的位置，用余下子串代替当前字符串,再继续找,直到找不到为止

public int javaXunHuan(String str,String strIndex){

int i =0;

int num = 0; //总个数初始化为0

while(i!=-1){

i=strindexOf(strIndex);

if(i!=-1)

num++;

str = strsubstring(i+strIndexlength());//余下子串替换当前串

}

return num;

}

}

输出结果：

3

用递归方法找到java的个数是6

用循环方法找到java的个数是6

以上就是关于java的递归查询怎么写全部的内容，包括:java的递归查询怎么写、用java的递归方法或者循环方法找出里面有几个java ，各位大哥大姐帮帮忙、等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！