Java对poi表格导出的代码封装

原创 已于 2023-09-24 23:01:53 修改 · 188 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

于 2023-09-24 21:45:46 首次发布

前言

本文展示的代码主要是对poi表格（xls）导出的一些封装，减少重复代码块，类封装了常用的导出形式（列-内容），支持常用的表格汇总公式，如合计，平均，累加，相除等。

效果图如下

image-20230924201807121

主要依赖

      <!--核心依赖-->	  
	  <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>4.0.1</version>
      </dependency>

	  <!--可有可无，可替换为其他-->
      <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.8.11</version>
      </dependency>

代码

StrapExcel

package com.strap.common.office;

import cn.hutool.core.text.CharSequenceUtil;
import cn.hutool.core.util.StrUtil;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFDataFormat;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.BorderStyle;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.usermodel.VerticalAlignment;

import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;

/**
 * <p>表格workbook定义</p>
 *
 * @author strap
 */
public class StrapExcel {

    private final HSSFWorkbook workbook;

    private HSSFCellStyle headerStyle;

    private HSSFCellStyle thStyle;

    private HSSFCellStyle cellStyle;

    private Map<String, HSSFCellStyle> formulaRecord;

    public StrapExcel() {
        this.workbook = new HSSFWorkbook();
    }

    public HSSFWorkbook getWorkbook() {
        return workbook;
    }

    public HSSFCellStyle cellStyle(Consumer<HSSFCellStyle> styleDeal, Consumer<HSSFFont> fontDeal) {
        HSSFCellStyle style = workbook.createCellStyle();
        style.setBorderTop(BorderStyle.THIN);
        style.setBorderBottom(BorderStyle.THIN);
        style.setBorderLeft(BorderStyle.THIN);
        style.setBorderRight(BorderStyle.THIN);
        style.setLocked(false);
        if (styleDeal == null) {
            // 自定义样式，居中
            style.setWrapText(true);
            style.setAlignment(HorizontalAlignment.CENTER);
            style.setVerticalAlignment(VerticalAlignment.CENTER);
        } else {
            styleDeal.accept(style);
        }
        HSSFFont font = workbook.createFont();
        // 设置头部粗体
        font.setFontName("仿宋_GB2312");
        if (fontDeal != null) {
            fontDeal.accept(font);
        }
        style.setFont(font);
        return style;
    }

    public HSSFCellStyle getHeaderStyle() {
        if (headerStyle == null) {
            headerStyle = cellStyle(null, font -> {
                font.setBold(true);
                font.setFontHeightInPoints((short) 15);
            });
        }
        return headerStyle;
    }

    public HSSFCellStyle getThStyle() {
        if (thStyle == null) {
            thStyle = cellStyle(null, font -> {
                font.setBold(true);
                font.setFontHeightInPoints((short) 12);
            });
        }
        return thStyle;
    }

    public HSSFCellStyle getCellStyle() {
        if (cellStyle == null) {
            cellStyle = cellStyle(null, font -> font.setFontHeightInPoints((short) 12));
        }
        return cellStyle;
    }

    public HSSFCellStyle getFormulaStyle(String format) {
        String key = CharSequenceUtil.nullToEmpty(format);
        if (formulaRecord == null) {
            formulaRecord = new HashMap<>();
        }
        return formulaRecord.computeIfAbsent(key, k -> cellStyle(style -> {
            style.setWrapText(true);
            style.setLocked(true);
            style.setAlignment(HorizontalAlignment.CENTER);
            style.setVerticalAlignment(VerticalAlignment.CENTER);
            if (StrUtil.isNotEmpty(format)) {
                short formatIdx = HSSFDataFormat.getBuiltinFormat(format);
                style.setDataFormat(formatIdx > -1 ? formatIdx : workbook.createDataFormat().getFormat(format));
            }
        }, font -> font.setFontHeightInPoints((short) 12)));
    }

    public void createSheet(StrapSheet strapSheet) throws Exception {
        strapSheet.createSheet(this);
        strapSheet.renderHeaderTitle();
        strapSheet.renderColList();
        strapSheet.renderCells();
        strapSheet.renderFormula();
    }

