前言

在平時的業務系統開發中，少不了需要用到導出、導入excel功能，今天我們就一起來總結一下！

下面給大家介紹一下幾種常用方法：

• apache poi
• easypoi
• easyexcel

一、Apache poi

大概在很久很久以前，微軟的電子表格軟件 Excel 以操作簡單、存儲數據直觀方便，還支持打印報表，在誕生之初，可謂深得辦公室里的白領青睞，極大的提升了工作的效率，不久之后，便成了辦公室里的必備工具。

隨著更多的新語言的崛起，例如我們所熟悉的 java，后來便有一些團隊開始開發一套能與 Excel 軟件無縫切換的操作工具！

當然，在java生態體系里面，能與Excel無縫銜接的第三方工具還有很多，在開始也給大家列出來三個，因為 apache poi 在業界使用的最廣泛，因此其他的工具不做過多介紹！

話不多說，直接開擼！

1.1 首先添加依賴

1. <dependencies>
2. <!--xls(03)-->
3. <dependency>
4. <groupId>org.apache.poi</groupId>
5. <artifactId>poi</artifactId>
6. <version>4.1.2</version>
7. </dependency>
8. <!--xlsx(07)-->
9. <dependency>
10. <groupId>org.apache.poi</groupId>
11. <artifactId>poi-ooxml</artifactId>
12. <version>4.1.2</version>
13. </dependency>
14. <!--時間格式化工具-->
15. <dependency>
16. <groupId>joda-time</groupId>
17. <artifactId>joda-time</artifactId>
18. <version>2.10.6</version>
19. </dependency>
20. </dependencies>

1.2 導出excel

導出操作，即使用 Java 寫出數據到 Excel 中，常見場景是將頁面上的數據導出，這些數據可能是財務數據，也可能是商品數據，生成 Excel 后返回給用戶下載文件。

在 poi 工具庫中，導出 api 可以分三種方式

• HSSF方式： 這種方式導出的文件格式為office 2003專用格式，即.xls，優點是導出數據速度快，但是 最多65536行 數據
• XSSF方式： 這種方式導出的文件格式為office 2007專用格式，即.xlsx，優點是導出的數據不受行數限制，缺點導出速度慢
• SXSSF方式： SXSSF 是 XSSF API的兼容流式擴展，主要解決當使用 XSSF 方式導出大數據量時，內存溢出的問題，支持導出大批量的excel數據

1.2.1 HSSF方式導出(.xls方式)

HSSF方式，最多只支持65536條數據導出，超過這個條數會報錯！

1. package cn.tedu.excel.test;
2.  
3. import org.apache.poi.hssf.usermodel.HSSFWorkbook;
4. import org.apache.poi.ss.usermodel.Cell;
5. import org.apache.poi.ss.usermodel.Row;
6. import org.apache.poi.ss.usermodel.Sheet;
7. import org.apache.poi.ss.usermodel.Workbook;
8.  
9. import java.io.FileOutputStream;
10.  
11. /**
12. * HSSF方式導出：HSSF方式，最多只支持65536條數據導出，超過這個條數會報錯！
13. * 就是.xls模式
14. */
15. public class ExcelWrite2003Test {
16. private static String PATH = "/Users/lixin/Desktop/";//自己輸出的路徑
17.  
18. public static void main(String[] args) throws Exception {
19. //時間
20. long begin = System.currentTimeMillis();
21.  
22. //創建一個工作簿
23. Workbook workbook = new HSSFWorkbook();
24. //創建表
25. Sheet sheet = workbook.createSheet();
26. //寫入數據
27. for (int rowNumber = 0; rowNumber < 65536; rowNumber++) {
28. //創建行
29. Row row = sheet.createRow(rowNumber);
30. for (int cellNumber = 0; cellNumber < 10; cellNumber++) {
31. //創建列
32. Cell cell = row.createCell(cellNumber);
33. cell.setCellValue(cellNumber);
34. }
35. }
36. System.out.println("結束！");
37. FileOutputStream fileOutputStream = new FileOutputStream(PATH + "用戶信息表-XLS.xls");
38. workbook.write(fileOutputStream);
39. fileOutputStream.close();
40. long end = System.currentTimeMillis();
41. System.out.println("時間為："+(double) (end - begin) / 1000);//2.262s
42. }
43. }

