Java中的文件解析——Excel解析-java黑洞网

本站消息

站长简介/公众号

出租广告位,需要合作请联系站长

gogogo

2679

文章

1325051

访问

+关注

分类

暂无分类

日期归档

2022-04(3)

2022-05(19)

2022-06(27)

2022-08(23)

2022-09(4)

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

发布于2023-02-04 17:42 阅读(832) 评论(0) 点赞(19) 收藏(1)

在日常的开发过程中，经常会使用到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读取数据


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) + "毫秒！");
	}
}