java常用工具类之Excel操作类及依赖包下载

Excel工具类ExcelUtil.java源码：

1. package com.itjh.javaUtil; 
2.   
3. import java.io.File; 
4. import java.io.FileInputStream; 
5. import java.io.FileNotFoundException; 
6. import java.io.FileOutputStream; 
7. import java.io.IOException; 
8. import java.io.OutputStream; 
9. import java.text.DecimalFormat; 
10. import java.util.LinkedList; 
11. import java.util.List; 
12.   
13. import javax.servlet.http.HttpServletResponse; 
14.   
15. import org.apache.poi.hssf.usermodel.HSSFCell; 
16. import org.apache.poi.hssf.usermodel.HSSFRichTextString; 
17. import org.apache.poi.hssf.usermodel.HSSFRow; 
18. import org.apache.poi.hssf.usermodel.HSSFSheet; 
19. import org.apache.poi.hssf.usermodel.HSSFWorkbook; 
20. import org.apache.poi.openxml4j.exceptions.InvalidFormatException; 
21. import org.apache.poi.ss.usermodel.Cell; 
22. import org.apache.poi.ss.usermodel.DateUtil; 
23. import org.apache.poi.ss.usermodel.Row; 
24. import org.apache.poi.ss.usermodel.Sheet; 
25. import org.apache.poi.ss.usermodel.Workbook; 
26. import org.apache.poi.ss.usermodel.WorkbookFactory; 
27.   
28. /** 
29.  * 封装对excel的操作，包括本地读写excel和流中输出excel,支持office 2007。<br/> 
30.  * 依赖于poi-3.9-20121203.jar,poi-ooxml-3.9-20121203.jar,poi-ooxml-schemas-3.9- 
31.  * 20121203.jar,dom4j-1.6.1.jar<br/> 
32.  * 有参构造函数参数为excel的全路径<br/> 
33.  *  
34.  * @author 宋立君 
35.  * @date 2014年07月03日 
36.  */ 
37. public class ExcelUtil { 
38.   
39.     // excel文件路径 
40.     private String path = ""; 
41.   
42.     // 写入excel时，是否自动扩展列宽度来符合内容。 
43.     private boolean autoColumnWidth = false; 
44.   
45.     /** 
46.      * 无参构造函数 默认 
47.      */ 
48.     public ExcelUtil() { 
49.     } 
50.   
51.     /** 
52.      * 有参构造函数 
53.      *  
54.      * @param path 
55.      *   excel路径 
56.      */ 
57.     public ExcelUtil(String path) { 
58.         this.path = path; 
59.     } 
60.   
61.     /** 
62.      * 读取某个工作簿上的所有单元格的值。 
63.      *  
64.      * @param sheetOrder 
65.      *   工作簿序号，从0开始。 
66.      * @return List<Object[]> 所有单元格的值。 
67.      * @throws IOException 
68.      *    加载excel文件IO异常。 
69.      * @throws FileNotFoundException 
70.      *    excel文件没有找到异常。 
71.      * @throws InvalidFormatException 
72.      * @author 宋立君 
73.      * @date 2014年07月03日 
74.      */ 
75.     public List<Object[]> read(int sheetOrder) throws FileNotFoundException, 
76.             IOException, InvalidFormatException { 
77.         FileInputStream fis = new FileInputStream(path); 
78.         Workbook workbook = WorkbookFactory.create(fis); 
79.         if (fis != null) { 
80.             fis.close(); 
81.         } 
82.         Sheet sheet = workbook.getSheetAt(sheetOrder); 
83.         // 用来记录excel值 
84.         List<Object[]> valueList = new LinkedList<Object[]>(); 
85.         // 循环遍历每一行、每一列。 
86.         for (Row row : sheet) { 
87.             // 每一行 
88.             Object[] rowObject = null; 
89.             for (Cell cell : row) { 
90.                 // cell.getCellType是获得cell里面保存的值的type 
91.                 switch (cell.getCellType()) { 
92.                 case Cell.CELL_TYPE_BOOLEAN: 
93.                     // 得到Boolean对象的方法 
94.                     rowObject = CollectionUtil.addObjectToArray(rowObject, 
95.                             cell.getBooleanCellValue()); 
96.                     break; 
97.                 case Cell.CELL_TYPE_NUMERIC: 
98.                     // 先看是否是日期格式 
99.                     if (DateUtil.isCellDateFormatted(cell)) { 
100.                         // 读取日期格式 
101.                         rowObject = CollectionUtil.addObjectToArray(rowObject, 
102.                                 cell.getDateCellValue()); 
103.                     } else { 
104.                         DecimalFormat df = new DecimalFormat(); 
105.                         // 单元格的值,替换掉, 
106.                         String value = df.format(cell.getNumericCellValue()) 
107.                                 .replace(",", ""); 
108.                         // 读取数字 
109.                         rowObject = CollectionUtil.addObjectToArray(rowObject, 
110.                                 value); 
111.                     } 
112.                     break; 
113.                 case Cell.CELL_TYPE_FORMULA: 
114.                     // 读取公式 
115.                     rowObject = CollectionUtil.addObjectToArray(rowObject, 
116.                             cell.getCellFormula()); 
117.                     break; 
118.                 case Cell.CELL_TYPE_STRING: 
119.                     // 读取String 
120.                     rowObject = CollectionUtil.addObjectToArray(rowObject, cell 
121.                             .getRichStringCellValue().toString()); 
122.                     break; 
123.                 } 
124.             } 
125.             // 将这行添加到list。 
126.             valueList.add(rowObject); 
127.         } 
128.         return valueList; 
129.     } 
130.   
131.     /** 
132.      * 读取某个工作簿上的某个单元格的值。 
133.      *  
134.      * @param sheetOrder 
135.      *   工作簿序号,从0开始。 
136.      * @param colum 
137.      *   列数 从1开始 
138.      * @param row 
139.      *   行数 从1开始 
140.      * @return 单元格的值。 
141.      * @throws Exception 
142.      *    加载excel异常。 
143.      * @author 宋立君 
144.      * @date 2014年07月03日 
145.      */ 
146.     public String read(int sheetOrder, int colum, int row) throws Exception { 
147.         FileInputStream fis = new FileInputStream(path); 
148.         Workbook workbook = WorkbookFactory.create(fis); 
149.         if (fis != null) { 
150.             fis.close(); 
151.         } 
152.         Sheet sheet = workbook.getSheetAt(sheetOrder); 
153.         Row rows = sheet.getRow(row - 1); 
154.         Cell cell = rows.getCell(colum - 1); 
155.         String content = cell.getStringCellValue(); 
156.         return content; 
157.     } 
158.   
159.     /** 
160.      * 在指定的工作簿、行、列书写值。 
161.      *  
162.      * @param sheetOrder 
163.      *   工作簿序号，基于0. 
164.      * @param colum 
165.      *   列 基于1 
166.      * @param row 
167.      *   行 基于1 
168.      * @param content 
169.      *   将要被书写的内容。 
170.      * @throws Exception 
171.      *    书写后保存异常。 
172.      * @author 宋立君 
173.      * @date 2014年07月03日 
174.      */ 
175.     public void write(int sheetOrder, int colum, int row, String content) 
176.             throws Exception { 
177.         FileInputStream fis = new FileInputStream(path); 
178.         Workbook workbook = WorkbookFactory.create(fis); 
179.         if (fis != null) { 
180.             fis.close(); 
181.         } 
182.         Sheet sheet = workbook.getSheetAt(sheetOrder); 
183.         Row rows = sheet.createRow(row - 1); 
184.         Cell cell = rows.createCell(colum - 1); 
185.         cell.setCellValue(content); 
186.         FileOutputStream fileOut = new FileOutputStream(path); 
187.         workbook.write(fileOut); 
188.         fileOut.close(); 
189.   
190.     } 
191.   
192.     /** 
193.      * 得到一个工作区最后一条记录的序号，相当于这个工作簿共多少行数据。 
194.      *  
195.      * @param sheetOrder 
196.      *   工作区序号 
197.      * @return int 序号。 
198.      * @throws IOException 
199.      *    根据excel路径加载excel异常。 
200.      * @throws InvalidFormatException 
201.      * @author 宋立君 
202.      * @date 2014年07月03日 
203.      */ 
204.     public int getSheetLastRowNum(int sheetOrder) throws IOException, 
205.             InvalidFormatException { 
206.         FileInputStream fis = new FileInputStream(path); 
207.         Workbook workbook = WorkbookFactory.create(fis); 
208.         if (fis != null) { 
209.             fis.close(); 
210.         } 
211.         Sheet sheet = workbook.getSheetAt(sheetOrder); 
212.         return sheet.getLastRowNum(); 
213.     } 
214.   
215.     /** 
216.      * 在磁盘生成一个含有内容的excel,路径为path属性 
217.      *  
218.      * @param sheetName 
219.      *   导出的sheet名称 
220.      * @param fieldName 
221.      *   列名数组 
222.      * @param data 
223.      *   数据组 
224.      * @throws IOException 
225.      * @author 宋立君 
226.      * @date 2014年07月03日 
227.      */ 
228.     public void makeExcel(String sheetName, String[] fieldName, 
229.             List<Object[]> data) throws IOException { 
230.         // 在内存中生成工作薄 
231.         HSSFWorkbook workbook = makeWorkBook(sheetName, fieldName, data); 
232.         // 截取文件夹路径 
233.         String filePath = path.substring(0, path.lastIndexOf("\\")); 
234.         // 如果路径不存在，创建路径 
235.         File file = new File(filePath); 
236.         // System.out.println(path+"-----------"+file.exists()); 
237.         if (!file.exists()) 
238.             file.mkdirs(); 
239.         FileOutputStream fileOut = new FileOutputStream(path); 
240.         workbook.write(fileOut); 
241.         fileOut.close(); 
242.     } 
243.   
244.     /** 
245.      * 在输出流中导出excel。 
246.      *  
247.      * @param excelName 
248.      *   导出的excel名称 包括扩展名 
249.      * @param sheetName 
250.      *   导出的sheet名称 
251.      * @param fieldName 
252.      *   列名数组 
253.      * @param data 
254.      *   数据组 
255.      * @param response 
256.      *   response 
257.      * @throws IOException 
258.      *    转换流时IO错误 
259.      * @author 宋立君 
260.      * @date 2014年07月03日 
261.      */ 
262.     public void makeStreamExcel(String excelName, String sheetName, 
263.             String[] fieldName, List<Object[]> data, 
264.             HttpServletResponse response) throws IOException { 
265.         OutputStream os = null; 
266.         response.reset(); // 清空输出流 
267.         os = response.getOutputStream(); // 取得输出流 
268.         response.setHeader("Content-disposition", "attachment; filename=" 
269.                 + new String(excelName.getBytes(), "ISO-8859-1")); // 设定输出文件头 
270.         response.setContentType("application/msexcel"); // 定义输出类型 
271.         // 在内存中生成工作薄 
272.         HSSFWorkbook workbook = makeWorkBook(sheetName, fieldName, data); 
273.         os.flush(); 
274.         workbook.write(os); 
275.     } 
276.   
277.     /** 
278.      * 根据条件，生成工作薄对象到内存。 
279.      *  
280.      * @param sheetName 
281.      *   工作表对象名称 
282.      * @param fieldName 
283.      *   首列列名称 
284.      * @param data 
285.      *   数据 
286.      * @return HSSFWorkbook 
287.      * @author 宋立君 
288.      * @date 2014年07月03日 
289.      */ 
290.     private HSSFWorkbook makeWorkBook(String sheetName, String[] fieldName, 
291.             List<Object[]> data) { 
292.         // 用来记录最大列宽,自动调整列宽。 
293.         Integer collength[] = new Integer[fieldName.length]; 
294.   
295.         // 产生工作薄对象 
296.         HSSFWorkbook workbook = new HSSFWorkbook(); 
297.         // 产生工作表对象 
298.         HSSFSheet sheet = workbook.createSheet(); 
299.         // 为了工作表能支持中文,设置字符集为UTF_16 
300.         workbook.setSheetName(0, sheetName); 
301.         // 产生一行 
302.         HSSFRow row = sheet.createRow(0); 
303.         // 产生单元格 
304.         HSSFCell cell; 
305.         // 写入各个字段的名称 
306.         for (int i = 0; i < fieldName.length; i++) { 
307.             // 创建第一行各个字段名称的单元格 
308.             cell = row.createCell((short) i); 
309.             // 设置单元格内容为字符串型 
310.             cell.setCellType(HSSFCell.CELL_TYPE_STRING); 
311.             // 为了能在单元格中输入中文,设置字符集为UTF_16 
312.             // cell.setEncoding(HSSFCell.ENCODING_UTF_16); 
313.             // 给单元格内容赋值 
314.             cell.setCellValue(new HSSFRichTextString(fieldName[i])); 
315.             // 初始化列宽 
316.             collength[i] = fieldName[i].getBytes().length; 
317.         } 
318.         // 临时单元格内容 
319.         String tempCellContent = ""; 
320.         // 写入各条记录,每条记录对应excel表中的一行 
321.         for (int i = 0; i < data.size(); i++) { 
322.             Object[] tmp = data.get(i); 
323.             // 生成一行 
324.             row = sheet.createRow(i + 1); 
325.             for (int j = 0; j < tmp.length; j++) { 
326.                 cell = row.createCell((short) j); 
327.                 // 设置单元格字符类型为String 
328.                 cell.setCellType(HSSFCell.CELL_TYPE_STRING); 
329.                 tempCellContent = (tmp[j] == null) ? "" : tmp[j].toString(); 
330.                 cell.setCellValue(new HSSFRichTextString(tempCellContent)); 
331.   
332.                 // 如果自动调整列宽度。 
333.                 if (autoColumnWidth) { 
334.                     if (j >= collength.length) { // 标题列数小于数据列数时。 
335.                         collength = CollectionUtil.addObjectToArray(collength, 
336.                                 tempCellContent.getBytes().length); 
337.                     } else { 
338.                         // 如果这个内容的宽度大于之前最大的，就按照这个设置宽度。 
339.                         if (collength[j] < tempCellContent.getBytes().length) { 
340.                             collength[j] = tempCellContent.getBytes().length; 
341.                         } 
342.                     } 
343.                 } 
344.             } 
345.         } 
346.   
347.         // 自动调整列宽度。 
348.         if (autoColumnWidth) { 
349.             // 调整列为这列文字对应的最大宽度。 
350.             for (int i = 0; i < fieldName.length; i++) { 
351.                 sheet.setColumnWidth(i, collength[i] * 2 * 256); 
352.             } 
353.         } 
354.         return workbook; 
355.     } 
356.   
357.     /** 
358.      * 功能：设置写入excel时，是否自动扩展列宽度来符合内容，默认为false。 
359.      *  
360.      * @author 宋立君 
361.      * @date 2014年07月03日 
362.      * @param autoColumnWidth 
363.      *   true或者false 
364.      */ 
365.     public void setAutoColumnWidth(boolean autoColumnWidth) { 
366.         this.autoColumnWidth = autoColumnWidth; 
367.     } 
368. }