1.2.2 XSSF方式導出(.xlsx)

XSSF方式支持大批量數據導出，所有的數據先寫入內存再導出，容易出現內存溢出！

1. package cn.tedu.excel.test;
2.  
3. import org.apache.poi.ss.usermodel.Cell;
4. import org.apache.poi.ss.usermodel.Row;
5. import org.apache.poi.ss.usermodel.Sheet;
6. import org.apache.poi.ss.usermodel.Workbook;
7. import org.apache.poi.xssf.usermodel.XSSFWorkbook;
8.  
9. import java.io.FileOutputStream;
10.  
11. /**
12. * .xlsx方式
13. */
14. public class ExcelWrite2007Test {
15. public static String PATH = "/Users/lixin/Desktop/";
16.  
17. public static void main(String[] args) throws Exception {
18. //時間
19. long begin = System.currentTimeMillis();
20.  
21. //創建一個工作簿
22. Workbook workbook = new XSSFWorkbook();
23. //創建表
24. Sheet sheet = workbook.createSheet();
25. //寫入數據
26. for (int rowNumber = 0; rowNumber < 65537; rowNumber++) {
27. Row row = sheet.createRow(rowNumber);
28. for (int cellNumber = 0; cellNumber < 10; cellNumber++) {
29. Cell cell = row.createCell(cellNumber);
30. cell.setCellValue(cellNumber);
31. }
32. }
33. System.out.println("結束");
34.  
35. FileOutputStream fileOutputStream = new FileOutputStream(PATH + "用戶信息表-XLSX.xlsx");
36. workbook.write(fileOutputStream);
37. fileOutputStream.close();
38. long end = System.currentTimeMillis();
39. System.out.println((double) (end - begin) / 1000);//5.003s
40. }
41. }

1.2.3、SXSSF方式導出

SXSSF方式是XSSF方式的一種延伸，主要特性是低內存，導出的時候，先將數據寫入磁盤再導出，避免報內存不足，導致程序運行異常，缺點是運行很慢！

1. package cn.tedu.excel.test;
2.  
3. import org.apache.poi.ss.usermodel.Cell;
4. import org.apache.poi.ss.usermodel.Row;
5. import org.apache.poi.ss.usermodel.Sheet;
6. import org.apache.poi.ss.usermodel.Workbook;
7. import org.apache.poi.xssf.streaming.SXSSFWorkbook;
8.  
9. import java.io.FileOutputStream;
10.  
11. public class ExcelWriteSXSSFTest {
12. public static String PATH = "/Users/lixin/Desktop/";
13.  
14. public static void main(String[] args) throws Exception {
15. //時間
16. long begin = System.currentTimeMillis();
17.  
18. //創建一個工作簿
19. Workbook workbook = new SXSSFWorkbook();
20.  
21. //創建表
22. Sheet sheet = workbook.createSheet();
23.  
24. //寫入數據
25. for (int rowNumber = 0; rowNumber < 100000; rowNumber++) {
26. Row row = sheet.createRow(rowNumber);
27. for (int cellNumber = 0; cellNumber < 10; cellNumber++) {
28. Cell cell = row.createCell(cellNumber);
29. cell.setCellValue(cellNumber);
30. }
31. }
32. System.out.println("over");
33.  
34. FileOutputStream fileOutputStream = new FileOutputStream(PATH + "用戶信息表-SXSSF.xlsx");
35. workbook.write(fileOutputStream);
36. fileOutputStream.close();
37. long end = System.currentTimeMillis();
38. System.out.println((double) (end - begin) / 1000);//6.39s
39. }
40. }

