使用poi寫excel，資料量超過幾萬時可能會記憶體溢位。可以參考下面的2篇文章來解決。

https://blog.csdn.net/daiyutage/article/details/53010491?utm_source=blogxgwz9

　　poi官網給了一種大批量資料寫入的方法。

使用SXXFWorkbook 類進行大批量寫入操作解決了這個問題。

import junit.framework.Assert;
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.ss.util.CellReference;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
 
    public static void main(String[] args) throws Throwable {
        SXSSFWorkbook wb = new SXSSFWorkbook(100); // keep 100 rows in memory, exceeding rows will be flushed to disk
 

        Sheet sh = wb.createSheet();
        for(int rownum = 0; rownum < 1000; rownum++){
            Row row = sh.createRow(rownum);
            for(int cellnum = 0; cellnum < 10; cellnum++){
                Cell cell = row.createCell(cellnum);
                String address = new CellReference(cell).formatAsString();
                cell.setCellValue(address);
            }
 
        }
 
        
 
// Rows with rownum < 900 are flushed and not accessible
        for(int rownum = 0; rownum < 900; rownum++){
          Assert.assertNull(sh.getRow(rownum));
        }
 
        // ther last 100 rows are still in memory
        for(int rownum = 900; rownum < 1000; rownum++){
            Assert.assertNotNull(sh.getRow(rownum));
        }
        
        FileOutputStream out = new FileOutputStream("/temp/sxssf.xlsx");
        wb.write(out);
        out.close();
 
        // dispose of temporary files backing this workbook on disk
        wb.dispose();
    }

　　通過設定SXXFWorkbook的構造引數，可以設定每次在記憶體中保持的行數，當達到這個值的時候，那麼會把這些資料flush到磁碟上，這樣就不會出現記憶體不夠的情況。

https://www.cnblogs.com/swordfall/p/8298386.html

1. Excel2003與Excel2007

兩個版本的最大行數和列數不同，2003版最大行數是65536行，最大列數是256列，2007版及以後的版本最大行數是1048576行，最大列數是16384列。

excel2003是以二進位制的方式儲存，這種格式不易被其他軟體讀取使用；而excel2007採用了基於XML的ooxml開放文件標準，ooxml使用XML和ZIP技術結合進行檔案儲存，XML是一個基於文字的格式，而且ZIP容器支援內容的壓縮，所以其一大優勢是可以大大減小檔案的尺寸。

2. 大批量資料讀寫

2.1 大批量資料寫入

對於大資料的Xlsx檔案的寫入，POI3.8提供了SXSSFSXSSFWorkbook類，採用快取方式進行大批量寫檔案。

詳情可以檢視poi官網示例：http://poi.apache.org/spreadsheet/how-to.html#sxssf或http://blog.csdn.net/daiyutage/article/details/53010491

2.2 大批量資料讀取

POI讀取Excel有兩種模式，一種是使用者模式，一種是SAX事件驅動模式，將xlsx格式的文件轉換成CSV格式後進行讀取。使用者模式API介面豐富，使用POI的API可以很容易讀取Excel，但使用者模式消耗的記憶體很大，當遇到很大sheet、大資料網格，假空行、公式等問題時，很容易導致記憶體溢位。POI官方推薦解決記憶體溢位的方式使用CVS格式解析，即SAX事件驅動模式。下面主要是講解如何讀取大批量資料：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>POIExcel</groupId>
  <artifactId>POIExcel</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>POIExcel Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.apache.poi</groupId>
      <artifactId>poi</artifactId>
      <version>3.17</version>
    </dependency>

    <dependency>
      <groupId>org.apache.poi</groupId>
      <artifactId>poi-ooxml</artifactId>
      <version>3.17</version>
    </dependency>

    <dependency>
      <groupId>org.apache.poi</groupId>
      <artifactId>poi-ooxml-schemas</artifactId>
      <version>3.17</version>
    </dependency>

    <dependency>
      <groupId>com.syncthemall</groupId>
      <artifactId>boilerpipe</artifactId>
      <version>1.2.1</version>
    </dependency>

    <dependency>
      <groupId>xerces</groupId>
      <artifactId>xercesImpl</artifactId>
      <version>2.11.0</version>
    </dependency>

    <dependency>
      <groupId>xml-apis</groupId>
      <artifactId>xml-apis</artifactId>
      <version>1.4.01</version>
    </dependency>

    <dependency>
      <groupId>org.apache.xmlbeans</groupId>
      <artifactId>xmlbeans</artifactId>
      <version>2.6.0</version>
    </dependency>

    <dependency>
      <groupId>sax</groupId>
      <artifactId>sax</artifactId>
      <version>2.0.1</version>
    </dependency>

    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>3.7</version>
    </dependency>

  </dependencies>
  <build>
    <finalName>POIExcel</finalName>
  </build>
