精华内容
下载资源
问答
  • 首先导入poi工具所需的依赖包 <!--POI操作excel--> <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>
    
    
    • 六.界面如下。
      在这里插入图片描述
    展开全文
  • 前言 实习期间遇到一个业务需求,要求具有excel导入和导出功能。由于公司框架的数据表格自带了excel导出功能(N年前的老框架,文档不全BUG贼多),所以只需怼excel导入即可,流程是这样的:选择excel →文件...Java

    前言

    实习期间遇到一个业务需求,要求具有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就介绍到这里啦,我是严光君,咱们下文再见~

    在这里插入图片描述
    创造不易,少侠请留步…… 动起可爱的双手,点个赞再走呗~ ٩(๑>◡<๑)۶

    展开全文
  • 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/

    ](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9wb2kuYXBhY2hlLm9yZy8?x-oss-process=image/format,png)
    在这里插入图片描述
    导入项目所依赖的jar包(注:这几个一个都不能少,不然会报些奇怪的错)
    导入项目所依赖的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/
    都看到这了给博主点个赞呗😁

    展开全文
  • Javapoi导入导出Excel

    2021-05-11 18:24:35
    前言 1、将用户信息导出为excel表格...操作Excel目前比较流行的就是Apache POI和 阿里巴巴的easyExcel! 接下来说说Apache下的POI吧 <dependencies> <!--xls(03)--> <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
    展开全文
  • 使用写入excel工具类的例子 说明:改工具类是网上公开的,来源现在找不着了,我只是在原基础上修改了下,抽离了泛型。如有侵权,请通知博主 工具类代码: ... import java.io.FileInputStream;...import java
  • 第一步,继承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模板生成文档的开源...
  • POI下usermodel相关包,它对用户友好,在ss包下有统一的接口,但它是把整个文件读取到内存中的,对于大量数据很容易导致内存溢出,所以只能用来处理相对较小量的数据 示例代码 public static List<Map<String,...
  • 使用读取excel工具类的例子 说明:这块代码是网上别人公开的,...import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.text.DecimalFormat; i
  • 只好发挥我一年多面向百度编程的经验一顿查,踩了好多坑最后确定了还是使用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>
  • 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对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的...
  • -- POI-EXCEL --> < dependency >   < groupId >org.apache.poi groupId >   < artifactId >poi artifactId >   < version >3.9 version > dependency > 有两种方式 ...
  • JAVA替换Word模板指定字符,并可插入图片。 之前有写过一篇使用jacob对word插入图片的博客。点击率蛮高8800多次,当然多亏了百度搜索引擎的帮忙???? 但是小编在使用以前写的代码走了一遍流程时,发现代码貌似会报错...
  • import java.lang.annotation.ElementType; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import jav...
  • excel文件导入导出,poi是比较常用的框架,最近经常用到...maven继承 <!--Excel begin --> <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId>
  • java poi 操作word文本,图表,遇到的问题直接上问题模板字段匹配问题图表问题 之前做过 一期 poi操作world 的文章. 然后前一段因为工作要求改版,改了很多很多版,模板也花里胡哨了,今天就把我出文章之后又遇到的...
  • java poi设置单元格样式

    千次阅读 2018-03-21 09:54:44
    // 可以继承于某一个样式,样式重复的,后面的样式会覆盖前面的样式 style .cloneStyleFrom (styles .get ( "base" )) ; style .setAlignment (HorizontalAlignment .LEFT ) ; style .setVerticalAlignment ...
  • 【项目实战】Java POI之Word导出经典案例一

    万次阅读 热门讨论 2016-12-09 14:50:20
    最近项目中需要用到数据的导出到Word,本在项目中使用POI将数据导入到Word,和Excel导出类似,先将jar包导入进去(我这里就省去导jar包啦),我直接上实现过程吧! 1、导入POI jar包; 2、创建新的Word模板,如下图...
  • java poi工具提供了对excel表格的操作功能。 但如果想要通过一个导出模板实现导出多种excel表格,就可以通过反射获取模板excel的字段,读取ORM模型时将其属性注入到该字段中。 下面是代码实现,注释写的也比较全面...
  • 头一次使用List的实体类做...关键词:POI、两(多)列比对,不同数据类型 import java.io.BufferedInputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; ...
  • 一、实现功能 1、支持表格、图像、插入页脚,其中图像包含base64 位和 只传入图像路径 2、要求使用对应的模板 故只能作为参考 3、里面的以下判断时根据 模板文件里面的key进行的特殊处理 ...import java....
  • POI及EasyExcel POI官网 EasyExcel官网 EasyExcel使用说明 POI 操作excel的组件列表: ​ HSSF : 它被用来读取和写入MS-Excel文件的xls格式。—03版本excel ​ XSSF : 它是用于MS-Excel中xlsx文件格式。—07...
  • 方案:用POI工具,抽取导入公共类(ExcelReadUtil),不同的数据库导入,都继承这个公共类中的抽象类excelReadTemplate,实现抽象类中的packageObject(封装实体类)与insertObject(批量插入)方法。 具体实现: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,200
精华内容 2,080
关键字:

java继承poi

java 订阅