1.3 導入excel

導入操作，即將 excel 中的數據采用java工具庫將其解析出來，進而將 excel 數據寫入數據庫！

同樣，在 poi 工具庫中，導入 api 也分三種方式，與上面的導出一一對應！

1.3.1 HSSF方式導入

1. package cn.tedu.excel.test;
2.  
3. import org.apache.poi.hssf.usermodel.HSSFDateUtil;
4. import org.apache.poi.hssf.usermodel.HSSFWorkbook;
5. import org.apache.poi.ss.usermodel.*;
6. import org.joda.time.DateTime;
7.  
8. import java.io.FileInputStream;
9. import java.util.Date;
10.  
11. public class ExcelRead2003Test {
12. public static String PATH = "/Users/lixin/Desktop/";
13.  
14. public static void main(String[] args) throws Exception {
15. //獲取文件流
16. FileInputStream inputStream = new FileInputStream(PATH + "用戶信息表2003read.xls");
17.  
18. //1.創建工作簿,使用excel能操作的這邊都看看操作
19. Workbook workbook = new HSSFWorkbook(inputStream);
20. //2.得到表
21. Sheet sheet = workbook.getSheetAt(0);
22. //3.得到行
23. Row row = sheet.getRow(0);
24. //4.得到列
25. Cell cell = row.getCell(0);
26. getValue(cell);
27. inputStream.close();
28. }
29.  
30. public static void getValue(Cell cell){
31. //匹配類型數據
32. if (cell != null) {
33. CellType cellType = cell.getCellType();
34. String cellValue = "";
35. switch (cellType) {
36. case STRING: //字符串
37. System.out.print("[String類型]");
38. cellValue = cell.getStringCellValue();
39. break;
40. case BOOLEAN: //布爾類型
41. System.out.print("[boolean類型]");
42. cellValue = String.valueOf(cell.getBooleanCellValue());
43. break;
44. case BLANK: //空
45. System.out.print("[BLANK類型]");
46. break;
47. case NUMERIC: //數字（日期、普通數字）
48. System.out.print("[NUMERIC類型]");
49. if (HSSFDateUtil.isCellDateFormatted(cell)) { //日期
50. System.out.print("[日期]");
51. Date date = cell.getDateCellValue();
52. cellValue = new DateTime(date).toString("yyyy-MM-dd");
53. } else {
54. //不是日期格式，防止數字過長
55. System.out.print("[轉換為字符串輸出]");
56. cell.setCellType(CellType.STRING);
57. cellValue = cell.toString();
58. }
59. break;
60. case ERROR:
61. System.out.print("[數據類型錯誤]");
62. break;
63. }
64. System.out.println(cellValue);
65. }
66. }
67. }

輸出結果類似如圖所示：

1.3.2 XSSF方式導入