</project>

2.2.2 POI以SAX解析excel2007檔案

解決思路：通過繼承DefaultHandler類，重寫process()，startElement()，characters()，endElement()這四個方法。process()方式主要是遍歷所有的sheet，並依次呼叫startElement()、characters()方法、endElement()這三個方法。startElement()用於設定單元格的數字型別（如日期、數字、字串等等）。characters()用於獲取該單元格對應的索引值或是內容值（如果單元格型別是字串、INLINESTR、數字、日期則獲取的是索引值；其他如布林值、錯誤、公式則獲取的是內容值）。endElement()根據startElement()的單元格數字型別和characters()的索引值或內容值，最終得出單元格的內容值，並打印出來。

1 package org.poi;
  2 
  3 import org.apache.poi.openxml4j.opc.OPCPackage;
  4 import org.apache.poi.ss.usermodel.BuiltinFormats;
  5 import org.apache.poi.ss.usermodel.DataFormatter;
  6 import org.apache.poi.xssf.eventusermodel.XSSFReader;
  7 import org.apache.poi.xssf.model.SharedStringsTable;
  8 import org.apache.poi.xssf.model.StylesTable;
  9 import org.apache.poi.xssf.usermodel.XSSFCellStyle;
 10 import org.apache.poi.xssf.usermodel.XSSFRichTextString;
 11 import org.xml.sax.Attributes;
 12 import org.xml.sax.InputSource;
 13 import org.xml.sax.SAXException;
 14 import org.xml.sax.XMLReader;
 15 import org.xml.sax.helpers.DefaultHandler;
 16 import org.xml.sax.helpers.XMLReaderFactory;
 17 
 18 import java.io.InputStream;
 19 import java.util.ArrayList;
 20 import java.util.List;
 21 
 22 /**
 23  * @author y
 24  * @create 2018-01-18 14:28
 25  * @desc POI讀取excel有兩種模式，一種是使用者模式，一種是事件驅動模式
 26  * 採用SAX事件驅動模式解決XLSX檔案，可以有效解決使用者模式記憶體溢位的問題，
 27  * 該模式是POI官方推薦的讀取大資料的模式，
 28  * 在使用者模式下，資料量較大，Sheet較多，或者是有很多無用的空行的情況下，容易出現記憶體溢位
 29  * <p>
 30  * 用於解決.xlsx2007版本大資料量問題
 31  **/
 32 public class ExcelXlsxReader extends DefaultHandler {
 33 
 34     /**
 35      * 單元格中的資料可能的資料型別
 36      */
 37     enum CellDataType {
 38         BOOL, ERROR, FORMULA, INLINESTR, SSTINDEX, NUMBER, DATE, NULL
 39     }
 40 
 41     /**
 42      * 共享字串表
 43      */
 44     private SharedStringsTable sst;
 45 
 46     /**
 47      * 上一次的索引值
 48      */
 49     private String lastIndex;
 50 
 51     /**
 52      * 檔案的絕對路徑
 53      */
 54     private String filePath = "";
 55 
 56     /**
 57      * 工作表索引
 58      */
 59     private int sheetIndex = 0;
 60 
 61     /**
 62      * sheet名
 63      */
 64     private String sheetName = "";
 65 
 66     /**
 67      * 總行數
 68      */
 69     private int totalRows=0;
 70 
 71     /**
 72      * 一行內cell集合
 73      */
 74     private List<String> cellList = new ArrayList<String>();
 75 
 76     /**
 77      * 判斷整行是否為空行的標記
 78      */
 79     private boolean flag = false;
 80 
 81     /**
 82      * 當前行
 83      */
 84     private int curRow = 1;
 85 
 86     /**
 87      * 當前列
 88      */
 89     private int curCol = 0;
 90 
 91     /**
 92      * T元素標識
 93      */
 94     private boolean isTElement;
 95 
 96     /**
 97      * 判斷上一單元格是否為文字空單元格
 98      */
 99     private boolean startElementFlag = true;
100     private boolean endElementFlag = false;
101     private boolean charactersFlag = false;
102 
103     /**
104      * 異常資訊，如果為空則表示沒有異常
105      */
106     private String exceptionMessage;
107 
108     /**
109      * 單元格資料型別，預設為字串型別
110      */
111     private CellDataType nextDataType = CellDataType.SSTINDEX;
112 
113     private final DataFormatter formatter = new DataFormatter();
114 
115     /**
116      * 單元格日期格式的索引
117      */
118     private short formatIndex;
119 
120     /**
121      * 日期格式字串
122      */
123     private String formatString;
124 
125     //定義前一個元素和當前元素的位置，用來計算其中空的單元格數量，如A6和A8等
126     private String prePreRef = "A", preRef = null, ref = null;
127 
128     //定義該文件一行最大的單元格數，用來補全一行最後可能缺失的單元格
129     private String maxRef = null;
130 
131     /**
132      * 單元格
133      */
134     private StylesTable stylesTable;
135 
136     /**
137      * 遍歷工作簿中所有的電子表格
138      * 並快取在mySheetList中
139      *
140      * @param filename
141      * @throws Exception
142      */
143     public int process(String filename) throws Exception {
144         filePath = filename;
145         OPCPackage pkg = OPCPackage.open(filename);
146         XSSFReader xssfReader = new XSSFReader(pkg);
147         stylesTable = xssfReader.getStylesTable();
148         SharedStringsTable sst = xssfReader.getSharedStringsTable();
149         XMLReader parser = XMLReaderFactory.createXMLReader("org.apache.xerces.parsers.SAXParser");
150         this.sst = sst;
151         parser.setContentHandler(this);
152         XSSFReader.SheetIterator sheets = (XSSFReader.SheetIterator) xssfReader.getSheetsData();
153         while (sheets.hasNext()) { //遍歷sheet
154             curRow = 1; //標記初始行為第一行
155             sheetIndex++;
156             InputStream sheet = sheets.next(); //sheets.next()和sheets.getSheetName()不能換位置，否則sheetName報錯
157             sheetName = sheets.getSheetName();
158             InputSource sheetSource = new InputSource(sheet);
159             parser.parse(sheetSource); //解析excel的每條記錄，在這個過程中startElement()、characters()、endElement()這三個函式會依次執行
160             sheet.close();
161         }
162         return totalRows; //返回該excel檔案的總行數，不包括首列和空行
163     }
164 
165     /**
166      * 第一個執行
167      *
168      * @param uri
169      * @param localName
170      * @param name
171      * @param attributes
172      * @throws SAXException
173      */
174     @Override
175     public void startElement(String uri, String localName, String name, Attributes attributes) throws SAXException {
176         //c => 單元格
177         if ("c".equals(name)) {
178 
179             //前一個單元格的位置
180             if (preRef == null) {
181                 preRef = attributes.getValue("r");
182 
183             } else {
184                 //中部文字空單元格標識 ‘endElementFlag’ 判斷前一次是否為文字空字串，true則表明不是文字空字串，false表明是文字空字串跳過把空字串的位置賦予preRef
185                 if (endElementFlag){
186                     preRef = ref;
187                 }
188             }
189 
190             //當前單元格的位置
191             ref = attributes.getValue("r");
192             //首部文字空單元格標識 ‘startElementFlag’ 判斷前一次，即首部是否為文字空字串，true則表明不是文字空字串，false表明是文字空字串, 且已知當前格，即第二格帶“B”標誌，則ref賦予preRef
193             if (!startElementFlag && !flag){ //上一個單元格為文字空單元格，執行下面的，使ref=preRef；flag為true表明該單元格之前有資料值，即該單元格不是首部空單元格，則跳過
194                 // 這裡只有上一個單元格為文字空單元格，且之前的幾個單元格都沒有值才會執行
195                 preRef = ref;
196             }
197 
198             //設定單元格型別
199             this.setNextDataType(attributes);
200             endElementFlag = false;
201             charactersFlag = false;
202             startElementFlag = false;
203         }
204 
205         //當元素為t時
206         if ("t".equals(name)) {
207             isTElement = true;
208         } else {
209             isTElement = false;
210         }
211 
212         //置空
213         lastIndex = "";
214     }
215 
216 
217 
218     /**
219      * 第二個執行
220      * 得到單元格對應的索引值或是內容值
221      * 如果單元格型別是字串、INLINESTR、數字、日期，lastIndex則是索引值
222      * 如果單元格型別是布林值、錯誤、公式，lastIndex則是內容值
223      * @param ch
224      * @param start
225      * @param length
226      * @throws SAXException
227      */
228     @Override
229     public void characters(char[] ch, int start, int length) throws SAXException {
230         startElementFlag = true;
231         charactersFlag = true;
232         lastIndex += new String(ch, start, length);
233     }
234 
235     /**
236      * 第三個執行
237      *
238      * @param uri
239      * @param localName
240      * @param name
241      * @throws SAXException
242      */
243     @Override
244     public void endElement(String uri, String localName, String name) throws SAXException {
245         //t元素也包含字串
246         if (isTElement) {//這個程式沒經過
247             //將單元格內容加入rowlist中，在這之前先去掉字串前後的空白符
248             String value = lastIndex.trim();
249             cellList.add(curCol, value);
250             endElementFlag = true;
251             curCol++;
252             isTElement = false;
253             //如果裡面某個單元格含有值，則標識該行不為空行
254             if (value != null && !"".equals(value)) {
255                 flag = true;
256             }
257         } else if ("v".equals(name)) {
258             //v => 單元格的值，如果單元格是字串，則v標籤的值為該字串在SST中的索引
259             String value = this.getDataValue(lastIndex.trim(), "");//根據索引值獲取對應的單元格值
260 
261             //補全單元格之間的空單元格
262             if (!ref.equals(preRef)) {
263                 int len = countNullCell(ref, preRef);
264                 for (int i = 0; i < len; i++) {
265                     cellList.add(curCol, "");
266                     curCol++;
267                 }
268             } else if (ref.equals(preRef) && !ref.startWith("A")){ //ref等於preRef，且以B或者C...開頭，表明首部為空格271                 int len = countNullCell(ref, "A");
272                 for (int i = 0; i <= len; i++) {
273                     cellList.add(curCol, "");
274                     curCol++;
275                 }
276             }
277             cellList.add(curCol, value);
278             curCol++;
279             endElementFlag = true;
280             //如果裡面某個單元格含有值，則標識該行不為空行
281             if (value != null && !"".equals(value)) {
282                 flag = true;
283             }
284         } else {
285             //如果標籤名稱為row，這說明已到行尾，呼叫optRows()方法
286             if ("row".equals(name)) {
287                 //預設第一行為表頭，以該行單元格數目為最大數目
288                 if (curRow == 1) {
289                     maxRef = ref;
290                 }
291                 //補全一行尾部可能缺失的單元格
292                 if (maxRef != null) {
293                     int len = -1;
294                     //前一單元格，true則不是文字空字串，false則是文字空字串
295                     if (charactersFlag){
296                         len = countNullCell(maxRef, ref);
297                     }else {
298                         len = countNullCell(maxRef, preRef);
299                     }
300                     for (int i = 0; i <= len; i++) {
301                         cellList.add(curCol, "");
302                         curCol++;
303                     }
304                 }
305 
306                 if (flag&&curRow!=1){ //該行不為空行且該行不是第一行，則傳送（第一行為列名，不需要）
307                     ExcelReaderUtil.sendRows(filePath, sheetName, sheetIndex, curRow, cellList);
308                     totalRows++;
309                 }
310 
311                 cellList.clear();
312                 curRow++;
313                 curCol = 0;
314                 preRef = null;
315                 prePreRef = null;
316                 ref = null;
317                 flag=false;
318             }
319         }
320     }
321 
322     /**
323      * 處理資料型別
324      *
325      * @param attributes
326      */
327     public void setNextDataType(Attributes attributes) {
328         nextDataType = CellDataType.NUMBER; //cellType為空，則表示該單元格型別為數字
329         formatIndex = -1;
330         formatString = null;
331         String cellType = attributes.getValue("t"); //單元格型別
332         String cellStyleStr = attributes.getValue("s"); //
333         String columnData = attributes.getValue("r"); //獲取單元格的位置，如A1,B1
334 
335         if ("b".equals(cellType)) { //處理布林值
336             nextDataType = CellDataType.BOOL;
337         } else if ("e".equals(cellType)) {  //處理錯誤
338             nextDataType = CellDataType.ERROR;
339         } else if ("inlineStr".equals(cellType)) {
340             nextDataType = CellDataType.INLINESTR;
341         } else if ("s".equals(cellType)) { //處理字串
342             nextDataType = CellDataType.SSTINDEX;
343         } else if ("str".equals(cellType)) {
344             nextDataType = CellDataType.FORMULA;
345         }
346 
347         if (cellStyleStr != null) { //處理日期
348             int styleIndex = Integer.parseInt(cellStyleStr);
349             XSSFCellStyle style = stylesTable.getStyleAt(styleIndex);
350             formatIndex = style.getDataFormat();
351             formatString = style.getDataFormatString();
352             if (formatString.contains("m/d/yyyy") || formatString.contains("yyyy/mm/dd")|| formatString.contains("yyyy/m/d") ) {
353                 nextDataType = CellDataType.DATE;
354                 formatString = "yyyy-MM-dd hh:mm:ss";
355             }
356 
357             if (formatString == null) {
358                 nextDataType = CellDataType.NULL;
359                 formatString = BuiltinFormats.getBuiltinFormat(formatIndex);
360             }
361         }
362     }
363 
364     /**
365      * 對解析出來的資料進行型別處理
366      * @param value   單元格的值，
367      *                value代表解析：BOOL的為0或1， ERROR的為內容值，FORMULA的為內容值，INLINESTR的為索引值需轉換為內容值，
368      *                SSTINDEX的為索引值需轉換為內容值， NUMBER為內容值，DATE為內容值
369      * @param thisStr 一個空字串
370      * @return
371      */
372     @SuppressWarnings("deprecation")
373     public String getDataValue(String value, String thisStr) {
374         switch (nextDataType) {
375             // 這幾個的順序不能隨便交換，交換了很可能會導致資料錯誤
376             case BOOL: //布林值
377                 char first = value.charAt(0);
378                 thisStr = first == '0' ? "FALSE" : "TRUE";
379                 break;
380             case ERROR: //錯誤
381                 thisStr = "\"ERROR:" + value.toString() + '"';
382                 break;
383             case FORMULA: //公式
384                 thisStr = '"' + value.toString() + '"';
385                 break;
386             case INLINESTR:
387                 XSSFRichTextString rtsi = new XSSFRichTextString(value.toString());
388                 thisStr = rtsi.toString();
389                 rtsi = null;
390                 break;
391             case SSTINDEX: //字串
392                 String sstIndex = value.toString();
393                 try {
394                     int idx = Integer.parseInt(sstIndex);
395                     XSSFRichTextString rtss = new XSSFRichTextString(sst.getEntryAt(idx));//根據idx索引值獲取內容值
396                     thisStr = rtss.toString();
397                     System.out.println(thisStr);
398                     //有些字串是文字格式的，但內容卻是日期
399 
400                     rtss = null;
401                 } catch (NumberFormatException ex) {
402                     thisStr = value.toString();
403                 }
404                 break;
405             case NUMBER: //數字
406                 if (formatString != null) {
407                     thisStr = formatter.formatRawCellContents(Double.parseDouble(value), formatIndex, formatString).trim();
408                 } else {
409                     thisStr = value;
410                 }
411                 thisStr = thisStr.replace("_", "").trim();
412                 break;
413             case DATE: //日期
414                 thisStr = formatter.formatRawCellContents(Double.parseDouble(value), formatIndex, formatString);
415                 // 對日期字串作特殊處理，去掉T
416                 thisStr = thisStr.replace("T", " ");
417                 break;
418             default:
419                 thisStr = " ";
420                 break;
421         }
422         return thisStr;
423     }
424 
425     public int countNullCell(String ref, String preRef) {
426         //excel2007最大行數是1048576，最大列數是16384，最後一列列名是XFD
427         String xfd = ref.replaceAll("\\d+", "");
428         String xfd_1 = preRef.replaceAll("\\d+", "");
429 
430         xfd = fillChar(xfd, 3, '@', true);
431         xfd_1 = fillChar(xfd_1, 3, '@', true);
432 
433         char[] letter = xfd.toCharArray();
434         char[] letter_1 = xfd_1.toCharArray();
435         int res = (letter[0] - letter_1[0]) * 26 * 26 + (letter[1] - letter_1[1]) * 26 + (letter[2] - letter_1[2]);
436         return res - 1;
437     }
438 
439     public String fillChar(String str, int len, char let, boolean isPre) {
440         int len_1 = str.length();
441         if (len_1 < len) {
442             if (isPre) {
443                 for (int i = 0; i < (len - len_1); i++) {
444                     str = let + str;
445                 }
446             } else {
447                 for (int i = 0; i < (len - len_1); i++) {
448                     str = str + let;
449                 }
450             }
451         }
452         return str;
453     }
454 
455     /**
456      * @return the exceptionMessage
457      */
458     public String getExceptionMessage() {
459         return exceptionMessage;
460     }
461 }

