Java中的文件解析——Excel解析

    在日常的开发过程中，经常会使用到excel工作簿进行数据的保存，那么在java中，通常会使用第三方提供的技术来进行excel文件的解析，比如：**Apache POI、JXL、Alibaba EasyExcel**。本文则使用的是Apache POI和Alibaba EasyExcel。

Apache POI

    目前Apache POI用的比较广泛的实现类是**XSSFWorkbook()**,主要因为当前版本的excel文件大多数都是以“**.xlsx**”结尾的，XSSFWorkbook()能识别的就是这种文件。当然Apache POI也提供了**HSSFWorkbook()**实现类，主要适用于以“**.xls**”结尾的excel文件，但是由于这种文件只能存储65535行数据，所以HSSFWorkbook()已经不常用了。

Apache POI所需要的jar依赖

Apache POI 解析Excel文件与创建Excel文件的流程

创建Excel

   1.创建WorkBook，一个WorkBook代表一个Excel文件

    2.以输出流的形式创建出Excel文件

    3.调用createSheet(0)创建工作簿

    4.调用createRow(0)创建行

    5.调用createCell(0)创建单元格

    6.调用setCellValue()完成对单元格内容的写入

    7.调用write()方法，将Workbook对象中包含的数据，通过输出流，写入至Excel文件

package com.fulian.Demo;

import java.io.FileOutputStream;
import java.io.IOException;
import java.time.LocalDateTime;
import java.util.UUID;

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;

