java继承poi

java使用POI导出excel表格

2019-02-25 19:38:00

首先导入poi工具所需的依赖包  <dependency> <groupId>org.apache.poi</groupId> <artifactId>p...

转载出处：https://blog.csdn.net/l1028386804/article/details/79659605

一.首先导入poi工具所需的依赖包

<!--POI操作excel-->
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi-scratchpad</artifactId>
			<version>3.11-beta2</version>
		</dependency>
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi-ooxml</artifactId>
			<version>3.11-beta2</version>
		</dependency>
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi-ooxml-schemas</artifactId>
			<version>3.11-beta2</version>
		</dependency>
		<dependency>
			<groupId>org.apache.poi</groupId>
			<artifactId>poi-excelant</artifactId>
			<version>3.11-beta2</version>
		</dependency>


二.编写ExportExcelUtil类

这个类使我们整个工具的核心，它实现了Excel文件的导出功能

package com.example.demo.util;

import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
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.hssf.util.HSSFColor;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFColor;
import org.apache.poi.xssf.usermodel.XSSFFont;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;


/**
 * 导出Excel
 * @author liuyazhuang
 *
 * @param <T>
 */
public class ExportExcelUtil<T>{

    // 2007 版本以上 最大支持1048576行
    public  final static String  EXCEl_FILE_2007 = "2007";
    // 2003 版本 最大支持65536 行
    public  final static String  EXCEL_FILE_2003 = "2003";

    /**
     * <p>
     * 导出无头部标题行Excel <br>
     * 时间格式默认：yyyy-MM-dd hh:mm:ss <br>
     * </p>
     *
     * @param title 表格标题
     * @param dataset 数据集合
     * @param out 输出流
     * @param version 2003 或者 2007，不传时默认生成2003版本
     */
    public void exportExcel(String title, Collection<T> dataset, OutputStream out, String version) {
        if(StringUtils.isEmpty(version) || EXCEL_FILE_2003.equals(version.trim())){
            exportExcel2003(title, null, dataset, out, "yyyy-MM-dd HH:mm:ss");
        }else{
            exportExcel2007(title, null, dataset, out, "yyyy-MM-dd HH:mm:ss");
        }
    }

    /**
     * <p>
     * 导出带有头部标题行的Excel <br>
     * 时间格式默认：yyyy-MM-dd hh:mm:ss <br>
     * </p>
     *
     * @param title 表格标题
     * @param headers 头部标题集合
     * @param dataset 数据集合
     * @param out 输出流
     * @param version 2003 或者 2007，不传时默认生成2003版本
     */
    public void exportExcel(String title,String[] headers, Collection<T> dataset, OutputStream out,String version) {
        if(StringUtils.isBlank(version) || EXCEL_FILE_2003.equals(version.trim())){
            exportExcel2003(title, headers, dataset, out, "yyyy-MM-dd HH:mm:ss");
        }else{
            exportExcel2007(title, headers, dataset, out, "yyyy-MM-dd HH:mm:ss");
        }
    }

