方法一：
 
……
 
String hql = "select t.fsHostip, t.fiReserve1 from Thostip as t where 1 = 1";
 
List ls = dao.getHibernateTemplate()。find(hql)；
 
Iterator it = ls.iterator()；
 
if(it.hasNext()){  // while 用这个的时候和下面的一样
 
Object[] obj = (Object[]) it.next()；
 
String ip = (String) obj[0];
 
Integer rs = (Integer) obj[1];
 
System.out.println(ip +","+rs)；
 
}
 
方法二：
 
//   for(int i = 0; i < ls.size()； i++){
 
//    Object[] obj = (Object[]) ls.get(i)；
 
//    String ip = (String)obj[0];
 
//    Integer rs = (Integer)obj[1];
 
//    System.out.println(ip +","+rs)；
 
//   }

1，java递归生成目录树 返回list<T>
 
递归方法返回List<T>类型
 
public List<ProductCategory> treeselect() {
        // 获取数据库表中的所有数据
        List<ProductCategory> dataList = productCategoryMapper.selectAll();
        log.info("dataList--->>>" + dataList.toString());
        List<ProductCategory> ProductCategoryList = new ArrayList<>();
        // 先找到1级分类
        for (ProductCategory ProductCategory : dataList) {
            if (ProductCategory.getParentId() == 0) {
                ProductCategoryList.add(ProductCategory);
            }
        }
        log.info("ProductCategoryList--->>>" + ProductCategoryList.toString());
        // 为一级菜单设置子菜单，getChild是递归调用的
        for (ProductCategory productCategory : ProductCategoryList) {
            productCategory.setChildren(getChilde(productCategory.getId(), dataList));
        }
        return ProductCategoryList;
    }
 
递归方法获取子菜单
 
    private List<ProductCategory> getChilde(Long id, List<ProductCategory> rootList) {
        //子菜单
        List<ProductCategory> childList = new ArrayList<>();
        for (ProductCategory productCategory : rootList) {
            // 遍历所有节点，将父菜单id与传过来的id比较
            if (productCategory.getParentId().equals(id)) {
                childList.add(productCategory);
            }
        }
        // 把子菜单的子菜单再循环一遍
        for (ProductCategory productCategory : childList) {
            productCategory.setChildren(getChilde(productCategory.getId(), rootList));
        }
        // 递归退出条件
        if (childList.size() == 0) {
            return null;
        }
        return childList;
    }
 
查询的数据结果
 
