递归和普通循环

递归,我这里简单理解为: 写一个方法A, 在方法中进行循环, 设置一个跳出条件, 满足条件则 return, 不满足则再调用一次方法 .

一个跳出条件, 一个循环调用方法A. 这两个组在一起形成了递归.

 

单纯的使用循环实现递归: 写一个方法, 方法里写循环, 设置一个跳出条件. 

 

递归和单纯使用循环, 差别就在于递归需要不断调用方法, 从性能资源上讲(其实性能上在目前来讲没多大影响). 个人还是建议用简单循环实现递归. 

    // 获取评论的子回复
//    private List<Map<String,Object>> getChild(String id, List<Map<String,Object>> allReply,Stack stack,List<Map<String, Object>> resultMap) {
//        // 准备装载子回复容器
//        List<Map<String, Object>> childMap = new ArrayList<>();
//        // 遍历该帖子下的所有回复
//        for (int i = 0; i < allReply.size(); i++) {
//            // 取出每一条回复对象
//            Map<String, Object> childReply = allReply.get(i);
//            // 取出每一条的父评论ID
//            String parentId = childReply.get("parentId").toString();
//            // 如果该回复的父评论ID等于传递进来的参数String id(父评论ID),则说明本条回复为此评论的子评论
//            if (id.equals(parentId)) {
//                // 装载至子回复容器
//                childMap.add(childReply);
//                // 压栈
//                stack.push(childReply);
//            }
//        }
//
//        // 遍历子回复,开启递归,查询每条子回复下的评论
//        for (int i = 0; i < childMap.size(); i++) {
//            Map<String, Object> childReply2 = childMap.get(i);
//            String replyId = childReply2.get("replyId").toString();
//            getChild(replyId,allReply,stack,resultMap);
//        }
//
//        // 递归跳出条件: 某条回复没有任何所属子评论(这是评论树的最后一条回复了)
//        if (childMap.size()==0) {
//            // 栈内存储有数据
//            while (stack.size() > 0) {
//                // 出栈
//                Map pop = (Map) stack.pop();
//                // 将出栈数据放至最终返回结果中
//                resultMap.add(pop);
//            }
//            return resultMap;
//        }
//        return resultMap;
//    }

 

// 单纯使用循环  
private Map<String,Object> getChildLoop(String custId, Map<String,Object> topReply, List<Map<String,Object>> allReply,String authorId, String useCase) {
        // 准备返回结果容器
        Map<String, Object> map = new HashMap<>();
        // 准备返回数据
        List<Map<String, Object>> resultMap = new ArrayList<>();
        // 准备装载子回复容器
        List<Map<String, Object>> childMap = new ArrayList<>();
        // 准备栈
        Stack stack = new Stack();
        childMap.add(topReply);

        String firstReply = topReply.get("replyId").toString();
        int flag = 0;
        while (flag == 0) {
            for (int i = 0; i < childMap.size(); i++) {
                Map<String, Object> childReply = childMap.get(i);
                String replyId = childReply.get("replyId").toString();
                for (int j = 0; j < allReply.size(); j++) {
                    // 取出每一条回复对象
                    Map<String, Object> childReply2 = allReply.get(j);
                    // 取出每一条的父评论ID
                    String parentId2 = childReply2.get("parentId").toString();
                    // 如果该回复的父评论ID等于传递进来的参数String id(父评论ID),则说明本条回复为此评论的子评论
                    if (replyId.equals(parentId2)) {
                        // 判断是否作者
                        if (childReply2.get("replyCust").equals(authorId)) childReply2.put("author","1");
                        // 判断该回复是否是浏览用户发表的
                        if (childReply2.get("replyCust").equals(custId)) childReply2.put("deleteReply","1");

                        if ("2".equals(useCase)) {
                            // 如果useCase==2 - 表明需要组装回复格式: 回复内容 @被回复人昵称: 被回复人的评论
                            Object replyCont = childReply2.get("replyCont");// 回复内容
                            Object nickName = childReply.get("nickName");// 被回复人昵称
                            Object respondentCont = childReply.get("replyCont");// 被回复人评论内容
                            if (firstReply.equals(parentId2)) {// 如果是二级评论
                                childReply2.put("replyCont",replyCont);
                            } else{
                                String a = replyCont+" @"+nickName+":"+respondentCont;
                                childReply2.put("replyCont",a);
                            }

                        }
                        // 装载至子回复容器
                        childMap.add(childReply2);
                        // 压栈
                        stack.push(childReply2);
                    }
                }
            }
            // 跳出循环条件,没有找不到子回复了.
            if (childMap.size() == 0) {
                flag = 1;
            }
            childMap.clear();
        }

        // 一级评论下有多少条回复总数
        map.put("replyCount",stack.size());

        // 栈内存储有数据
        while (stack.size() > 0) {
            // 出栈
            Map pop = (Map) stack.pop();
            // 将出栈数据放至最终返回结果中
            resultMap.add(pop);
            if ("1".equals(useCase)&&resultMap.size()==4) {// 仅拿到前四条回复即可
                stack.clear();
            }
        }
        map.put("replyList",resultMap);
        return map;
    }