1. package cn.tedu.excel.test;
2.  
3. import org.apache.poi.hssf.usermodel.HSSFDateUtil;
4. import org.apache.poi.ss.usermodel.*;
5. import org.apache.poi.xssf.usermodel.XSSFWorkbook;
6. import org.joda.time.DateTime;
7.  
8. import java.io.FileInputStream;
9. import java.util.Date;
10.  
11. public class ExcelRead2007Test {
12. public static String PATH = "/Users/lixin/Desktop/";
13.  
14. public static void main(String[] args) throws Exception {
15. //獲取文件流
16. FileInputStream inputStream = new FileInputStream(PATH + "用戶信息表2007read.xlsx");
17.  
18. //1.創建工作簿,使用excel能操作的這邊都看看操作
19. Workbook workbook = new XSSFWorkbook(inputStream);
20. //2.得到表
21. Sheet sheet = workbook.getSheetAt(0);
22. //3.得到行
23. Row row = sheet.getRow(0);
24. //4.得到列
25. Cell cell = row.getCell(0);
26. getValue(cell);
27. inputStream.close();
28. }
29. public static void getValue(Cell cell){
30. //匹配類型數據
31. if (cell != null) {
32. CellType cellType = cell.getCellType();
33. String cellValue = "";
34. switch (cellType) {
35. case STRING: //字符串
36. System.out.print("[String類型]");
37. cellValue = cell.getStringCellValue();
38. break;
39. case BOOLEAN: //布爾類型
40. System.out.print("[boolean類型]");
41. cellValue = String.valueOf(cell.getBooleanCellValue());
42. break;
43. case BLANK: //空
44. System.out.print("[BLANK類型]");
45. break;
46. case NUMERIC: //數字（日期、普通數字）
47. System.out.print("[NUMERIC類型]");
48. if (HSSFDateUtil.isCellDateFormatted(cell)) { //日期
49. System.out.print("[日期]");
50. Date date = cell.getDateCellValue();
51. cellValue = new DateTime(date).toString("yyyy-MM-dd");
52. } else {
53. //不是日期格式，防止數字過長
54. System.out.print("[轉換為字符串輸出]");
55. cell.setCellType(CellType.STRING);
56. cellValue = cell.toString();
57. }
58. break;
59. case ERROR:
60. System.out.print("[數據類型錯誤]");
61. break;
62. }
63. System.out.println(cellValue);
64. }
65. }
66. }

1.3.3 SXSSF方式導入

1. package cn.tedu.excel.test;
2.  
3. import org.apache.poi.ooxml.util.SAXHelper;
4. import org.apache.poi.openxml4j.opc.OPCPackage;
5. import org.apache.poi.xssf.eventusermodel.ReadOnlySharedStringsTable;
6. import org.apache.poi.xssf.eventusermodel.XSSFReader;
7. import org.apache.poi.xssf.eventusermodel.XSSFSheetXMLHandler;
8. import org.apache.poi.xssf.model.StylesTable;
9. import org.apache.poi.xssf.usermodel.XSSFComment;
10. import org.xml.sax.InputSource;
11. import org.xml.sax.XMLReader;
12.  
13. import java.io.InputStream;
14. import java.util.ArrayList;
15. import java.util.Iterator;
16. import java.util.List;
17. import java.util.stream.Collectors;
18.  
19. public class ExcelReadSXSSFTest {
20. public static String PATH = "/Users/lixin/Desktop/";
21.  
22. public static void main(String[] args) throws Exception {
23. //獲取文件流
24.  
25. //1.創建工作簿,使用excel能操作的這邊都看看操作
26. OPCPackage opcPackage = OPCPackage.open(PATH + "用戶信息表2007read.xlsx");
27. XSSFReader xssfReader = new XSSFReader(opcPackage);
28. StylesTable stylesTable = xssfReader.getStylesTable();
29. ReadOnlySharedStringsTable sharedStringsTable = new ReadOnlySharedStringsTable(opcPackage);
30. // 創建XMLReader，設置ContentHandler
31. XMLReader xmlReader = SAXHelper.newXMLReader();
32. xmlReader.setContentHandler(new XSSFSheetXMLHandler(stylesTable, sharedStringsTable, new SimpleSheetContentsHandler(), false));
33. // 解析每個Sheet數據
34. Iterator<InputStream> sheetsData = xssfReader.getSheetsData();
35. while (sheetsData.hasNext()) {
36. try (InputStream inputStream = sheetsData.next();) {
37. xmlReader.parse(new InputSource(inputStream));
38. }
39. }
40. }
41. /**
42. * 內容處理器
43. */
44. public static class SimpleSheetContentsHandler implements XSSFSheetXMLHandler.SheetContentsHandler {
45.  
46. protected List<String> row;
47.  
48. @Override
49. public void startRow(int rowNum) {
50. row = new ArrayList<>();
51. }
52.  
53. @Override
54. public void endRow(int rowNum) {
55. if (row.isEmpty()) {
56. return;
57. }
58. // 處理數據
59. System.out.println(row.stream().collect(Collectors.joining(" ")));
60. }
61.  
62. @Override
63. public void cell(String cellReference, String formattedValue, XSSFComment comment) {
64. row.add(formattedValue);
65. }
66.  
67. @Override
68. public void headerFooter(String text, boolean isHeader, String tagName) {
69. }
70. }
71. }

