Java-POI表格导入导出
Java-POI表格导入导出，给予POI4.1.2，poi-bin-4.1.2-20200217 版本，2020.2.17官网发布的库
.
1 一、读取表格
2
3
4
5 <%@ page import="codedna616.demo.commom.POIExcelReader" %>
6 <%@ page import="codedna616.demo.commom.Student" %>
7 <%@ page import="java.util.List" %>
8 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
9 <html>
10 <head>
11 <title>读取表格数据</title>
12
13 <style>
14 table td{border:1px solid #F00}
15 </style>
16 </head>
17 <body>
18 <%
19 //"想办法找到要提供下载的文件的物理路径＋文件名";
20 String localFilePath = request.getServletContext().getRealPath("") + "\本地导出的文件.xls";
21 %>
22 <h3>读取表格实例 <%=localFilePath%></h3>
23
24
25 <%
26 // 读取Excel文件内容
27 List<Student> readResult = POIExcelReader.readExcel(localFilePath);
28 out.println("<table style="border:1px">");
29 out.println("<tr><td>编号</td><td>姓名</td><td>学号</td> <br>");
30 for (Student item : readResult) {
31 out.println("<tr><td>"+item.getId() + "</td><td>" + item.getName() + "</td><td>" + item.getStudentNo() + "</td></tr>"+"");
32 }
33 out.println("</table>");
34 %>
35 </body>
36 </html>
37
38
39
40
41 二、导出本地表格
42
43 <%@ page import="java.io.FileInputStream" %>
44 <%@ page import="java.net.URLEncoder" %>
45 <%@ page import="codedna616.demo.commom.Utils" %>
46 <%@ page import="codedna616.demo.commom.Student" %>
47 <%@ page import="codedna616.demo.commom.PoiExportExcelUtil" %>
48 <%@ page import="java.io.FileOutputStream" %>
49 <%@ page import="java.util.List" %>
50 <%@ page import="java.util.ArrayList" %><%--
51 Created by IntelliJ IDEA.
52 User: Administrator
53 Date: 2020/7/16
54 Time: 9:27
55 To change this template use File | Settings | File Templates.
56 --%>
57 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
58 <html>
59 <head>
60 <title>下载表格</title>
61 </head>
62 <body>
63 <%
64 if (request.getParameter("type") == "2003") {
65
66 } else {
67
68 }
69
70 String[] columnNames = {"ID", "姓名", "学号"};
71
72 List<Student> list = new ArrayList<>();
73 for (int i = 1; i <= 100; i++) {
74 Student model = new Student();
75 model.Id = Integer.toString(i);
76 model.Name = "学生" + i;
77 model.StudentNo = "序号000" + i;
78 list.add(model);
79 }
80
81 //方式1：直接导出表格测试【保存到本地】
82 PoiExportExcelUtil<Student> util = new PoiExportExcelUtil<Student>();
83
84 String localFilePath = request.getServletContext().getRealPath("") + "\本地导出的文件.xls";
85 util.exportExcel("用户导出", columnNames, list, new FileOutputStream(localFilePath), PoiExportExcelUtil.EXCEL_FILE_2003);
86
87 out.print("写入完成"+localFilePath);
88 %>
89 </body>
90 </html>
91
92
93
94
95
96
97
98 三、下载表格
99
100
101
102 <%@ page import="java.net.URLEncoder" %>
103 <%@ page import="codedna616.demo.commom.Utils" %>
104 <%@ page import="java.io.FileInputStream" %>
105
106 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
107 <html>
108 <head>
109 <title>下载web表格</title>
110 </head>
111 <body>
112 <%
113
114 //方式2：通过流下载文件（适合web下载）
115 //关于文件下载时采用文件流输出的方式处理：
116 //加上response.reset()，并且所有的％>后面不要换行，包括最后一个；
117 response.reset();//可以加也可以不加
118 response.setContentType("application/x-download");
119 //application.getRealPath("/main/mvplayer/CapSetup.msi");获取的物理路径
120
121 //"想办法找到要提供下载的文件的物理路径＋文件名";
122 String localFilePath=request.getServletContext().getRealPath("")+"\本地导出的文件.xls";
123
124 String filedisplay ="web下载的文件"+ Utils.getDateTimeNow()+".xls" ;//"给用户提供的下载文件名";
125 filedisplay = URLEncoder.encode(filedisplay,"UTF-8");
126 response.addHeader("Content-Disposition","attachment;filename=" + filedisplay);
127
128 java.io.OutputStream outp = null;
129 java.io.FileInputStream in = null;
130 try {
131 outp = response.getOutputStream();
132 in = new FileInputStream(localFilePath);
133 byte[] b = new byte[1024];
134 int i = 0;
135 while((i = in.read(b)) > 0) {
136 outp.write(b, 0, i);
137 }
138 outp.flush();
139 //要加以下两句话，否则会报错
140 //java.lang.IllegalStateException: getOutputStream() has already been called for //this response
141
142 out.clear();
143 out = pageContext.pushBody();
144
145
146 } catch(Exception e){
147 System.out.println("Error!");
148 e.printStackTrace();
149 }finally{
150 if(in != null){
151 in.close();
152 in = null;
153 }
154 //这里不能关闭
155 //if(outp != null) {
156 //outp.close();
157 //outp = null;
158 //}
159 }
160
161 %>
162 </body>
163 </html>
164
165
166 核心方法如下，建议下载完整代码查看
167
168
169
170 ==》》》读取表格
171
172 POIExcelReader.java
173
174
175
176 package codedna616.demo.commom;
177
178 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
179 import org.apache.poi.ss.usermodel.Cell;
180 import org.apache.poi.ss.usermodel.Row;
181 import org.apache.poi.ss.usermodel.Sheet;
182 import org.apache.poi.ss.usermodel.Workbook;
183 import org.apache.poi.xssf.usermodel.XSSFWorkbook;
184 //import org.springframework.web.multipart.MultipartFile;
185
186 import java.io.File;
187 import java.io.FileInputStream;
188 import java.io.IOException;
189 import java.io.InputStream;
190 import java.text.DecimalFormat;
191 import java.util.*;
192 import java.util.logging.Logger;
193
194 /**
195 * Author: Dreamer-1
196 * Date: 2019-03-01
197 * Time: 10:21
198 * Description: 读取Excel内容
199 */
200 public class POIExcelReader {
201
202 private static Logger logger = Logger.getLogger(POIExcelReader.class.getName()); // 日志打印类
203
204 private static final String XLS = "xls";
205 private static final String XLSX = "xlsx";
206
207 /**
208 * 根据文件后缀名类型获取对应的工作簿对象
209 * @param inputStream 读取文件的输入流
210 * @param fileType 文件后缀名类型（xls或xlsx）
211 * @return 包含文件数据的工作簿对象
212 * @throws IOException
213 */
214 public static Workbook getWorkbook(InputStream inputStream, String fileType) throws IOException {
215 Workbook workbook = null;
216 if (fileType.equalsIgnoreCase(XLS)) {
217 workbook = new HSSFWorkbook(inputStream);
218 } else if (fileType.equalsIgnoreCase(XLSX)) {
219 workbook = new XSSFWorkbook(inputStream);
220 }
221 return workbook;
222 }
223
224 /**
225 * 读取Excel文件内容
226 * @param fileName 要读取的Excel文件所在路径
227 * @return 读取结果列表，读取失败时返回null
228 */
229 public static List<Student> readExcel(String fileName) {
230
231 Workbook workbook = null;
232 FileInputStream inputStream = null;
233
234 try {
235 // 获取Excel后缀名
236 String fileType = fileName.substring(fileName.lastIndexOf(".") + 1, fileName.length());
237 // 获取Excel文件
238 File excelFile = new File(fileName);
239 if (!excelFile.exists()) {
240 logger.warning("指定的Excel文件不存在！");
241 return null;
242 }
243
244 // 获取Excel工作簿
245 inputStream = new FileInputStream(excelFile);
246 workbook = getWorkbook(inputStream, fileType);
247
248 // 读取excel中的数据
249 List<Student> resultDataList = parseExcel(workbook);
250
251 return resultDataList;
252 } catch (Exception e) {
253 logger.warning("解析Excel失败，文件名：" + fileName + " 错误信息：" + e.getMessage());
254 return null;
255 } finally {
256 try {
257 if (null != workbook) {
258 workbook.close();
259 }
260 if (null != inputStream) {
261 inputStream.close();
262 }
263 } catch (Exception e) {
264 logger.warning("关闭数据流出错！错误信息：" + e.getMessage());
265 return null;
266 }
267 }
268 }
269
270 /**
271 * 读取Excel文件内容
272 * @param file 上传的Excel文件
273 * @return 读取结果列表，读取失败时返回null
274 */
275 // public static List<Student> readExcel(MultipartFile file) {
276 //
277 // Workbook workbook = null;
278 //
279 // try {
280 // // 获取Excel后缀名
281 // String fileName = file.getOriginalFilename();
282 // if (fileName == null || fileName.isEmpty() || fileName.lastIndexOf(".") < 0) {
283 // logger.warning("解析Excel失败，因为获取到的Excel文件名非法！");
284 // return null;
285 // }
286 // String fileType = fileName.substring(fileName.lastIndexOf(".") + 1, fileName.length());
287 //
288 // // 获取Excel工作簿
289 // workbook = getWorkbook(file.getInputStream(), fileType);
290 //
291 // // 读取excel中的数据
292 // List<Student> resultDataList = parseExcel(workbook);
293 //
294 // return resultDataList;
295 // } catch (Exception e) {
296 // logger.warning("解析Excel失败，文件名：" + file.getOriginalFilename() + " 错误信息：" + e.getMessage());
297 // return null;
298 // } finally {
299 // try {
300 // if (null != workbook) {
301 // workbook.close();
302 // }
303 // } catch (Exception e) {
304 // logger.warning("关闭数据流出错！错误信息：" + e.getMessage());
305 // return null;
306 // }
307 // }
308 // }
309
310
311 /**
312 * 解析Excel数据
313 * @param workbook Excel工作簿对象
314 * @return 解析结果
315 */
316 private static List<Student> parseExcel(Workbook workbook) {
317 List<Student> resultDataList = new ArrayList<>();
318 // 解析sheet
319 for (int sheetNum = 0; sheetNum < workbook.getNumberOfSheets(); sheetNum++) {
320 Sheet sheet = workbook.getSheetAt(sheetNum);
321
322 // 校验sheet是否合法
323 if (sheet == null) {
324 continue;
325 }
326
327 // 获取第一行数据
328 int firstRowNum = sheet.getFirstRowNum();
329 Row firstRow = sheet.getRow(firstRowNum);
330 if (null == firstRow) {
331 logger.warning("解析Excel失败，在第一行没有读取到任何数据！");
332 }
333
334 // 解析每一行的数据，构造数据对象
335 int rowStart = firstRowNum + 1;
336 int rowEnd = sheet.getPhysicalNumberOfRows();
337 for (int rowNum = rowStart; rowNum < rowEnd; rowNum++) {
338 Row row = sheet.getRow(rowNum);
339
340 if (null == row) {
341 continue;
342 }
343
344 Student resultData = convertRowToData(row);
345 if (null == resultData) {
346 logger.warning("第 " + row.getRowNum() + "行数据不合法，已忽略！");
347 continue;
348 }
349 resultDataList.add(resultData);
350 }
351 }
352
353 return resultDataList;
354 }
355
356 /**
357 * 将单元格内容转换为字符串
358 * @param cell
359 * @return
360 */
361 private static String convertCellValueToString(Cell cell) {
362 if(cell==null){
363 return null;
364 }
365 String returnValue = null;
366 switch (cell.getCellType()) {
367 case NUMERIC: //数字
368 Double doubleValue = cell.getNumericCellValue();
369
370 // 格式化科学计数法，取一位整数
371 DecimalFormat df = new DecimalFormat("0");
372 returnValue = df.format(doubleValue);
373 break;
374 case STRING: //字符串
375 returnValue = cell.getStringCellValue();
376 break;
377 case BOOLEAN: //布尔
378 Boolean booleanValue = cell.getBooleanCellValue();
379 returnValue = booleanValue.toString();
380 break;
381 case BLANK: // 空值
382 break;
383 case FORMULA: // 公式
384 returnValue = cell.getCellFormula();
385 break;
386 case ERROR: // 故障
387 break;
388 default:
389 break;
390 }
391 return returnValue;
392 }
393
394 /**
395 * 提取每一行中需要的数据，构造成为一个结果数据对象
396 *
397 * 当该行中有单元格的数据为空或不合法时，忽略该行的数据
398 *
399 * @param row 行数据
400 * @return 解析后的行数据对象，行数据错误时返回null
401 */
402 private static Student convertRowToData(Row row) {
403 Student resultData = new Student();
404
405 Cell cell;
406 int cellNum = 0;
407 // 获取第一列
408 cell = row.getCell(0);
409 String id = convertCellValueToString(cell);
410 resultData.setId(id);
411 // 第二列
412 cell = row.getCell(1);
413 String name = convertCellValueToString(cell);
414 resultData.setName(name);
415 // 第三列
416 cell = row.getCell(2);
417 String sutdnetNo = convertCellValueToString(cell);
418 resultData.setStudentNo(sutdnetNo);
419
420 return resultData;
421 }
422
423 }
424
425
426
427
428 ==》》》》导出表格
429
430 PoiExportExcelUtil.java文件
431 package codedna616.demo.commom;
432
433 import java.io.IOException;
434 import java.io.OutputStream;
435 import java.lang.reflect.Field;
436 import java.lang.reflect.InvocationTargetException;
437 import java.lang.reflect.Method;
438 import java.text.SimpleDateFormat;
439 import java.util.Collection;
440 import java.util.Date;
441 import java.util.Iterator;
442 import java.util.regex.Matcher;
443 import java.util.regex.Pattern;
444
445 //import org.apache.commons.lang3.StringUtils;
446 import org.apache.poi.hssf.usermodel.HSSFCell;
447 import org.apache.poi.hssf.usermodel.HSSFCellStyle;
448 import org.apache.poi.hssf.usermodel.HSSFFont;
449 import org.apache.poi.hssf.usermodel.HSSFRichTextString;
450 import org.apache.poi.hssf.usermodel.HSSFRow;
451 import org.apache.poi.hssf.usermodel.HSSFSheet;
452 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
453 import org.apache.poi.hssf.util.HSSFColor;
454 import org.apache.poi.xssf.usermodel.XSSFCell;
455 import org.apache.poi.xssf.usermodel.XSSFCellStyle;
456 import org.apache.poi.xssf.usermodel.XSSFColor;
457 import org.apache.poi.xssf.usermodel.XSSFFont;
458 import org.apache.poi.xssf.usermodel.XSSFRichTextString;
459 import org.apache.poi.xssf.usermodel.XSSFRow;
460 import org.apache.poi.xssf.usermodel.XSSFSheet;
461 import org.apache.poi.xssf.usermodel.XSSFWorkbook;
462
463
464 /**
465 * 导出Excel
466 *
467 * @param <T>
468 * @author
469 */
470 public class PoiExportExcelUtil<T> {
471
472 // 2007 版本以上 最大支持1048576行
473 public final static String EXCEl_FILE_2007 = "2007";
474 // 2003 版本 最大支持65536 行
475 public final static String EXCEL_FILE_2003 = "2003";
476
477 /**
478 * <p>
479 * 导出无头部标题行Excel <br>
480 * 时间格式默认：yyyy-MM-dd hh:mm:ss <br>
481 * </p>
482 *
483 * @param title 表格标题
484 * @param dataset 数据集合
485 * @param out 输出流
486 * @param version 2003 或者 2007，不传时默认生成2003版本
487 */
488 public void exportExcel(String title, Collection<T> dataset, OutputStream out, String version) {
489 if (Utils.isNullOrEmpty(version) || EXCEL_FILE_2003.equals(version.trim())) {
490 exportExcel2003(title, null, dataset, out, "yyyy-MM-dd HH:mm:ss");
491 } else {
492 exportExcel2007(title, null, dataset, out, "yyyy-MM-dd HH:mm:ss");
493 }
494 }
495
496 /**
497 * <p>
498 * 导出带有头部标题行的Excel <br>
499 * 时间格式默认：yyyy-MM-dd hh:mm:ss <br>
500 * </p>
501 *
502 * @param title 表格标题
503 * @param headers 头部标题集合
504 * @param dataset 数据集合
505 * @param out 输出流
506 * @param version 2003 或者 2007，不传时默认生成2003版本
507 */
508 public void exportExcel(String title, String[] headers, Collection<T> dataset, OutputStream out, String version) {
509 if (Utils.isNullOrEmpty(version) || EXCEL_FILE_2003.equals(version.trim())) {
510 exportExcel2003(title, headers, dataset, out, "yyyy-MM-dd HH:mm:ss");
511 } else {
512 exportExcel2007(title, headers, dataset, out, "yyyy-MM-dd HH:mm:ss");
513 }
514 }
515
516 /**
517 * <p>
518 * 通用Excel导出方法,利用反射机制遍历对象的所有字段，将数据写入Excel文件中 <br>
519 * 此版本生成2007以上版本的文件 (文件后缀：xlsx)
520 * </p>
521 *
522 * @param title 表格标题名
523 * @param headers 表格头部标题集合
524 * @param dataset 需要显示的数据集合,集合中一定要放置符合JavaBean风格的类的对象。此方法支持的
525 * JavaBean属性的数据类型有基本数据类型及String,Date
526 * @param out 与输出设备关联的流对象，可以将EXCEL文档导出到本地文件或者网络中
527 * @param pattern 如果有时间数据，设定输出格式。默认为"yyyy-MM-dd hh:mm:ss"
528 */
529 @SuppressWarnings({"unchecked", "rawtypes"})
530 public void exportExcel2007(String title, String[] headers, Collection<T> dataset, OutputStream out, String pattern) {
531 // 声明一个工作薄
532 XSSFWorkbook workbook = new XSSFWorkbook();
533 // 生成一个表格
534 XSSFSheet sheet = workbook.createSheet(title);
535 // 设置表格默认列宽度为15个字节
536 sheet.setDefaultColumnWidth(20);
537 // 生成一个样式
538 XSSFCellStyle style = workbook.createCellStyle();
539 // 设置这些样式
540 style.setFillForegroundColor(new XSSFColor(java.awt.Color.gray));
541 // style.setFillPattern(XSSFCellStyle.SOLID_FOREGROUND);
542 //
543 // style.setBorderBottom(XSSFCellStyle.BORDER_THIN);
544 // style.setBorderLeft(XSSFCellStyle.BORDER_THIN);
545 // style.setBorderRight(XSSFCellStyle.BORDER_THIN);
546 // style.setBorderTop(XSSFCellStyle.BORDER_THIN);
547 // style.setAlignment(XSSFCellStyle.ALIGN_CENTER);
548 // 生成一个字体
549 XSSFFont font = workbook.createFont();
550 //font.setBoldweight(XSSFFont.BOLDWEIGHT_BOLD);
551 font.setFontName("宋体");
552 font.setColor(new XSSFColor(java.awt.Color.BLACK));
553 font.setFontHeightInPoints((short) 11);
554 // 把字体应用到当前的样式
555 style.setFont(font);
556 // 生成并设置另一个样式
557 XSSFCellStyle style2 = workbook.createCellStyle();
558 style2.setFillForegroundColor(new XSSFColor(java.awt.Color.WHITE));
559 // style2.setFillPattern(XSSFCellStyle.SOLID_FOREGROUND);
560 // style2.setBorderBottom(XSSFCellStyle.BORDER_THIN);
561 // style2.setBorderLeft(XSSFCellStyle.BORDER_THIN);
562 // style2.setBorderRight(XSSFCellStyle.BORDER_THIN);
563 // style2.setBorderTop(XSSFCellStyle.BORDER_THIN);
564 // style2.setAlignment(XSSFCellStyle.ALIGN_CENTER);
565 // style2.setVerticalAlignment(XSSFCellStyle.VERTICAL_CENTER);
566 // 生成另一个字体
567 XSSFFont font2 = workbook.createFont();
568 //font2.setBoldweight(XSSFFont.BOLDWEIGHT_NORMAL);
569 // 把字体应用到当前的样式
570 style2.setFont(font2);
571
572 // 产生表格标题行
573 XSSFRow row = sheet.createRow(0);
574 XSSFCell cellHeader;
575 for (int i = 0; i < headers.length; i++) {
576 cellHeader = row.createCell(i);
577 cellHeader.setCellStyle(style);
578 cellHeader.setCellValue(new XSSFRichTextString(headers[i]));
579 }
580
581 // 遍历集合数据，产生数据行
582 Iterator<T> it = dataset.iterator();
583 int index = 0;
584 T t;
585 Field[] fields;
586 Field field;
587 XSSFRichTextString richString;
588 Pattern p = Pattern.compile("^//d+(//.//d+)?$");
589 Matcher matcher;
590 String fieldName;
591 String getMethodName;
592 XSSFCell cell;
593 Class tCls;
594 Method getMethod;
595 Object value;
596 String textValue;
597 SimpleDateFormat sdf = new SimpleDateFormat(pattern);
598 while (it.hasNext()) {
599 index++;
600 row = sheet.createRow(index);
601 t = (T) it.next();
602 // 利用反射，根据JavaBean属性的先后顺序，动态调用getXxx()方法得到属性值
603 fields = t.getClass().getDeclaredFields();
604 for (int i = 0; i < fields.length; i++) {
605 cell = row.createCell(i);
606 cell.setCellStyle(style2);
607 field = fields[i];
608 fieldName = field.getName();
609 getMethodName = "get" + fieldName.substring(0, 1).toUpperCase()
610 + fieldName.substring(1);
611 try {
612 tCls = t.getClass();
613 getMethod = tCls.getMethod(getMethodName, new Class[]{});
614 value = getMethod.invoke(t, new Object[]{});
615 // 判断值的类型后进行强制类型转换
616 textValue = null;
617 if (value instanceof Integer) {
618 cell.setCellValue((Integer) value);
619 } else if (value instanceof Float) {
620 textValue = String.valueOf((Float) value);
621 cell.setCellValue(textValue);
622 } else if (value instanceof Double) {
623 textValue = String.valueOf((Double) value);
624 cell.setCellValue(textValue);
625 } else if (value instanceof Long) {
626 cell.setCellValue((Long) value);
627 }
628 if (value instanceof Boolean) {
629 textValue = "是";
630 if (!(Boolean) value) {
631 textValue = "否";
632 }
633 } else if (value instanceof Date) {
634 textValue = sdf.format((Date) value);
635 } else {
636 // 其它数据类型都当作字符串简单处理
637 if (value != null) {
638 textValue = value.toString();
639 }
640 }
641 if (textValue != null) {
642 matcher = p.matcher(textValue);
643 if (matcher.matches()) {
644 // 是数字当作double处理
645 cell.setCellValue(Double.parseDouble(textValue));
646 } else {
647 richString = new XSSFRichTextString(textValue);
648 cell.setCellValue(richString);
649 }
650 }
651 } catch (SecurityException e) {
652 e.printStackTrace();
653 } catch (NoSuchMethodException e) {
654 e.printStackTrace();
655 } catch (IllegalArgumentException e) {
656 e.printStackTrace();
657 } catch (IllegalAccessException e) {
658 e.printStackTrace();
659 } catch (InvocationTargetException e) {
660 e.printStackTrace();
661 } finally {
662 // 清理资源
663 }
664 }
665 }
666 try {
667 workbook.write(out);
668 } catch (IOException e) {
669 e.printStackTrace();
670 }
671 }
672
673
674 /**
675 * <p>
676 * 通用Excel导出方法,利用反射机制遍历对象的所有字段，将数据写入Excel文件中 <br>
677 * 此方法生成2003版本的excel,文件名后缀：xls <br>
678 * </p>
679 *
680 * @param title 表格标题名
681 * @param headers 表格头部标题集合
682 * @param dataset 需要显示的数据集合,集合中一定要放置符合JavaBean风格的类的对象。此方法支持的
683 * JavaBean属性的数据类型有基本数据类型及String,Date
684 * @param out 与输出设备关联的流对象，可以将EXCEL文档导出到本地文件或者网络中
685 * @param pattern 如果有时间数据，设定输出格式。默认为"yyyy-MM-dd hh:mm:ss"
686 */
687 @SuppressWarnings({"unchecked", "rawtypes"})
688 public void exportExcel2003(String title, String[] headers, Collection<T> dataset, OutputStream out, String pattern) {
689 // 声明一个工作薄
690 HSSFWorkbook workbook = new HSSFWorkbook();
691 // 生成一个表格
692 HSSFSheet sheet = workbook.createSheet(title);
693 // 设置表格默认列宽度为15个字节
694 sheet.setDefaultColumnWidth(20);
695 // 生成一个样式
696 HSSFCellStyle style = workbook.createCellStyle();
697 // 设置这些样式
698 // style.setFillForegroundColor(HSSFColor.GREY_50_PERCENT.index);
699 // style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
700 // style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
701 // style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
702 // style.setBorderRight(HSSFCellStyle.BORDER_THIN);
703 // style.setBorderTop(HSSFCellStyle.BORDER_THIN);
704 // style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
705 // 生成一个字体
706 HSSFFont font = workbook.createFont();
707 // font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
708 font.setFontName("宋体");
709 // font.setColor(HSSFColor.WHITE.index);
710 font.setFontHeightInPoints((short) 11);
711 // 把字体应用到当前的样式
712 style.setFont(font);
713 // 生成并设置另一个样式
714 HSSFCellStyle style2 = workbook.createCellStyle();
715 // style2.setFillForegroundColor(HSSFColor.WHITE.index);
716 // style2.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
717 // style2.setBorderBottom(HSSFCellStyle.BORDER_THIN);
718 // style2.setBorderLeft(HSSFCellStyle.BORDER_THIN);
719 // style2.setBorderRight(HSSFCellStyle.BORDER_THIN);
720 // style2.setBorderTop(HSSFCellStyle.BORDER_THIN);
721 // style2.setAlignment(HSSFCellStyle.ALIGN_CENTER);
722 // style2.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
723 // 生成另一个字体
724 HSSFFont font2 = workbook.createFont();
725 // font2.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
726 // 把字体应用到当前的样式
727 style2.setFont(font2);
728
729 // 产生表格标题行
730 HSSFRow row = sheet.createRow(0);
731 HSSFCell cellHeader;
732 for (int i = 0; i < headers.length; i++) {
733 cellHeader = row.createCell(i);
734 cellHeader.setCellStyle(style);
735 cellHeader.setCellValue(new HSSFRichTextString(headers[i]));
736 }
737
738 // 遍历集合数据，产生数据行
739 Iterator<T> it = dataset.iterator();
740 int index = 0;
741 T t;
742 Field[] fields;
743 Field field;
744 HSSFRichTextString richString;
745 Pattern p = Pattern.compile("^//d+(//.//d+)?$");
746 Matcher matcher;
747 String fieldName;
748 String getMethodName;
749 HSSFCell cell;
750 Class tCls;
751 Method getMethod;
752 Object value;
753 String textValue;
754 SimpleDateFormat sdf = new SimpleDateFormat(pattern);
755 while (it.hasNext()) {
756 index++;
757 row = sheet.createRow(index);
758 t = (T) it.next();
759 // 利用反射，根据JavaBean属性的先后顺序，动态调用getXxx()方法得到属性值
760 fields = t.getClass().getDeclaredFields();
761 for (int i = 0; i < fields.length; i++) {
762 cell = row.createCell(i);
763 cell.setCellStyle(style2);
764 field = fields[i];
765 fieldName = field.getName();
766 getMethodName = "get" + fieldName.substring(0, 1).toUpperCase()
767 + fieldName.substring(1);
768 try {
769 tCls = t.getClass();
770 getMethod = tCls.getMethod(getMethodName, new Class[]{});
771 value = getMethod.invoke(t, new Object[]{});
772 // 判断值的类型后进行强制类型转换
773 textValue = null;
774 if (value instanceof Integer) {
775 cell.setCellValue((Integer) value);
776 } else if (value instanceof Float) {
777 textValue = String.valueOf((Float) value);
778 cell.setCellValue(textValue);
779 } else if (value instanceof Double) {
780 textValue = String.valueOf((Double) value);
781 cell.setCellValue(textValue);
782 } else if (value instanceof Long) {
783 cell.setCellValue((Long) value);
784 }
785 if (value instanceof Boolean) {
786 textValue = "是";
787 if (!(Boolean) value) {
788 textValue = "否";
789 }
790 } else if (value instanceof Date) {
791 textValue = sdf.format((Date) value);
792 } else {
793 // 其它数据类型都当作字符串简单处理
794 if (value != null) {
795 textValue = value.toString();
796 }
797 }
798 if (textValue != null) {
799 matcher = p.matcher(textValue);
800 if (matcher.matches()) {
801 // 是数字当作double处理
802 cell.setCellValue(Double.parseDouble(textValue));
803 } else {
804 richString = new HSSFRichTextString(textValue);
805 cell.setCellValue(richString);
806 }
807 }
808 } catch (SecurityException e) {
809 e.printStackTrace();
810 } catch (NoSuchMethodException e) {
811 e.printStackTrace();
812 } catch (IllegalArgumentException e) {
813 e.printStackTrace();
814 } catch (IllegalAccessException e) {
815 e.printStackTrace();
816 } catch (InvocationTargetException e) {
817 e.printStackTrace();
818 } finally {
819 // 清理资源
820 }
821 }
822 }
823 try {
824 workbook.write(out);
825 } catch (IOException e) {
826 e.printStackTrace();
827 }catch (Exception e) {
828 e.printStackTrace();
829 }
830 }
831 }
下载链接：http://video-course-upyun.51minicloud.com/java/POIDemo_codedna618.zip
http://edu.51minicloud.com/Course/Detail?vid=1137
备用下载链接：
一、读取表格
<%@ page import="codedna616.demo.commom.POIExcelReader" %>
<%@ page import="codedna616.demo.commom.Student" %>
<%@ page import="java.util.List" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>读取表格数据</title>
<style>
table td{border:1px solid #F00}
</style>
</head>
<body>
<%
//"想办法找到要提供下载的文件的物理路径＋文件名";
String localFilePath = request.getServletContext().getRealPath("") + "\本地导出的文件.xls";
%>
<h3>读取表格实例 <%=localFilePath%></h3>
<%
// 读取Excel文件内容
List<Student> readResult = POIExcelReader.readExcel(localFilePath);
out.println("<table style="border:1px">");
out.println("<tr><td>编号</td><td>姓名</td><td>学号</td> <br>");
for (Student item : readResult) {
out.println("<tr><td>"+item.getId() + "</td><td>" + item.getName() + "</td><td>" + item.getStudentNo() + "</td></tr>"+"");
}
out.println("</table>");
%>
</body>
</html>
二、导出本地表格
<%@ page import="java.io.FileInputStream" %>
<%@ page import="java.net.URLEncoder" %>
<%@ page import="codedna616.demo.commom.Utils" %>
<%@ page import="codedna616.demo.commom.Student" %>
<%@ page import="codedna616.demo.commom.PoiExportExcelUtil" %>
<%@ page import="java.io.FileOutputStream" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %><%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2020/7/16
Time: 9:27
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>下载表格</title>
</head>
<body>
<%
if (request.getParameter("type") == "2003") {
} else {
}
String[] columnNames = {"ID", "姓名", "学号"};
List<Student> list = new ArrayList<>();
for (int i = 1; i <= 100; i++) {
Student model = new Student();
model.Id = Integer.toString(i);
model.Name = "学生" + i;
model.StudentNo = "序号000" + i;
list.add(model);
}
//方式1：直接导出表格测试【保存到本地】
PoiExportExcelUtil<Student> util = new PoiExportExcelUtil<Student>();
String localFilePath = request.getServletContext().getRealPath("") + "\本地导出的文件.xls";
util.exportExcel("用户导出", columnNames, list, new FileOutputStream(localFilePath), PoiExportExcelUtil.EXCEL_FILE_2003);
out.print("写入完成"+localFilePath);
%>
</body>
</html>
三、下载表格
<%@ page import="java.net.URLEncoder" %>
<%@ page import="codedna616.demo.commom.Utils" %>
<%@ page import="java.io.FileInputStream" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>下载web表格</title>
</head>
<body>
<%
//方式2：通过流下载文件（适合web下载）
//关于文件下载时采用文件流输出的方式处理：
//加上response.reset()，并且所有的％>后面不要换行，包括最后一个；
response.reset();//可以加也可以不加
response.setContentType("application/x-download");
//application.getRealPath("/main/mvplayer/CapSetup.msi");获取的物理路径
//"想办法找到要提供下载的文件的物理路径＋文件名";
String localFilePath=request.getServletContext().getRealPath("")+"\本地导出的文件.xls";
String filedisplay ="web下载的文件"+ Utils.getDateTimeNow()+".xls" ;//"给用户提供的下载文件名";
filedisplay = URLEncoder.encode(filedisplay,"UTF-8");
response.addHeader("Content-Disposition","attachment;filename=" + filedisplay);
java.io.OutputStream outp = null;
java.io.FileInputStream in = null;
try {
outp = response.getOutputStream();
in = new FileInputStream(localFilePath);
byte[] b = new byte[1024];
int i = 0;
while((i = in.read(b)) > 0) {
outp.write(b, 0, i);
}
outp.flush();
//要加以下两句话，否则会报错
//java.lang.IllegalStateException: getOutputStream() has already been called for //this response
out.clear();
out = pageContext.pushBody();
} catch(Exception e){
System.out.println("Error!");
e.printStackTrace();
}finally{
if(in != null){
in.close();
in = null;
}
//这里不能关闭
//if(outp != null) {
//outp.close();
//outp = null;
//}
}
%>
</body>
</html>
核心方法如下，建议下载完整代码查看
==》》》读取表格
POIExcelReader.java
package codedna616.demo.commom;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
//import org.springframework.web.multipart.MultipartFile;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.text.DecimalFormat;
import java.util.*;
import java.util.logging.Logger;
/**
* Author: Dreamer-1
* Date: 2019-03-01
* Time: 10:21
* Description: 读取Excel内容
*/
public class POIExcelReader {
private static Logger logger = Logger.getLogger(POIExcelReader.class.getName()); // 日志打印类
private static final String XLS = "xls";
private static final String XLSX = "xlsx";
/**
* 根据文件后缀名类型获取对应的工作簿对象
* @param inputStream 读取文件的输入流
* @param fileType 文件后缀名类型（xls或xlsx）
* @return 包含文件数据的工作簿对象
* @throws IOException
*/
public static Workbook getWorkbook(InputStream inputStream, String fileType) throws IOException {
Workbook workbook = null;
if (fileType.equalsIgnoreCase(XLS)) {
workbook = new HSSFWorkbook(inputStream);
} else if (fileType.equalsIgnoreCase(XLSX)) {
workbook = new XSSFWorkbook(inputStream);
}
return workbook;
}
/**
* 读取Excel文件内容
* @param fileName 要读取的Excel文件所在路径
* @return 读取结果列表，读取失败时返回null
*/
public static List<Student> readExcel(String fileName) {
Workbook workbook = null;
FileInputStream inputStream = null;
try {
// 获取Excel后缀名
String fileType = fileName.substring(fileName.lastIndexOf(".") + 1, fileName.length());
// 获取Excel文件
File excelFile = new File(fileName);
if (!excelFile.exists()) {
logger.warning("指定的Excel文件不存在！");
return null;
}
// 获取Excel工作簿
inputStream = new FileInputStream(excelFile);
workbook = getWorkbook(inputStream, fileType);
// 读取excel中的数据
List<Student> resultDataList = parseExcel(workbook);
return resultDataList;
} catch (Exception e) {
logger.warning("解析Excel失败，文件名：" + fileName + " 错误信息：" + e.getMessage());
return null;
} finally {
try {
if (null != workbook) {
workbook.close();
}
if (null != inputStream) {
inputStream.close();
}
} catch (Exception e) {
logger.warning("关闭数据流出错！错误信息：" + e.getMessage());
return null;
}
}
}
/**
* 读取Excel文件内容
* @param file 上传的Excel文件
* @return 读取结果列表，读取失败时返回null
*/
// public static List<Student> readExcel(MultipartFile file) {
//
// Workbook workbook = null;
//
// try {
// // 获取Excel后缀名
// String fileName = file.getOriginalFilename();
// if (fileName == null || fileName.isEmpty() || fileName.lastIndexOf(".") < 0) {
// logger.warning("解析Excel失败，因为获取到的Excel文件名非法！");
// return null;
// }
// String fileType = fileName.substring(fileName.lastIndexOf(".") + 1, fileName.length());
//
// // 获取Excel工作簿
// workbook = getWorkbook(file.getInputStream(), fileType);
//
// // 读取excel中的数据
// List<Student> resultDataList = parseExcel(workbook);
//
// return resultDataList;
// } catch (Exception e) {
// logger.warning("解析Excel失败，文件名：" + file.getOriginalFilename() + " 错误信息：" + e.getMessage());
// return null;
// } finally {
// try {
// if (null != workbook) {
// workbook.close();
// }
// } catch (Exception e) {
// logger.warning("关闭数据流出错！错误信息：" + e.getMessage());
// return null;
// }
// }
// }
/**
* 解析Excel数据
* @param workbook Excel工作簿对象
* @return 解析结果
*/
private static List<Student> parseExcel(Workbook workbook) {
List<Student> resultDataList = new ArrayList<>();
// 解析sheet
for (int sheetNum = 0; sheetNum < workbook.getNumberOfSheets(); sheetNum++) {
Sheet sheet = workbook.getSheetAt(sheetNum);
// 校验sheet是否合法
if (sheet == null) {
continue;
}
// 获取第一行数据
int firstRowNum = sheet.getFirstRowNum();
Row firstRow = sheet.getRow(firstRowNum);
if (null == firstRow) {
logger.warning("解析Excel失败，在第一行没有读取到任何数据！");
}
// 解析每一行的数据，构造数据对象
int rowStart = firstRowNum + 1;
int rowEnd = sheet.getPhysicalNumberOfRows();
for (int rowNum = rowStart; rowNum < rowEnd; rowNum++) {
Row row = sheet.getRow(rowNum);
if (null == row) {
continue;
}
Student resultData = convertRowToData(row);
if (null == resultData) {
logger.warning("第 " + row.getRowNum() + "行数据不合法，已忽略！");
continue;
}
resultDataList.add(resultData);
}
}
return resultDataList;
}
/**
* 将单元格内容转换为字符串
* @param cell
* @return
*/
private static String convertCellValueToString(Cell cell) {
if(cell==null){
return null;
}
String returnValue = null;
switch (cell.getCellType()) {
case NUMERIC: //数字
Double doubleValue = cell.getNumericCellValue();
// 格式化科学计数法，取一位整数
DecimalFormat df = new DecimalFormat("0");
returnValue = df.format(doubleValue);
break;
case STRING: //字符串
returnValue = cell.getStringCellValue();
break;
case BOOLEAN: //布尔
Boolean booleanValue = cell.getBooleanCellValue();
returnValue = booleanValue.toString();
break;
case BLANK: // 空值
break;
case FORMULA: // 公式
returnValue = cell.getCellFormula();
break;
case ERROR: // 故障
break;
default:
break;
}
return returnValue;
}
/**
* 提取每一行中需要的数据，构造成为一个结果数据对象
*
* 当该行中有单元格的数据为空或不合法时，忽略该行的数据
*
* @param row 行数据
* @return 解析后的行数据对象，行数据错误时返回null
*/
private static Student convertRowToData(Row row) {
Student resultData = new Student();
Cell cell;
int cellNum = 0;
// 获取第一列
cell = row.getCell(0);
String id = convertCellValueToString(cell);
resultData.setId(id);
// 第二列
cell = row.getCell(1);
String name = convertCellValueToString(cell);
resultData.setName(name);
// 第三列
cell = row.getCell(2);
String sutdnetNo = convertCellValueToString(cell);
resultData.setStudentNo(sutdnetNo);
return resultData;
}
}
==》》》》导出表格
PoiExportExcelUtil.java文件
package codedna616.demo.commom;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
//import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFColor;
import org.apache.poi.xssf.usermodel.XSSFFont;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
/**
* 导出Excel
*
* @param <T>
* @author
*/
public class PoiExportExcelUtil<T> {
// 2007 版本以上 最大支持1048576行
public final static String EXCEl_FILE_2007 = "2007";
// 2003 版本 最大支持65536 行
public final static String EXCEL_FILE_2003 = "2003";
/**
* <p>
* 导出无头部标题行Excel <br>
* 时间格式默认：yyyy-MM-dd hh:mm:ss <br>
* </p>
*
* @param title 表格标题
* @param dataset 数据集合
* @param out 输出流
* @param version 2003 或者 2007，不传时默认生成2003版本
*/
public void exportExcel(String title, Collection<T> dataset, OutputStream out, String version) {
if (Utils.isNullOrEmpty(version) || EXCEL_FILE_2003.equals(version.trim())) {
exportExcel2003(title, null, dataset, out, "yyyy-MM-dd HH:mm:ss");
} else {
exportExcel2007(title, null, dataset, out, "yyyy-MM-dd HH:mm:ss");
}
}
/**
* <p>
* 导出带有头部标题行的Excel <br>
* 时间格式默认：yyyy-MM-dd hh:mm:ss <br>
* </p>
*
* @param title 表格标题
* @param headers 头部标题集合
* @param dataset 数据集合
* @param out 输出流
* @param version 2003 或者 2007，不传时默认生成2003版本
*/
public void exportExcel(String title, String[] headers, Collection<T> dataset, OutputStream out, String version) {
if (Utils.isNullOrEmpty(version) || EXCEL_FILE_2003.equals(version.trim())) {
exportExcel2003(title, headers, dataset, out, "yyyy-MM-dd HH:mm:ss");
} else {
exportExcel2007(title, headers, dataset, out, "yyyy-MM-dd HH:mm:ss");
}
}
/**
* <p>
* 通用Excel导出方法,利用反射机制遍历对象的所有字段，将数据写入Excel文件中 <br>
* 此版本生成2007以上版本的文件 (文件后缀：xlsx)
* </p>
*
* @param title 表格标题名
* @param headers 表格头部标题集合
* @param dataset 需要显示的数据集合,集合中一定要放置符合JavaBean风格的类的对象。此方法支持的
* JavaBean属性的数据类型有基本数据类型及String,Date
* @param out 与输出设备关联的流对象，可以将EXCEL文档导出到本地文件或者网络中
* @param pattern 如果有时间数据，设定输出格式。默认为"yyyy-MM-dd hh:mm:ss"
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public void exportExcel2007(String title, String[] headers, Collection<T> dataset, OutputStream out, String pattern) {
// 声明一个工作薄
XSSFWorkbook workbook = new XSSFWorkbook();
// 生成一个表格
XSSFSheet sheet = workbook.createSheet(title);
// 设置表格默认列宽度为15个字节
sheet.setDefaultColumnWidth(20);
// 生成一个样式
XSSFCellStyle style = workbook.createCellStyle();
// 设置这些样式
style.setFillForegroundColor(new XSSFColor(java.awt.Color.gray));
// style.setFillPattern(XSSFCellStyle.SOLID_FOREGROUND);
//
// style.setBorderBottom(XSSFCellStyle.BORDER_THIN);
// style.setBorderLeft(XSSFCellStyle.BORDER_THIN);
// style.setBorderRight(XSSFCellStyle.BORDER_THIN);
// style.setBorderTop(XSSFCellStyle.BORDER_THIN);
// style.setAlignment(XSSFCellStyle.ALIGN_CENTER);
// 生成一个字体
XSSFFont font = workbook.createFont();
//font.setBoldweight(XSSFFont.BOLDWEIGHT_BOLD);
font.setFontName("宋体");
font.setColor(new XSSFColor(java.awt.Color.BLACK));
font.setFontHeightInPoints((short) 11);
// 把字体应用到当前的样式
style.setFont(font);
// 生成并设置另一个样式
XSSFCellStyle style2 = workbook.createCellStyle();
style2.setFillForegroundColor(new XSSFColor(java.awt.Color.WHITE));
// style2.setFillPattern(XSSFCellStyle.SOLID_FOREGROUND);
// style2.setBorderBottom(XSSFCellStyle.BORDER_THIN);
// style2.setBorderLeft(XSSFCellStyle.BORDER_THIN);
// style2.setBorderRight(XSSFCellStyle.BORDER_THIN);
// style2.setBorderTop(XSSFCellStyle.BORDER_THIN);
// style2.setAlignment(XSSFCellStyle.ALIGN_CENTER);
// style2.setVerticalAlignment(XSSFCellStyle.VERTICAL_CENTER);
// 生成另一个字体
XSSFFont font2 = workbook.createFont();
//font2.setBoldweight(XSSFFont.BOLDWEIGHT_NORMAL);
// 把字体应用到当前的样式
style2.setFont(font2);
// 产生表格标题行
XSSFRow row = sheet.createRow(0);
XSSFCell cellHeader;
for (int i = 0; i < headers.length; i++) {
cellHeader = row.createCell(i);
cellHeader.setCellStyle(style);
cellHeader.setCellValue(new XSSFRichTextString(headers[i]));
}
// 遍历集合数据，产生数据行
Iterator<T> it = dataset.iterator();
int index = 0;
T t;
Field[] fields;
Field field;
XSSFRichTextString richString;
Pattern p = Pattern.compile("^//d+(//.//d+)?$");
Matcher matcher;
String fieldName;
String getMethodName;
XSSFCell cell;
Class tCls;
Method getMethod;
Object value;
String textValue;
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
while (it.hasNext()) {
index++;
row = sheet.createRow(index);
t = (T) it.next();
// 利用反射，根据JavaBean属性的先后顺序，动态调用getXxx()方法得到属性值
fields = t.getClass().getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
cell = row.createCell(i);
cell.setCellStyle(style2);
field = fields[i];
fieldName = field.getName();
getMethodName = "get" + fieldName.substring(0, 1).toUpperCase()
+ fieldName.substring(1);
try {
tCls = t.getClass();
getMethod = tCls.getMethod(getMethodName, new Class[]{});
value = getMethod.invoke(t, new Object[]{});
// 判断值的类型后进行强制类型转换
textValue = null;
if (value instanceof Integer) {
cell.setCellValue((Integer) value);
} else if (value instanceof Float) {
textValue = String.valueOf((Float) value);
cell.setCellValue(textValue);
} else if (value instanceof Double) {
textValue = String.valueOf((Double) value);
cell.setCellValue(textValue);
} else if (value instanceof Long) {
cell.setCellValue((Long) value);
}
if (value instanceof Boolean) {
textValue = "是";
if (!(Boolean) value) {
textValue = "否";
}
} else if (value instanceof Date) {
textValue = sdf.format((Date) value);
} else {
// 其它数据类型都当作字符串简单处理
if (value != null) {
textValue = value.toString();
}
}
if (textValue != null) {
matcher = p.matcher(textValue);
if (matcher.matches()) {
// 是数字当作double处理
cell.setCellValue(Double.parseDouble(textValue));
} else {
richString = new XSSFRichTextString(textValue);
cell.setCellValue(richString);
}
}
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} finally {
// 清理资源
}
}
}
try {
workbook.write(out);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* <p>
* 通用Excel导出方法,利用反射机制遍历对象的所有字段，将数据写入Excel文件中 <br>
* 此方法生成2003版本的excel,文件名后缀：xls <br>
* </p>
*
* @param title 表格标题名
* @param headers 表格头部标题集合
* @param dataset 需要显示的数据集合,集合中一定要放置符合JavaBean风格的类的对象。此方法支持的
* JavaBean属性的数据类型有基本数据类型及String,Date
* @param out 与输出设备关联的流对象，可以将EXCEL文档导出到本地文件或者网络中
* @param pattern 如果有时间数据，设定输出格式。默认为"yyyy-MM-dd hh:mm:ss"
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public void exportExcel2003(String title, String[] headers, Collection<T> dataset, OutputStream out, String pattern) {
// 声明一个工作薄
HSSFWorkbook workbook = new HSSFWorkbook();
// 生成一个表格
HSSFSheet sheet = workbook.createSheet(title);
// 设置表格默认列宽度为15个字节
sheet.setDefaultColumnWidth(20);
// 生成一个样式
HSSFCellStyle style = workbook.createCellStyle();
// 设置这些样式
// style.setFillForegroundColor(HSSFColor.GREY_50_PERCENT.index);
// style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
// style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
// style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
// style.setBorderRight(HSSFCellStyle.BORDER_THIN);
// style.setBorderTop(HSSFCellStyle.BORDER_THIN);
// style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
// 生成一个字体
HSSFFont font = workbook.createFont();
// font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
font.setFontName("宋体");
// font.setColor(HSSFColor.WHITE.index);
font.setFontHeightInPoints((short) 11);
// 把字体应用到当前的样式
style.setFont(font);
// 生成并设置另一个样式
HSSFCellStyle style2 = workbook.createCellStyle();
// style2.setFillForegroundColor(HSSFColor.WHITE.index);
// style2.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
// style2.setBorderBottom(HSSFCellStyle.BORDER_THIN);
// style2.setBorderLeft(HSSFCellStyle.BORDER_THIN);
// style2.setBorderRight(HSSFCellStyle.BORDER_THIN);
// style2.setBorderTop(HSSFCellStyle.BORDER_THIN);
// style2.setAlignment(HSSFCellStyle.ALIGN_CENTER);
// style2.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
// 生成另一个字体
HSSFFont font2 = workbook.createFont();
// font2.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
// 把字体应用到当前的样式
style2.setFont(font2);
// 产生表格标题行
HSSFRow row = sheet.createRow(0);
HSSFCell cellHeader;
for (int i = 0; i < headers.length; i++) {
cellHeader = row.createCell(i);
cellHeader.setCellStyle(style);
cellHeader.setCellValue(new HSSFRichTextString(headers[i]));
}
// 遍历集合数据，产生数据行
Iterator<T> it = dataset.iterator();
int index = 0;
T t;
Field[] fields;
Field field;
HSSFRichTextString richString;
Pattern p = Pattern.compile("^//d+(//.//d+)?$");
Matcher matcher;
String fieldName;
String getMethodName;
HSSFCell cell;
Class tCls;
Method getMethod;
Object value;
String textValue;
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
while (it.hasNext()) {
index++;
row = sheet.createRow(index);
t = (T) it.next();
// 利用反射，根据JavaBean属性的先后顺序，动态调用getXxx()方法得到属性值
fields = t.getClass().getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
cell = row.createCell(i);
cell.setCellStyle(style2);
field = fields[i];
fieldName = field.getName();
getMethodName = "get" + fieldName.substring(0, 1).toUpperCase()
+ fieldName.substring(1);
try {
tCls = t.getClass();
getMethod = tCls.getMethod(getMethodName, new Class[]{});
value = getMethod.invoke(t, new Object[]{});
// 判断值的类型后进行强制类型转换
textValue = null;
if (value instanceof Integer) {
cell.setCellValue((Integer) value);
} else if (value instanceof Float) {
textValue = String.valueOf((Float) value);
cell.setCellValue(textValue);
} else if (value instanceof Double) {
textValue = String.valueOf((Double) value);
cell.setCellValue(textValue);
} else if (value instanceof Long) {
cell.setCellValue((Long) value);
}
if (value instanceof Boolean) {
textValue = "是";
if (!(Boolean) value) {
textValue = "否";
}
} else if (value instanceof Date) {
textValue = sdf.format((Date) value);
} else {
// 其它数据类型都当作字符串简单处理
if (value != null) {
textValue = value.toString();
}
}
if (textValue != null) {
matcher = p.matcher(textValue);
if (matcher.matches()) {
// 是数字当作double处理
cell.setCellValue(Double.parseDouble(textValue));
} else {
richString = new HSSFRichTextString(textValue);
cell.setCellValue(richString);
}
}
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} finally {
// 清理资源
}
}
}
try {
workbook.write(out);
} catch (IOException e) {
e.printStackTrace();
}catch (Exception e) {
e.printStackTrace();
}
}
}
jar文件和代码下载地址，使用ideaj ，java-jdk1.8 导入即可：http://edu.51minicloud.com/ThirdPartDown/Down?id=3034906a3884487e8d93f0a546daea4a&title=cnblog