    public byte[] getBytes() throws Exception {
        try (ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
            workbook.write(bos);
            return bos.toByteArray();
        }
    }

    public void saveFile(String filePath) throws Exception {
        try (FileOutputStream fos = new FileOutputStream(filePath)) {
            workbook.write(fos);
        }
    }

}

StrapSheet

package com.strap.common.office;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.collection.IterUtil;
import cn.hutool.core.text.CharSequenceUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.StrUtil;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.BorderStyle;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.RegionUtil;

import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>表格worksheet定义</p>
 *
 * @author strap
 */
public class StrapSheet {

    private static final String DEFAULT_SHEET_NAME = "Sheet";

    private static final String DEFAULT_TOTAL_NAME = "合计";

    private String sheetName;

    private String headerTitle;

    private List<StrapCol> colList;

    private List<List<Object>> cells;

    private int cellStart = -1;

    private HSSFSheet sheet;

    private StrapExcel strapExcel;

    public StrapSheet() {
        this.colList = new ArrayList<>();
        this.cells = new ArrayList<>();
    }

    public String getSheetName() {
        return sheetName;
    }

    public StrapSheet sheetName(String sheetName) {
        this.sheetName = sheetName;
        return this;
    }

    public String getHeaderTitle() {
        return headerTitle;
    }

    public StrapSheet headerTitle(String headerTitle) {
        this.headerTitle = headerTitle;
        return this;
    }

    public List<StrapCol> getColList() {
        return colList;
    }

    public StrapSheet initColList(List<StrapCol> colList) {
        this.colList = colList;
        return this;
    }

    public StrapSheet addColList(String... cols) {
        if (ArrayUtil.isNotEmpty(cols)) {
            Arrays.stream(cols).forEach(s -> addColList(new StrapCol(s)));
        }
        return this;
    }

    public StrapSheet addColList(StrapCol... cols) {
        if (ArrayUtil.isNotEmpty(cols)) {
            Arrays.stream(cols).forEach(this::addColList);
        }
        return this;
    }

    public StrapSheet addColList(List<StrapCol> cols) {
        if (ArrayUtil.isNotEmpty(cols)) {
            cols.forEach(this::addColList);
        }
        return this;
    }

    public int addColList(StrapCol col) {
        int index = CollectionUtil.indexOf(this.colList, c -> c.getColName().equals(col.getColName()));
        if (index == -1) {
            this.colList.add(col);
            index = this.colList.size() - 1;
        }
        return index;
    }

    public List<List<Object>> getCells() {
        return cells;
    }

    public StrapSheet addValuesList(List<List<Object>> values) {
        if (CollectionUtil.isNotEmpty(values)) {
            this.cells.addAll(values);
        }
        return this;
    }

    public StrapSheet addValues(Object... values) {
        if (ArrayUtil.isNotEmpty(values)) {
            this.cells.add(Arrays.stream(values).collect(Collectors.toList()));
        }
        return this;
    }

    public StrapSheet addValuesMap(List<Map<String, Object>> values) {
        if (CollectionUtil.isNotEmpty(values)) {
            for (Map<String, Object> val : values) {
                Map<Integer, Object> record = new HashMap<>();
                for (Map.Entry<String, Object> entry : val.entrySet()) {
                    int index = addColList(new StrapCol(entry.getKey()));
                    record.put(index, entry.getValue());
                }
                int maxSize = record.keySet().stream().max(Integer::compareTo).orElse(0) + 1;
                Object[] targetValues = new Object[maxSize];
                for (Map.Entry<Integer, Object> entry : record.entrySet()) {
                    targetValues[entry.getKey()] = entry.getValue();
                }
                addValues(targetValues);
            }

        }
        return this;
    }

    public HSSFSheet getSheet() {
        return sheet;
    }

    public void createSheet(StrapExcel strapExcel) throws Exception {
        if (StrUtil.isEmpty(sheetName)) {
            sheetName = DEFAULT_SHEET_NAME;
        } else if (sheetName.length() > 27) {
            // 名称最长31
            sheetName = sheetName.substring(0, 27);
        }
        this.strapExcel = strapExcel;
        HSSFWorkbook workbook = strapExcel.getWorkbook();
        int sheetIndex = workbook.getSheetIndex(sheetName);
        int i = 0;
        while (sheetIndex > -1) {
            sheetIndex = workbook.getSheetIndex(sheetName + ++i);
        }
        this.sheet = workbook.createSheet(i > 0 ? sheetName + i : sheetName);
    }