{
  "code": "0",
  "message": "成功",
  "data": [
    {
      "id": "3771306d-b43f-4eea-b759-d06cccb0d74f",
      "scaleId": "22fe7a08-667f-478f-b194-17b2667eb602",
      "name": "技术",
      "weight": 1,
      "parentId": "top",
      "childList": [
        {
          "id": "7007496f-e438-4be1-95cd-2460346adafc",
          "scaleId": "22fe7a08-667f-478f-b194-17b2667eb602",
          "name": "集成",
          "weight": 27,
          "parentId": "3771306d-b43f-4eea-b759-d06cccb0d74f",
          "childList": [
			"childList": [
            {
              "id": "7470fdbb-b7fa-4476-98aa-a54478dab960",
              "scaleId": "22fe7a08-667f-478f-b194-17b2667eb602",
              "name": "计划与调度",
              "weight": 16,
              "parentId": "93cebf9d-2c9f-4316-975a-c8a97822f5b1",
              "variable": 24
            },
            {
              "id": "79d3006b-19df-46f6-aa68-891e2dc05963",
              "scaleId": "22fe7a08-667f-478f-b194-17b2667eb602",
              "name": "安全环保",
              "weight": 13,
              "parentId": "93cebf9d-2c9f-4316-975a-c8a97822f5b1",
              "variable": 27
            },
            {
              "id": "b6ae80a7-9c75-466d-9025-82dc64e6321b",
              "scaleId": "22fe7a08-667f-478f-b194-17b2667eb602",
              "name": "生产作业",
              "weight": 26,
              "parentId": "93cebf9d-2c9f-4316-975a-c8a97822f5b1",
              "variable": 25
            }
		  ]
          "variable": 17
        },
        {
          "id": "c109d13e-c1e3-4480-89eb-81f3f32ff2b5",
          "scaleId": "22fe7a08-667f-478f-b194-17b2667eb602",
          "name": "信息安全",
          "weight": 27,
          "parentId": "3771306d-b43f-4eea-b759-d06cccb0d74f",
          "childList": null,
          "variable": 18
        },
        {
          "id": "f6075a8d-1301-4447-be78-06ee6bd013ac",
          "scaleId": "22fe7a08-667f-478f-b194-17b2667eb602",
          "name": "数据",
          "weight": 46,
          "parentId": "3771306d-b43f-4eea-b759-d06cccb0d74f",
          "childList": null,
          "variable": 16
        }
      ],
      "variable": 11
    },
    {
      "id": "483d73d8-f5ce-4ff0-82d4-c17bafcc31f6",
      "scaleId": "22fe7a08-667f-478f-b194-17b2667eb602",
      "name": "人员",
      "weight": 1,
      "parentId": "top",
      "childList": [
        {
          "id": "0046bad2-6e4b-4c3b-a4a5-92d3f39edd70",
          "scaleId": "22fe7a08-667f-478f-b194-17b2667eb602",
          "name": "人员技能",
          "weight": 50,
          "parentId": "483d73d8-f5ce-4ff0-82d4-c17bafcc31f6",
          "childList": null,
          "variable": 15
        },
        {
          "id": "ad76e507-77c0-4846-b500-42f3675824af",
          "scaleId": "22fe7a08-667f-478f-b194-17b2667eb602",
          "name": "组织战略",
          "weight": 50,
          "parentId": "483d73d8-f5ce-4ff0-82d4-c17bafcc31f6",
          "childList": null,
          "variable": 14
        }
      ],
      "variable": 10
    }
  ],
  "timestamp": 1626937445890
}
 
2，java 求树中每一层的所有节点之和
 
递归方法的参数为List类型，返回值为void
 
 	/**
     * 校验指标权值是否合法
     * @param list
     * @return
     */
    public void checkList(List<DiagnosisMetric> list){
        // 出口
        if(list.size() == 0){
            return;
        }
        // 校验权值和是否等于100
        if(checkWeight(list) != 100){
            String parentMetricName = getParentMetricName(list.get(0).getParentId());
            log.info("【"+parentMetricName+"】的下级指标权重和不等于1！");
            throw new BusinessRuntimeException(ResultStatus.DIAG_METRIC_WEIGHT_ERROR);
        }
        // 继续校验下一级指标
        for(DiagnosisMetric parent : list){
            List<DiagnosisMetric> childs = getChilds(parent);
            checkList(childs);
        }
    }
 
    /**
     * 校验同一级指标权重是否合法
     * @param metrics
     * @return
     */
    public Integer checkWeight(List<DiagnosisMetric> metrics){
        int sum = 0;
        if(metrics.size() > 0){
            for(DiagnosisMetric metric : metrics){
                sum += metric.getWeight();
            }
            if(sum != 100){
                log.error("指标权重不等于100：{}", JSONObject.toJSONString(metrics));
            }
            return sum;
        }
        return sum;
    }

java中递归的使用
 
 
 
当某个类的存储可以以树形结构存储时，即某个类的属性存在存储本类列表的集合时，可使用此递归将所有子节点数据封装到第一层列表中。
 
 
    /**
     * @deprecated 传入节点列表，将节点列表及其下所有子节点封到原列表中；
     * @param nodes 节点list
     * @return 节点及其所有子节点list
     */
    public static List<Node> getAllNodes(List<Node> nodes) {
    	//不可使用增强for
        for (int i = nodes.size() - 1; i >= 0; i--) {
            Node node = nodes.get(i);
            if (!CollectionUtils.isEmpty(node.getChildren())) {
                nodes.addAll(getAllNodes(node.getChildren()));
            }
            node.setChildren(null);
        }
        return nodes;
    }
 
第一次写博客，希望自己可以坚持思考、学习、记录。

 
一、递归算法设计的基本思想是：
 
对于一个复杂的问题，把原问题分解为若干个相对简单类同的子问题，继续下去直到子问题简单到能够直接求解，也就是说到了递推的出口，这样原问题就有递推得解。
 
在做递归算法的时候，一定要把握住出口，也就是做递归算法必须要有一个明确的递归结束条件。这一点是非常重要的。其实这个出口是非常好理解的，就是一个条件，当满足了这个条件的时候我们就不再递归了。
 
关键要抓住的是：
 
(1)递归出口
 
(2)地推逐步向出口逼近
 
二、递归算法实例
 
(1)阶乘：
 
要求：给定一个数值，计算出它的阶乘值，例如5的阶乘为5*4*3*2*1
 
实现：
 
  // 利用递归实现一个数的阶乘值
 
private static BigDecimal getNum(BigDecimal inNum) {
 
if (inNum.compareTo(BigDecimal.ONE) == 0) {
 
return inNum;
 
}
 
return inNum.multiply(getNum(inNum.subtract(BigDecimal.ONE)));
 
}
 
(2)Fibonacci数列：1，1，2，3，5，8，13……
 
要求：找出数列中指定index位置的数值
 
实现：
 
  // 利用递归实现了Fibonacci数列
 
private static int fab(int index) {
 
if (index == 1 || index == 2) {
 
return 1;
 
} else {
 
return fab(index - 1) + fab(index - 2);
 
}
 
}
 
(3)汉诺塔
 
要求：汉诺塔挪动
 
实现：
 
    private static final String DISK_B = "diskB";
 
    private static final String DISK_C = "diskC";
 
    private static final String DISK_A = "diskA";
 
    static String from=DISK_A;
 
    static String to=DISK_C;
 
    static String mid=DISK_B;
 
    public static void main(String[] args) {
 
        String input=JOptionPane.showInputDialog("please input the number of the disks you want me move.");
 
        int num=Integer.parseInt(input);
 
        move(num,from,mid,to);
 
    }
 
  // 利用递归实现汉诺塔
 
private static void move(int num, String from2, String mid2, String to2) {
 
if (num == 1) {
 
System.out.println("move disk 1 from " + from2 + " to " + to2);
 
} else {
 
move(num - 1, from2, to2, mid2);
 
System.out.println("move disk " + num + " from " + from2 + " to " + to2);
 
move(num - 1, mid2, from2, to2);
 
}
 
}
 
(4)排列组合
 
要求：将输入的一个字符串中的所有元素进行排序并输出，例如：你给出的参数是"abc"，
 
则程序会输出
 
abc
 
acb
 
bac
 
bca
 
cab
 
cba
 
实现：
 
    public static void permute(String str) {
 
    char[] strArray = str.toCharArray();
 
     permute(strArray, 0, strArray.length - 1);
 
  }
 
  // 利用递归实现，将输入的一个字符串中的所有元素进行排序并输出
 
public static void permute(char[] list, int low, int high) {
 
int i;
 
if (low == high) {
 
String cout = "";
 
for (i = 0; i <= high; i++) {
 
cout += list[i];
 
}
 
System.out.println(cout);
 
} else {
 
for (i = low; i <= high; i++) {
 
char temp = list[low];
 
list[low] = list[i];
 
list[i] = temp;
 
permute(list, low + 1, high);
 
temp = list[low];
 
list[low] = list[i];
 
list[i] = temp;
 
}
 
}
 
}
 
总结递归算法来说，这个根就是那个出口，只要找到这个出口所在，那么算法自然而然就能水到渠成了。