Excel 无限级递归文档生成

写了一个小工具，excel无限层级文档生成

无限层级，映入脑海的就是"递归调用"。看到有人说这个问题，就即兴写了个简单的工具，也算不上工具，实现更恰当

该图片是生成的结果图：

 

Grade类 是无限级的实体类构建

import lombok.Data;

import java.util.List;

@Data
public class Grade {

    private String grade;//层级

    private List gradeList;

    public Grade(String grade) {
        this.grade = grade;
    }

    public Grade(String grade, List gradeList) {
        this.grade = grade;
        this.gradeList = gradeList;
    }
}

 

实现功能类，数据构建的是无限级的数据

import com.meehoo.biz.common.util.BaseUtil;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.junit.Test;

import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;

public class ExcelTest {


    @Test
    public void export() throws Exception {
        HSSFWorkbook wb = new HSSFWorkbook();
        List gradeList = buildData(3,4);
        creatExcel(gradeList,wb.createSheet("nolimit-grade"));
        OutputStream outputStream = new FileOutputStream("E:\\other\\nolimit.xls");
        wb.write(outputStream);
    }

    public void creatExcel(List list,HSSFSheet sheet) throws Exception {
        //起始位置（0，0）
        creatExcel(list,sheet,0,0);
    }

    private int creatExcel(List list,HSSFSheet sheet,int row,int colum){
        if(!BaseUtil.listNotNull(list))
            return row;

        for (Grade t : list) {
            HSSFRow hssfRow = sheet.createRow(row);
            hssfRow.createCell(colum).setCellValue(t.getGrade());
            /*
                若当前层级下还有层级，我们只需要知道，当前层级的“最后一层”子层级 数据行数的下一行；
                当为最后一个层级时，只需要在当前列的下一行填充数据。
             */
            if(BaseUtil.listNotNull(t.getGradeList())) {
                row = creatExcel(t.getGradeList(), sheet, row+1, colum+1);
            }else {
                row++;
            }

        }
        return row;
    }

    /**
     * 无限级数据构建
     * @param size 每个层级数据量
     * @param floor 层级数
     * @return
     */
    public List buildData(int size,int floor){
        return buildData(1, floor,size);
    }

    private List buildData(int grade, int floor,int size){
        if(grade > floor)
            return null;

        List listInside = new ArrayList<>();
        for (int i = 1; i <= size; i++) {
            /*
                若为最后一层数据，直接添加；
                非最后一层，需要为当前层级的每条数据（例如：1-1，1-2为同一层级的数据），添加它的子层级的所有数据
             */
            if(grade == floor){
                listInside.add(new Grade("层级"+grade+"-"+(i)));
            }else {
                listInside.add(new Grade("层级"+grade+"-"+(i), buildData(grade+1,floor,size)));
            }
        }
        return listInside;
    }

}

      以上是一个递归的使用，思想借鉴了汉诺塔实现思路，将N个盘子挪动，看成3个盘子的挪动，对于递归调用有些生疏的话，可以手动实现下