您的位置:

java权限递归(递归赋权限)

本文目录一览:

关于java中的递归

hi(n

+

1);

System.out.println("你好"

+

n);

这两句调换一下,就不会反了。

因为最后一个递归调用最先返回,而第一次打印就是在这个返回之后调用的。

执行过程:

main-hi(1)-hi(2)-hi(3)...hi(20)。

hi(19):

hi(20)返回,

print(19).

返回

hi(18):

hi(19)返回,

print(18).

返回

...

hi(1):hi(2)返回,print(1).返回

main:

下一句,退出.

递归只重复函数的内容。

如果是非引用型参数,其值在递归返回后不会受影响。这个跟普通的函数调用没有区别。

但是,递归需要注意两个基本问题:

1)

必须要有终止条件。

2)

递归层次不能太深,否则可能引起调用栈溢出,导致程序崩溃。

在JAVA中什么是递归?有什么用?

Java方法递归是指在一个方法的内部调用自身的过程,以此类推就是java方法递归的理解思想,具体来讲就是把规模大的问题转化为规模小的相似的子问题来解决。在函数实现时,因为解决大问题的方法和解决小问题的方法往往是同一个方法,所以就产生了函数调用它自身的情况。另外这个解决问题的函数必须有明显的结束条件,这样就不会产生无限递归的情况了。因此,java方法递归的两个条件就是,一通过递归调用来缩小问题规模,且新问题与原问题有着相同的形式;二存在一种简单情境,可以使递归在简单情境下退出。

java递归如何理解

可以理解为递归,就是自己调用自己而已.每个递归都有一个结束条件.这个递归的结束条件就是a==1;

当a==1的时候,终止递归,return 1.这个 1 给上一层调用者.也即是 plus(2)

简单的说可以理解为, plus(10)=plus(9)+10.

plus(9)=plus(8)+9

以此类推

plus(2)=plus(1)+2

plus(2)=1(plus(1),既a==1,递归结束,renturn 1)+2

java的递归查询怎么写

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

/** 

    * 说明方法描述:将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如何理解递归

1、递归做为一种算法在程序设计语言中广泛使用,是指函数/过程/子程序在运行过程中直接或间接调用自身而产生的重入现象。

2、递归算法一般用于解决三类问题:

1)数据的定义是按递归定义的。(Fibonacci(斐波那契)的函数)

2)问题解法按递归算法实现。(回溯)

3)数据的结构形式是按递归定义的。(树的遍历,图的搜索)