2.2.3 POI通過繼承HSSFListener類來解決Excel2003檔案

解決思路：重寫process()，processRecord()兩個方法，其中processRecord是核心方法，用於處理sheetName和各種單元格數字型別。

package org.poi;

import org.apache.poi.hssf.eventusermodel.*;
import org.apache.poi.hssf.eventusermodel.dummyrecord.LastCellOfRowDummyRecord;
import org.apache.poi.hssf.eventusermodel.dummyrecord.MissingCellDummyRecord;
import org.apache.poi.hssf.model.HSSFFormulaParser;
import org.apache.poi.hssf.record.*;
import org.apache.poi.hssf.usermodel.HSSFDataFormatter;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

import java.io.FileInputStream;
import java.util.ArrayList;
import java.util.List;

/**
 * @author y
 * @create 2018-01-19 14:18
 * @desc 用於解決.xls2003版本大資料量問題
 **/
public class ExcelXlsReader implements HSSFListener {

    private int minColums = -1;

    private POIFSFileSystem fs;

    /**
     * 總行數
     */
    private int totalRows=0;

    /**
     * 上一行row的序號
     */
    private int lastRowNumber;

    /**
     * 上一單元格的序號
     */
    private int lastColumnNumber;

    /**
     * 是否輸出formula，還是它對應的值
     */
    private boolean outputFormulaValues = true;