二、Easypoi

以前的以前，有個大佬程序員，跳到一家公司之后就和業務人員聊上了，這些業務員對excel報表有著許許多多的要求，比如想要一個報表，他的表頭是一個多行表頭，過幾天之后，他想要給這些表頭添加樣式，比如關鍵的數據標紅，再過幾天，他想要再末尾添加一條合計的數據，等等！

起初還好，都是copy、copy，之后發現系統中出現大量的重復代碼，于是有一天真的忍受不了了，采用注解搞定來搞定這些定制化成程度高的邏輯，將公共化抽離出來，于是誕生了 easypoi！它的底層也是基于 apache poi 進行深度開發的，它主要的特點就是將更多重復的工作，全部簡單化，避免編寫重復的代碼！

下面，我們就一起來了解一下這款高大上的開源工具：easypoi

2.1 添加依賴包

1. <dependencies>
2. <dependency>
3. <groupId>cn.afterturn</groupId>
4. <artifactId>easypoi-base</artifactId>
5. <version>4.1.0</version>
6. </dependency>
7. <dependency>
8. <groupId>cn.afterturn</groupId>
9. <artifactId>easypoi-web</artifactId>
10. <version>4.1.0</version>
11. </dependency>
12. <dependency>
13. <groupId>cn.afterturn</groupId>
14. <artifactId>easypoi-annotation</artifactId>
15. <version>4.1.0</version>
16. </dependency>
17. <dependency>
18. <groupId>com.googlecode.json-simple</groupId>
19. <artifactId>json-simple</artifactId>
20. <version>1.1.1</version>
21. </dependency>
22. </dependencies>

2.2 采用注解導出導入

easypoi 最大的亮點就是基于注解實體類來導出、導入excel，使用起來非常簡單！

我們創建一個實體類UserEntity，其中@Excel注解表示導出文件的頭部信息。

添加Lombok插件，替代set和get方法

2.2.1 導出操作

1. package cn.tedu.excel.easypoi;
2.  
3. import cn.afterturn.easypoi.excel.ExcelExportUtil;
4. import cn.afterturn.easypoi.excel.annotation.Excel;
5. import cn.afterturn.easypoi.excel.entity.ExportParams;
6. import lombok.AllArgsConstructor;
7. import lombok.Data;
8. import lombok.NoArgsConstructor;
9. import org.apache.poi.ss.usermodel.Workbook;
10.  
11. import java.io.FileOutputStream;
12. import java.util.ArrayList;
13. import java.util.Date;
14. import java.util.List;
15.  
16. @Data
17. @NoArgsConstructor
18. @AllArgsConstructor
19. public class UserEntity {
20. @Excel(name = "姓名")
21. private String name;
22. @Excel(name = "年齡")
23. private int age;
24. @Excel(name = "操作時間",format="yyyy-MM-dd HH:mm:ss", width = 20.0)
25. private Date time;
26.  
27. public static void main(String[] args) throws Exception {
28. List<UserEntity> dataList = new ArrayList<>();
29. for (int i = 0; i < 10; i++) {
30. UserEntity userEntity = new UserEntity();
31. userEntity.setName("張三" + i);
32. userEntity.setAge(20 + i);
33. userEntity.setTime(new Date(System.currentTimeMillis() + i));
34. dataList.add(userEntity);
35. }
36. //生成excel文檔
37. Workbook workbook = ExcelExportUtil.exportExcel(new ExportParams("用戶","用戶信息"),
38. UserEntity.class, dataList);
39. FileOutputStream fos = new FileOutputStream("/Users/lixin/Desktop/easypoi-user.xls");
40. workbook.write(fos);
41. fos.close();
42. }
43. }