    public int nextRowIndex() {
        int lastRowNum = sheet.getLastRowNum();
        if (lastRowNum == 0) {
            return sheet.getRow(lastRowNum) == null ? 0 : 1;
        }
        return lastRowNum + 1;
    }

    public void fillValue(HSSFCell cell, Object value) {
        String s = StrUtil.toStringOrNull(value);
        if (CharSequenceUtil.isEmpty(s)) {
            cell.setCellValue("");
        } else if (value instanceof Number || NumberUtil.isNumber(s)) {
            cell.setCellValue(Double.parseDouble(s));
        } else {
            cell.setCellValue(s);
        }
    }

    public void initMergeCell(int firstRow, int lastRow, int firstCol, int lastCol) {
        CellRangeAddress cellRangeAddress = new CellRangeAddress(firstRow, lastRow, firstCol, lastCol);
        sheet.addMergedRegion(cellRangeAddress);
        RegionUtil.setBorderTop(BorderStyle.THIN, cellRangeAddress, sheet);
        RegionUtil.setBorderBottom(BorderStyle.THIN, cellRangeAddress, sheet);
        RegionUtil.setBorderLeft(BorderStyle.THIN, cellRangeAddress, sheet);
        RegionUtil.setBorderRight(BorderStyle.THIN, cellRangeAddress, sheet);
    }

    private int getColSize() {
        return CollectionUtil.isEmpty(colList) ? CollectionUtil.size(IterUtil.getFirst(cells)) : colList.size();
    }

    public void renderHeaderTitle() {
        if (CharSequenceUtil.isNotEmpty(headerTitle)) {
            int index = nextRowIndex();
            HSSFRow row = sheet.createRow(index);
            row.setHeight((short) (450));
            HSSFCell cell = row.createCell(0);
            cell.setCellValue(headerTitle);
            cell.setCellStyle(strapExcel.getHeaderStyle());
            initMergeCell(index, index, 0, getColSize() - 1);
        }
    }

    public void renderColList() {
        if (CollectionUtil.isNotEmpty(getColList())) {
            HSSFRow thRow = sheet.createRow(nextRowIndex());
            thRow.setHeight((short) 500);
            for (int i = 0; i < getColList().size(); i++) {
                HSSFCell cell = thRow.createCell(i);
                StrapCol strapCol = getColList().get(i);
                cell.setCellValue(strapCol.getColName());
                cell.setCellStyle(strapExcel.getThStyle());
                sheet.setColumnWidth(i, strapCol.getWidth());
            }
        }
    }

    public void renderCells() {
        if (CollectionUtil.isNotEmpty(cells)) {
            int currentRowIndex = nextRowIndex();
            cellStart = currentRowIndex;
            for (List<Object> innerCells : cells) {
                HSSFRow row = sheet.createRow(currentRowIndex++);
                for (int i = 0; i < innerCells.size(); i++) {
                    HSSFCell cell = row.createCell(i);
                    cell.setCellStyle(strapExcel.getCellStyle());
                    fillValue(cell, innerCells.get(i));
                }
                int colSize = getColSize();
                if (colSize > innerCells.size()) {
                    // 空位置补充画方格
                    for (int i = innerCells.size(); i < colSize; i++) {
                        HSSFCell cell = row.createCell(i);
                        cell.setCellStyle(strapExcel.getCellStyle());
                    }
                }
            }
        }
    }