    /**
     * 用於轉換formulas
     */
    private EventWorkbookBuilder.SheetRecordCollectingListener workbookBuildingListener;

    //excel2003工作簿
    private HSSFWorkbook stubWorkbook;

    private SSTRecord sstRecord;

    private FormatTrackingHSSFListener formatListener;

    private final HSSFDataFormatter formatter = new HSSFDataFormatter();

    /**
     * 檔案的絕對路徑
     */
    private String filePath = "";

    //表索引
    private int sheetIndex = 0;

    private BoundSheetRecord[] orderedBSRs;

    @SuppressWarnings("unchecked")
    private ArrayList boundSheetRecords = new ArrayList();

    private int nextRow;

    private int nextColumn;

    private boolean outputNextStringRecord;

    //當前行
    private int curRow = 0;

    //儲存一行記錄所有單元格的容器
    private List<String> cellList = new ArrayList<String>();

    /**
     * 判斷整行是否為空行的標記
     */
    private boolean flag = false;

    @SuppressWarnings("unused")
    private String sheetName;

    /**
     * 遍歷excel下所有的sheet
     *
     * @param fileName
     * @throws Exception
     */
    public int process(String fileName) throws Exception {
        filePath = fileName;
        this.fs = new POIFSFileSystem(new FileInputStream(fileName));
        MissingRecordAwareHSSFListener listener = new MissingRecordAwareHSSFListener(this);
        formatListener = new FormatTrackingHSSFListener(listener);
        HSSFEventFactory factory = new HSSFEventFactory();
        HSSFRequest request = new HSSFRequest();
        if (outputFormulaValues) {
            request.addListenerForAllRecords(formatListener);
        } else {
            workbookBuildingListener = new EventWorkbookBuilder.SheetRecordCollectingListener(formatListener);
            request.addListenerForAllRecords(workbookBuildingListener);
        }
        factory.processWorkbookEvents(request, fs);

        return totalRows; //返回該excel檔案的總行數，不包括首列和空行
    }