導出文件預覽圖如下：

2.2.2 導入操作

1. package cn.tedu.excel.easypoi;
2.  
3. import cn.afterturn.easypoi.excel.ExcelImportUtil;
4. import cn.afterturn.easypoi.excel.annotation.Excel;
5. import cn.afterturn.easypoi.excel.entity.ImportParams;
6. import lombok.AllArgsConstructor;
7. import lombok.Data;
8. import lombok.NoArgsConstructor;
9.  
10. import java.io.File;
11. import java.util.Date;
12. import java.util.List;
13. import org.json.simple.JSONArray;
14.  
15. @Data
16. @NoArgsConstructor
17. @AllArgsConstructor
18. public class StudentEntity {
19. @Excel(name = "姓名")
20. private String name;
21. @Excel(name = "年齡")
22. private int age;
23. @Excel(name = "操作時間",format="yyyy-MM-dd HH:mm:ss", width = 20.0)
24. private Date time;
25.  
26. public static void main(String[] args) {
27. ImportParams params = new ImportParams();
28. params.setTitleRows(1);
29. params.setHeadRows(1);
30. long start = new Date().getTime();
31. List<StudentEntity> list = ExcelImportUtil.importExcel(new File("/Users/lixin/Desktop/easypoi-user1.xls"),
32. UserEntity.class, params);
33. System.out.println(new Date().getTime() - start);
34. System.out.println(JSONArray.toJSONString(list));
35. }
36. }

輸出結果為：

[UserEntity(name=張三0, age=20, time=Mon Mar 29 11:29:52 CST 2021),UserEntity(name=李四, age=21, time=Mon Mar 29 11:29:52 CST 2021),UserEntity(name=王武, age=22, time=Mon Mar 29 11:29:52 CST 2021),UserEntity(name=趙六, age=23, time=Mon Mar 29 11:29:52 CST 2021),UserEntity(name=null, age=0, time=null),UserEntity(name=null, age=0, time=null),UserEntity(name=null, age=0, time=null),UserEntity(name=null, age=0, time=null),UserEntity(name=null, age=0, time=null),UserEntity(name=null, age=0, time=null)]

2.3 自定義數據結構導出導入

easypoi 同樣也支持自定義數據結構導出導入excel。

自定義數據導出 excel

2.3.1 導出操作

1. public static void main(String[] args) throws Exception {
2. //封裝表頭
3. List<ExcelExportEntity> entityList = new ArrayList<ExcelExportEntity>();
4. entityList.add(new ExcelExportEntity("姓名", "name"));
5. entityList.add(new ExcelExportEntity("年齡", "age"));
6. ExcelExportEntity entityTime = new ExcelExportEntity("操作時間", "time");
7. entityTime.setFormat("yyyy-MM-dd HH:mm:ss");
8. entityTime.setWidth(20.0);
9. entityList.add(entityTime);
10. //封裝數據體
11. List<Map<String, Object>> dataList = new ArrayList<>();
12. for (int i = 0; i < 10; i++) {
13. Map<String, Object> userEntityMap = new HashMap<>();
14. userEntityMap.put("name", "張三" + i);
15. userEntityMap.put("age", 20 + i);
16. userEntityMap.put("time", new Date(System.currentTimeMillis() + i));
17. dataList.add(userEntityMap);
18. }
19. //生成excel文檔
20. Workbook workbook = ExcelExportUtil.exportExcel(new ExportParams("學生","用戶信息"), entityList, dataList);
21. FileOutputStream fos = new FileOutputStream("/Users/lixin/Desktop/easypoi-user2.xls");
22. workbook.write(fos);
23. fos.close();
24. }

2.3.2 導入操作

1. public static void main(String[] args) {
2. ImportParams params = new ImportParams();
3. params.setTitleRows(1);
4. params.setHeadRows(1);
5. long start = new Date().getTime();
6. List<Map<String, Object>> list = ExcelImportUtil.importExcel(new File("/Users/lixin/Desktop/easypoi-user2.xls"),
7. Map.class, params);
8. System.out.println(new Date().getTime() - start);
9. System.out.println(JSONArray.toJSONString(list));
10. }