public class Demo03 {
    public static void main(String[] args) {
        try (Workbook workbook = new XSSFWorkbook();
                FileOutputStream out = new FileOutputStream("d:\\test\\demo.xlsx")) {

            // 创建工作簿sheet
            Sheet sheet0 = workbook.createSheet("2020数据列表");
            Sheet sheet1 = workbook.createSheet("2021数据列表");
            Sheet sheet2 = workbook.createSheet("2022数据列表");

            //创建数据行Row
            Row row0 = sheet0.createRow(0);
            Row row = sheet0.createRow(1);
            
            // 创建单元格
            Cell cell00 = row0.createCell(0);
            cell00.setCellValue("UUID值");
            
            Cell cell0 = row.createCell(0);
            cell0.setCellValue(UUID.randomUUID().toString());
            

            Cell cell01 = row0.createCell(1);
            cell01.setCellValue("Math随机值");
            
            Cell cell1 = row.createCell(1);
            cell1.setCellValue(Math.random()*1000);
            

            Cell cell02 = row0.createCell(2);
            cell02.setCellValue("当前时间");
            
            Cell cell2 = row.createCell(2);
            cell2.setCellValue(LocalDateTime.now());
            
            // 将Workbook对象中包含的数据，通过输出流，写入至Excel文件
            workbook.write(out);
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

  当前新写入 excel文件内容如下

解析Excel

    1.以输入流的形式获取到excel文件

    2.创建WorkBook，传入该输入流

    3.调用getSheetAt(0)，获取到工作簿

    4.调用getRow()获取到行

    5.getCell()获取到单元格

    6.调用getStringCellValue()获取到String的类型的值，调用getNumericCellValue()获取到double类型的值

package com.fulian.Demo;

import java.io.FileInputStream;
import java.io.IOException;

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;

public class Demo07 {
    public static void main(String[] args) {
        try (Workbook workbook = new XSSFWorkbook(new FileInputStream("d:\\test\\demo.xlsx"))) {
            // 获取工作簿
            Sheet sheet = workbook.getSheetAt(0);
            
            for(int i = 1 ; i <= sheet.getLastRowNum();i++) {
                Row row = sheet.getRow(i);
                
                // 按照下标获取当前行的单元格
                Cell cell0 = row.getCell(0); // UUID
                Cell cell1 = row.getCell(1); // Math
                Cell cell2 = row.getCell(2); // 日期
                
                System.out.println("UUID值：" + cell0.getStringCellValue());
                System.out.println("Math随机值：" + cell1.getNumericCellValue());
                System.out.println("当前时间：" + cell2.getNumericCellValue());
            }
        }catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// 运行结果
UUID值：83d82313-cade-42bf-8aae-193ce655ea56
Math随机值：461.97493844727467
当前时间：44754.60497915509

    在上面的案例中，我们不难发现：当传入一个日期类型的字段值，excel文件中显示的是数字，因此就必须要设置单元格样式了。

    首先调用workbook的createCellStyle()方法创建单元格格式对象CellStyle，然后调用workbook的createDataFormat()方法，获取到DataFormat类型的对象，通过DataFormat.getFormat(),设置单元格的格式，获取到该格式编码并作为参数传入CellStyle.setDataFormat()方法，在单元格需要设置格式时，调用setCellStyle()方法，传入一个cellStyle对象，最后，调用setCellValue(new Date())，传入一个Date对象，完成对单元格日期格式的设置。

package com.fulian.Demo;

import java.io.FileOutputStream;
import java.io.IOException;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.UUID;

import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.DataFormat;
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;

public class Demo03 {
    public static void main(String[] args) {
        try (Workbook workbook = new XSSFWorkbook();
                FileOutputStream out = new FileOutputStream("d:\\test\\demo.xlsx")) {

            // 创建单元格格式
            // 获取格式编码
            DataFormat dataFormat = workbook.createDataFormat();
            short formatCode = dataFormat.getFormat("yyyy-MM-dd HH:mm:ss");

            // 创建CellStyle单元格格式对象
            CellStyle cellStyle = workbook.createCellStyle();
            cellStyle.setDataFormat(formatCode); // 设置单元格格式编码

            // 创建工作簿sheet
            Sheet sheet0 = workbook.createSheet("2020数据列表");
            Sheet sheet1 = workbook.createSheet("2021数据列表");
            Sheet sheet2 = workbook.createSheet("2022数据列表");

            // 创建数据行Row
            Row row0 = sheet0.createRow(0);
            Row row = sheet0.createRow(1);

            // 创建单元格
            Cell cell00 = row0.createCell(0);
            cell00.setCellValue("UUID值");

            Cell cell0 = row.createCell(0);
            cell0.setCellValue(UUID.randomUUID().toString());

            Cell cell01 = row0.createCell(1);
            cell01.setCellValue("Math随机值");

            Cell cell1 = row.createCell(1);
            cell1.setCellValue(Math.random() * 1000);

            Cell cell02 = row0.createCell(2);
            cell02.setCellValue("当前时间");

            Cell cell2 = row.createCell(2);
            
            cell2.setCellStyle(cellStyle); // 设置单元格格式
            cell2.setCellValue(new Date());

            // 将Workbook对象中包含的数据，通过输出流，写入至Excel文件
            workbook.write(out);

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

修改后demo文件内容即可正常显示日期类型：

EasyExcel

    EasyExcel是一个基于Java的简单、省内存的读写Excel的开源项目。在尽可能节约内存的情况下支持读写百M的Excel。

EasyExcel所需要的依赖

EasyExcel 解析Excel文件与创建Excel文件的流程

创建Excel文件

    创建文本文件主要使用write()方法，需要的参数是Excel文件的地址，和要写入内容的类型，这里提前准备了一个Order类，在Order类中，注解@ExcelProperty()代表列头单元格的内容，注解@NumberFormat()代表单元格格式，但是如果数据单元格是一个LocalDateTime类型的对象，程序会识别不到，需要定义一个converter转换器对象，官方文档给出了LocalDateTimeConverter实现类，这里就需要手动创建并导入。代码如下：

package com.fulian.demo;

import java.util.ArrayList;
import java.util.List;

import com.alibaba.excel.EasyExcel;
import com.fulian.entity.Order;

public class Demo01 {
    public static void main(String[] args) {
        
        // 写入100w
        EasyExcel.write("d:\\test\\easy100w.xlsx", Order.class)
                 .sheet("订单列表")
                 .doWrite(data());
    }
    
    // 创建100w条订单数据
    private static List<Order> data() {
        List<Order> list = new ArrayList<Order>();
        for (int i = 0; i < 1000000; i++) {
            list.add(new Order());
        }
        return list;
    }
}

Order类

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.UUID;

import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.annotation.format.NumberFormat;

public class Order {
    @ExcelProperty("订单编号")
    private String orderId; // 订单编号
    
    @ExcelProperty("支付金额")
    @NumberFormat("￥#,###")
    private Double payment; // 支付金额
    
    @ExcelProperty(value = "创建日期",converter = LocalDateTimeConverter.class)
    private LocalDateTime creationTime; // 创建时间

    public Order() {
        this.orderId = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddhhmmss"))
                + UUID.randomUUID().toString().substring(0, 5);
        this.payment = Math.random() * 10000;
        this.creationTime = LocalDateTime.now();
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public Double getPayment() {
        return payment;
    }

    public void setPayment(Double payment) {
        this.payment = payment;
    }

    public LocalDateTime getCreationTime() {
        return creationTime;
    }

    public void setCreationTime(LocalDateTime creationTime) {
        this.creationTime = creationTime;
    }

    @Override
    public String toString() {
        return "Order [orderId=" + orderId + ", payment=" + payment + ", creationTime=" + creationTime + "]";
    }
}

LocalDateTimeConverter实现类

package com.fulian.entity;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.CellData;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.property.ExcelContentProperty;

public class LocalDateTimeConverter implements Converter<LocalDateTime> {

    @Override
    public Class<LocalDateTime> supportJavaTypeKey() {
        return LocalDateTime.class;
    }

    @Override
    public CellDataTypeEnum supportExcelTypeKey() {
        return CellDataTypeEnum.STRING;
    }

    @Override
    public LocalDateTime convertToJavaData(CellData cellData, ExcelContentProperty contentProperty,
            GlobalConfiguration globalConfiguration) {
        return LocalDateTime.parse(cellData.getStringValue(), DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }

    @Override
    public CellData<String> convertToExcelData(LocalDateTime value, ExcelContentProperty contentProperty,
            GlobalConfiguration globalConfiguration) {
        return new CellData<>(value.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
    }

}

运行结果

解析Excel文件

    读取数据需要调用read()方法，参数包括：文件地址，读取内容的类型以及监听器对象，而这里使用的是AnalysisEventListener的一个匿名子类，只重写了3个方法：invoke()方法表示监听器在获取到每行的数据时需要执行的操作；incokeHeadMap()方法表示把列头中的单元格内容存到一个map集合中，后续需要列头时只需要调用map集合即可；doAfterAllAnalysed()方法表示所有数据读完后的操作。代码如下：

package com.fulian.demo;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.fulian.entity.Order;

public class Demo02 {
    public static void main(String[] args) {

        List<Order> orderList = new ArrayList<Order>(); 
        
        EasyExcel.read("d:\\test\\easy100w.xlsx", Order.class,new AnalysisEventListener<Order>() {
            @Override
            public void invoke(Order order, AnalysisContext arg1) {
                // 读取每条数据
                orderList.add(order);
            }

            @Override
            public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
                // 读取到列头
                System.out.println(headMap);
                super.invokeHeadMap(headMap, context);
            }

            @Override
            public void doAfterAllAnalysed(AnalysisContext arg0) {
                // 读取完毕
                System.out.println("END");
            }
        }).sheet().doRead();
        
        for(Order order : orderList) {
            System.out.println(order);
        }
    }
}

超大Excel文件的读写时间

XSSF写入数据

比如说要写入100万条数据，如果我们使用XSSFWorkbook（）实现类，那么写入的过程中需要占据大量的cpu和内存，耗费时间较慢，代码如下

package com.fulian.Demo;

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

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;

public class Demo11 {
    public static void main(String[] args) {
        long begin = System.currentTimeMillis();
        
        try (Workbook workbook = new XSSFWorkbook();
                FileOutputStream out = new FileOutputStream("d:\\test\\demo\\XSSF100w.xlsx")) {
        
            Sheet sheet = workbook.createSheet();
        
            for (int i = 0; i < 1000000; i++) {
                Row row = sheet.createRow(i);
                Cell cell = row.createCell(0);
                cell.setCellValue(i);
            }
            
            workbook.write(out);
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        long end = System.currentTimeMillis();
        
        System.out.println("共耗时：" + (end - begin) + "毫秒！");
    }
}

结果：

SXSSF写入数据

使用SXSSFWorkbook()实现类，可以通过设置构造方法中的参数，当内存中的行数达到这个参数值时，会立即释放内存，把数据存储到磁盘中，大大减缓了cpu和内存空间的使用，提高了运行速度。代码如下：

package com.fulian.Demo;

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

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.streaming.SXSSFWorkbook;

public class Demo12 {
    public static void main(String[] args) {
        long begin = System.currentTimeMillis();
        
        try (Workbook workbook = new SXSSFWorkbook(100);
                FileOutputStream out = new FileOutputStream("d:\\test\\demo\\SXSSF100w.xlsx")) {
        
            Sheet sheet = workbook.createSheet();
        
            for (int i = 0; i < 1000000; i++) {
                Row row = sheet.createRow(i);
                Cell cell = row.createCell(0);
                cell.setCellValue(i);
            }
            
            workbook.write(out);
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        long end = System.currentTimeMillis();
        
        System.out.println("共耗时：" + (end - begin) + "毫秒！");
    }
}

结果：

EasyExcel写入数据

package com.fulian.demo;

import java.util.ArrayList;
import java.util.List;

import com.alibaba.excel.EasyExcel;

public class Demo03 {
    public static void main(String[] args) {
        long begin = System.currentTimeMillis();

        // 写入100w
        EasyExcel.write("d:\\test\\demo\\easy100w.xlsx", Integer.class).sheet().doWrite(data());

        long end = System.currentTimeMillis();

        System.out.println("共耗时：" + (end - begin) + "毫秒！");
    }

    // 创建100w条数据
    private static List<Integer> data() {
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < 1000000; i++) {
            list.add(i);
        }
        return list;
    }
}

结果：

EasyExcel读取数据

读取数据需要调用read()方法，参数包括：文件地址，读取内容的类型以及监听器对象，而这里使用的是AnalysisEventListener的一个匿名子类，只重写了3个方法：invoke()方法表示监听器在获取到每行的数据时需要执行的操作；incokeHeadMap()方法表示把列头中的单元格内容存到一个map集合中，后续需要列头时只需要调用map集合即可；doAfterAllAnalysed()方法表示所有数据读完后的操作。代码如下：

package com.fulian.demo;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;

public class Demo04 {
    public static void main(String[] args) {
        long begin = System.currentTimeMillis();
        
        List<Integer> list = new ArrayList<Integer>(); 
        
        EasyExcel.read("d:\\test\\demo\\easy100w.xlsx", Integer.class,new AnalysisEventListener<Integer>() {
            @Override
            public void invoke(Integer i, AnalysisContext arg1) {
                // 读取每条数据
                list.add(i);
            }

            @Override
            public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
                // 读取到列头
                System.out.println(headMap);
                super.invokeHeadMap(headMap, context);
            }

            @Override
            public void doAfterAllAnalysed(AnalysisContext arg0) {
                // 读取完毕
                System.out.println("END");
            }
        }).sheet().doRead();
        
        long end = System.currentTimeMillis();
        
        System.out.println("共耗时：" + (end - begin) + "毫秒！");
    }
}

结果：

结论

    EasyExcel技术在读写超大Excel文件时相比POI读写超大Excel文件上读写速度、性能、内存占用等优势较为明显，而且在是实体类上通过注解的形式，更加明显的表示出excel文件的列名以及单元格的形式，兼容性更强，上手更加容易、灵活。