【CSDN】java使用POI&EasyExcel操作文件学习笔记

1.Apache poi

参考CSDN url:CSDN POI文档

参考B站视频:B站 POI视频

官网: https://poi.apache.org/

POI介绍

POI介绍
Apache POI是用Java编写的免费开源的跨平台的Java API，Apache POI提供API给Java程序对Microsoft Office格式档案读和写的功能，其中使用最多的就是使用POI操作Excel文件。

Java 解析、生成Excel比较有名的框架有POI、JXL,但是他们都存在一个严重的问题,就是非常损耗内存,也就是数据量比较大的时候有可能出现OOM的问题,但是POI有一套SAX模式的API可以一定程度的解决一些内存溢出的问题,但是依旧没有完全的解决内存消耗过大的问题.

Excel表格不同版本的区别

• Excel 03版本最多支持行数65536，并且后缀为xls

• 

• Excel 07+版本理论上没有限制，但实际支持行数：1048576，并且后缀xlsx
  
  

• 引入依赖:

<dependency>
           <!-- 03 版本-->
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.14</version>
        </dependency>
        <!-- 07 版本-->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.14</version>
        </dependency>

• 文件分类

HSSF － 提供读写Microsoft Excel XLS格式(Microsoft Excel 97(-2003)档案的功能
XSSF － 提供读写Microsoft Excel OOXML XLSX格式(Microsoft Excel XML(2007+)档案的功能（我们使用）
SXSSF - 提供低内存占用量读写 Microsoft Excel OOXML XLSX 格式档案的功能
HWPF － 提供读写Microsoft Word DOC97 格式(Microsoft Word 97 (-2003))档案的功能
XWPF - 提供读写 Microsoft Word DOC2003 格式 (WordprocessingML (2007+)) 档案的功能
HSLF/XSLF － 提供读写Microsoft PowerPoint格式档案的功能
HDGF/XDGF － 提供读Microsoft Visio格式档案的功能
HPBF － 提供读Microsoft Publisher格式档案的功能
HSMF － 提供读Microsoft Outlook格式档案的功能

1.1.java读excel的步骤

1：创建工作簿对象 Workbook
2：获得工作表对象 sheet
3：遍历工作表对象 获得行对象 Row
4：遍历行对象 获得单元格（列）对象 Cell
5：获得数据
6：关闭

1.1.1 java使用HSSFWorkbook实现对excel读(03版本)

//读取excel
    @Test
    public void readExcel03() throws IOException {
        String fileUrl = basePath + "03版本测试.xls";
        FileInputStream fileInputStream = new FileInputStream(fileUrl);
        //创建工作簿
        Workbook workbook = new HSSFWorkbook(fileInputStream);
        //获取工作表,既可以根据工作表的顺序获取，也可以根据工作表的名称获取
        Sheet sheetAt = workbook.getSheetAt(0);//顺序获取
        //Sheet sheetAt = workbook.getSheet("school");//名称获取
        //获取行
        Row row = sheetAt.getRow(0);
        //获取
        Cell cell = row.getCell(0);
        //读取数据
        String value = cell.getStringCellValue();
        System.out.println(value);
        //关闭流
        fileInputStream.close();
        workbook.close();
    }

1.1.2 java使用HSSFWorkbook实现对excel读(07版本)

  //读取excel
    @Test
    public void readExcel07() throws IOException {
        String fileUrl = basePath + "07版本测试.xlsx";
        FileInputStream fileInputStream = new FileInputStream(fileUrl);
        //创建工作簿
        Workbook workbook = new XSSFWorkbook(fileInputStream);
        //获取工作表,既可以根据工作表的顺序获取，也可以根据工作表的名称获取
        Sheet sheetAt = workbook.getSheetAt(0);//顺序获取
        //Sheet sheetAt = workbook.getSheet("school");//名称获取
        //获取行
        Row row = sheetAt.getRow(0);
        //获取
        Cell cell = row.getCell(0);
        //读取数据
        String value = cell.getStringCellValue();
        System.out.println(value);
        //关闭流
        fileInputStream.close();
        workbook.close();
    }

1.1.3批量数据读取

1.1.3.1 03版本批量读取

//批量读取excel03
    public void readBatchExcelCellType() throws IOException {
        String fileUrl = basePath + "商品表.xls";
        FileInputStream fileInputStream = new FileInputStream(fileUrl);
        //创建工作簿
        Workbook workbook = new HSSFWorkbook(fileInputStream);
        //获取工作表,既可以根据工作表的顺序获取，也可以根据工作表的名称获取
        Sheet sheetAt = workbook.getSheetAt(0);//顺序获取
        //Sheet sheetAt = workbook.getSheet("school");//名称获取
        //获取行
        Row title = sheetAt.getRow(0);
        //非空判断
        if (title != null) {
            //获取标题的单元格数量,用于遍历获取所有单元格
            int cellNum = title.getPhysicalNumberOfCells();
            for (int i = 0; i < cellNum; i++) {
                Cell cell = title.getCell(i);
                if (cell != null) {
                    String value = cell.getStringCellValue();
                    System.out.println(value);
                }
            }
        }
        //获取标题以下的具体内容
        int rowNum = sheetAt.getPhysicalNumberOfRows();
        for (int i = 1; i < rowNum; i++) {
            //获取每一行里面有多少单元格
            Row row = sheetAt.getRow(i);
            if (row != null) {
                int cellNum = row.getPhysicalNumberOfCells();
                //遍历每一行多少个单元格
                for (int j = 0; j < cellNum; j++) {
                    Cell cell = row.getCell(j);
                    if (cell != null) {
//                        String value = cell.getStringCellValue();
//                        System.out.println(value);
                        int cellType = cell.getCellType();
                        /**
                         * Numeric (0) 数值型(整数,小数,日期)
                         * String  (1) 字符串
                         * Formula (2) 公式
                         * Blank   (3) 空字符串(没有值),但是有单元格格式
                         * Boolean (4) 布尔值
                         * Error   (5) 错误单元格
                         */
                        switch (cellType) {
                            case Cell.CELL_TYPE_STRING:
                                String value = cell.getStringCellValue();
                                System.out.println(value);
                                break;
                            case Cell.CELL_TYPE_NUMERIC:
                                //判断啊是否为日期类型
                                if (DateUtil.isCellDateFormatted(cell)) {
                                    Date dateCellValue = cell.getDateCellValue();
                                    String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(dateCellValue);
                                    System.out.println(format);
                                } else {
                                    double numericCellValue = cell.getNumericCellValue();
                                    System.out.println(numericCellValue);
                                }
                                break;
                            case Cell.CELL_TYPE_FORMULA:
                                break;
                            case Cell.CELL_TYPE_BOOLEAN:
                                break;
                            case Cell.CELL_TYPE_ERROR:
                                break;
                            default:
                                break;
                        }


                    }
                }
            }
        }

1.1.3.2 07版本批量读取 (未写)

1.1.4 读取工具类封装

如果数据类型为：数值型，CELL_TYPE_NUMERIC，那么通过cell.getNumericCellValue()获得的是1.0，2.0等带1位小数的值，如果想变为整数，有2种方式：

//把数字当成String来读，避免出现1读成1.0的情况 方法1
cell.setCellType(Cell.CELL_TYPE_STRING);
System.out.println(cell.getStringCellValue());
//直接通过格式化，避免出现1读成1.0的情况 方法2
System.out.println(nf.format(cell.getNumericCellValue()));

@Data
public class Product {
    private String name;
    public Integer id;
    public Integer price;
    private Integer count;
    private Date createTime;
}




/**
 * @program: project_maven
 * @description: 解析Excel表格工具类
 * @author: cyj
 * @create: 2023-10-19 22:25
 */
public class ExcelUtils {

    public static void main(String[] args) throws Exception {
        String fileUrl = Demo1.basePath + "商品表2.xls";
        FileInputStream fileInputStream = new FileInputStream(fileUrl);
        Workbook workbook = new HSSFWorkbook(fileInputStream);
        Class<Product> aClass = Product.class;
        List<Product> objects = readExcel(workbook, aClass);
        fileInputStream.close();
        workbook.close();
        System.out.println(objects);
    }

    /**
     * 目的:用户只需要传入Workbook对象(匹配版本),文件输入流,对应实体类Class
     * 就可以得到解析表格以后的结果,同时通过传入的试题类型集合的方式来返回
     */
    public static <T> List<T> readExcel(Workbook workbook, Class<T> tClass) throws Exception {
        //给用户返回的实体类集合
        List<T> result = new ArrayList<>();
        //在工作簿中获取目标工作表
        Sheet sheet = workbook.getSheetAt(0);
        //获取工作表中的行数
        int rowNums = sheet.getPhysicalNumberOfRows();

        //获取第一行数据(隐藏行)
        Row row = sheet.getRow(1);
        //遍历第一行数据,遍历出的数据就是当前实体类对应的所有属性,同时要把这些数据放入到Map中的key
        ArrayList<String> key = new ArrayList<>();
        //具体遍历:标题
        for (Cell cell : row) {
            String value = cell.getStringCellValue();
            key.add(value);
            System.out.println(value);
        }

        //具体遍历：正式数据
        for (int i = 2; i < rowNums; i++) {
            Row row2 = sheet.getRow(i);
            if (row2 != null) {
                int j = 0;
                HashMap<String, String> excelMap = new HashMap<>();
                for (Cell cell : row2) {
                    if (cell != null) {
                        String cellString = getCellString(cell);
                        System.out.println(cellString);
                        if (StringUtils.isNotBlank(cellString)) {
                            excelMap.put(key.get(j++), cellString);//id:1, name:鼠标，price:20...
                        }
                    }

                }
                //创建对应实体类类型,并且把读取到的数据转化为实体类对象
                T t = mapToEntity(excelMap, tClass);
                result.add(t);
            }

        }

        return result;
    }

    private static String getCellString(Cell cell) {
        String value = null;
        int cellType = cell.getCellType();
        /**
         * Numeric (0) 数值型(整数,小数,日期)
         * String  (1) 字符串
         * Formula (2) 公式
         * Blank   (3) 空字符串(没有值),但是有单元格格式
         * Boolean (4) 布尔值
         * Error   (5) 错误单元格
         */
        switch (cellType) {
            case Cell.CELL_TYPE_STRING:
                value = cell.getStringCellValue();
                break;
            case Cell.CELL_TYPE_NUMERIC:
                //判断啊是否为日期类型
                if (DateUtil.isCellDateFormatted(cell)) {
                    Date dateCellValue = cell.getDateCellValue();
                    value = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(dateCellValue);
                } else {
                    value = nf.format(cell.getNumericCellValue());
                }
                break;
            case Cell.CELL_TYPE_FORMULA:
                value = String.valueOf(cell.getCellFormula());
                break;
            case Cell.CELL_TYPE_BOOLEAN:
                value = String.valueOf(cell.getBooleanCellValue());
                break;
            case Cell.CELL_TYPE_ERROR:
                value = "非法字符";
                break;
            default:
                value = "未知类型";
                break;
        }
        return value;
    }


    public static <T> T mapToEntity(Map<String, String> map, Class<T> entity) {
        T t = null;
        try {
            //[反射isAccessible相关内容] https://blog.csdn.net/weixin_33840661/article/details/91962579
            t = entity.newInstance();
            for (Field field : entity.getDeclaredFields()) {
                if (map.containsKey(field.getName())) {
                    boolean accessible = field.isAccessible();
                    field.setAccessible(true);
                    //获取Map中的属性对应的值
                    String str = map.get(field.getName());
                    //获取实体类属性的类型
                    String type = field.getGenericType().toString();
                    //重新指定对应属性的值
                    if (str != null) {
                        if (type.equals("class java.lang.String")) {
                            field.set(t, str);
                        } else if (type.equals("class java.lang.Double")) {
                            field.set(t, Double.parseDouble(String.valueOf(str)));
                        } else if (type.equals("class java.lang.Integer")) {
                            field.set(t, Integer.parseInt(String.valueOf(str)));
                        } else if (type.equals("class java.util.Date")) {
                            Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(str);
                            field.set(t, date);
                        }
                    }
                    field.setAccessible(accessible);
                }
            }
        } catch (Exception e) {
            System.out.println("map to entity错误," + e.getMessage());
            e.printStackTrace();
        }
        return t;
    }


    public static NumberFormat nf = NumberFormat.getNumberInstance();

    static {
        nf.setGroupingUsed(false);//防止excel数值类型有小数点
    }
}

1.1.5 读取公式

//读取excel07公式
    @Test
    public void readFormula() throws IOException {
        String fileUrl = basePath + "读取公式.xlsx";
        FileInputStream fileInputStream = new FileInputStream(fileUrl);
        //创建工作簿
        Workbook workbook = new XSSFWorkbook(fileInputStream);
        //获取工作表,既可以根据工作表的顺序获取，也可以根据工作表的名称获取
        Sheet sheetAt = workbook.getSheetAt(0);//顺序获取
        //Sheet sheetAt = workbook.getSheet("school");//名称获取
        //获取行
        Row row = sheetAt.getRow(2);
        //获取
        Cell cell = row.getCell(0);
        System.out.println(cell.getNumericCellValue());

        //读取公式
        String cellFormula = cell.getCellFormula();
        System.out.println(cellFormula);
        //获取计算结果
        XSSFFormulaEvaluator xssfFormulaEvaluator = new XSSFFormulaEvaluator(((XSSFWorkbook) workbook));
        CellValue evaluate = xssfFormulaEvaluator.evaluate(cell);
        String val = evaluate.formatAsString();
        System.out.println(nf.format(Double.parseDouble(val)));

        //关闭流
        fileInputStream.close();
        workbook.close();
    }

1.2 java写excel的步骤

• 创建工作簿: Workbook
• 创建工作表:sheet
• 创建行: Row
• 创建列(单元格): Cell
• 具体数据写入

1.2.1java使用HSSFWorkbook实现对excel写(03版本)

 //03版本写入
  //03版本写入
    @Test
    public void writeExcel03() throws IOException {
        //1.创建工作簿
        Workbook workbook = new HSSFWorkbook();
        //2.创建工作表
        Sheet sheet = workbook.createSheet("03版本测试");
        //3.创建行(第一行)
        Row row1 = sheet.createRow(0);
        //4.创建单元格,写入数据(1,1)
        Cell cell11 = row1.createCell(0);
        cell11.setCellValue("商品ID");
        //5.创建单元格,写入数据(1.2)
        Cell cell12 = row1.createCell(1);
        cell12.setCellValue("商品名称");
        //6.创建行(第二行)
        Row row2 = sheet.createRow(1);
        //7.创建单元格,写入数据(2.1)
        Cell cell21 = row2.createCell(0);
        cell21.setCellValue(1);
        //8.创建单元格,写入数据(2.2)
        Cell cell22 = row2.createCell(1);
        cell22.setCellValue("鼠标");
        //生成一张表-IO流
        FileOutputStream outputStream = new FileOutputStream(basePath+"03版本测试.xls");
        workbook.write(outputStream);
        //关闭输出流
        outputStream.close();
    }

1.2.2.java使用XSSFWorkbook实现对excel写(07版本)

//07版本写入
    @Test
    public void writeExcel07() throws IOException {
        //1.创建工作簿
        Workbook workbook = new XSSFWorkbook();
        //2.创建工作表
        Sheet sheet = workbook.createSheet("07版本测试");
        //3.创建行(第一行)
        Row row1 = sheet.createRow(0);
        //4.创建单元格,写入数据(1,1)
        Cell cell11 = row1.createCell(0);
        cell11.setCellValue("商品ID");
        //5.创建单元格,写入数据(1.2)
        Cell cell12 = row1.createCell(1);
        cell12.setCellValue("商品名称");
        //6.创建行(第二行)
        Row row2 = sheet.createRow(1);
        //7.创建单元格,写入数据(2.1)
        Cell cell21 = row2.createCell(0);
        cell21.setCellValue(1);
        //8.创建单元格,写入数据(2.2)
        Cell cell22 = row2.createCell(1);
        cell22.setCellValue("鼠标");
        //生成一张表-IO流
        FileOutputStream outputStream = new FileOutputStream(basePath+"07版本测试.xlsx");
        workbook.write(outputStream);
        //关闭输出流
        outputStream.close();
    }

1.2.3 批量数据写入

不管是03版本还是07版本，那么我们在实际开发中都会碰到批量写入数据的操作，尤其数据量比较多的时候，那么03和07版本处理的方式是不同的。

• 03版本HSSF
  • 最多支持65536行数据，超出会抛出异常
  • 操作方式为:先将所有的数据放到缓存中，最后一次性写入磁盘，写入速度快
• 07版本XSSF
  • 数据的写入速度会比较慢,因为:①XSSFWorkbook使用的是OpenXML格式，而HSSFWorkbook使用的是OLE2格式。OpenXML格式是基于XML的文件格式，而OLE2是二进制文件格式。在写入数据时，XSSFWorkbook需要将数据转换为XML格式，然后再写入文件。相比之下，HSSFWorkbook直接将数据以二进制形式写入文件，更加高效。②XSSFWorkbook生成的文件通常会比HSSFWorkbook生成的文件要大。由于文件体积更大，写入操作需要更多的时间。(当内存饱和时，XSSFWorkbook 不会自动将一部分数据写入文件中。如果内存不足以容纳所有数据，可能会导致 OutOfMemoryError 异常。)
  • 可以写入较大的数据,比如10W+条数据.
    无论是使用 XSSFWorkbook 还是 HSSFWorkbook，在进行批量写出时，都会将所有数据临时存储在内存中。这是因为在写出 Excel 文件之前，需要先将数据写入到内存中的相应数据结构中，然后再将整个数据结构写出到文件中。

1.2.3.1 03版本批量导出

耗时:2949ms
//批量导出03
   public void wirteBatchData03() throws IOException {
       long start = System.currentTimeMillis();
       Workbook workbook = new HSSFWorkbook();
       Sheet sheet = workbook.createSheet("03");
       for (int i = 0; i < 65536; i++) {
           Row row = sheet.createRow(i);
           for (int j = 0; j < 20; j++) {
               Cell cell = row.createCell(j);
               cell.setCellValue(j+1);
           }
       }
       Sheet sheet2 = workbook.createSheet("03-2");
       for (int i = 0; i < 65536; i++) {
           Row row = sheet2.createRow(i);
           for (int j = 0; j < 20; j++) {
               Cell cell = row.createCell(j);
               cell.setCellValue(j+1);
           }
       }
       FileOutputStream outputStream = new FileOutputStream(basePath+"03版本批量导出测试.xls");
       workbook.write(outputStream);
       outputStream.close();
       long end = System.currentTimeMillis();
       System.out.println(end-start);//2949
   }

1.2.3.2 07版本批量导出

 耗时:21226ms
@Test
  //批量导出07
  public void wirteBatchData07() throws IOException {
      long start = System.currentTimeMillis();
      Workbook workbook = new XSSFWorkbook();
      Sheet sheet = workbook.createSheet("07");
      for (int i = 0; i < 65536; i++) {
          Row row = sheet.createRow(i);
          for (int j = 0; j < 20; j++) {
              Cell cell = row.createCell(j);
              cell.setCellValue(j+1);
          }
      }
      Sheet sheet2 = workbook.createSheet("07-2");
      for (int i = 0; i < 65536; i++) {
          Row row = sheet2.createRow(i);
          for (int j = 0; j < 20; j++) {
              Cell cell = row.createCell(j);
              cell.setCellValue(j+1);
          }
      }
      FileOutputStream outputStream = new FileOutputStream(basePath+"07版本批量导出测试.xlsx");
      workbook.write(outputStream);
      outputStream.close();
      long end = System.currentTimeMillis();
      System.out.println(end-start);//21226
  }

1.2.4 大数据写SXSSF (07升级版)

• 为了解决大数据量写入的问题，所以官方提供了SXSSF来解决大文件写入问题，所以它可以写入非常大量的数据，比如上百万条数据，并且写入速度更快，占用内存更少。
• 官方文档翻译:SXSSF在兼容XSSF的同时，能够应对大数据量和内存空间有限的情况。SXSSF每次获取的行数是在一个数值范围内，这个范围被称为"滑动窗口"，在这个窗口内的数据均存在于内存中，超出这个窗口大小时，数据会被写入磁盘，由此控制内存使用，相比较而言，XSSF则每次都是获取全部行。
• 窗口默认大小为100(可以自定义)，如果数据为101行，那么此时超出了窗口限制，索引值最小的行会被”刷入"磁盘，需要注意，SXSSF会自动分配临时文件，这些临时文件需要我们手动清除，清除的方式是使用dispose()方法中。
• 自定义的方式:SXSSFWorkbook wb = new SXSSFWorkbook(自定义窗口大小)

耗时:3267ms
@Test
    //批量导出07
    public void wirteBigBatchData07() throws IOException {
        long start = System.currentTimeMillis();
        Workbook workbook = new SXSSFWorkbook(200);
        Sheet sheet = workbook.createSheet("07");
        for (int i = 0; i < 65536; i++) {
            Row row = sheet.createRow(i);
            for (int j = 0; j < 20; j++) {
                Cell cell = row.createCell(j);
                cell.setCellValue(j+1);
            }
        }
        Sheet sheet2 = workbook.createSheet("07-2");
        for (int i = 0; i < 65536; i++) {
            Row row = sheet2.createRow(i);
            for (int j = 0; j < 20; j++) {
                Cell cell = row.createCell(j);
                cell.setCellValue(j+1);
            }
        }
        FileOutputStream outputStream = new FileOutputStream(basePath+"07版本big批量导出测试.xlsx");
        workbook.write(outputStream);
        outputStream.close();
        long end = System.currentTimeMillis();
        System.out.println(end-start);//3267
    }

1.3. poi工具类

public class POIUtils {
    private final static String xls = "xls";
    private final static String xlsx = "xlsx";
    private final static String DATE_FORMAT = "yyyy/MM/dd";

    /**
     * 读入excel文件，解析后返回
     *
     * @param file
     * @throws IOException
     */
    public static List<String[]> readExcel(MultipartFile file) throws IOException {
        //检查文件
        checkFile(file);
        //获得Workbook工作薄对象
        Workbook workbook = getWorkBook(file);
        //创建返回对象，把每行中的值作为一个数组，所有行作为一个集合返回
        List<String[]> list = new ArrayList<String[]>();
        if (workbook != null) {
            for (int sheetNum = 0; sheetNum < workbook.getNumberOfSheets(); sheetNum++) {
                //获得当前sheet工作表
                Sheet sheet = workbook.getSheetAt(sheetNum);
                if (sheet == null) {
                    continue;
                }
                //获得当前sheet的开始行
                int firstRowNum = sheet.getFirstRowNum();
                //获得当前sheet的结束行
                int lastRowNum = sheet.getLastRowNum();
                //循环除了第一行的所有行
                for (int rowNum = firstRowNum + 1; rowNum <= lastRowNum; rowNum++) {
                    //获得当前行
                    Row row = sheet.getRow(rowNum);
                    if (row == null) {
                        continue;
                    }
                    //获得当前行的开始列
                    int firstCellNum = row.getFirstCellNum();
                    //获得当前行的列数
                    int lastCellNum = row.getPhysicalNumberOfCells();
                    String[] cells = new String[row.getPhysicalNumberOfCells()];
                    //循环当前行
                    for (int cellNum = firstCellNum; cellNum < lastCellNum; cellNum++) {
                        Cell cell = row.getCell(cellNum);
                        cells[cellNum] = getCellValue(cell);
                    }
                    list.add(cells);
                }
            }
            workbook.close();
        }
        return list;
    }

    //校验文件是否合法
    public static void checkFile(MultipartFile file) throws IOException {
        //判断文件是否存在
        if (null == file) {
            throw new FileNotFoundException("文件不存在！");
        }
        //获得文件名
        String fileName = file.getOriginalFilename();
        //判断文件是否是excel文件
        if (!fileName.endsWith(xls) && !fileName.endsWith(xlsx)) {
            throw new IOException(fileName + "不是excel文件");
        }
    }

    public static Workbook getWorkBook(MultipartFile file) {
        //获得文件名
        String fileName = file.getOriginalFilename();
        //创建Workbook工作薄对象，表示整个excel
        Workbook workbook = null;
        try {
            //获取excel文件的io流
            InputStream is = file.getInputStream();
            //根据文件后缀名不同(xls和xlsx)获得不同的Workbook实现类对象
            if (fileName.endsWith(xls)) {
                //2003
                workbook = new HSSFWorkbook(is);
            } else if (fileName.endsWith(xlsx)) {
                //2007
                workbook = new XSSFWorkbook(is);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return workbook;
    }

    public static String getCellValue(Cell cell) {
        String cellValue = "";
        if (cell == null) {
            return cellValue;
        }
        //如果当前单元格内容为日期类型，需要特殊处理
        String dataFormatString = cell.getCellStyle().getDataFormatString();
        if (dataFormatString.equals("m/d/yy")) {
            cellValue = new SimpleDateFormat(DATE_FORMAT).format(cell.getDateCellValue());
            return cellValue;
        }
        //把数字当成String来读，避免出现1读成1.0的情况
        if (cell.getCellType() == Cell.CELL_TYPE_NUMERIC) {
            cell.setCellType(Cell.CELL_TYPE_STRING);
        }
        //判断数据的类型
        switch (cell.getCellType()) {
            case Cell.CELL_TYPE_NUMERIC: //数字
                cellValue = String.valueOf(cell.getNumericCellValue());
                break;
            case Cell.CELL_TYPE_STRING: //字符串
                cellValue = String.valueOf(cell.getStringCellValue());
                break;
            case Cell.CELL_TYPE_BOOLEAN: //Boolean
                cellValue = String.valueOf(cell.getBooleanCellValue());
                break;
            case Cell.CELL_TYPE_FORMULA: //公式
                cellValue = String.valueOf(cell.getCellFormula());
                break;
            case Cell.CELL_TYPE_BLANK: //空值
                cellValue = "";
                break;
            case Cell.CELL_TYPE_ERROR: //故障
                cellValue = "非法字符";
                break;
            default:
                cellValue = "未知类型";
                break;
        }
        return cellValue;
    }
}

2.阿里巴巴EasyExcel

2.1介绍

EasyExcel是一个基于Java的简单、省内存的读写Excel的开源项目。在尽可能节约内存的情况下支持读写百M的Excel
官方网站
git地址
总结：快速、简单避免OOM的Java处理Excel工具
注意：这个工具操作方法官方文档提供的非常详细，甚至连不同的需求如何写的代码都有对应案例。

2.1 具体操作

依赖(和POI版本兼容问题)

		<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>easyexcel</artifactId>
            <version>3.3.2</version>
        </dependency>

2.1.1 写操作

 /**
     * 最简单的写
     * <p>
     * 1. 创建excel对应的实体对象 参照{@link DemoData}
     * <p>
     * 2. 直接写即可
     */
    @Test
    public void simpleWrite() {
        // 注意 simpleWrite在数据量不大的情况下可以使用（5000以内，具体也要看实际情况），数据量大参照 重复多次写入

        // 写法1 JDK8+
        // since: 3.0.0-beta1
        String fileName = DemoData.class.getResource("/").getPath() + "写07测试2.xlsx";
//        String fileName =  "./写07测试2.xlsx";
        // 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
        // 如果这里想使用03 则 传入excelType参数即可
        EasyExcel.write(fileName, DemoData.class)
                .sheet("模板")
                .doWrite(() -> {
                    // 分页查询数据
                    return data();
                });

//        // 写法2
//        fileName = com.sitech.poi.excel.Demo1.basePath + "写07测试.xlsx";
//        // 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
//        // 如果这里想使用03 则 传入excelType参数即可
//        EasyExcel.write(fileName, DemoData.class).sheet("模板").doWrite(data());
//
//        // 写法3
//        fileName = com.sitech.poi.excel.Demo1.basePath + "写07测试.xlsx";
//        // 这里 需要指定写用哪个class去写
//        try (ExcelWriter excelWriter = EasyExcel.write(fileName, DemoData.class).build()) {
//            WriteSheet writeSheet = EasyExcel.writerSheet("模板").build();
//            excelWriter.write(data(), writeSheet);
//        }
    }
    private List<DemoData> data() {
        List<DemoData> list = ListUtils.newArrayList();
        for (int i = 0; i < 10; i++) {
            DemoData data = new DemoData();
            data.setString("字符串" + i);
            data.setDate(new Date());
            data.setDoubleData(0.56);
            list.add(data);
        }
        return list;
    }

2.1.1 读操作

需要导入官方提供的读的监听器

@Data
@Slf4j
public class SimpleRead {
    public static void main(String[] args) {
        log.info("你好啊");
    }
    @Test
    /**
     * 最简单的读
     * <p>
     * 1. 创建excel对应的实体对象 参照{@link DemoData}
     * <p>
     * 2. 由于默认一行行的读取excel，所以需要创建excel一行一行的回调监听器，参照{@link DemoDataListener}
     * <p>
     * 3. 直接读即可
     */
    public void simpleRead() {
        // 写法1：JDK8+ ,不用额外写一个DemoDataListener
        // since: 3.0.0-beta1
        String fileName = DemoDAO.class.getResource("/").getPath() + "写07测试2.xlsx";
        // 这里默认每次会读取100条数据 然后返回过来 直接调用使用数据就行
        // 具体需要返回多少行可以在`PageReadListener`的构造函数设置
        EasyExcel.read(fileName, DemoDataWrite.class, new PageReadListener<DemoDataWrite>(dataList -> {//可以替换自己写的监听器
            for (DemoDataWrite demoData : dataList) {
                log.info("读取到一条数据{}", JSON.toJSONString(demoData));
            }
        })).sheet().doRead();

//        // 写法2：
//        // 匿名内部类 不用额外写一个DemoDataListener
//        fileName = TestFileUtil.getPath() + "demo" + File.separator + "demo.xlsx";
//        // 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
//        EasyExcel.read(fileName, DemoData.class, new ReadListener<DemoData>() {
//            /**
//             * 单次缓存的数据量
//             */
//            public static final int BATCH_COUNT = 100;
//            /**
//             *临时存储
//             */
//            private List<DemoData> cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
//
//            @Override
//            public void invoke(DemoData data, AnalysisContext context) {
//                cachedDataList.add(data);
//                if (cachedDataList.size() >= BATCH_COUNT) {
//                    saveData();
//                    // 存储完成清理 list
//                    cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
//                }
//            }
//
//            @Override
//            public void doAfterAllAnalysed(AnalysisContext context) {
//                saveData();
//            }
//
//            /**
//             * 加上存储数据库
//             */
//            private void saveData() {
//                log.info("{}条数据，开始存储数据库！", cachedDataList.size());
//                log.info("存储数据库成功！");
//            }
//        }).sheet().doRead();
//
//        // 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
//        // 写法3：
//        fileName = TestFileUtil.getPath() + "demo" + File.separator + "demo.xlsx";
//        // 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
//        EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).sheet().doRead();
//
//        // 写法4
//        fileName = TestFileUtil.getPath() + "demo" + File.separator + "demo.xlsx";
//        // 一个文件一个reader
//        try (ExcelReader excelReader = EasyExcel.read(fileName, DemoData.class, new DemoDataListener()).build()) {
//            // 构建一个sheet 这里可以指定名字或者no
//            ReadSheet readSheet = EasyExcel.readSheet(0).build();
//            // 读取一个sheet
//            excelReader.read(readSheet);
//        }
    }
}

// 有个很重要的点 DemoDataListener 不能被spring管理，要每次读取excel都要new,然后里面用到spring可以构造方法传进去
@Slf4j
public class DemoDataListener implements ReadListener<DemoData> {

    /**
     * 每隔5条存储数据库，实际使用中可以100条，然后清理list ，方便内存回收
     */
    private static final int BATCH_COUNT = 100;
    /**
     * 缓存的数据
     */
    private List<DemoData> cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
    /**
     * 假设这个是一个DAO，当然有业务逻辑这个也可以是一个service。当然如果不用存储这个对象没用。
     */
    private DemoDAO demoDAO;

    public DemoDataListener() {
        // 这里是demo，所以随便new一个。实际使用如果到了spring,请使用下面的有参构造函数
        demoDAO = new DemoDAO();
    }

    /**
     * 如果使用了spring,请使用这个构造方法。每次创建Listener的时候需要把spring管理的类传进来
     *
     * @param demoDAO
     */
    public DemoDataListener(DemoDAO demoDAO) {
        this.demoDAO = demoDAO;
    }

    /**
     * 这个每一条数据解析都会来调用
     *
     * @param data    one row value. Is is same as {@link AnalysisContext#readRowHolder()}
     * @param context
     */
    @Override
    public void invoke(DemoData data, AnalysisContext context) {
        log.info("解析到一条数据:{}", JSON.toJSONString(data));
        cachedDataList.add(data);
        // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
        if (cachedDataList.size() >= BATCH_COUNT) {
            saveData();
            // 存储完成清理 list
            cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
        }
    }

    /**
     * 所有数据解析完成了 都会来调用
     *
     * @param context
     */
    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        // 这里也要保存数据，确保最后遗留的数据也存储到数据库
        saveData();
        log.info("所有数据解析完成！");
    }

    /**
     * 加上存储数据库
     */
    private void saveData() {
        log.info("{}条数据，开始存储数据库！", cachedDataList.size());
        demoDAO.save(cachedDataList);
        log.info("存储数据库成功！");
    }
}