更多的 api 操作可以訪問 Easypoi - 接口文檔

三、Easyexcel

easyexcel 是阿里巴巴開源的一款 excel 解析工具，底層邏輯也是基于 apache poi 進行二次開發的。不同的是，再讀寫數據的時候，采用 sax 模式一行一行解析，在并發量很大的情況下，依然能穩定運行！

下面，我們就一起來了解一下這款新起之秀！

3.1 添加依賴包

1. <!-- EasyExcel -->
2. <dependency>
3. <groupId>com.alibaba</groupId>
4. <artifactId>easyexcel</artifactId>
5. <version>2.2.6</version>
6. </dependency>
7. <!--常用工具庫-->
8. <dependency>
9. <groupId>com.google.guava</groupId>
10. <artifactId>guava</artifactId>
11. <version>29.0-jre</version>
12. </dependency>

3.2 采用注解導出導入

easyexcel 同樣也支持采用注解方式進行導出、導入！

首先，我們創建一個實體類UserEntity，其中@ExcelProperty注解表示導出文件的頭部信息。

3.2.1 導出操作

1. package cn.tedu.excel.easyexcel;
2.  
3. import com.alibaba.excel.EasyExcel;
4. import com.alibaba.excel.annotation.ExcelProperty;
5. import lombok.AllArgsConstructor;
6. import lombok.Data;
7. import lombok.NoArgsConstructor;
8. import org.springframework.format.annotation.DateTimeFormat;
9.  
10. import java.util.ArrayList;
11. import java.util.Date;
12. import java.util.List;
13.  
14. @Data
15. @NoArgsConstructor
16. @AllArgsConstructor
17. public class UserEntity {
18. @ExcelProperty(value = "姓名")
19. private String name;
20.  
21. @ExcelProperty(value = "年齡")
22. private int age;
23.  
24. @DateTimeFormat(fallbackPatterns = "yyyy-MM-dd HH:mm:ss")
25. @ExcelProperty(value = "操作時間")
26. private Date time;
27.  
28. public static void main(String[] args) {
29. List<UserEntity> dataList = new ArrayList<>();
30. for (int i = 0; i < 10; i++) {
31. UserEntity userEntity = new UserEntity();
32. userEntity.setName("張三" + i);
33. userEntity.setAge(20 + i);
34. userEntity.setTime(new Date(System.currentTimeMillis() + i));
35. dataList.add(userEntity);
36. }
37. EasyExcel.write("/Users/lixin/Desktop/easyexcel-user1.xls", UserEntity.class).sheet("用戶信息").doWrite(dataList);
38. }
39. }

導出預覽圖：

3.2.2 導入操作

1. package cn.tedu.excel.easyexcel;
2.  
3. import com.alibaba.excel.EasyExcel;
4. import org.json.simple.JSONArray;
5.  
6. import java.util.List;
7.  
8. public class DemoData {
9. public static void main(String[] args) {
10. String filePath = "/Users/lixin/Desktop/easyexcel-user1.xls";
11. List<DemoData> list = EasyExcel.read(filePath).head(UserEntity.class).sheet().doReadSync();
12. System.out.println(JSONArray.toJSONString(list));
13. }
14. }

結果顯示：

[UserEntity(name=張三0, age=20, time=Mon Mar 29 16:42:20 CST 2021),UserEntity(name=張三1, age=21, time=Mon Mar 29 16:42:20 CST 2021),UserEntity(name=張三2, age=22, time=Mon Mar 29 16:42:20 CST 2021),UserEntity(name=張三3, age=23, time=Mon Mar 29 16:42:20 CST 2021),UserEntity(name=張三4, age=24, time=Mon Mar 29 16:42:20 CST 2021),UserEntity(name=張三5, age=25, time=Mon Mar 29 16:42:20 CST 2021),UserEntity(name=張三6, age=26, time=Mon Mar 29 16:42:20 CST 2021),UserEntity(name=張三7, age=27, time=Mon Mar 29 16:42:20 CST 2021),UserEntity(name=張三8, age=28, time=Mon Mar 29 16:42:20 CST 2021),UserEntity(name=張三9, age=29, time=Mon Mar 29 16:42:20 CST 2021)]