    public void renderFormula() throws Exception {
        if (cellStart > -1 && CollectionUtil.isNotEmpty(colList) && colList.stream().anyMatch(StrapCol::isFormula)) {
            HSSFRow row = sheet.createRow(nextRowIndex());
            for (int i = 0; i < colList.size(); i++) {
                HSSFCell cell = row.createCell(i);
                StrapCol strapCol = colList.get(i);
                String formula = Optional.ofNullable(strapCol.getFormula()).map(
                        f -> f.type(strapCol, colList, cellStart, cells.size())
                ).orElse(null);
                if (StrUtil.isEmpty(formula)) {
                    fillValue(cell, i == 0 && CharSequenceUtil.isEmpty(strapCol.getCustomVal()) ? DEFAULT_TOTAL_NAME : strapCol.getCustomVal());
                    cell.setCellStyle(CharSequenceUtil.isEmpty(strapCol.getFormat()) ? strapExcel.getCellStyle() : strapExcel.getFormulaStyle(strapCol.getFormat()));
                } else {
                    cell.setCellFormula(formula);
                    cell.setCellStyle(strapExcel.getFormulaStyle(strapCol.getFormat()));
                }
            }
        }
    }

}

StrapCol

package com.strap.common.office;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.text.CharSequenceUtil;
import cn.hutool.core.util.StrUtil;
import org.apache.poi.ss.util.CellReference;

import java.util.List;

/**
 * <p>表格列定义</p>
 *
 * @author strap
 */
public class StrapCol {

    /**
     * 列名
     */
    private final String colName;

    /**
     * 头部列名宽度
     */
    private final Integer width;

    /**
     * 合计方式
     */
    private Formula formula;

    /**
     * 合计时使用的自定义值
     */
    private String customVal;

    /**
     * 合计时分子列
     */
    private String numerator;

    /**
     * 合计时分母列
     */
    private String denominator;

    /**
     * 自定义合计格式
     */
    private String format;

    public StrapCol(String colName) {
        this.colName = colName;
        this.width = 700 + colName.length() * 600;
    }

    public StrapCol(String colName, Integer width) {
        this.colName = colName;
        this.width = width;
    }

    public Formula getFormula() {
        return formula;
    }

    public StrapCol setFormula(Formula formula) {
        this.formula = formula;
        return this;
    }

    public String getFormat() {
        return format;
    }

    public StrapCol setFormat(String format) {
        this.format = format;
        return this;
    }

    public String getColName() {
        return colName;
    }

    public Integer getWidth() {
        return width;
    }

    public StrapCol setCustomVal(String customVal) {
        this.customVal = customVal;
        return this;
    }

    public StrapCol setDivide(String numerator, String denominator, String format) {
        this.numerator = numerator;
        this.denominator = denominator;
        this.format = format;
        this.formula = Formula.Divide;
        return this;
    }

    public String getCustomVal() {
        return customVal;
    }

    public String getNumerator() {
        return numerator;
    }

    public String getDenominator() {
        return denominator;
    }

    public boolean isFormula() {
        return getFormula() != null || CharSequenceUtil.isNotEmpty(customVal);
    }

    public enum Formula {
        SUM {
            @Override
            public String type(StrapCol strapCol, List<StrapCol> colList, int start, int cellSize) {
                int i = CollectionUtil.indexOf(colList, col -> strapCol.getColName().equals(col.getColName()));
                if (i > -1) {
                    String s = CellReference.convertNumToColString(i);
                    return StrUtil.format("SUM({}{}:{}{})", s, start + 1, s, start + cellSize);
                }
                return "";
            }
        },

        COUNT {
            @Override
            public String type(StrapCol strapCol, List<StrapCol> colList, int start, int cellSize) {
                int i = CollectionUtil.indexOf(colList, col -> strapCol.getColName().equals(col.getColName()));
                if (i > -1) {
                    String s = CellReference.convertNumToColString(i);
                    return StrUtil.format("COUNTA({}{}:{}{})", s, start + 1, s, start + cellSize);
                }
                return "";
            }
        },

        AVERAGE {
            @Override
            public String type(StrapCol strapCol, List<StrapCol> colList, int start, int cellSize) {
                int i = CollectionUtil.indexOf(colList, col -> strapCol.getColName().equals(col.getColName()));
                if (i > -1) {
                    String s = CellReference.convertNumToColString(i);
                    return StrUtil.format("SUM({}{}:{}{})/{}", s, start + 1, s, start + cellSize, cellSize);
                }
                return "";
            }
        },