    /**
     * HSSFListener 監聽方法，處理Record
     * 處理每個單元格
     * @param record
     */
    @SuppressWarnings("unchecked")
    public void processRecord(Record record) {
        int thisRow = -1;
        int thisColumn = -1;
        String thisStr = null;
        String value = null;
        switch (record.getSid()) {
            case BoundSheetRecord.sid:
                boundSheetRecords.add(record);
                break;
            case BOFRecord.sid: //開始處理每個sheet
                BOFRecord br = (BOFRecord) record;
                if (br.getType() == BOFRecord.TYPE_WORKSHEET) {
                    //如果有需要，則建立子工作簿
                    if (workbookBuildingListener != null && stubWorkbook == null) {
                        stubWorkbook = workbookBuildingListener.getStubHSSFWorkbook();
                    }

                    if (orderedBSRs == null) {
                        orderedBSRs = BoundSheetRecord.orderByBofPosition(boundSheetRecords);
                    }
                    sheetName = orderedBSRs[sheetIndex].getSheetname();
                    sheetIndex++;
                }
                break;
            case SSTRecord.sid:
                sstRecord = (SSTRecord) record;
                break;
            case BlankRecord.sid: //單元格為空白
                BlankRecord brec = (BlankRecord) record;
                thisRow = brec.getRow();
                thisColumn = brec.getColumn();
                thisStr = "";
                cellList.add(thisColumn, thisStr);
                break;
            case BoolErrRecord.sid: //單元格為布林型別
                BoolErrRecord berec = (BoolErrRecord) record;
                thisRow = berec.getRow();
                thisColumn = berec.getColumn();
                thisStr = berec.getBooleanValue() + "";
                cellList.add(thisColumn, thisStr);
                checkRowIsNull(thisStr);  //如果裡面某個單元格含有值，則標識該行不為空行
                break;
            case FormulaRecord.sid://單元格為公式型別
                FormulaRecord frec = (FormulaRecord) record;
                thisRow = frec.getRow();
                thisColumn = frec.getColumn();
                if (outputFormulaValues) {
                    if (Double.isNaN(frec.getValue())) {
                        outputNextStringRecord = true;
                        nextRow = frec.getRow();
                        nextColumn = frec.getColumn();
                    } else {
                        thisStr = '"' + HSSFFormulaParser.toFormulaString(stubWorkbook, frec.getParsedExpression()) + '"';
                    }
                } else {
                    thisStr = '"' + HSSFFormulaParser.toFormulaString(stubWorkbook, frec.getParsedExpression()) + '"';
                }
                cellList.add(thisColumn, thisStr);
                checkRowIsNull(thisStr);  //如果裡面某個單元格含有值，則標識該行不為空行
                break;
            case StringRecord.sid: //單元格中公式的字串
                if (outputNextStringRecord) {
                    StringRecord srec = (StringRecord) record;
                    thisStr = srec.getString();
                    thisRow = nextRow;
                    thisColumn = nextColumn;
                    outputNextStringRecord = false;
                }
                break;
            case LabelRecord.sid:
                LabelRecord lrec = (LabelRecord) record;
                curRow = thisRow = lrec.getRow();
                thisColumn = lrec.getColumn();
                value = lrec.getValue().trim();
                value = value.equals("") ? "" : value;
                cellList.add(thisColumn, value);
                checkRowIsNull(value);  //如果裡面某個單元格含有值，則標識該行不為空行
                break;
            case LabelSSTRecord.sid: //單元格為字串型別
                LabelSSTRecord lsrec = (LabelSSTRecord) record;
                curRow = thisRow = lsrec.getRow();
                thisColumn = lsrec.getColumn();
                if (sstRecord == null) {
                    cellList.add(thisColumn, "");
                } else {
                    value = sstRecord.getString(lsrec.getSSTIndex()).toString().trim();
                    value = value.equals("") ? "" : value;
                    cellList.add(thisColumn, value);
                    checkRowIsNull(value);  //如果裡面某個單元格含有值，則標識該行不為空行
                }
                break;
            case NumberRecord.sid: //單元格為數字型別
                NumberRecord numrec = (NumberRecord) record;
                curRow = thisRow = numrec.getRow();
                thisColumn = numrec.getColumn();

                //第一種方式
                //value = formatListener.formatNumberDateCell(numrec).trim();//這個被寫死，採用的m/d/yy h:mm格式，不符合要求

                //第二種方式，參照formatNumberDateCell裡面的實現方法編寫
                Double valueDouble=((NumberRecord)numrec).getValue();
                String formatString=formatListener.getFormatString(numrec);
                if (formatString.contains("m/d/yy")){
                    formatString="yyyy-MM-dd hh:mm:ss";
                }
                int formatIndex=formatListener.getFormatIndex(numrec);
                value=formatter.formatRawCellContents(valueDouble, formatIndex, formatString).trim();

                value = value.equals("") ? "" : value;
                //向容器加入列值
                cellList.add(thisColumn, value);
                checkRowIsNull(value);  //如果裡面某個單元格含有值，則標識該行不為空行
                break;
            default:
                break;
        }

        //遇到新行的操作
        if (thisRow != -1 && thisRow != lastRowNumber) {
            lastColumnNumber = -1;
        }

        //空值的操作
        if (record instanceof MissingCellDummyRecord) {
            MissingCellDummyRecord mc = (MissingCellDummyRecord) record;
            curRow = thisRow = mc.getRow();
            thisColumn = mc.getColumn();
            cellList.add(thisColumn, "");
        }

        //更新行和列的值
        if (thisRow > -1)
            lastRowNumber = thisRow;
        if (thisColumn > -1)
            lastColumnNumber = thisColumn;

        //行結束時的操作
        if (record instanceof LastCellOfRowDummyRecord) {
            if (minColums > 0) {
                //列值重新置空
                if (lastColumnNumber == -1) {
                    lastColumnNumber = 0;
                }
            }
            lastColumnNumber = -1;

            if (flag&&curRow!=0) { //該行不為空行且該行不是第一行，傳送（第一行為列名，不需要）
                ExcelReaderUtil.sendRows(filePath, sheetName, sheetIndex, curRow + 1, cellList); //每行結束時，呼叫sendRows()方法
                totalRows++;
            }
            //清空容器
            cellList.clear();
            flag=false;
        }
    }

