POI 读取Excel文档中的数据——兼容Excel2003和Excel2007

 1 /*
 2  * IExcelParse.java
 3  * 
 4  * 2016-1-6 下午4:45:53
 5  * 
 6  * RecluseKapoor
 7  *  
 8  * Copyright © 2016, RecluseKapoor. All rights reserved.
 9  * 
10  */
11 package com.rk.pub.poi.excel;
12 
13 /**
14  * @Title: recluse-Excel文件解析接口
15  * 
16  * @Description:Excel文件解析接口，所有版本的Excel解析类都要实现该接口
17  * 
18  * @Company: 卡普工作室
19  * 
20  * @Website: http://www.cnblogs.com/reclusekapoor/
21  * 
22  * @author: RecluseKapoor
23  * 
24  * @CreateDate：2016-1-6 下午9:42:08
25  * 
26  * @version: 1.0
27  * 
28  * @lastModify:
29  * 
30  */
31 public interface IExcelParse {
32     public void loadExcel(String path) throws Exception;
33 
34     public String getSheetName(int sheetNo);
35 
36     public int getSheetCount() throws Exception;
37 
38     public int getRowCount(int sheetNo);
39 
40     public int getRealRowCount(int sheetNo);
41 
42     public String readExcelByRowAndCell(int sheetNo, int rowNo, int cellNo)
43             throws Exception;
44 
45     public String[] readExcelByRow(int sheetNo, int rowNo) throws Exception;
46 
47     public String[] readExcelByCell(int sheetNo, int cellNo) throws Exception;
48 
49     public void close();
50 }

  1 /*
  2  * ExcelParse2003.java
  3  * 
  4  * 2016-1-6 下午4:45:53
  5  * 
  6  * RecluseKapoor
  7  *  
  8  * Copyright © 2016, RecluseKapoor. All rights reserved.
  9  * 
 10  */
 11 package com.rk.pub.poi.excel;
 12 
 13 import java.io.FileInputStream;
 14 import java.io.FileNotFoundException;
 15 import java.io.IOException;
 16 import java.sql.Timestamp;
 17 import java.text.DecimalFormat;
 18 import java.util.Date;
 19 
 20 import org.apache.poi.hssf.usermodel.HSSFCell;
 21 import org.apache.poi.hssf.usermodel.HSSFDateUtil;
 22 import org.apache.poi.hssf.usermodel.HSSFRow;
 23 import org.apache.poi.hssf.usermodel.HSSFSheet;
 24 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 25 import org.apache.poi.poifs.filesystem.POIFSFileSystem;
 26 
 27 /**
 28  * @Title: recluse--2003版Excel文件解析工具
 29  * 
 30  * @Description: 解析2003版Excel文件具体实现类
 31  * 
 32  * @Company: 卡普工作室
 33  * 
 34  * @Website: http://www.cnblogs.com/reclusekapoor/
 35  * 
 36  * @author: RecluseKapoor
 37  * 
 38  * @CreateDate：2016-1-6 下午9:59:51
 39  * 
 40  * @version: 1.0
 41  * 
 42  * @lastModify:
 43  * 
 44  */
 45 public class ExcelParse2003 implements IExcelParse {
 46     // Excel工作区
 47     private HSSFWorkbook wb = null;
 48 
 49     /**
 50      * 加载excel文件，获取excel工作区
 51      * 
 52      * @param filePathAndName
 53      * @throws FileNotFoundException
 54      * @throws IOException
 55      */
 56     @Override
 57     public void loadExcel(String filePathAndName) throws FileNotFoundException,
 58             IOException {
 59         FileInputStream fis = null;
 60         POIFSFileSystem fs = null;
 61         try {
 62             fis = new FileInputStream(filePathAndName);
 63             fs = new POIFSFileSystem(fis);
 64             wb = new HSSFWorkbook(fs);
 65         } catch (FileNotFoundException e) {
 66             e.printStackTrace();
 67             throw new FileNotFoundException("加载Excel文件失败：" + e.getMessage());
 68         } catch (IOException e) {
 69             e.printStackTrace();
 70             throw new IOException("加载Excel文件失败：" + e.getMessage());
 71         } finally {
 72             if (fis != null) {
 73                 fis.close();
 74                 fis = null;
 75             }
 76             if (fs != null) {
 77                 fs.close();
 78             }
 79         }
 80     }
 81 
 82     /**
 83      * 获取sheet页名称
 84      * 
 85      * @param sheetNo
 86      * @return
 87      */
 88     public String getSheetName(int sheetNo) {
 89         return wb.getSheetName(sheetNo - 1);
 90     }
 91 
 92     /**
 93      * 获取sheet页数
 94      * 
 95      * @return int
 96      */
 97     public int getSheetCount() throws Exception {
 98         int sheetCount = wb.getNumberOfSheets();
 99         if (sheetCount == 0) {
100             throw new Exception("Excel中没有SHEET页");
101         }
102         return sheetCount;
103     }
104 
105     /**
106      * 获取sheetNo页行数
107      * 
108      * @param sheetNo
109      * @return
110      */
111     public int getRowCount(int sheetNo) {
112         int rowCount = 0;
113         HSSFSheet sheet = wb.getSheetAt(sheetNo - 1);
114         rowCount = sheet.getLastRowNum();
115         return rowCount;
116     }
117 
118     /**
119      * 获取sheetNo页行数(含有操作或者内容的真实行数)
120      * 
121      * @param sheetNo
122      * @return
123      */
124     public int getRealRowCount(int sheetNo) {
125         int rowCount = 0;
126         int rowNum = 0;
127         HSSFSheet sheet = wb.getSheetAt(sheetNo - 1);
128         rowCount = sheet.getLastRowNum();
129         if (rowCount == 0) {
130             return rowCount;
131         }
132         HSSFRow row = null;
133         HSSFCell cell = null;
134         rowNum = rowCount;
135         for (int i = 0; i < rowCount; i++) {
136             row = sheet.getRow(rowNum);
137             rowNum--;
138             if (row == null) {
139                 continue;
140             }
141             short firstCellNum = row.getFirstCellNum();
142             short lastCellNum = row.getLastCellNum();
143             for (int j = firstCellNum; j < lastCellNum; j++) {
144                 cell = row.getCell(j);
145                 if (cell == null) {
146                     continue;
147                 } else if (cell.getCellType() == HSSFCell.CELL_TYPE_BLANK) {
148                     continue;
149                 } else if (cell.getCellType() == HSSFCell.CELL_TYPE_STRING) {
150                     String value = cell.getStringCellValue();
151                     if (value == null || value.equals("")) {
152                         continue;
153                     } else {
154                         value = value.trim();
155                         if (value.isEmpty() || value.equals("")
156                                 || value.length() == 0) {
157                             continue;
158                         }
159                     }
160                 }
161                 rowCount = rowNum + 1;
162                 return rowCount;
163             }
164         }
165         rowCount = rowNum;
166         return rowCount;
167     }
168 
169     /**
170      * 读取第sheetNo个sheet页中第rowNo行第cellNo列的数据
171      * 
172      * @param sheetNo
173      *            sheet页编号
174      * @param rowNo
175      *            行号
176      * @param cellNo
177      *            列号
178      * @return 返回相应的excel单元格内容
179      * @throws Exception
180      */
181     public String readExcelByRowAndCell(int sheetNo, int rowNo, int cellNo)
182             throws Exception {
183         String rowCellData = "";
184         sheetNo = sheetNo - 1;
185         HSSFSheet sheet = wb.getSheetAt(sheetNo);
186         String sheetName = wb.getSheetName(sheetNo);
187         try {
188             HSSFRow row = sheet.getRow(rowNo - 1);
189             if (row == null) {
190                 return "NoData";
191             }
192             HSSFCell cell = row.getCell((cellNo - 1));
193             if (cell == null) {
194                 return "NoData";
195             }
196             int cellType = cell.getCellType();
197             if (cellType == HSSFCell.CELL_TYPE_NUMERIC) {// 数值(包括excel中数值、货币、日期、时间、会计专用等单元格格式)
198                 //判断数值是否为日期或时间；但是该判断方法存在漏洞，只能识别一种日期格式。
199                 if (HSSFDateUtil.isCellDateFormatted(cell)) {//日期、时间
200                     double d = cell.getNumericCellValue();
201                     Date date = HSSFDateUtil.getJavaDate(d);
202                     Timestamp timestamp = new Timestamp(date.getTime());
203                     String temp = timestamp.toString();
204                     if (temp.endsWith("00:00:00.0")) {
205                         rowCellData = temp.substring(0,
206                                 temp.lastIndexOf("00:00:00.0"));
207                     } else if (temp.endsWith(".0")) {
208                         rowCellData = temp.substring(0, temp.lastIndexOf(".0"));
209                     } else {
210                         rowCellData = timestamp.toString();
211                     }
212                 } else {//数值、货币、会计专用、百分比、分数、科学记数 单元格式
213                     rowCellData = new DecimalFormat("0.########").format(cell
214                             .getNumericCellValue());
215                 }
216             } else if (cellType == HSSFCell.CELL_TYPE_STRING) {// 字符串
217                 rowCellData = cell.getStringCellValue();
218             } else if (cellType == HSSFCell.CELL_TYPE_FORMULA) {// 公式
219                 double d = cell.getNumericCellValue();
220                 rowCellData = String.valueOf(d);
221             } else if (cellType == HSSFCell.CELL_TYPE_BLANK) {// 空值
222                 rowCellData = "";
223             } else if (cellType == HSSFCell.CELL_TYPE_BOOLEAN) {// boolean值
224                 rowCellData = "";
225             } else if (cellType == HSSFCell.CELL_TYPE_ERROR) {// 异常
226                 rowCellData = "";
227             } else {
228 
229             }
230         } catch (Exception e) {
231             e.printStackTrace();
232             throw new Exception(sheetName + "sheet页中" + "第" + rowNo + "行" + "第"
233                     + cellNo + "列" + "数据不符合要求,请检查sheet页");
234         }
235         return rowCellData;
236     }
237 
238     /**
239      * 读取第sheetNo个sheet页中第rowNo行的数据
240      * 
241      * @param sheetNo
242      *            指定sheetNo页
243      * @param rowNo
244      *            指定rowNo行
245      * @return 返回第rowNo行的数据
246      * @throws Exception
247      */
248     public String[] readExcelByRow(int sheetNo, int rowNo) throws Exception {
249         String[] rowData = null;
250         HSSFSheet sheet = wb.getSheetAt(sheetNo - 1);
251         HSSFRow row = sheet.getRow(rowNo - 1);
252         int cellCount = row.getLastCellNum();
253         rowData = new String[cellCount];
254         for (int k = 1; k <= cellCount; k++) {
255             rowData[k - 1] = readExcelByRowAndCell(sheetNo, rowNo, k);
256         }
257         return rowData;
258     }
259 
260     /**
261      * 读取第sheetNo个sheet页中第cellNo列的数据
262      * 
263      * @param sheetNo
264      *            指定sheetNo页
265      * @param cellNo
266      *            指定cellNo列号
267      * @return 返回第cellNo列的数据
268      * @throws Exception
269      */
270     public String[] readExcelByCell(int sheetNo, int cellNo) throws Exception {
271         String[] cellData = null;
272         HSSFSheet sheet = wb.getSheetAt(sheetNo - 1);
273         int rowCount = sheet.getLastRowNum();
274         cellData = new String[rowCount + 1];
275         for (int i = 0; i <= rowCount; i++) {
276             cellData[i] = readExcelByRowAndCell(sheetNo - 1, i, cellNo - 1);
277         }
278         return cellData;
279     }
280 
281     /**
282      * 关闭excel工作区，释放资源
283      * 
284      * @throws Exception
285      */
286     @Override
287     public void close() {
288         if (wb != null) {
289             try {
290                 wb.close();
291                 wb = null;
292             } catch (IOException e) {
293                 e.printStackTrace();
294             }
295         }
296     }
297 }

  1 /*
  2  * ExcelParse2007.java
  3  * 
  4  * 2016-1-6 下午4:45:53
  5  * 
  6  * RecluseKapoor
  7  *  
  8  * Copyright © 2016, RecluseKapoor. All rights reserved.
  9  * 
 10  */
 11 package com.rk.pub.poi.excel;
 12 
 13 import java.io.FileInputStream;
 14 import java.io.FileNotFoundException;
 15 import java.io.IOException;
 16 import java.sql.Timestamp;
 17 import java.text.DecimalFormat;
 18 import java.util.Date;
 19 
 20 import org.apache.poi.ss.usermodel.DateUtil;
 21 import org.apache.poi.xssf.usermodel.XSSFCell;
 22 import org.apache.poi.xssf.usermodel.XSSFRow;
 23 import org.apache.poi.xssf.usermodel.XSSFSheet;
 24 import org.apache.poi.xssf.usermodel.XSSFWorkbook;
 25 
 26 /**
 27  * @Title: recluse--2007版Excel文件解析工具
 28  * 
 29  * @Description: 解析2007版Excel文件具体实现类
 30  * 
 31  * @Company: 卡普工作室
 32  * 
 33  * @Website: http://www.cnblogs.com/reclusekapoor/
 34  * 
 35  * @author: RecluseKapoor
 36  * 
 37  * @CreateDate：2016-1-6 下午9:51:15
 38  * 
 39  * @version: 1.0
 40  * 
 41  * @lastModify:
 42  * 
 43  */
 44 public class ExcelParse2007 implements IExcelParse {
 45     // Excel工作区
 46     private XSSFWorkbook wb = null;
 47 
 48     /**
 49      * 加载excel文件，获取excel工作区
 50      * 
 51      * @param filePathAndName
 52      * @throws FileNotFoundException
 53      * @throws IOException
 54      */
 55     public void loadExcel(String filePathAndName) throws FileNotFoundException,
 56             IOException {
 57         FileInputStream fis = null;
 58         try {
 59             fis = new FileInputStream(filePathAndName);
 60             wb = new XSSFWorkbook(fis);
 61         } catch (FileNotFoundException e) {
 62             e.printStackTrace();
 63             throw new FileNotFoundException("加载Excel文件失败：" + e.getMessage());
 64         } catch (IOException e) {
 65             e.printStackTrace();
 66             throw new IOException("加载Excel文件失败：" + e.getMessage());
 67         } finally {
 68             if (fis != null) {
 69                 fis.close();
 70                 fis = null;
 71             }
 72         }
 73     }
 74 
 75     /**
 76      * 获取sheet页名称
 77      * 
 78      * @param sheetNo
 79      * @return
 80      */
 81     public String getSheetName(int sheetNo) {
 82         return wb.getSheetName(sheetNo - 1);
 83     }
 84 
 85     /**
 86      * 获取sheet页数
 87      * 
 88      * @return int
 89      */
 90     public int getSheetCount() throws Exception {
 91         int sheetCount = wb.getNumberOfSheets();
 92         if (sheetCount == 0) {
 93             throw new Exception("Excel中没有SHEET页");
 94         }
 95         return sheetCount;
 96     }
 97 
 98     /**
 99      * 获取sheetNo页行数
100      * 
101      * @param sheetNo
102      * @return
103      */
104     public int getRowCount(int sheetNo) {
105         int rowCount = 0;
106         XSSFSheet sheet = wb.getSheetAt(sheetNo - 1);
107         rowCount = sheet.getLastRowNum();
108         return rowCount;
109     }
110 
111     /**
112      * 获取sheetNo页行数(含有操作或者内容的真实行数)
113      * 
114      * @param sheetNo
115      * @return
116      */
117     public int getRealRowCount(int sheetNo) {
118         int rowCount = 0;
119         int rowNum = 0;
120         XSSFSheet sheet = wb.getSheetAt(sheetNo - 1);
121         rowCount = sheet.getLastRowNum();
122         if (rowCount == 0) {
123             return rowCount;
124         }
125         XSSFRow row = null;
126         XSSFCell cell = null;
127         rowNum = rowCount;
128         for (int i = 0; i < rowCount; i++) {
129             row = sheet.getRow(rowNum);
130             rowNum--;
131             if (row == null) {
132                 continue;
133             }
134             short firstCellNum = row.getFirstCellNum();
135             short lastCellNum = row.getLastCellNum();
136             for (int j = firstCellNum; j < lastCellNum; j++) {
137                 cell = row.getCell(j);
138                 if (cell == null) {
139                     continue;
140                 } else if (cell.getCellType() == XSSFCell.CELL_TYPE_BLANK) {
141                     continue;
142                 } else if (cell.getCellType() == XSSFCell.CELL_TYPE_STRING) {
143                     String value = cell.getStringCellValue();
144                     if (value == null || value.equals("")) {
145                         continue;
146                     } else {
147                         value = value.trim();
148                         if (value.isEmpty() || value.equals("")
149                                 || value.length() == 0) {
150                             continue;
151                         }
152                     }
153                 }
154                 rowCount = rowNum + 1;
155                 return rowCount;
156             }
157         }
158 
159         rowCount = rowNum;
160         return rowCount;
161     }
162 
163     /**
164      * 读取第sheetNo个sheet页中第rowNo行第cellNo列的数据(通过)
165      * 
166      * @param sheetNo
167      *            sheet页编号
168      * @param rowNo
169      *            行号
170      * @param cellNo
171      *            列号
172      * @return 返回相应的excel单元格内容
173      * @throws Exception
174      */
175     public String readExcelByRowAndCell(int sheetNo, int rowNo, int cellNo)
176             throws Exception {
177         String rowCellData = "";
178         XSSFSheet sheet = wb.getSheetAt(sheetNo - 1);
179         String sheetName = wb.getSheetName(sheetNo - 1);
180         try {
181             XSSFRow row = sheet.getRow(rowNo - 1);
182             if (row == null) {
183                 return "NoData";
184             }
185             XSSFCell cell = row.getCell((short) (cellNo - 1));
186             if (cell == null) {
187                 return "NoData";
188             }
189             int cellType = cell.getCellType();
190             String df = cell.getCellStyle().getDataFormatString();
191             if (cellType == XSSFCell.CELL_TYPE_NUMERIC) {// 数值(包括excel中数值、货币、日期、时间、会计专用等单元格格式)
192                 double d = cell.getNumericCellValue();
193                 // 判断数值是否是日期，该方法只能识别部分日期格式,故加入第二个判断条件对不能识别的日期再次进行识别
194                 if (DateUtil.isCellDateFormatted(cell)
195                         || df.contains("yyyy\"年\"m\"月\"d\"日\"")) {// 日期、时间单元格格式
196                     Date date = DateUtil.getJavaDate(d);
197                     Timestamp timestamp = new Timestamp(date.getTime());
198                     String temp = timestamp.toString();
199                     if (temp.endsWith("00:00:00.0")) {// yyyy-MM-dd 格式
200                         rowCellData = temp.substring(0,
201                                 temp.lastIndexOf("00:00:00.0"));
202                     } else if (temp.endsWith(".0")) {// yyyy-MM-dd hh:mm:ss 格式
203                         rowCellData = temp.substring(0, temp.lastIndexOf(".0"));
204                     } else {
205                         rowCellData = timestamp.toString();
206                     }
207                 } else {// 数值、货币、会计专用、百分比、分数、科学记数 单元格式
208                     rowCellData = new DecimalFormat("0.########").format(d);
209                 }
210             } else if (cellType == XSSFCell.CELL_TYPE_STRING) {// 文本
211                 rowCellData = cell.getStringCellValue();
212             } else if (cellType == XSSFCell.CELL_TYPE_FORMULA) {// 公式
213                 double d = cell.getNumericCellValue();
214                 rowCellData = String.valueOf(d);
215             } else if (cellType == XSSFCell.CELL_TYPE_BLANK) {// 空
216                 rowCellData = "";
217             } else if (cellType == XSSFCell.CELL_TYPE_BOOLEAN) {// 布尔值
218                 rowCellData = "";
219             } else if (cellType == XSSFCell.CELL_TYPE_ERROR) {// 异常
220                 rowCellData = "";
221             } else {
222                 throw new Exception(sheetName + " sheet页中" + "第" + rowNo + "行"
223                         + "第" + cellNo + "列,单元格格式无法识别，请检查sheet页");
224             }
225         } catch (Exception e) {
226             e.printStackTrace();
227             throw new Exception(sheetName + "sheet页中" + "第" + rowNo + "行" + "第"
228                     + cellNo + "列" + "数据不符合要求,请检查sheet页");
229         }
230         return rowCellData;
231     }
232 
233     /**
234      * 读取第sheetNo个sheet页中第rowNo行的数据
235      * 
236      * @param sheetNo
237      *            指定sheetNo页
238      * @param rowNo
239      *            指定rowNo行
240      * @return
241      * @throws Exception
242      */
243     public String[] readExcelByRow(int sheetNo, int rowNo) throws Exception {
244         String[] rowData = null;
245         XSSFSheet sheet = wb.getSheetAt(sheetNo - 1);
246         XSSFRow row = sheet.getRow(rowNo - 1);
247         int cellCount = row.getLastCellNum();
248         rowData = new String[cellCount];
249         for (int k = 1; k <= cellCount; k++) {
250             rowData[k - 1] = readExcelByRowAndCell(sheetNo, rowNo, k);
251         }
252         return rowData;
253     }
254 
255     /**
256      * 读取第sheetNo个sheet页中第cellNo列的数据
257      * 
258      * @param sheetNo
259      *            指定sheetNo页
260      * @param cellNo
261      *            指定cellNo列号
262      * @return
263      * @throws Exception
264      */
265     public String[] readExcelByCell(int sheetNo, int cellNo) throws Exception {
266         String[] cellData = null;
267         XSSFSheet sheet = wb.getSheetAt(sheetNo - 1);
268         int rowCount = sheet.getLastRowNum();
269         cellData = new String[rowCount + 1];
270         for (int i = 0; i <= rowCount; i++) {
271             cellData[i] = readExcelByRowAndCell(sheetNo - 1, i, cellNo - 1);
272         }
273         return cellData;
274     }
275 
276     /**
277      * 关闭excel工作区，释放资源
278      * 
279      * @throws Exception
280      */
281     @Override
282     public void close() {
283         if (wb != null) {
284             try {
285                 wb.close();
286             } catch (IOException e) {
287                 e.printStackTrace();
288             } finally {
289                 wb = null;
290             }
291         }
292     }
293 }

  1 /*
  2  * ExcelParse.java
  3  * 
  4  * 2016-1-6 下午4:45:53
  5  * 
  6  * RecluseKapoor
  7  *  
  8  * Copyright © 2016, RecluseKapoor. All rights reserved.
  9  * 
 10  */
 11 package com.rk.pub.poi;
 12 
 13 import com.rk.pub.poi.excel.ExcelParse2003;
 14 import com.rk.pub.poi.excel.ExcelParse2007;
 15 import com.rk.pub.poi.excel.IExcelParse;
 16 
 17 /**
 18  * @Title:recluse-Excel文件解析工具类（兼容2003和2007版本Excel）
 19  * 
 20  * @Description: 该工具类用于解析Excel文件，同时兼容2003版和2007版Excel文件的解析，且随时可以进行新版本的扩展，
 21  *               <p>
 22  *               若要支持新版本Excel格式的解析，只需要在excle包下新增一个实现了IExcelParse接口的实现类，
 23  *               <p>
 24  *               在新增的实现类中实现新对版本Excel格式的解析的功能代码即可 ； 该扩展方法可以最大程度的实现解耦 。
 25  *               <p>
 26  * 
 27  * @Company: 卡普工作室
 28  * 
 29  * @Website: http://www.cnblogs.com/reclusekapoor/
 30  * 
 31  * @author: RecluseKapoor
 32  * 
 33  * @CreateDate：2016-1-6 下午9:43:56
 34  * 
 35  * @version: 1.0
 36  * 
 37  * @lastModify:
 38  * 
 39  */
 40 public class ExcelParse {
 41 
 42     private IExcelParse excelParse = null;
 43 
 44     /**
 45      * 加载实例，根据不同版本的Excel文件，加载不同的具体实现实例
 46      * 
 47      * @param path
 48      * @return
 49      */
 50     private boolean getInstance(String path) throws Exception {
 51         path = path.toLowerCase();
 52         if (path.endsWith(".xls")) {
 53             excelParse = new ExcelParse2003();
 54         } else if (path.endsWith(".xlsx")) {
 55             excelParse = new ExcelParse2007();
 56         } else {
 57             throw new Exception("对不起，目前系统不支持对该版本Excel文件的解析。");
 58         }
 59         return true;
 60     }
 61 
 62     /**
 63      * 获取excel工作区
 64      * 
 65      * @param path
 66      * @throws Exception
 67      */
 68     public void loadExcel(String filePathAndName) throws Exception {
 69         getInstance(filePathAndName);
 70         excelParse.loadExcel(filePathAndName);
 71     }
 72 
 73     /**
 74      * 获取sheet页名称
 75      * 
 76      * @param sheetNo
 77      * @return
 78      */
 79     public String getSheetName(int sheetNo) {
 80         return excelParse.getSheetName(sheetNo);
 81     }
 82 
 83     /**
 84      * 获取sheet页数
 85      * 
 86      * @return
 87      * @throws Exception
 88      */
 89     public int getSheetCount() throws Exception {
 90         return excelParse.getSheetCount();
 91     }
 92 
 93     /**
 94      * 获取sheetNo页行数
 95      * 
 96      * @param sheetNo
 97      * @return
 98      * @throws Exception
 99      */
100     public int getRowCount(int sheetNo) {
101         return excelParse.getRowCount(sheetNo);
102     }
103 
104     /**
105      * 获取sheetNo页行数(含有操作或者内容的真实行数)
106      * 
107      * @param sheetNo
108      * @return
109      * @throws Exception
110      */
111     public int getRealRowCount(int sheetNo) {
112         return excelParse.getRealRowCount(sheetNo);
113     }
114 
115     /**
116      * 读取第sheetNo个sheet页中第rowNo行第cellNo列的数据
117      * 
118      * @param sheetNo
119      *            sheet页编号
120      * @param rowNo
121      *            行号
122      * @param cellNo
123      *            列号
124      * @return 返回相应的excel单元格内容
125      * @throws Exception
126      */
127     public String readExcelByRowAndCell(int sheetNo, int rowNo, int cellNo)
128             throws Exception {
129         return excelParse.readExcelByRowAndCell(sheetNo, rowNo, cellNo);
130     }
131 
132     /**
133      * 读取指定SHEET页指定行的Excel内容
134      * 
135      * @param sheetNo
136      *            指定SHEET页
137      * @param lineNo
138      *            指定行
139      * @return
140      * @throws Exception
141      */
142     public String[] readExcelByRow(int sheetNo, int rowNo) throws Exception {
143         return excelParse.readExcelByRow(sheetNo, rowNo);
144     }
145 
146     /**
147      * 读取指定SHEET页指定列中的数据
148      * 
149      * @param sheetNo
150      *            指定SHEET页
151      * @param cellNo
152      *            指定列号
153      * @return
154      * @throws Exception
155      */
156     public String[] readExcelByCell(int sheetNo, int cellNo) throws Exception {
157         return excelParse.readExcelByCell(sheetNo, cellNo);
158     }
159 
160     /**
161      * 关闭excel工作区，释放资源
162      * 
163      */
164     public void close() {
165         excelParse.close();
166     }
167 
168     /**
169      * 测试方法
170      * 
171      * @param args
172      */
173     public static void main(String[] args) {
174         ExcelParse parse = new ExcelParse();
175         try {
176             // 加载excel文件
177             parse.loadExcel("E:\\2007.xls");
178             // 统计sheet页数
179             System.out.println(parse.getSheetCount());
180             // 读取单元格信息
181             System.out.println(parse.readExcelByRowAndCell(1, 1, 1));
182         } catch (Exception e) {
183             e.printStackTrace();
184         } finally {
185             // 释放资源
186             parse.close();
187         }
188     }
189 
190 }