    /**
     * <p>
     * 通用Excel导出方法,利用反射机制遍历对象的所有字段，将数据写入Excel文件中 <br>
     * 此版本生成2007以上版本的文件 (文件后缀：xlsx)
     * </p>
     *
     * @param title
     *            表格标题名
     * @param headers
     *            表格头部标题集合
     * @param dataset
     *            需要显示的数据集合,集合中一定要放置符合JavaBean风格的类的对象。此方法支持的
     *            JavaBean属性的数据类型有基本数据类型及String,Date
     * @param out
     *            与输出设备关联的流对象，可以将EXCEL文档导出到本地文件或者网络中
     * @param pattern
     *            如果有时间数据，设定输出格式。默认为"yyyy-MM-dd hh:mm:ss"
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public void exportExcel2007(String title, String[] headers, Collection<T> dataset, OutputStream out, String pattern) {
        // 声明一个工作薄
        XSSFWorkbook workbook = new XSSFWorkbook();
        // 生成一个表格
        XSSFSheet sheet = workbook.createSheet(title);
        // 设置表格默认列宽度为15个字节
        sheet.setDefaultColumnWidth(20);
        // 生成一个样式
        XSSFCellStyle style = workbook.createCellStyle();
        // 设置这些样式
        style.setFillForegroundColor(new XSSFColor(java.awt.Color.gray));
        style.setFillPattern(XSSFCellStyle.SOLID_FOREGROUND);
        style.setBorderBottom(XSSFCellStyle.BORDER_THIN);
        style.setBorderLeft(XSSFCellStyle.BORDER_THIN);
        style.setBorderRight(XSSFCellStyle.BORDER_THIN);
        style.setBorderTop(XSSFCellStyle.BORDER_THIN);
        style.setAlignment(XSSFCellStyle.ALIGN_CENTER);
        // 生成一个字体
        XSSFFont font = workbook.createFont();
        font.setBoldweight(XSSFFont.BOLDWEIGHT_BOLD);
        font.setFontName("宋体");
        font.setColor(new XSSFColor(java.awt.Color.BLACK));
        font.setFontHeightInPoints((short) 11);
        // 把字体应用到当前的样式
        style.setFont(font);
        // 生成并设置另一个样式
        XSSFCellStyle style2 = workbook.createCellStyle();
        style2.setFillForegroundColor(new XSSFColor(java.awt.Color.WHITE));
        style2.setFillPattern(XSSFCellStyle.SOLID_FOREGROUND);
        style2.setBorderBottom(XSSFCellStyle.BORDER_THIN);
        style2.setBorderLeft(XSSFCellStyle.BORDER_THIN);
        style2.setBorderRight(XSSFCellStyle.BORDER_THIN);
        style2.setBorderTop(XSSFCellStyle.BORDER_THIN);
        style2.setAlignment(XSSFCellStyle.ALIGN_CENTER);
        style2.setVerticalAlignment(XSSFCellStyle.VERTICAL_CENTER);
        // 生成另一个字体
        XSSFFont font2 = workbook.createFont();
        font2.setBoldweight(XSSFFont.BOLDWEIGHT_NORMAL);
        // 把字体应用到当前的样式
        style2.setFont(font2);

        // 产生表格标题行
        XSSFRow row = sheet.createRow(0);
        XSSFCell cellHeader;
        for (int i = 0; i < headers.length; i++) {
            cellHeader = row.createCell(i);
            cellHeader.setCellStyle(style);
            cellHeader.setCellValue(new XSSFRichTextString(headers[i]));
        }

        // 遍历集合数据，产生数据行
        Iterator<T> it = dataset.iterator();
        int index = 0;
        T t;
        Field[] fields;
        Field field;
        XSSFRichTextString richString;
        Pattern p = Pattern.compile("^//d+(//.//d+)?$");
        Matcher matcher;
        String fieldName;
        String getMethodName;
        XSSFCell cell;
        Class tCls;
        Method getMethod;
        Object value;
        String textValue;
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        while (it.hasNext()) {
            index++;
            row = sheet.createRow(index);
            t = (T) it.next();
            // 利用反射，根据JavaBean属性的先后顺序，动态调用getXxx()方法得到属性值
            fields = t.getClass().getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                cell = row.createCell(i);
                cell.setCellStyle(style2);
                field = fields[i];
                fieldName = field.getName();
                getMethodName = "get" + fieldName.substring(0, 1).toUpperCase()
                        + fieldName.substring(1);
                try {
                    tCls = t.getClass();
                    getMethod = tCls.getMethod(getMethodName, new Class[] {});
                    value = getMethod.invoke(t, new Object[] {});
                    // 判断值的类型后进行强制类型转换
                    textValue = null;
                    if (value instanceof Integer) {
                        cell.setCellValue((Integer) value);
                    } else if (value instanceof Float) {
                        textValue = String.valueOf((Float) value);
                        cell.setCellValue(textValue);
                    } else if (value instanceof Double) {
                        textValue = String.valueOf((Double) value);
                        cell.setCellValue(textValue);
                    } else if (value instanceof Long) {
                        cell.setCellValue((Long) value);
                    }
                    if (value instanceof Boolean) {
                        textValue = "是";
                        if (!(Boolean) value) {
                            textValue = "否";
                        }
                    } else if (value instanceof Date) {
                        textValue = sdf.format((Date) value);
                    } else {
                        // 其它数据类型都当作字符串简单处理
                        if (value != null) {
                            textValue = value.toString();
                        }
                    }
                    if (textValue != null) {
                        matcher = p.matcher(textValue);
                        if (matcher.matches()) {
                            // 是数字当作double处理
                            cell.setCellValue(Double.parseDouble(textValue));
                        } else {
                            richString = new XSSFRichTextString(textValue);
                            cell.setCellValue(richString);
                        }
                    }
                } catch (SecurityException e) {
                    e.printStackTrace();
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } finally {
                    // 清理资源
                }
            }
        }
        try {
            workbook.write(out);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }



    /**
     * <p>
     * 通用Excel导出方法,利用反射机制遍历对象的所有字段，将数据写入Excel文件中 <br>
     * 此方法生成2003版本的excel,文件名后缀：xls <br>
     * </p>
     *
     * @param title
     *            表格标题名
     * @param headers
     *            表格头部标题集合
     * @param dataset
     *            需要显示的数据集合,集合中一定要放置符合JavaBean风格的类的对象。此方法支持的
     *            JavaBean属性的数据类型有基本数据类型及String,Date
     * @param out
     *            与输出设备关联的流对象，可以将EXCEL文档导出到本地文件或者网络中
     * @param pattern
     *            如果有时间数据，设定输出格式。默认为"yyyy-MM-dd hh:mm:ss"
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public void exportExcel2003(String title, String[] headers, Collection<T> dataset, OutputStream out, String pattern) {
        // 声明一个工作薄
        HSSFWorkbook workbook = new HSSFWorkbook();
        // 生成一个表格
        HSSFSheet sheet = workbook.createSheet(title);
        // 设置表格默认列宽度为15个字节
        sheet.setDefaultColumnWidth(20);
        // 生成一个样式
        HSSFCellStyle style = workbook.createCellStyle();
        // 设置这些样式
        style.setFillForegroundColor(HSSFColor.GREY_50_PERCENT.index);
        style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
        style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
        style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
        style.setBorderRight(HSSFCellStyle.BORDER_THIN);
        style.setBorderTop(HSSFCellStyle.BORDER_THIN);
        style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
        // 生成一个字体
        HSSFFont font = workbook.createFont();
        font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
        font.setFontName("宋体");
        font.setColor(HSSFColor.WHITE.index);
        font.setFontHeightInPoints((short) 11);
        // 把字体应用到当前的样式
        style.setFont(font);
        // 生成并设置另一个样式
        HSSFCellStyle style2 = workbook.createCellStyle();
        style2.setFillForegroundColor(HSSFColor.WHITE.index);
        style2.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
        style2.setBorderBottom(HSSFCellStyle.BORDER_THIN);
        style2.setBorderLeft(HSSFCellStyle.BORDER_THIN);
        style2.setBorderRight(HSSFCellStyle.BORDER_THIN);
        style2.setBorderTop(HSSFCellStyle.BORDER_THIN);
        style2.setAlignment(HSSFCellStyle.ALIGN_CENTER);
        style2.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
        // 生成另一个字体
        HSSFFont font2 = workbook.createFont();
        font2.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
        // 把字体应用到当前的样式
        style2.setFont(font2);

        // 产生表格标题行
        HSSFRow row = sheet.createRow(0);
        HSSFCell cellHeader;
        for (int i = 0; i < headers.length; i++) {
            cellHeader = row.createCell(i);
            cellHeader.setCellStyle(style);
            cellHeader.setCellValue(new HSSFRichTextString(headers[i]));
        }

        // 遍历集合数据，产生数据行
        Iterator<T> it = dataset.iterator();
        int index = 0;
        T t;
        Field[] fields;
        Field field;
        HSSFRichTextString richString;
        Pattern p = Pattern.compile("^//d+(//.//d+)?$");
        Matcher matcher;
        String fieldName;
        String getMethodName;
        HSSFCell cell;
        Class tCls;
        Method getMethod;
        Object value;
        String textValue;
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        while (it.hasNext()) {
            index++;
            row = sheet.createRow(index);
            t = (T) it.next();
            // 利用反射，根据JavaBean属性的先后顺序，动态调用getXxx()方法得到属性值
            fields = t.getClass().getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                cell = row.createCell(i);
                cell.setCellStyle(style2);
                field = fields[i];
                fieldName = field.getName();
                getMethodName = "get" + fieldName.substring(0, 1).toUpperCase()
                        + fieldName.substring(1);
                try {
                    tCls = t.getClass();
                    getMethod = tCls.getMethod(getMethodName, new Class[] {});
                    value = getMethod.invoke(t, new Object[] {});
                    // 判断值的类型后进行强制类型转换
                    textValue = null;
                    if (value instanceof Integer) {
                        cell.setCellValue((Integer) value);
                    } else if (value instanceof Float) {
                        textValue = String.valueOf((Float) value);
                        cell.setCellValue(textValue);
                    } else if (value instanceof Double) {
                        textValue = String.valueOf((Double) value);
                        cell.setCellValue(textValue);
                    } else if (value instanceof Long) {
                        cell.setCellValue((Long) value);
                    }
                    if (value instanceof Boolean) {
                        textValue = "是";
                        if (!(Boolean) value) {
                            textValue = "否";
                        }
                    } else if (value instanceof Date) {
                        textValue = sdf.format((Date) value);
                    } else {
                        // 其它数据类型都当作字符串简单处理
                        if (value != null) {
                            textValue = value.toString();
                        }
                    }
                    if (textValue != null) {
                        matcher = p.matcher(textValue);
                        if (matcher.matches()) {
                            // 是数字当作double处理
                            cell.setCellValue(Double.parseDouble(textValue));
                        } else {
                            richString = new HSSFRichTextString(textValue);
                            cell.setCellValue(richString);
                        }
                    }
                } catch (SecurityException e) {
                    e.printStackTrace();
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } finally {
                    // 清理资源
                }
            }
        }
        try {
            workbook.write(out);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

为了演示导出功能，这里我们创建了一个Person类。
3、创建Student类
package com.example.demo;

public class Person {

    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    private void getString(){
        System.out.println("hello java");
    }
}


使用junit 测试用例，生成表格

@Test
    public void excelExport() throws FileNotFoundException {
        ExportExcelUtil<Student> util = new ExportExcelUtil<Student>();
        // 准备数据
        List<Student> list = new ArrayList<>();
            list.add(new Student(1,"张三","男"));
            list.add(new Student(2,"李四","男"));
            list.add(new Student(3,"王五","女"));

        String[] columnNames = { "ID", "姓名", "性别" };
        util.exportExcel("用户导出", columnNames, list, new FileOutputStream("D:/test.xls"), ExportExcelUtil.EXCEL_FILE_2003);
    }

三、项目扩展

以上实现均是在本地磁盘生成excel文件，但更多的时候，我们需要通过点击网页上的某个按钮来自动生成并下载Excel文档，那么，这又如何实现呢？下面我们就一起来实现这个功能。
1、扩展ExportExcelUtil类

根据Java的继承思想，我们不在ExportExcelUtil类上修改添加，我们创建一个ExportExcelUtil类的子类ExportExcelWrapper，这个类继承ExportExcelUtil的所有功能，同时，扩展了网页生成Excel的功能。具体代码如下：
package com.example.demo.util;


import java.net.URLEncoder;
import java.util.Collection;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;

/**
 * 包装类
 * @author liuyazhuang
 *
 * @param <T>
 */
public class ExportExcelWrapper<T> extends ExportExcelUtil<T> {
    /**
     * <p>
     * 导出带有头部标题行的Excel <br>
     * 时间格式默认：yyyy-MM-dd hh:mm:ss <br>
     * </p>
     *
     * @param title 表格标题
     * @param headers 头部标题集合
     * @param dataset 数据集合
     * @param out 输出流
     * @param version 2003 或者 2007，不传时默认生成2003版本
     */
    public void exportExcel(String fileName, String title, String[] headers, Collection<T> dataset, HttpServletResponse response,String version) {
        try {
            response.setContentType("application/vnd.ms-excel");
            response.addHeader("Content-Disposition", "attachment;filename="+ URLEncoder.encode(fileName, "UTF-8") + ".xls");
            if(StringUtils.isBlank(version) || EXCEL_FILE_2003.equals(version.trim())){
                exportExcel2003(title, headers, dataset, response.getOutputStream(), "yyyy-MM-dd hh:mm:ss");
            }else{
                exportExcel2007(title, headers, dataset, response.getOutputStream(), "yyyy-MM-dd hh:mm:ss");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


四.controller层代码

@ResponseBody
    @PostMapping("/get/excel")
    public void getExcel(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // 准备数据
        List<Student> list = new ArrayList<>();
            list.add(new Student(1,"张三","男"));
            list.add(new Student(2,"李四","男"));
            list.add(new Student(3,"翠花","女"));
        String[] columnNames = { "ID", "姓名", " 性别"};
        String fileName = "excel1";
        ExportExcelWrapper<Student> util = new ExportExcelWrapper<Student>();
        util.exportExcel(fileName, fileName, columnNames, list, response, ExportExcelUtil.EXCEL_FILE_2003);
    }


五.用户登录之后进入index界面，在该界面上可以点击下载excel表格

<!DOCTYPE html>
<html lang="zh-CN"xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>导出Excel</title>
</head>
<body>
<span>shiro 登录验证 通过</span>
<form id="form_login" action="http://127.0.0.1:8083/get/excel" method="post">
</form>
<button id="btn-submit" onclick="beforeSubmit()">Submit</button>
<script type="text/javascript">
    var loginForm = document.getElementById('form_login');
    function beforeSubmit() {
        loginForm.submit();
    }
</script>
</body>
</html>



六.界面如下。

收起

展开全文

Java使用POI导入excel教程

2021-01-26 17:03:16

前言实习期间遇到一个业务需求，要求具有excel导入和导出功能。由于公司框架的数据表格自带了excel导出功能（N年前的老框架，文档不全BUG贼多），所以只需怼excel导入即可，流程是这样的：选择excel →文件...Java课


文章目录
前言
1、工作准备
2、小试牛刀
3、小结
写在最后

前言
实习期间遇到一个业务需求，要求具有excel导入和导出功能。由于公司框架的数据表格自带了excel导出功能，所以只需excel导入即可，流程是这样的：选择excel →文件上传→处理数据。
项目使用的Jar包是Apache POI，关于Apache POI，简单介绍一下：

Apache POI是基于Office Open XML标准（OOXML）和Microsoft的OLE2复合文档格式（OLE2）处理各种文件格式的开源项目。简言之，就是用来操作office的工具箱。

其中操作Excel的模块有两个：

HSSF - 操作xls格式excel（低版本），有数据量限制
XSSF - 操作xlsx格式excel（高版本），支持百万级数据量

1、工作准备
打开maven仓库：https://mvnrepository.com/，输入POI，如下图：



点进去，推荐选择的版本特点——时间不早不晚，多人使用的（遇到问题降低了解决难度），如下图：



这里选择3.17版本（beta可以理解为测试、抢先，通常是有新功能或大的调整），点击，复制maven坐标，如下图：



poi-ooxml如是，然后把它们贴入pom.xml，如下图：



然后在idea中右键选中：Maven→Reimport，或者点击enable auto import，让maven把jar包接入项目即可。
2、小试牛刀
由于excel存在版本区别，需要分别处理xls和xlsx格式，分别对应HSSF、XSSF开头的API，按住CTRL + SHIFT + ALT + U，查看继承关系图，可以发现它们有相同的接口：



其它类，如：HSSFSheet、XSSFSheet也可以通过Sheet接口引用（里式替换法则），测试代码如下（xlxs）：
    private static void parseXlsxDemo() throws Exception {
        // File类：以抽象的方式代表文件名和目录路径名
        File file = new File("d:\\good.xls");
        // 建立文件输入流
        FileInputStream fis = new FileInputStream(file);
        // 声明并创建一个工作簿
        HSSFWorkbook workbook = new HSSFWorkbook(fis);
        // sheet表示文件页，下标从0开始，表示第一页
        HSSFSheet sheet = workbook.getSheetAt(0);
        // 获取总行数（第一页）
        int rows = sheet.getPhysicalNumberOfRows();
        for (int i = 0; i < rows; i++) {
            // 先获取行对象，再操作列
            Row row = sheet.getRow(i);
            // 获取每一行的格子数（列数）
            int cols = row.getPhysicalNumberOfCells();
            for (int j = 0; j < cols; j++) {
                // 获取格子对象
                Cell cell = row.getCell(j);
                // 输出格子对象
                System.out.printf("%s\t", cell.toString());
            }
            // 换行输出
            System.out.println();
        }
    }

文件截图+运行效果：



细心的朋友会发现，0变成了0.0，1变成了1.0，这是因为POI默认数字为浮点数。数据类型稍微有点复杂，此处不深究，下面是修改后的完整代码：
package ltd.newson.poi;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import java.io.File;
import java.io.FileInputStream;

/**
 * @Title: ReadExcel
 * @Author: newson.ltd
 * @Date: 2021-01-26 下午 12:01
 * @Version: 1.0
 * @Description: excel demo
 */
public class ReadExcel {

    public static void main(String[] args) throws Exception {
        String fileName1 = "d:\\good.xls";
        String fileName2 = "d:\\good.xlsx";
        parseXls(fileName1);
        parseXlsx(fileName2);
    }

    /**
     * 读取xls格式excel
     * @param fileName
     * @throws Exception
     */
    private static void parseXls(String fileName) throws Exception {
        // 1、读取文件（逐层包装，装饰器模式）
        FileInputStream fis = new FileInputStream(new File(fileName));
        Workbook workbook = new HSSFWorkbook(fis);
        // 2、获取要处理的页面
        Sheet sheet = workbook.getSheetAt(0);
        // 3、处理单元格
        printCell(sheet);

    }

    /**
     * 读取xlsx格式excel
     * @param fileName
     * @throws Exception
     */
    private static void parseXlsx(String fileName) throws Exception {
        FileInputStream fis = new FileInputStream(new File(fileName));
        Workbook workbook = new XSSFWorkbook(fis);
        Sheet sheet = workbook.getSheetAt(0);
        printCell(sheet);

    }

    /**
     * 打印单元格
     * @param sheet
     */
    private static void printCell(Sheet sheet) {
        // 获取当前页的总行数
        int totalRowNums = sheet.getPhysicalNumberOfRows();
        for (int i = 0; i < totalRowNums; i++) {
            // 获取行
            Row row = sheet.getRow(i);
            // 获取列数（格子数）
            int cells = row.getPhysicalNumberOfCells();
            StringBuilder builder = new StringBuilder();
            for (int j = 0; j < cells; j++) {
                Cell cell = row.getCell(j);
                builder.append(getCellValue(cell)).append("\t");
            }
            System.out.print(builder.append("\n").toString());
        }
    }

    /**
     * 获取单元格的值，此处做简单处理
     * @param cell
     * @return
     */
    private static String getCellValue(Cell cell) {
        // 部分API已过时，此处是更新后的
        CellType cellType = cell.getCellTypeEnum();
        if (cellType == CellType.BOOLEAN) {
            return String.valueOf(cell.getBooleanCellValue());
        }
        if (cellType == CellType.NUMERIC) {
            return cell.getNumericCellValue() + "";
        }
        return cell.getStringCellValue();
    }

}


运行截图：



补充：注意getCellValue()中的API，有些教程可能会使用cell.getCellType()和Cell.CELL_TYPE_XXX（XXX表示数据类型），这些方法在新的POI中被标记为@deprecated（过时的），建议换成上述方法内的API。
3、小结
通过代码＋注释的解读，会发现excel的读取是这么的简单，归纳一下操作步骤：

输入目标文件，获取wordbook对象（工作簿）
通过workbook对象获取sheet对象（要操作的页面）
通过sheet对象获取当前页的总行数
开循环，获取行对象，并通过行获取每一行的列数（格子数）
再开个循环，通过行对象获取每一个格子对象
操作格子对象（注意数据类型）

最后一步也是比较复杂的一步，需要具体情况具体分析。本示例操作单页，多页同理。最后扩展一下excel单元格的数据类型：




CellType
含义




_NONE
未知类型


NUMERIC
数值类型（整数、小数、日期）


STRING
字符串


FORMULA
公式


BLANK
空白格（有样式）


BOOLEAN
布尔值


ERROR
错误单元格



写在最后
本次Java读取excel就介绍到这里啦，我是严光君，咱们下文再见~ 




创造不易，少侠请留步…… 动起可爱的双手，点个赞再走呗~ ٩(๑>◡<๑)۶

CellType	含义
_NONE	未知类型
NUMERIC	数值类型（整数、小数、日期）
STRING	字符串
FORMULA	公式
BLANK	空白格（有样式）
BOOLEAN	布尔值
ERROR	错误单元格

收起

展开全文

excel

java使用POI读写Excel(踩坑总结)

千次阅读 2020-03-11 23:12:59

前期准备：到官网下载pol的jar包:https://poi.apache.org/ 导入项目所依赖的jar包（注：这几个一个都不...import java.io.IOException; import org.apache.poi.xssf.usermodel.XSSFCell; import org.apache.poi....

前期准备：

到官网下载pol的jar包:https://poi.apache.org/




导入项目所依赖的jar包（注：这几个一个都不能少，不然会报些奇怪的错）



代码：

使用POI读取Excel并输出
import java.io.IOException;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class demo1 {
	public static void main(String[] args) throws IOException {
		//获取工作簿对象
		XSSFWorkbook workbook1 = new XSSFWorkbook("././POL/hello.xlsx");
		//获取工作表
		XSSFSheet sheet = workbook1.getSheetAt(0);

		int lastRowNum = sheet.getLastRowNum();
		for(int i=0;i<=lastRowNum;i++) {
			XSSFRow row = sheet.getRow(i);
			if(row!=null) {
				short cellNum = row.getLastCellNum();
				for (int j = 0; j <= cellNum; j++) {
					XSSFCell cell = row.getCell(j);
					if (cell!=null) {
						String stringcelString = cell.getStringCellValue();
						System.out.println(stringcelString);
					}
				}
			}
		}
		workbook1.close();
	}
}

运行效果：



使用POI创建Excel文件
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import java.io.FileOutputStream;
import java.io.IOException;

public class demo1 {
	public static void main(String[] args) throws IOException {
		//创建工作对象
		XSSFWorkbook workbook = new XSSFWorkbook();
		//创建工作表
		XSSFSheet sheet = workbook.createSheet("demo1");
		//创建行
		XSSFRow row = sheet.createRow(0);
		//创建单元格
		row.createCell(0).setCellValue("hello");
		//创建行
		XSSFRow row1 = sheet.createRow(1);
		//创建单元格
		row1.createCell(0).setCellValue("world");
		
		FileOutputStream outputStream = new FileOutputStream("././POL/hello.xlsx");
		
		workbook.write(outputStream);
		outputStream.flush();
		
		//释放资源
		outputStream.close();
		workbook.close();
		System.out.println("写入成功");
	}
}

运行效果：


原文章在博主的网站也有：http://runsel.cn/

都看到这了给博主点个赞呗😁

收起

展开全文

Java用poi导入导出Excel

2021-05-11 18:24:35

前言 1、将用户信息导出为excel表格...操作Excel目前比较流行的就是Apache POI和阿里巴巴的easyExcel！接下来说说Apache下的POI吧 <dependencies>  <dependency> <gr...

前言

1、将用户信息导出为excel表格（导出数据….）

2、将Excel表中的信息录入到网站数据库（习题上传….）

开发中经常会设计到excel的处理，如导出Excel，导入Excel到数据库中！

操作Excel目前比较流行的就是 Apache POI 和 阿里巴巴的 easyExcel ！

接下来说说Apache下的POI吧

<dependencies>
    <!--xls(03)-->
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>3.9</version>
    </dependency>
    <!--xlsx(07)-->
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi-ooxml</artifactId>
        <version>3.9</version>
    </dependency>
    <!--日期格式化工具-->
    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
        <version>2.10.1</version>
    </dependency>
    <!--test-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

注意：

1、jar包需要保持版本（version）一样

2、2003 版本和 2007 版本存在兼容性的问题！03版本最多只有 65536 行！07版本没有限制

2、Excel导入

public void importExcel(@RequestParam("file") MultipartFile multipartFile) {
        //MultipartFile转换成File
        File file=MultipartFile2FileUtil.MultipartFile2File(multipartFile);
        //需要解析的Excel文件
        try {
            //获取工作簿
            /**
             * 构造函数获取一个FileInputStream对象
             * FileUtils.openInputStream 调用了 FileInputStream 的构造函数去打开一个文件（open0是一个本地方法，打开指定文件进行读取）
             * 对FileInputStream中的open调用open0方法---> https://blog.csdn.net/zhlily1/article/details/109468154
             */
            FileInputStream fs = FileUtils.openInputStream(file);
            XSSFWorkbook workbook = new XSSFWorkbook(fs);
            //获取最Excel中的sheet数量
            int numberOfSheets = workbook.getNumberOfSheets();
            for (int j=0;j<numberOfSheets;j++){
            //获取第一个工作表
                XSSFSheet hs = workbook.getSheetAt(j);
                //获取Sheet的第一个行号和最后一个行号
                int last = hs.getLastRowNum();
                int first = hs.getFirstRowNum() + 1;
                //遍历获取单元格里的信息
                List<AuditContentImportBo> list = new ArrayList<>();
                //注：row为行   cell为列
                for (int i = first; i <= last; i++) {
                    XSSFRow row = hs.getRow(i);
                    String cell1=new String();
                    //可以在这里遍历row，获取当前行每列的数据
                    if (!StringUtil.isNullOrEmpty(cell1)) {
                        try {
                            cell1=row.getCell(1).getStringCellValue();
                        }catch (Exception e){
                            cell1=String.valueOf(row.getCell(1).getNumericCellValue());
                        }
                    }
                }
                String name = hs.getSheetName();
                equipmentAuditContentService.importEquipmentAuditContent(name, list);
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //清空文件缓存，并且调用delete0关闭文件
        MultipartFile2FileUtil.deleteFile(file);
    }

3、MultipartFile2FileUtil工具类

public class MultipartFile2FileUtil {
    /**
     * MultipartFile转换为File
     * @param multipartFile
     * @return
     * MultipartFile继承了InputStreamSource
     */
    public static File MultipartFile2File(MultipartFile multipartFile){
        //文件上传前的名称
        String fileName = multipartFile.getOriginalFilename();
        //new 一个 file
        File file = new File(fileName);
        OutputStream out = null;
        try{
            //获取文件流，以文件流的方式输出到新文件 
//    InputStream in = multipartFile.getInputStream();
            //获取到一个file的输出流
            out = new FileOutputStream(file);
            //获取multipartFile的字节文件，并将字节文件遍历write到out输出流
            byte[] ss = multipartFile.getBytes();
            for(int i = 0; i < ss.length; i++){
                out.write(ss[i]);
            }
        }catch(IOException e){
            e.printStackTrace();
        }finally {
            //进行判断关闭输出流
            if (out != null){
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return file;
    }
    public static void deleteFile(File file){
        File f = new File(file.toURI());
        f.delete();
    }
}

4、导出Excel

public ApiResult exportAuditContent(HttpServletResponse response, @RequestBody ExportAuditContentIds exportAuditContentIds){
        OutputStream outputStream = tryCatch2gGetOutput(response);
        List<Entity> entitys=dao.getEntitys();
        HSSFWorkbook workbook = new HSSFWorkbook();
        //headers
        String[] headers=new String[]{"表头1","表头2","表头3"};
        int sheetNum=0;
        //遍历查到的list
        for (Entity entity : entitys) {
            List<List<String>> result=new ArrayList<>();
            //sheetName
            String sheetTitle=entity.getSheetName();
            for (entity exportAuditContent : auditContent.getContentName()) {
                List<String> str=new ArrayList<>();
                str.add(exportAuditContent.getXXX());
                str.add(exportAuditContent.getXXX());
                str.add(exportAuditContent.getXXX());
                result.add(str);
            }
                ExcelForMoreSheet.exportExcel(workbook,sheetNum,sheetTitle,headers,result,outputStream);
            sheetNum++;
        }
        try {
            workbook.write(outputStream);
            outputStream.close();
        } catch (Exception e) {
            throw new AnyException("导出出错");
        }
        return success("导出成功","成功");
    }

5、tryCatch2gGetOutput

private OutputStream tryCatch2gGetOutput(HttpServletResponse response){
        try {
            OutputStream output = response.getOutputStream();
            response.reset();
            String filename = "title"+new SimpleDateFormat("yyyy-MM-dd").format(new Date()) +".xls";
            response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
            response.setHeader("Content-Disposition", "attachment;filename="
                    .concat(String.valueOf(URLEncoder.encode(filename, "UTF-8"))));
            response.setHeader("Access-Control-Allow-Origin", "*");
            response.setHeader("Cache-Control", "no-cache");
            return output;
        } catch (Exception e) {
            throw new AnyException("导出出错");
        }
    }

6、Excel导出工具类

package com.troo;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.joda.time.DateTime;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class ExcelForMoreSheet {
    /**
     * @Title: exportExcel
     * @Description: 导出Excel的方法
     * @author: evan @ 2014-01-09
     * @param workbook
     * @param sheetNum (sheet的位置，0表示第一个表格中的第一个sheet)
     * @param sheetTitle  （sheet的名称）
     * @param headers    （表格的标题）
     * @param result   （表格的数据）
     * @param out  （输出流）
     * @throws Exception
     */
    public static void exportExcel(HSSFWorkbook workbook, int sheetNum,
                            String sheetTitle, String[] headers, List<List<String>> result,
                            OutputStream out)  {
        // 生成一个表格
        HSSFSheet sheet = workbook.createSheet();
        workbook.setSheetName(sheetNum, sheetTitle);
        // 设置表格默认列宽度为20个字节
        sheet.setDefaultColumnWidth((short) 20);
        // 生成一个样式
        HSSFCellStyle style = workbook.createCellStyle();
        // 设置这些样式
        style.setFillForegroundColor(HSSFColor.PALE_BLUE.index);
        style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
        style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
        style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
        style.setBorderRight(HSSFCellStyle.BORDER_THIN);
        style.setBorderTop(HSSFCellStyle.BORDER_THIN);
        style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
        // 生成一个字体
        HSSFFont font = workbook.createFont();
        font.setColor(HSSFColor.BLACK.index);
        font.setFontHeightInPoints((short) 12);
        font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
        // 把字体应用到当前的样式
        style.setFont(font);
        // 指定当单元格内容显示不下时自动换行
        style.setWrapText(true);
        // 产生表格标题行
        HSSFRow row = sheet.createRow(0);
        for (int i = 0; i < headers.length; i++) {
            HSSFCell cell = row.createCell((short) i);
            cell.setCellStyle(style);
            HSSFRichTextString text = new HSSFRichTextString(headers[i]);
            cell.setCellValue(text.toString());
        }
        // 遍历集合数据，产生数据行
        if (result != null) {
            int index = 1;
            for (List<String> m : result) {
                row = sheet.createRow(index);
                int cellIndex = 0;
                for (String str : m) {
                    HSSFCell cell = row.createCell((short) cellIndex);
                    if (str==null){
                        str="";
                    }
                    cell.setCellValue(str.toString());
                    cellIndex++;
                }
                index++;
            }
        }
    }
}

7、Entity类

public class Entity{
    private String sheetName;
    private List<SubEntity> subEntitys;
}
public class ExportAuditContent {
    private String param1;
    private String param2;
    private String param3;
}

8、03版测试

String PATH = "D:\\idea.webProject\\26";
@Test
public void testWrite03() throws Exception {
    // 1、创建一个工作簿
    Workbook workbook = new HSSFWorkbook();
    // 2、创建一个工作表
    Sheet sheet = workbook.createSheet("统计表");
    // 3、创建一个行  （1,1）
    Row row1 = sheet.createRow(0);
    // 4、创建一个单元格
    Cell cell11 = row1.createCell(0);
    cell11.setCellValue("今日新增");
    // (1,2)
    Cell cell12 = row1.createCell(1);
    cell12.setCellValue(666);
    // 第二行 (2,1)
    Row row2 = sheet.createRow(1);
    Cell cell21 = row2.createCell(0);
    cell21.setCellValue("统计时间");
    // (2,2)
    Cell cell22 = row2.createCell(1);
    String time = new DateTime().toString("yyyy-MM-dd HH:mm:ss");
    cell22.setCellValue(time);
    // 生成一张表（IO 流）  03 版本就是使用 xls结尾！
    FileOutputStream fileOutputStream = new FileOutputStream(PATH + "zh03.xls");
    // 输出
    workbook.write(fileOutputStream);
    // 关闭流
    fileOutputStream.close();
    System.out.println("zh03 生成完毕！");
}



9、07版测试

@org.junit.Test
    public void testWrite07() throws IOException {
        //1、创建一个工作簿
         Workbook workbook = new XSSFWorkbook();
         //2、创建一个工作表
        Sheet sheet = workbook.createSheet("统计表");
        //3、创建一个行（1,1）
        Row row1=sheet.createRow(0);
        //4、创建一个单元格
        Cell cell11 = row1.createCell(0);
        cell11.setCellValue("今日新增");

        Cell cell12 = row1.createCell(1);
        cell12.setCellValue("今日无增");

        //创建一个行（2,1）
        Row row2 = sheet.createRow(1);
        //创建一个单元格
        Cell cell21 = row2.createCell(0);
        cell21.setCellValue("统计时间");

        Cell cell22 = row2.createCell(1);
        String time = new DateTime().toString("yyyy-mm-dd HH:mm:ss");
        cell22.setCellValue(time);

        //生成一张表 io流  注意这里是07版本
        FileOutputStream fileOutputStream = new FileOutputStream(path+"java07.xlsx");
        workbook.write(fileOutputStream);
        //关闭流
        fileOutputStream.close();
        System.out.println("07版本文件生成完毕");
    }



测试成功！

10、总结：

在ApachePoi 官方提供了对操作大数据量的导入导出的工具和解决办法，操作Excel2007使用XSSF对象，可以分为三种模式：

用户模式：用户模式有许多封装好的方法操作简单，但创建太多的对象，非常耗内存（之前使用的方法）
	事件模式：基于SAX方式解析XML，SAX全称Simple API for XML，它是一个接口，也是一个软件包。它是一种XML解析的替代方法，不同于DOM解析XML文档时把所有内容一次性加载到内存中的方式，它逐行扫描文档，一边扫描，一边解析。
	SXSSF对象：是用来生成海量excel数据文件，主要原理是借助临时存储空间生成excel

收起

展开全文

JAVA使用POI写入excel 工具类【通用】
2020-07-17 09:58:19
使用写入excel工具类的例子说明:改工具类是网上公开的，来源现在找不着了，我只是在原基础上修改了下，抽离了泛型。如有侵权，请通知博主工具类代码: ... import java.io.FileInputStream;...import java
收起
excel
java使用POI操作Word文档，写入文字与图片
千次阅读 2018-08-10 10:49:33
第一步，继承XWPFDocument，写一个操作图片写入大小、位置的方法，如果没有此方法，图片写入不会报错，但是打开Word文档，会看不到图片： package word; import java.io.IOException; import java.io....
收起
java通过poi-tl使用word模版生成word文件
千次阅读 热门讨论 2017-11-13 14:36:10
问题解决：1、使用apache poi 来生成word文件 2、使用Poi-tl生成本章主要讲如何使用poi-tl通过模版文件生成word文件。关于poi-tl poi-tl：poi template language 一个基于poi的word模板生成文档的开源...
收起
word文档生成
【Java】POI读取Excel的两种模式
2020-05-19 10:58:15
POI下usermodel相关包，它对用户友好，在ss包下有统一的接口，但它是把整个文件读取到内存中的，对于大量数据很容易导致内存溢出，所以只能用来处理相对较小量的数据示例代码 public static List<Map<String,...
收起
excel 用户模式
JAVA使用poi读取excel的工具类【通用】
2020-07-17 09:41:37
使用读取excel工具类的例子说明：这块代码是网上别人公开的，...import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.text.DecimalFormat; i
收起
excel
java使用poi工具读取word文档并将数据存储到数据库中
千次阅读 2021-01-03 15:33:21
只好发挥我一年多面向百度编程的经验一顿查，踩了好多坑最后确定了还是使用Apache poi工具，咱程序员呐，可以当时写不出来但是一定得会面向百度编程????????。从网上找了一些POI工具介绍 Apache poi的hwpf模块是...
收起
Java poi 导出excel
2020-09-04 11:11:09
POI依赖： <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId> <version>3.9</version> </dependency> <dependency>
收起
excel
java poi生成word
千次阅读 2019-11-16 12:06:42
package ... import java.awt.image.BufferedImage; import java.io.ByteArrayInputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import...
收起
Java POI(一)
2020-07-26 21:07:49
Java POI-3.17 单元格相关文本格式通常，Excel的单元格格式能够根据输入的值进行智能转换（其实没那么智能），所以更多的是在智能转换不满足需求时，需要手动规范单元格格式，即自定义格式。 CellStyle通过...
收起
【JAVA_POI】解析word文档二（doc）4.1.2版本
2020-08-19 14:35:03
二、java对word文件的解析 2.1 引入所需要的jar包 org.apache.poi poi-scratchpad 4.1.2 org.apache.poi poi-ooxml 4.1.2 2.2常用方法 HWPFDocument（文档类）： xd.characterLength(); //返回文档的字符长度。 xd....
收起
Java 使用 POI 3.17根据Word 模板替换、操作书签
万次阅读 热门讨论 2018-04-09 12:04:58
查找了大量的文档发现很多的博客对这个进行了介绍，主要有2种方案做处理，jacob 和poi。但是现在的服务器基本上是部署在Linux上，所以jacob基本上是不可行的。所以呢，主要是使用poi来进行这些操作。 Apache poi的...
收起
Java通过Poi的开发Excel导入导出和下载功能
千次阅读 2018-12-13 13:29:17
-- POI-EXCEL --> < dependency > < groupId >org.apache.poi groupId > < artifactId >poi artifactId > < version >3.9 version > dependency > 有两种方式 ...
收起
最新实用版——JAVA使用POI替换Word模板中指定字符，并可插入图片。
千次阅读 热门讨论 2020-11-12 10:19:40
JAVA替换Word模板指定字符，并可插入图片。之前有写过一篇使用jacob对word插入图片的博客。点击率蛮高8800多次，当然多亏了百度搜索引擎的帮忙???? 但是小编在使用以前写的代码走了一遍流程时，发现代码貌似会报错...
收起
word springboot
01.Java-POI-Excel报表导出-以文件流的形式返回页面供下载
千次阅读 2019-04-12 15:04:43
import java.lang.annotation.ElementType; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import jav...
收起
Excel 自定义注解报表导出文件流导出
JAVA POI 对excel进行导入导出
2020-11-28 13:05:58
excel文件导入导出，poi是比较常用的框架，最近经常用到...maven继承  <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId>
收起
excel
java poi 操作word遇到的问题
2021-07-21 18:52:02
java poi 操作word文本，图表，遇到的问题直接上问题模板字段匹配问题图表问题之前做过一期 poi操作world 的文章. 然后前一段因为工作要求改版，改了很多很多版，模板也花里胡哨了，今天就把我出文章之后又遇到的...
收起
ide
java poi设置单元格样式
千次阅读 2018-03-21 09:54:44
// 可以继承于某一个样式，样式重复的，后面的样式会覆盖前面的样式 style .cloneStyleFrom (styles .get ( "base" )) ; style .setAlignment (HorizontalAlignment .LEFT ) ; style .setVerticalAlignment ...
收起
excel
【项目实战】Java POI之Word导出经典案例一
万次阅读 热门讨论 2016-12-09 14:50:20
最近项目中需要用到数据的导出到Word，本在项目中使用POI将数据导入到Word，和Excel导出类似，先将jar包导入进去（我这里就省去导jar包啦），我直接上实现过程吧！ 1、导入POI jar包； 2、创建新的Word模板，如下图...
收起
java poi实现excel表格导入导出
2017-10-16 16:16:08
java poi工具提供了对excel表格的操作功能。但如果想要通过一个导出模板实现导出多种excel表格，就可以通过反射获取模板excel的字段，读取ORM模型时将其属性注入到该字段中。下面是代码实现，注释写的也比较全面...
收起
excel
Java POI Excel操作，List实体类的一些操作
2018-12-03 15:27:11
头一次使用List的实体类做...关键词：POI、两（多）列比对，不同数据类型 import java.io.BufferedInputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; ...
收起
实体类
java poi根据模板生成docx
2020-01-15 18:22:29
一、实现功能 1、支持表格、图像、插入页脚，其中图像包含base64 位和只传入图像路径 2、要求使用对应的模板故只能作为参考 3、里面的以下判断时根据模板文件里面的key进行的特殊处理 ...import java....
收起
docx
JAVA操作excel-POI及EasyExcel
2021-05-12 14:18:59
POI及EasyExcel POI官网 EasyExcel官网 EasyExcel使用说明 POI 操作excel的组件列表： HSSF : 它被用来读取和写入MS-Excel文件的xls格式。—03版本excel XSSF : 它是用于MS-Excel中xlsx文件格式。—07...
收起
excel
java POI读取excel,并导入数据库
2020-12-24 14:23:07
方案：用POI工具，抽取导入公共类（ExcelReadUtil），不同的数据库导入，都继承这个公共类中的抽象类excelReadTemplate，实现抽象类中的packageObject（封装实体类）与insertObject（批量插入）方法。具体实现： ...
收起

java使用POI导出excel表格

Java使用POI导入excel教程

文章目录

前言

1、工作准备

2、小试牛刀

3、小结

写在最后

java使用POI读写Excel(踩坑总结)

Java用poi导入导出Excel

前言

2、Excel导入

10、总结：

JAVA使用POI写入excel 工具类【通用】

java使用POI操作Word文档，写入文字与图片

java通过poi-tl使用word模版生成word文件

【Java】POI读取Excel的两种模式

JAVA使用poi读取excel的工具类【通用】

java使用poi工具读取word文档并将数据存储到数据库中

Java poi 导出excel

java poi生成word

Java POI(一)

【JAVA_POI】解析word文档二（doc）4.1.2版本

Java 使用 POI 3.17根据Word 模板替换、操作书签

Java通过Poi的开发Excel导入导出和下载功能

最新实用版——JAVA使用POI替换Word模板中指定字符，并可插入图片。

01.Java-POI-Excel报表导出-以文件流的形式返回页面供下载

JAVA POI 对excel进行导入导出

java poi 操作word遇到的问题

java poi设置单元格样式

【项目实战】Java POI之Word导出经典案例一

java poi实现excel表格导入导出

Java POI Excel操作，List实体类的一些操作

java poi根据模板生成docx

JAVA操作excel-POI及EasyExcel

java POI读取excel,并导入数据库

java继承poi