    /**
     * 如果裡面某個單元格含有值，則標識該行不為空行
     * @param value
     */
    public void checkRowIsNull(String value){
        if (value != null && !"".equals(value)) {
            flag = true;
        }
    }
}

2.2.4 輔助類ExcelReaderUtil

呼叫ExcelXlsReader類和ExcelXlsxReader類對excel2003和excel2007兩個版本進行大批量資料讀取：

package org.poi;

import java.util.List;

/**
 * @author y
 * @create 2018-01-19 0:13
 * @desc
 **/
public class ExcelReaderUtil {
    //excel2003副檔名
    public static final String EXCEL03_EXTENSION = ".xls";
    //excel2007副檔名
    public static final String EXCEL07_EXTENSION = ".xlsx";

    /**
     * 每獲取一條記錄，即列印
     * 在flume裡每獲取一條記錄即傳送，而不必快取起來，可以大大減少記憶體的消耗，這裡主要是針對flume讀取大資料量excel來說的
     * @param sheetName
     * @param sheetIndex
     * @param curRow
     * @param cellList
     */
    public static void sendRows(String filePath, String sheetName, int sheetIndex, int curRow, List<String> cellList) {
            StringBuffer oneLineSb = new StringBuffer();
            oneLineSb.append(filePath);
            oneLineSb.append("--");
            oneLineSb.append("sheet" + sheetIndex);
            oneLineSb.append("::" + sheetName);//加上sheet名
            oneLineSb.append("--");
            oneLineSb.append("row" + curRow);
            oneLineSb.append("::");
            for (String cell : cellList) {
                oneLineSb.append(cell.trim());
                oneLineSb.append("|");
            }
            String oneLine = oneLineSb.toString();
            if (oneLine.endsWith("|")) {
                oneLine = oneLine.substring(0, oneLine.lastIndexOf("|"));
            }// 去除最後一個分隔符

            System.out.println(oneLine);
    }

    public static void readExcel(String fileName) throws Exception {
        int totalRows =0;
        if (fileName.endsWith(EXCEL03_EXTENSION)) { //處理excel2003檔案
            ExcelXlsReader excelXls=new ExcelXlsReader();
            totalRows =excelXls.process(fileName);
        } else if (fileName.endsWith(EXCEL07_EXTENSION)) {//處理excel2007檔案
            ExcelXlsxReader excelXlsxReader = new ExcelXlsxReader();
            totalRows = excelXlsxReader.process(fileName);
        } else {
            throw new Exception("檔案格式錯誤，fileName的副檔名只能是xls或xlsx。");
        }
        System.out.println("傳送的總行數：" + totalRows);
    }

    public static void main(String[] args) throws Exception {
        String path="C:\\Users\\y****\\Desktop\\TestSample\\H_20171226_***_*****_0430.xlsx";
        ExcelReaderUtil.readExcel(path);
    }
}

github地址：

https://github.com/SwordfallYeung/POIExcel