        Divide {
            @Override
            public String type(StrapCol strapCol, List<StrapCol> colList, int start, int cellSize) {
                int x = CollectionUtil.indexOf(colList, col -> strapCol.getNumerator().equals(col.getColName()));
                int y = CollectionUtil.indexOf(colList, col -> strapCol.getDenominator().equals(col.getColName()));
                if (x > -1 && y > -1) {
                    String xStr = CellReference.convertNumToColString(x);
                    String yStr = CellReference.convertNumToColString(y);
                    int rowIndex = start + cellSize + 1;
                    return StrUtil.format("IF({}{}=0, \"-\", {}{}/{}{})", yStr, rowIndex, xStr, rowIndex, yStr, rowIndex);
                }
                return "";
            }
        };

        public abstract String type(StrapCol strapCol, List<StrapCol> colList, int start, int cellSize);
    }

}

Demo

package com.strap.test.office;


import cn.hutool.core.map.MapUtil;
import com.strap.common.office.StrapCol;
import com.strap.common.office.StrapExcel;
import com.strap.common.office.StrapSheet;
import org.junit.Test;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

public class TestExport {


    @Test
    public void exportXls() throws Exception {

        List<StrapCol> strapCols = Arrays.asList(
                new StrapCol("班级", 5000), // 自定义列宽
                new StrapCol("姓名").setFormula(StrapCol.Formula.COUNT), // 统计行
                new StrapCol("年龄").setFormula(StrapCol.Formula.AVERAGE).setFormat("0.0"), // 列平均，保留一位小数
                new StrapCol("分数").setFormula(StrapCol.Formula.SUM), // 列累加
                new StrapCol("平均分").setDivide("分数", "姓名", "0.0"), // 不同汇总列相除
                new StrapCol("评级", 5000).setCustomVal("这是自定义值") // 自定义汇总值
        );
        StrapExcel strapExcel = new StrapExcel();

        // 创建第一个sheet
        strapExcel.createSheet(
                new StrapSheet().addColList(strapCols)
                        .sheetName("一年（1）班")   // 表名
                        .headerTitle("一年（1）班成绩统计") // 表头名
                        .addValuesMap(
                                Arrays.asList(
                                        MapUtil.builder(new HashMap<String, Object>()).put("班级", "一年（1）班")
                                                .put("姓名", "林一").put("评级", "B")
                                                .put("年龄", 8).put("平均分", 55).put("分数", 55.6).build(),
                                        MapUtil.builder(new HashMap<String, Object>()).put("班级", "一年（1）班")
                                                .put("姓名", "徐二").put("评级", "C")
                                                .put("年龄", 7).put("平均分", 66).put("分数", 55.6).build()
                                )
                        ).addValuesList(
                                Arrays.asList(
                                        Arrays.asList("一年（1）班", "张三", 7, 75.5, 65, "A"),
                                        Arrays.asList("一年（1）班", "李四", 6, 63.5, 65, "C"),
                                        Arrays.asList("一年（1）班", "陈五", 8, 62.5, 65, "B"),
                                        Arrays.asList("一年（1）班", "王六", 7, 80.5, 65, "A")
                                )
                        )
        );

        // 创建第二个sheet
        strapExcel.createSheet(
                new StrapSheet().addColList(strapCols)
                        .sheetName("一年（2）班")
                        .headerTitle("一年（2）班成绩统计")
                        .addValuesMap(
                                Arrays.asList(
                                        MapUtil.builder(new HashMap<String, Object>()).put("班级", "一年（2）班")
                                                .put("姓名", "林一").put("评级", "B")
                                                .put("年龄", 8).put("平均分", 55).put("分数", 55.6).build(),
                                        MapUtil.builder(new HashMap<String, Object>()).put("班级", "一年（2）班")
                                                .put("姓名", "徐二").put("评级", "C")
                                                .put("年龄", 7).put("平均分", 66).put("分数", 55.6).build()
                                )
                        ).addValuesList(
                                Arrays.asList(
                                        Arrays.asList("一年（2）班", "张三", 7, 75.5, 65, "A"),
                                        Arrays.asList("一年（2）班", "李四", 6, 63.5, 65, "C"),
                                        Arrays.asList("一年（2）班", "陈五", 8, 62.5, 65, "B"),
                                        Arrays.asList("一年（2）班", "王六", 7, 80.5, 65, "A")
                                )
                        )
        );

        // 创建第三个sheet
        strapExcel.createSheet(new StrapSheet().addColList(strapCols)
                .sheetName("一年（3）班")
                .headerTitle("一年（3）班成绩统计")
                .addValuesMap(
                        Arrays.asList(
                                MapUtil.builder(new HashMap<String, Object>()).put("班级", "一年（3）班")
                                        .put("姓名", "林一").put("评级", "B")
                                        .put("年龄", 8).put("平均分", 55).put("分数", 55.6).build(),
                                MapUtil.builder(new HashMap<String, Object>()).put("班级", "一年（3）班")
                                        .put("姓名", "徐二").put("评级", "C")
                                        .put("年龄", 7).put("平均分", 66).put("分数", 55.6).build()
                        )
                ).addValuesList(
                        Arrays.asList(
                                Arrays.asList("一年（3）班", "张三", 7, 75.5, 65, "A"),
                                Arrays.asList("一年（3）班", "李四", 6, 63.5, 65, "C"),
                                Arrays.asList("一年（3）班", "陈五", 8, 62.5, 65, "B"),
                                Arrays.asList("一年（3）班", "王六", 7, 80.5, 65, "A")
                        )
                )
        );


        // byte[] bytes = strapExcel.getBytes();
        strapExcel.saveFile("E:\\test.xls");
    }

}
Java POI 使用封装
TJ的博客
08-31 445
1、读取数据 import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator; import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.DateUtil; import org.apache.poi.ss.usermodel.FormulaEvaluator
java excel poi导出 支持多表头的公共导出方法
最新发布
茉么乔的博客
08-01 1091
java excel poi导出 多表头 导出公共方法
poi简单的封装工具
01-04
简易封装poi， 将文件与对象直接进行映射， 可以快速读写文件。方便快捷的更专注于业务。 什么时候开始资源描述需要50个字以上了，简直看不懂这个操作，是不是蠢啊
poi导出excel二次封装，简单易用，完全不需要了解poi的api就可以使用
09-20
对poi导出excel进行了二次封装，封装后只需要使用模板导出excel就可以了，简单易用，example包里面有几个实例，可以看看，该工程已经上传到github上了，有兴趣的同学可以一起来改进它，https://github.com/xgtxxxx/poi-template
Java POI的封装
weixin_44455476的博客
03-28 366
加入以下依赖 <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId> <version>4.0.1</version> </dependency> <dependen...
java poi 封装_Java的POI的封装与应用
weixin_36339470的博客
02-13 248
Java对Excel表格的导出一直是对我有种可怕噩梦的东西，每次对要建立行与列，并一个一个放值，我是从心底拒绝的。处于项目需求，需要导出表格，于是找到网上一版很好的开发， 《不想用POI？几行代码完成Excel导出导入》原文链接： https://juejin.im/post/5c3b683ee51d4551d14175ee但是、我们项目不支持如此进行开发，===================...
精选资源
POI导出Tree结构数据（连接线）.doc
03-23
POI框架导出Tree结构数据（连接线） 一、问题描述及现象需求说明 ...我们需要对POI框架进行深入了解和分析，然后使用递归和封装的方法来解决模板/指标定位位置的问题、Row对象覆盖的问题和连接线的问题。
精选资源
poi 导出多表头
03-03
- `ExcelService.java`：服务层可能封装了具体的 POI 操作，提供给控制器或其他组件调用。 - `ExcelController.java`：控制器层处理 HTTP 请求，调用服务层的方法来生成 Excel 并返回给客户端。 - `说明.txt`：可能...
精选资源
POI导出word工具类
03-08
在Java代码中，我们通常会用到`XWPFDocument`、`XWPFParagraph`、`XWPFRun`、`XWPFTable`和`XWPFTableCell`等类。 1. **导出07版Word(docx)**：导出docx文件的核心在于创建`XWPFDocument`对象，并通过它来添加各种...
Java使用POI导出Excel文件
wildcat的博客
06-20 6958
Java使用POI导出Excel文件，设置边框、字体、单元格背景、行距、单元格合并、单元格宽度自适应、文本水平居中、垂直居中、标题跟内容样式分离
Java的POI的封装与应用
weixin_30335353的博客
03-16 156
Java对Excel表格的导出一直是对我有种可怕噩梦的东西，每次对要建立行与列，并一个一个放值，我是从心底拒绝的。 处于项目需求，需要导出表格，于是找到网上一版很好的开发， 《不想用POI？几行代码完成Excel导出导入》原文链接： https://juejin.im/post/5c3b683ee51d4551d14175ee 但是、我们项目不支持如此进行开发， ===========...
JAVA语言工具类封装-基于poi的excel导出功能
红豆和绿豆的博客
09-08 1131
http://blog.youkuaiyun.com/caisini_vc/article/details/52387842 excel导出基本上是必备的功能，如果条目超过65535  是csv，否则xls。 一句话使用： [java] view plain copy   OrderInfoExcelBuilder.getInsta
POI封装之一
iteye_4301的博客
08-17 184
某日，同学求助，他们每个月要从一个Excel表格A中获取一些数据，导入到一个统一的Excel B中，Excel B是全量的，每个月追加进去。 其实直接通过POI，比较简单的就可以实现了，但是自己又开始抽筋了，要做一番设计。 封装一下POI吧，这样感觉干净些。 原生的POI少了两个特性，一个是过滤，一个是数据绑定。 我先定义接口： [code="java"] publ...
封装PoiExcelUtils
smart_an的专栏
12-06 1470
上面的工具类封装具有一定难度，尽量理解即可。网络上还有一种封装方式，需要调用者自己在外部组装好各个字段对应的Map传入Util。但个人认为POI本身效率就不高，所以这点性能提升可有可无，用起来还麻烦。至此，对POI的学习告一段落，请不要在生产环境使用PoiExcelUtils（可能发生OOM），推荐使用EasyExcel。作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO进群，大家一起学习，一起进步，一起对抗互联网寒冬。
封装poi导入篇
weixin_30558305的博客
11-25 164
前言 有封装的想法好久了，项目中有不少地方需要使用导入功能，导入虽说不能，但是每次都要为了特定类写一个特定方法，很麻烦，我很讨厌一直写这种东西了，正好趁着这次机会就写一个可以解决这种问题的小项目。 maven <dependency> <groupId>org.apache.poi</groupId> <artifactI...
自用POI工具封装——待改进
Manxiaoji_2020的博客
01-06 359
POI改进思路 Poi是一个对excel表格进行操作的工具类，但是由于内部的操作过于复杂，使用起来有点困难，所以我对Poi进行了简单的封装，但是在与朋友进行沟通后，我们认为我封装的工具类还可以进行进一步的封装，以下是我自己的思路，欢迎各位来进行讨论。 poi是一个竖向操作的工具（自己理解的），他需要先创建一个row，才能创建一个cell，我自己理解是，row相当于一条线上的一段，而cell才是存放地址的一段空间。 我的第一次封装，是将这种竖向的存储改成了横向的，因为平时我们惯用的是一行是相当于一个对象，所
POI封装之六
iteye_4301的博客
08-26 145
[code="java"] public class POICell implements ICell { private Cell cell; private String key; private FormulaEvaluator fe; private IRow row; private static final Map CACHE = new Ha...
【POI】个人封装的常用的导入导出方法
lzq2357639195的博客
12-29 591
本文保存一些个人封装的常用的POI导入导出方法，随时调整
java用 poi封装一个excel导出模板工具类
tomisa的博客
03-11 503
记录封装一个excel导出工具类 因为业务需求需要支持导入导出功能，之前需要导出功能的模块比较少，可以直接调poi包的API接口，现在不行了，好几十个。。。一个一个写估计要通宵，因此写一个统一的导出模板。话不多说上代码！！ 业务代码不方便贴出来，用demo演示。 jar包： <!-- poi --> <dependency> <groupId>org.apache.poi</groupId>
Java快速导出Excel的POI和JXLS封装技术
1. Java与Excel导出技术：文档标题明确指出“java excle导出封装”，这表明该文件涉及到Java语言如何将数据导出到Excel文件的技术实现。在Java开发中，经常需要将数据以表格形式展示，而Excel是一个非常流行和通用的...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值