3.3 自定義數據結構導出導入

easyexcel 同樣也支持自定義數據結構導出導入excel。

3.3.1 導出操作

1. public static void main(String[] args) {
2. //表頭
3. List<List<String>> headList = new ArrayList<>();
4. headList.add(Lists.newArrayList("姓名"));
5. headList.add(Lists.newArrayList("年齡"));
6. headList.add(Lists.newArrayList("操作時間"));
7.  
8. //數據體
9. List<List<Object>> dataList = new ArrayList<>();
10. for (int i = 0; i < 10; i++) {
11. List<Object> data = new ArrayList<>();
12. data.add("張三" + i);
13. data.add(20 + i);
14. data.add(new Date(System.currentTimeMillis() + i));
15. dataList.add(data);
16. }
17. EasyExcel.write("/Users/hello/Documents/easyexcel-user2.xls").head(headList).sheet("用戶信息").doWrite(dataList);
18. }

3.3.2 導入操作

1. public static void main(String[] args) {
2. String filePath = "/Users/panzhi/Documents/easyexcel-user2.xls";
3. UserDataListener userDataListener = new UserDataListener();
4. EasyExcel.read(filePath, userDataListener).sheet().doRead();
5. System.out.println("表頭：" + JSONArray.toJSONString(userDataListener.getHeadList()));
6. System.out.println("數據體：" + JSONArray.toJSONString(userDataListener.getDataList()));
7. }

運行結果如圖所示：

表頭：[{0:"姓名",1:"年齡",2:"操作時間"}]
數據體：[{0:"張三0",1:"20",2:"2021-03-29 16:31:39"},{0:"張三1",1:"21",2:"2021-03-29 16:31:39"},{0:"張三2",1:"22",2:"2021-03-29 16:31:39"},{0:"張三3",1:"23",2:"2021-03-29 16:31:39"},{0:"張三4",1:"24",2:"2021-03-29 16:31:39"},{0:"張三5",1:"25",2:"2021-03-29 16:31:39"},{0:"張三6",1:"26",2:"2021-03-29 16:31:39"},{0:"張三7",1:"27",2:"2021-03-29 16:31:39"},{0:"張三8",1:"28",2:"2021-03-29 16:31:39"},{0:"張三9",1:"29",2:"2021-03-29 16:31:39"}]

更多的 api 操作可以訪問 easyexcel - 接口文檔！

四、總結

總體來說，Easypoi 和 Easyexcel 都是基于Apache poi進行二次開發的。

不同點在于：

• Easypoi 在讀寫數據的時候，優先是先將數據寫入內存，優點是讀寫性能非常高，但是當數據量很大的時候，會出現oom，當然它也提供了 sax 模式的讀寫方式，需要調用特定的方法實現。
• Easyexcel 基于sax模式進行讀寫數據，不會出現oom情況，程序有過高并發場景的驗證，因此程序運行比較穩定，相對于 Easypoi 來說，讀寫性能稍慢！

Easypoi 與 Easyexcel 還有一點區別在于，Easypoi 對定制化的導出支持非常的豐富，如果當前的項目需求，并發量不大、數據量也不大，但是需要導出 excel 的文件樣式千差萬別，那么我推薦你用 easypoi；反之，使用 easyexcel ！

到此這篇關于Java操作excel的三種常見方法的文章就介紹到這了,更多相關Java操作excel內容請搜索服務器之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持服務器之家！

原文鏈接：https://blog.csdn.net/qq1808814025/article/details/115294105