Java-POI 4.1.2 表格导入导出2020.2.17官网发布的库

Java-POI表格导入导出

Java-POI表格导入导出,给予POI4.1.2,poi-bin-4.1.2-20200217 版本,2020.2.17官网发布的库

Java-POI 4.1.2 表格导入导出2020.2.17官网发布的库

 

 

 .

Java-POI 4.1.2 表格导入导出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://51minicloud.com/ThirdPartDown/Down?id=3034906a3884487e8d93f0a546daea4a&title=cnblog

上一篇:利用Python读取和修改Excel文件(包括xls文件和xlsx文件)——基于xlrd、xlwt和openpyxl模块


下一篇:Python系列(6)——将三种类型的数据添加进新sheet及已有的sheet中且不覆盖原数据