Apache POI组件操作Excel

    Apache的POI组件是Java操作Microsoft Office办公套件的强大API，其中对Word，Excel和PowperPoint都有支持，当然使用较多的还是Excel，因为Word和PowerPoint用程序动态操作的应用较少。那么本文就结合POI来介绍一下操作Excel的方法。 
    Office 2007的文件结构完全不同于2003，所以对于两个版本的Office组件，POI有不同的处理API，分开使用即可。首先来说几个Excel的基本概念。对于一个Excel文件，这称为一个工作簿（Workbook），打开Excel之后，在下方会有sheet1/2/3这样的选项卡，点击可以切换到不同的sheet中，这个sheet称作工作表。每个工作表就是我们编辑的区域，这是一张二维表，阿拉伯数字控制行数，从1开始，而程序中还是0，类似数组和集合。字母控制列数，从A开始，Z以后是两个字母控制。对于每一行，我们称为Row，列就是Column，行列可以确定唯一的一个元素，那么就是单元格，称为Cell。 
    POI组件可以方便的操纵这些元素，但初次接触POI可能会有畏惧心理，因为要对每个单元格进行设置，那么不管是用数组还是集合，从工作簿，工作表，行下来的代码量都不会小，这是不能避免的，但是按照这个处理顺序走，就一定可以得到结果。 
    有了这些基础的概念之后，我们就可以操作Excel了。先来看一下所需的依赖，因为涉及到2007，就要额外加一些依赖。 
 
    下面从读取Excel开始，首先建立一个Excel 2003以下版本的xls文件。设定几列来看。来存储学生信息的Excel表如下： 
 
    这里的姓名，性别和班级是文本值，而年龄和成绩是数字值，这在设计对象和处理时要注意区分。那么可以如下设计这个对象： 
Java代码  

1. package org.ourpioneer.excel.bean;  
2. /** 
3.  * 学生信息 
4.  *  
5.  * @author Nanlei 
6.  *  
7.  */  
8. public class Student {  
9.     private String name;  
10.     private String gender;  
11.     private int age;  
12.     private String sclass;  
13.     private int score;  
14.     public Student() {  
15.         super();  
16.     }  
17.     public Student(String name, String gender, int age, String sclass, int score) {  
18.         super();  
19.         this.name = name;  
20.         this.gender = gender;  
21.         this.age = age;  
22.         this.sclass = sclass;  
23.         this.score = score;  
24.     }  
25. //省略了getter和setter方法  
26.     @Override  
27.     public String toString() {  
28.         return "Student [age=" + age + ", gender=" + gender + ", name=" + name  
29.                 + ", sclass=" + sclass + ", score=" + score + "]";  
30.     }  
31. }  

    提供一个有参数的构造方法，用于生成对象写入Excel文档。这个对象就能刻画Excel文件中的数据了，下面就是写程序将Excel文件加载并处理，然后将内容读出，读取顺序是工作簿->工作表->行->单元格。这样一分析就很简单了。我们定义两个Excel文件，内容相同，只是版本不同，分2003和2007来处理。 
    创建工作簿时可以接收一个输入流对象，那么输入流对象可以从文件对象来生成，这样就可以继续进行了。取出工作表，取出行，遍历单元格，数据就拿到了。代码如下： 
Java代码  

1. package org.ourpioneer.excel;  
2. import java.io.File;  
3. import java.io.FileInputStream;  
4. import java.io.IOException;  
5. import java.io.InputStream;  
6. import java.util.ArrayList;  
7. import java.util.List;  
8. import org.apache.poi.hssf.usermodel.HSSFCell;  
9. import org.apache.poi.hssf.usermodel.HSSFRow;  
10. import org.apache.poi.hssf.usermodel.HSSFSheet;  
11. import org.apache.poi.hssf.usermodel.HSSFWorkbook;  
12. import org.ourpioneer.excel.bean.Student;  
13. /** 
14.  * POI读取Excel示例，分2003和2007 
15.  *  
16.  * @author Nanlei 
17.  *  
18.  */  
19. public class ReadExcel {  
20.     private static String xls2003 = "C:\\student.xls";  
21.     private static String xlsx2007 = "C:\\student.xlsx";  
22.     /** 
23.      * 读取Excel2003的示例方法 
24.      *  
25.      * @param filePath 
26.      * @return 
27.      */  
28. private static List<Student> readFromXLS2003(String filePath) {  
29.         File excelFile = null;// Excel文件对象  
30.         InputStream is = null;// 输入流对象  
31.         String cellStr = null;// 单元格，最终按字符串处理  
32.         List<Student> studentList = new ArrayList<Student>();// 返回封装数据的List  
33.         Student student = null;// 每一个学生信息对象  
34. try {  
35.             excelFile = new File(filePath);  
36.             is = new FileInputStream(excelFile);// 获取文件输入流  
37.             HSSFWorkbook workbook2003 = new HSSFWorkbook(is);// 创建Excel2003文件对象  
38.             HSSFSheet sheet = workbook2003.getSheetAt(0);// 取出第一个工作表，索引是0  
39.             // 开始循环遍历行，表头不处理，从1开始  
40.             for (int i = 1; i <= sheet.getLastRowNum(); i++) {  
41.                 student = new Student();// 实例化Student对象  
42.                 HSSFRow row = sheet.getRow(i);// 获取行对象  
43.                 if (row == null) {// 如果为空，不处理  
44.                     continue;  
45.                 }  
46. // 循环遍历单元格  
47.                 for (int j = 0; j < row.getLastCellNum(); j++) {  
48.                     HSSFCell cell = row.getCell(j);// 获取单元格对象  
49.                     if (cell == null) {// 单元格为空设置cellStr为空串  
50.                         cellStr = "";  
51.                     } else if (cell.getCellType() == HSSFCell.CELL_TYPE_BOOLEAN) {// 对布尔值的处理  
52.                         cellStr = String.valueOf(cell.getBooleanCellValue());  
53.                     } else if (cell.getCellType() == HSSFCell.CELL_TYPE_NUMERIC) {// 对数字值的处理  
54.                         cellStr = cell.getNumericCellValue() + "";  
55.                     } else {// 其余按照字符串处理  
56.                         cellStr = cell.getStringCellValue();  
57.                     }  
58. // 下面按照数据出现位置封装到bean中  
59.                     if (j == 0) {  
60.                         student.setName(cellStr);  
61.                     } else if (j == 1) {  
62.                         student.setGender(cellStr);  
63.                     } else if (j == 2) {  
64.                         student.setAge(new Double(cellStr).intValue());  
65.                     } else if (j == 3) {  
66.                         student.setSclass(cellStr);  
67.                     } else {  
68.                         student.setScore(new Double(cellStr).intValue());  
69.                     }  
70.                 }  
71.                 studentList.add(student);// 数据装入List  
72.             }  
73. } catch (IOException e) {  
74.             e.printStackTrace();  
75.         } finally {// 关闭文件流  
76.             if (is != null) {  
77.                 try {  
78.                     is.close();  
79.                 } catch (IOException e) {  
80.                     e.printStackTrace();  
81.                 }  
82.             }  
83.         }  
84.         return studentList;  
85.     }  
86. /** 
87.      * 主函数 
88.      *  
89.      * @param args 
90.      */  
91.     public static void main(String[] args) {  
92.         long start = System.currentTimeMillis();  
93.         List<Student> list = readFromXLS2003(xls2003);  
94.         for (Student student : list) {  
95.             System.out.println(student);  
96.         }  
97.         long end = System.currentTimeMillis();  
98.         System.out.println((end - start) + " ms done!");  
99.     }  
100. }  

    做几点说明，如果不处理表头，那么就从准备处理的行开始，而整个sheet对行的索引是从0开始的，而Excel中是1，这点和数组/集合类似。对于单元格中的数字，默认按double类型处理，所以只能字符串转double，再取出int值。最后执行主函数，得到如下内容： 
 
    这样就拿到对象的List了，之后要持久到数据库或者直接做业务逻辑就随心所欲了。下面来看2007的处理，处理流程和2003是类似的，区别就是使用的对象，2003中对象是HSSF*格式的，而2007是XSSF*格式的。方法如下： 
Java代码  

1. public static List<Student> readFromXLSX2007(String filePath) {  
2.         File excelFile = null;// Excel文件对象  
3.         InputStream is = null;// 输入流对象  
4.         String cellStr = null;// 单元格，最终按字符串处理  
5.         List<Student> studentList = new ArrayList<Student>();// 返回封装数据的List  
6.         Student student = null;// 每一个学生信息对象  
7.         try {  
8.             excelFile = new File(filePath);  
9.             is = new FileInputStream(excelFile);// 获取文件输入流  
10.             XSSFWorkbook workbook2007 = new XSSFWorkbook(is);// 创建Excel2003文件对象  
11.             XSSFSheet sheet = workbook2007.getSheetAt(0);// 取出第一个工作表，索引是0  
12.             // 开始循环遍历行，表头不处理，从1开始  
13.             for (int i = 1; i <= sheet.getLastRowNum(); i++) {  
14.                 student = new Student();// 实例化Student对象  
15.                 XSSFRow row = sheet.getRow(i);// 获取行对象  
16.                 if (row == null) {// 如果为空，不处理  
17.                     continue;  
18.                 }  
19.                 // 循环遍历单元格  
20.                 for (int j = 0; j < row.getLastCellNum(); j++) {  
21.                     XSSFCell cell = row.getCell(j);// 获取单元格对象  
22.                     if (cell == null) {// 单元格为空设置cellStr为空串  
23.                         cellStr = "";  
24.                     } else if (cell.getCellType() == HSSFCell.CELL_TYPE_BOOLEAN) {// 对布尔值的处理  
25.                         cellStr = String.valueOf(cell.getBooleanCellValue());  
26.                     } else if (cell.getCellType() == HSSFCell.CELL_TYPE_NUMERIC) {// 对数字值的处理  
27.                         cellStr = cell.getNumericCellValue() + "";  
28.                     } else {// 其余按照字符串处理  
29.                         cellStr = cell.getStringCellValue();  
30.                     }  
31.                     // 下面按照数据出现位置封装到bean中  
32.                     if (j == 0) {  
33.                         student.setName(cellStr);  
34.                     } else if (j == 1) {  
35.                         student.setGender(cellStr);  
36.                     } else if (j == 2) {  
37.                         student.setAge(new Double(cellStr).intValue());  
38.                     } else if (j == 3) {  
39.                         student.setSclass(cellStr);  
40.                     } else {  
41.                         student.setScore(new Double(cellStr).intValue());  
42.                     }  
43.                 }  
44.                 studentList.add(student);// 数据装入List  
45.             }  
46.         } catch (IOException e) {  
47.             e.printStackTrace();  
48.         } finally {// 关闭文件流  
49.             if (is != null) {  
50.                 try {  
51.                     is.close();  
52.                 } catch (IOException e) {  
53.                     e.printStackTrace();  
54.                 }  
55.             }  
56.         }  
57.         return studentList;  
58.     }  

    再次运行主函数，我们得到如下输出： 
 
    可以看出，对2007的处理时间明显增长，还是2003版本效率更好，不过在使用Office组件时2007更便捷，而处理2003的程序效率更好。如何使用二者？根据程序业务来综合决定，看看牺牲掉哪部分。 
    下面来做简单的文件写入，也就是准备输入写入Excel文件，为了演示，直接创建对象，而实际应用中数据可以是来自数据库的。写入文件就是文件解析的逆过程。但POI的组件不是从单元格开始创建文件的，还是从工作簿开始创建，进而创建工作表，行和单元格，最终将整个工作簿写入文件，完成操作。我们来看具体写法。 
Java代码  

1. package org.ourpioneer.excel;  
2. import java.io.File;  
3. import java.io.FileOutputStream;  
4. import java.util.ArrayList;  
5. import java.util.Arrays;  
6. import java.util.List;  
7. import org.apache.poi.hssf.usermodel.HSSFCell;  
8. import org.apache.poi.hssf.usermodel.HSSFRow;  
9. import org.apache.poi.hssf.usermodel.HSSFSheet;  
10. import org.apache.poi.hssf.usermodel.HSSFWorkbook;  
11. import org.ourpioneer.excel.bean.Student;  
12. /** 
13.  * 生成Excel示例，2003和2007 
14.  *  
15.  * @author Nanlei 
16.  *  
17.  */  
18. public class GenerateExcel {  
19.     private static String xls2003 = "C:\\student.xls";  
20.     private static String xlsx2007 = "C:\\student.xlsx";  
21.     private static List<Student> studentList = null;  
22.     private static Student[] students = new Student[4];  
23.     /** 
24.      * 静态块初始化数据 
25.      */  
26.     static {  
27.         studentList = new ArrayList<Student>();  
28.         students[0] = new Student("张三", "男", 23, "一班", 94);  
29.         students[1] = new Student("李四", "女", 20, "一班", 92);  
30.         students[2] = new Student("王五", "男", 21, "一班", 87);  
31.         students[3] = new Student("赵六", "女", 22, "一班", 83);  
32.         studentList.addAll(Arrays.asList(students));  
33.     }  
34.     /** 
35.      * 创建2003文件的方法 
36.      *  
37.      * @param filePath 
38.      */  
39.     public static void generateExcel2003(String filePath) {  
40.         // 先创建工作簿对象  
41.         HSSFWorkbook workbook2003 = new HSSFWorkbook();  
42.         // 创建工作表对象并命名  
43.         HSSFSheet sheet = workbook2003.createSheet("学生信息统计表");  
44.         // 遍历集合对象创建行和单元格  
45.         for (int i = 0; i < studentList.size(); i++) {  
46.             // 取出Student对象  
47.             Student student = studentList.get(i);  
48.             // 创建行  
49.             HSSFRow row = sheet.createRow(i);  
50.             // 开始创建单元格并赋值  
51.             HSSFCell nameCell = row.createCell(0);  
52.             nameCell.setCellValue(student.getName());  
53.             HSSFCell genderCell = row.createCell(1);  
54.             genderCell.setCellValue(student.getGender());  
55.             HSSFCell ageCell = row.createCell(2);  
56.             ageCell.setCellValue(student.getAge());  
57.             HSSFCell sclassCell = row.createCell(3);  
58.             sclassCell.setCellValue(student.getSclass());  
59.             HSSFCell scoreCell = row.createCell(4);  
60.             scoreCell.setCellValue(student.getScore());  
61.         }  
62.         // 生成文件  
63.         File file = new File(filePath);  
64.         FileOutputStream fos = null;  
65.         try {  
66.             fos = new FileOutputStream(file);  
67.             workbook2003.write(fos);  
68.         } catch (Exception e) {  
69.             e.printStackTrace();  
70.         } finally {  
71.             if (fos != null) {  
72.                 try {  
73.                     fos.close();  
74.                 } catch (Exception e) {  
75.                     e.printStackTrace();  
76.                 }  
77.             }  
78.         }  
79.     }  
80.     /** 
81.      * 主函数 
82.      *  
83.      * @param args 
84.      */  
85.     public static void main(String[] args) {  
86.         long start = System.currentTimeMillis();  
87.         generateExcel2003(xls2003);  
88.         long end = System.currentTimeMillis();  
89.         System.out.println((end - start) + " ms done!");  
90.     }  
91. }  

    这样就生成了2003版Excel文件，只是最简单的操作，并没有涉及到单元格格式等操作，而2007的方法就是改改对象的名称，很简单，这里不再贴出了。 
     现在来看看Excel的基本设置问题，以2007为例，先从工作簿来说，设置列宽，因为生成表格列应该固定，而行是遍历生成的，所以可以在工作簿级别来设置列宽，那么可以如下来进行。 
    首先是创建工作簿和工作表了： 
Java代码  

1.         // 创建Excel2007工作簿对象  
2.         XSSFWorkbook workbook2007 = new XSSFWorkbook();  
3.         // 创建工作表对象并命名  
4.         XSSFSheet sheet = workbook2007.createSheet("学生信息统计表");  
5. 之后是设置格式：  
6.         // 设置行列的默认宽度和高度  
7.         sheet.setColumnWidth(0, 32 * 80);// 对A列设置宽度为80像素  
8.         sheet.setColumnWidth(1, 32 * 80);  
9.         sheet.setColumnWidth(2, 32 * 80);  
10.         sheet.setColumnWidth(3, 32 * 80);  
11.         sheet.setColumnWidth(4, 32 * 80);  

    在这之前要先创建一个工作表sheet，然后就可以对每列设置列宽了。而行高一般针对不同的行有不同的设置，比如表头行，合计行，数据行等，那么分别设置会比较好。设置完列宽和行高，剩下就是对单元格的设置，比如居中，边框，字体等。设置好样式后将样式应用于所需要的单元格，就得到了整体的效果，比如： 
Java代码  

1. // 创建样式  
2.         XSSFFont font = workbook2007.createFont();  
3.         XSSFCellStyle headerStyle = workbook2007.createCellStyle();  
4.         // 设置垂直居中  
5.         headerStyle.setAlignment(HorizontalAlignment.CENTER);  
6.         headerStyle.setVerticalAlignment(VerticalAlignment.CENTER);  
7.         // 设置边框  
8.         headerStyle.setBorderTop(BorderStyle.THIN);  
9.         headerStyle.setBorderBottom(BorderStyle.THIN);  
10.         headerStyle.setBorderLeft(BorderStyle.THIN);  
11.         headerStyle.setBorderRight(BorderStyle.THIN);  
12.         // 字体加粗  
13.         font.setBold(true);  
14.         // 设置长文本自动换行  
15.         headerStyle.setWrapText(true);  
16.         headerStyle.setFont(font);  

    这里我们定义的是表头的样式，其中垂直居中时的设置要设置两次，而且方法名不同，要注意。边框就很简单了，上下左右设置四次，字体加粗就是布尔值设定了，之后是文本自动换行，意思就是在固定单元格长度不变时是否自动折行。然后将字体样式加入到单元格样式中即可。 
    下面针对之前的例子设计表头，如下： 
Java代码  

1. // 创建表头  
2.         XSSFRow headerRow = sheet.createRow(0);  
3.         headerRow.setHeightInPoints(25f);// 设置行高度  
4.         XSSFCell nameHeader = headerRow.createCell(0);  
5.         nameHeader.setCellValue("姓名");  
6.         nameHeader.setCellStyle(headerStyle);  
7.         XSSFCell genderHeader = headerRow.createCell(1);  
8.         genderHeader.setCellValue("性别");  
9.         genderHeader.setCellStyle(headerStyle);  
10.         XSSFCell ageHeader = headerRow.createCell(2);  
11.         ageHeader.setCellValue("年龄");  
12.         ageHeader.setCellStyle(headerStyle);  
13.         XSSFCell classHeader = headerRow.createCell(3);  
14.         classHeader.setCellValue("班级");  
15.         classHeader.setCellStyle(headerStyle);  
16.         XSSFCell scoreHeader = headerRow.createCell(4);  
17.         scoreHeader.setCellValue("成绩");  
18.         scoreHeader.setCellStyle(headerStyle);  

    这里的代码会有大段的重复，因为都是一个套路下来的，最后别忘加入样式就行了，这样表格头部就做好了。剩下的是遍历数据出行。 
Java代码  

1. for (int i = 0; i < studentList.size(); i++) {  
2.             XSSFRow row = sheet.createRow(i + 1);  
3.             row.setHeightInPoints(20f);  
4.             Student student = studentList.get(i);  
5.             XSSFCell nameCell = row.createCell(0);  
6.             nameCell.setCellValue(student.getName());  
7.             nameCell.setCellStyle(cellStyle);  
8.             XSSFCell genderCell = row.createCell(1);  
9.             genderCell.setCellValue(student.getGender());  
10.             genderCell.setCellStyle(cellStyle);  
11.             XSSFCell ageCell = row.createCell(2);  
12.             ageCell.setCellValue(student.getAge());  
13.             ageCell.setCellStyle(cellStyle);  
14.             XSSFCell classCell = row.createCell(3);  
15.             classCell.setCellValue(student.getSclass());  
16.             classCell.setCellStyle(cellStyle);  
17.             XSSFCell scoreCell = row.createCell(4);  
18.             scoreCell.setCellValue(student.getScore());  
19.             scoreCell.setCellStyle(cellStyle);  
20.         }  

    用for循环就可以完成任务，需要注意的是循环变量仍然从0开始走，这是为了遍历集合的方便，而创建行就是从i+1开始走了，因为0行是表头，已经占用了。下面就是先设定行高，之后开始取值，赋值，设定格式，结构也很统一。 
    完成遍历后，来看看合并，Excel中的合并单元格也是很常用的操作，比如本例中，将班级都设置成一班后，那么就想让班级这列合并，该如何操作呢？ 
Java代码  

1. // 合并班级  
2. sheet.addMergedRegion(new CellRangeAddress(1, 4, 3, 3));  

    这是对sheet级别的操作，因为是在sheet上合并单元格，就是加一个合并的区域，这个区域接收四个参数，就是开始的行，结束的行，开始的列，结束的列，这个位置一般比较确定，或者用循环变量计算得出。班级，从第二行开始，第五行结束，对应索引是1，4，而列不变，就是在列上合并，就都是3即可。 
    至此我们已经将数据遍历得出生成了Excel表格，设置了单元格样式也进行了合并，那么还有合计没有说，用合计可以直接设置公式，也可以程序计算好后直接填充，后者一般用于比较复杂的报表，就不用在POI中设置合并的位置，减少复杂度。结合本例，我们来计算平均年龄和成绩之和。如下： 
Java代码  

1. // 数据分析行  
2.         int dadaRowNum = sheet.getLastRowNum();  
3.         XSSFRow totalRow = sheet.createRow(dadaRowNum + 1);// 获取已有的行数，加1再出新行  
4.         totalRow.setHeightInPoints(25f);  
5.         XSSFCell analyticsCell = totalRow.createCell(0);  
6.         analyticsCell.setCellValue("数据分析");  
7.         analyticsCell.setCellStyle(headerStyle);  
8.         XSSFCell avgAgeCell = totalRow.createCell(1);  
9.         avgAgeCell.setCellValue("平均年龄");  
10.         avgAgeCell.setCellStyle(headerStyle);  
11.         XSSFCell avgAgeValueCell = totalRow.createCell(2);  
12.         avgAgeValueCell.setCellStyle(headerStyle);  
13.         avgAgeValueCell.setCellFormula("AVERAGE(C2:C" + (dadaRowNum + 1) + ")");  
14.         XSSFCell sumScoreCell = totalRow.createCell(3);  
15.         sumScoreCell.setCellValue("总成绩");  
16.         sumScoreCell.setCellStyle(headerStyle);  
17.         XSSFCell sumScoreValueCell = totalRow.createCell(4);  
18.         sumScoreValueCell.setCellStyle(headerStyle);  
19.         sumScoreValueCell.setCellFormula("SUM(E2:E" + (dadaRowNum + 1) + ")");  

    这里使用Excel函数的时候我们已经知道数据所在的位置，就直接使用了单元格的代号进行运算了，要注意使用公式时的方法中不用写=号，POI会自动为我们添加进去，这里就直接写公式的内容即可。在实际中可能会有动态计算的任务，那么就根据业务复杂度来选择是用Excel公式进行运算还是程序运算好后直接赋值显示。 
    最后是生成文件的步骤，这已经介绍过了，都很简单： 
Java代码  

1.         // 生成文件  
2. File file = new File(filePath);  
3. OutputStream os = null;  
4. try {  
5.     os = new FileOutputStream(file);  
6.     workbook2007.write(os);  
7. } catch (IOException e) {  
8.     e.printStackTrace();  
9. } finally {  
10.     if (os != null) {  
11.         try {  
12.             os.close();  
13.         } catch (IOException e) {  
14.         }  
15.     }  
16. }  

    最后是执行测试了，写个主函数来运行： 
Java代码  

1. public static void main(String[] args) {  
2.         long start = System.currentTimeMillis();  
3.         generateExcel2007(xlsx2007);  
4.         long end = System.currentTimeMillis();  
5.         System.out.println((end - start) + " ms done!");  
6.     }  

    将以上所有内容封装在静态方法generateExcel2007(String filePath)中，执行即可得到生成的Excel报表了，我们得到了这样的一个报表： 
 
    这就是最终得到的结果了。POI操作Excel的基本设置就基本涵盖了，剩下的就是灵活运用，生成符合自己需求的报表了。 
    下一篇将结合一个具体实例来介绍复杂报表的分析和制作，完成如下图所示的报表： 
    现在来看看Excel的基本设置问题，以2007为例，先从工作簿来说，设置列宽，因为生成表格列应该固定，而行是遍历生成的，所以可以在工作簿级别来设置列宽，那么可以如下来进行。 
    首先是创建工作簿和工作表了： 
Java代码  

1.         // 创建Excel2007工作簿对象  
2.         XSSFWorkbook workbook2007 = new XSSFWorkbook();  
3.         // 创建工作表对象并命名  
4.         XSSFSheet sheet = workbook2007.createSheet("学生信息统计表");  
5. 之后是设置格式：  
6.         // 设置行列的默认宽度和高度  
7.         sheet.setColumnWidth(0, 32 * 80);// 对A列设置宽度为80像素  
8.         sheet.setColumnWidth(1, 32 * 80);  
9.         sheet.setColumnWidth(2, 32 * 80);  
10.         sheet.setColumnWidth(3, 32 * 80);  
11.         sheet.setColumnWidth(4, 32 * 80);  

    在这之前要先创建一个工作表sheet，然后就可以对每列设置列宽了。而行高一般针对不同的行有不同的设置，比如表头行，合计行，数据行等，那么分别设置会比较好。设置完列宽和行高，剩下就是对单元格的设置，比如居中，边框，字体等。设置好样式后将样式应用于所需要的单元格，就得到了整体的效果，比如： 
Java代码  

1. // 创建样式  
2.         XSSFFont font = workbook2007.createFont();  
3.         XSSFCellStyle headerStyle = workbook2007.createCellStyle();  
4.         // 设置垂直居中  
5.         headerStyle.setAlignment(HorizontalAlignment.CENTER);  
6.         headerStyle.setVerticalAlignment(VerticalAlignment.CENTER);  
7.         // 设置边框  
8.         headerStyle.setBorderTop(BorderStyle.THIN);  
9.         headerStyle.setBorderBottom(BorderStyle.THIN);  
10.         headerStyle.setBorderLeft(BorderStyle.THIN);  
11.         headerStyle.setBorderRight(BorderStyle.THIN);  
12.         // 字体加粗  
13.         font.setBold(true);  
14.         // 设置长文本自动换行  
15.         headerStyle.setWrapText(true);  
16.         headerStyle.setFont(font);  

    这里我们定义的是表头的样式，其中垂直居中时的设置要设置两次，而且方法名不同，要注意。边框就很简单了，上下左右设置四次，字体加粗就是布尔值设定了，之后是文本自动换行，意思就是在固定单元格长度不变时是否自动折行。然后将字体样式加入到单元格样式中即可。 
    下面针对之前的例子设计表头，如下： 
Java代码  

1. // 创建表头  
2.         XSSFRow headerRow = sheet.createRow(0);  
3.         headerRow.setHeightInPoints(25f);// 设置行高度  
4.         XSSFCell nameHeader = headerRow.createCell(0);  
5.         nameHeader.setCellValue("姓名");  
6.         nameHeader.setCellStyle(headerStyle);  
7.         XSSFCell genderHeader = headerRow.createCell(1);  
8.         genderHeader.setCellValue("性别");  
9.         genderHeader.setCellStyle(headerStyle);  
10.         XSSFCell ageHeader = headerRow.createCell(2);  
11.         ageHeader.setCellValue("年龄");  
12.         ageHeader.setCellStyle(headerStyle);  
13.         XSSFCell classHeader = headerRow.createCell(3);  
14.         classHeader.setCellValue("班级");  
15.         classHeader.setCellStyle(headerStyle);  
16.         XSSFCell scoreHeader = headerRow.createCell(4);  
17.         scoreHeader.setCellValue("成绩");  
18.         scoreHeader.setCellStyle(headerStyle);  

    这里的代码会有大段的重复，因为都是一个套路下来的，最后别忘加入样式就行了，这样表格头部就做好了。剩下的是遍历数据出行。 
Java代码  

1. for (int i = 0; i < studentList.size(); i++) {  
2.             XSSFRow row = sheet.createRow(i + 1);  
3.             row.setHeightInPoints(20f);  
4.             Student student = studentList.get(i);  
5.             XSSFCell nameCell = row.createCell(0);  
6.             nameCell.setCellValue(student.getName());  
7.             nameCell.setCellStyle(cellStyle);  
8.             XSSFCell genderCell = row.createCell(1);  
9.             genderCell.setCellValue(student.getGender());  
10.             genderCell.setCellStyle(cellStyle);  
11.             XSSFCell ageCell = row.createCell(2);  
12.             ageCell.setCellValue(student.getAge());  
13.             ageCell.setCellStyle(cellStyle);  
14.             XSSFCell classCell = row.createCell(3);  
15.             classCell.setCellValue(student.getSclass());  
16.             classCell.setCellStyle(cellStyle);  
17.             XSSFCell scoreCell = row.createCell(4);  
18.             scoreCell.setCellValue(student.getScore());  
19.             scoreCell.setCellStyle(cellStyle);  
20.         }  

    用for循环就可以完成任务，需要注意的是循环变量仍然从0开始走，这是为了遍历集合的方便，而创建行就是从i+1开始走了，因为0行是表头，已经占用了。下面就是先设定行高，之后开始取值，赋值，设定格式，结构也很统一。 
    完成遍历后，来看看合并，Excel中的合并单元格也是很常用的操作，比如本例中，将班级都设置成一班后，那么就想让班级这列合并，该如何操作呢？ 
Java代码  

1. // 合并班级  
2. sheet.addMergedRegion(new CellRangeAddress(1, 4, 3, 3));  

    这是对sheet级别的操作，因为是在sheet上合并单元格，就是加一个合并的区域，这个区域接收四个参数，就是开始的行，结束的行，开始的列，结束的列，这个位置一般比较确定，或者用循环变量计算得出。班级，从第二行开始，第五行结束，对应索引是1，4，而列不变，就是在列上合并，就都是3即可。 
    至此我们已经将数据遍历得出生成了Excel表格，设置了单元格样式也进行了合并，那么还有合计没有说，用合计可以直接设置公式，也可以程序计算好后直接填充，后者一般用于比较复杂的报表，就不用在POI中设置合并的位置，减少复杂度。结合本例，我们来计算平均年龄和成绩之和。如下： 
Java代码  

1. // 数据分析行  
2.         int dadaRowNum = sheet.getLastRowNum();  
3.         XSSFRow totalRow = sheet.createRow(dadaRowNum + 1);// 获取已有的行数，加1再出新行  
4.         totalRow.setHeightInPoints(25f);  
5.         XSSFCell analyticsCell = totalRow.createCell(0);  
6.         analyticsCell.setCellValue("数据分析");  
7.         analyticsCell.setCellStyle(headerStyle);  
8.         XSSFCell avgAgeCell = totalRow.createCell(1);  
9.         avgAgeCell.setCellValue("平均年龄");  
10.         avgAgeCell.setCellStyle(headerStyle);  
11.         XSSFCell avgAgeValueCell = totalRow.createCell(2);  
12.         avgAgeValueCell.setCellStyle(headerStyle);  
13.         avgAgeValueCell.setCellFormula("AVERAGE(C2:C" + (dadaRowNum + 1) + ")");  
14.         XSSFCell sumScoreCell = totalRow.createCell(3);  
15.         sumScoreCell.setCellValue("总成绩");  
16.         sumScoreCell.setCellStyle(headerStyle);  
17.         XSSFCell sumScoreValueCell = totalRow.createCell(4);  
18.         sumScoreValueCell.setCellStyle(headerStyle);  
19.         sumScoreValueCell.setCellFormula("SUM(E2:E" + (dadaRowNum + 1) + ")");  

    这里使用Excel函数的时候我们已经知道数据所在的位置，就直接使用了单元格的代号进行运算了，要注意使用公式时的方法中不用写=号，POI会自动为我们添加进去，这里就直接写公式的内容即可。在实际中可能会有动态计算的任务，那么就根据业务复杂度来选择是用Excel公式进行运算还是程序运算好后直接赋值显示。 
    最后是生成文件的步骤，这已经介绍过了，都很简单： 
Java代码  

1.         // 生成文件  
2. File file = new File(filePath);  
3. OutputStream os = null;  
4. try {  
5.     os = new FileOutputStream(file);  
6.     workbook2007.write(os);  
7. } catch (IOException e) {  
8.     e.printStackTrace();  
9. } finally {  
10.     if (os != null) {  
11.         try {  
12.             os.close();  
13.         } catch (IOException e) {  
14.         }  
15.     }  
16. }  

    最后是执行测试了，写个主函数来运行： 
Java代码  

1. public static void main(String[] args) {  
2.         long start = System.currentTimeMillis();  
3.         generateExcel2007(xlsx2007);  
4.         long end = System.currentTimeMillis();  
5.         System.out.println((end - start) + " ms done!");  
6.     }  

    将以上所有内容封装在静态方法generateExcel2007(String filePath)中，执行即可得到生成的Excel报表了，我们得到了这样的一个报表： 
 
    这就是最终得到的结果了。POI操作Excel的基本设置就基本涵盖了，剩下的就是灵活运用，生成符合自己需求的报表了。 
    本篇就来详细分析一下复杂报表的分析与设计问题，并用POI通过程序来生成Excel报表。首先说一点文档相关内容。使用POI组件可以生成Office文档，而Office文档也有一些属性，比如作者，分类，公司等信息。我们若通过程序生成时，这一步就直接略过了，但有时我们会需要这些信息，要写入一些文档信息，那么该如何实现呢？ 
    我们分2003和2007两个版本说明，因为操作是不太一样的。看下面的代码： 
Java代码  

1. // 设置核心属性  
2.         POIXMLProperties.CoreProperties props = workbook2007.getProperties()  
3.                 .getCoreProperties();  
4.         props.setCreator("Nanlei");  
5.         props.setCategory("POI程序测试");  
6.         props.setTitle("学生信息表");  
7.         // 设置扩展属性  
8.         POIXMLProperties.ExtendedProperties extProps = workbook2007  
9.                 .getProperties().getExtendedProperties();  
10.         // 设置自定义属性  
11.         POIXMLProperties.CustomProperties customProps = workbook2007  
12.                 .getProperties().getCustomProperties();  

    生成2007的Excel时，只需上述步骤便可加入我们需要的属性了，具体的属性含义可以参考官方文档，这里仅仅添加作者，分类和标题，生成Excel文档后，我们可以查看到入校内容： 
 
    那么这里就是我们设置的一些信息了。而对于2003，则需要如下的步骤： 
Java代码  

1. // 创建工作簿对象  
2. HSSFWorkbook workbook2003 = new HSSFWorkbook();  
3. workbook2003.createInformationProperties();  
4. SummaryInformation si = workbook2003.getSummaryInformation();  
5. si.setAuthor("Nanlei");  
6. si.setTitle("学生信息表");  
7. si.setComments("POI程序测试");  
8. DocumentSummaryInformation dsi = workbook2003  
9.         .getDocumentSummaryInformation();  
10. dsi.setCompany("Pioneer");  

    要注意的是第二行，必须执行createInformationProperties()方法，之后才可以设置属性，这和2007的做法是不同的。这里只是给出示例，就不深入讨论每个设置项了。 
    回头来看报表。中国式的复杂报表基本上是合计，合计再合计，就是数值分析到一个阶段后出一次合计，这个阶段可以按照业务的不同元素来划分。本例是根据经销商，省份最终到达事业部。那么设计数据库时就要唯一区分开这些元素，根据这些标识来实现划分，合并等，首先来准备一些数据。 
Java代码  

1. static {  
2.         cruiseServiceLocationList = new ArrayList<CruiseServiceLocation>();  
3.         csl[0] = new CruiseServiceLocation("T001", "北京市", "北京总部", "bj", "清华大学",  
4.                 20);  
5.         csl[1] = new CruiseServiceLocation("T001", "北京市", "北京总部", "bj", "北京大学",  
6.                 30);  
7.         csl[2] = new CruiseServiceLocation("T001", "北京市", "海淀经销商", "bjhd",  
8.                 "西直门", 15);  
9.         csl[3] = new CruiseServiceLocation("T001", "北京市", "海淀经销商", "bjhd",  
10.                 "首都机场", 50);  
11.         csl[7] = new CruiseServiceLocation("T001", "辽宁省", "大连经销商", "lndl",  
12.                 "河口软件园", 15);  
13.         csl[8] = new CruiseServiceLocation("T001", "辽宁省", "大连经销商", "lndl",  
14.                 "七贤岭腾飞软件园", 13);  
15.         csl[9] = new CruiseServiceLocation("T001", "辽宁省", "大连经销商", "lndl",  
16.                 "高新园区信达街", 11);  
17.         csl[19] = new CruiseServiceLocation("T003", "河北省", "石家庄经销商", "hbsjz",  
18.                 "火车站", 4);  
19.         csl[20] = new CruiseServiceLocation("", "", "", "", "", 0);// 合并算法捕捉最后一行有问题，增补一行无效数据，计算时去除  
20.         cruiseServiceLocationList.addAll(Arrays.asList(csl));  
21.     }  

    (具体数据请参考源码，附件中下载) 
    注意在最后增补一条无效数据，因为算法的限制，读取最后一行比较时可能会将其略过，所以这样保证所有数据都能被正常读出。这个数据结构根据事业部代号，省份和经销商名称来区分各个元素。 
    算法就是根据标识位的不同来区分是否该进行特殊处理了，这之前数据要排好顺序，就可以分门别类进行了，来看一下合计算法： 
Java代码  

1. // 合计量的计算  
2.         CruiseServiceLocation cslTotal = null;  
3.         List<CruiseServiceLocation> cslList = new ArrayList<CruiseServiceLocation>();  
4.         // 合并计算控制  
5.         double totalDealer = 0;  
6.         double totalProvince = 0;  
7.         double totalDivision = 0;  
8.         int locationNum = 0;  
9.         // 循环遍历List  
10.         for (int i = 0; i < cruiseServiceLocationList.size(); i++) {  
11.             cslList.add(cruiseServiceLocationList.get(i));  
12.             // 是否是最后一条记录的开关  
13.             boolean last = (i == cruiseServiceLocationList.size() - 1);  
14.             // 取出相邻的两条记录进行比较  
15.             CruiseServiceLocation csl1 = null;  
16.             CruiseServiceLocation csl2 = null;  
17.             if (!last) {  
18.                 csl1 = cruiseServiceLocationList.get(i);  
19.                 csl2 = cruiseServiceLocationList.get(i + 1);  
20.             } else {  
21.                 // 防止最后一条记录无法加入集合  
22.                 csl1 = cruiseServiceLocationList.get(i);  
23.                 if (cruiseServiceLocationList.size() != 1)  
24.                     csl2 = cruiseServiceLocationList.get(i - 1);  
25.                 else  
26.                     csl2 = cruiseServiceLocationList.get(i);  
27.             }  
28.             // 开始处理  
29.             if (csl1.getDealerName().equals(csl2.getDealerName())) {  
30.                 locationNum++;  
31.                 totalDealer += csl1.getMiles();  
32.             } else {  
33.                 locationNum++;  
34.                 totalDealer += csl1.getMiles();  
35.                 cslTotal = new CruiseServiceLocation();  
36.                 cslTotal.setTotalDealer(totalDealer);  
37.                 cslTotal.setLocationNum(locationNum);  
38.                 cslList.add(cslTotal);  
39.                 totalDealer = 0;  
40.                 locationNum = 0;  
41.             }  
42.             if (csl1.getProvince().equals(csl2.getProvince())) {  
43.                 totalProvince += csl1.getMiles();  
44.             } else {  
45.                 totalProvince += csl1.getMiles();  
46.                 cslTotal = new CruiseServiceLocation();  
47.                 cslTotal.setTotalProvince(totalProvince);  
48.                 cslList.add(cslTotal);  
49.                 totalProvince = 0;  
50.             }  
51.             if (csl1.getDivision().equals(csl2.getDivision())) {  
52.                 totalDivision += csl1.getMiles();  
53.             } else {  
54.                 totalDivision += csl1.getMiles();  
55.                 cslTotal = new CruiseServiceLocation();  
56.                 cslTotal.setTotalDivision(totalDivision);  
57.                 cslList.add(cslTotal);  
58.                 totalDivision = 0;  
59.             }  
60.         }  

    其中Bean的设计如下： 
Java代码  

1. package org.ourpioneer.excel.bean;  
2.   
3. /** 
4.  * 巡航服务地点bean 
5.  *  
6.  * @author Nanlei 
7.  *  
8.  */  
9. public class CruiseServiceLocation {  
10.     private String division;// 事业部  
11.     private String province;// 省份  
12.     private String dealerName;// 经销商名称  
13.     private String dealerCode;// 经销商代码  
14.     private String location;// 巡航服务地点  
15.     private double miles;// 巡航服务里程  
16.     private int locationNum;// 地点条数  
17.     private double totalDealer;// 经销商合计  
18.     private double totalProvince;// 省份合计  
19.     private double totalDivision;// 事业部合计  
20.   
21.     public CruiseServiceLocation() {  
22.         super();  
23.     }  
24.   
25.     public CruiseServiceLocation(String division, String province,  
26.             String dealerName, String dealerCode, String location, double miles) {  
27.         super();  
28.         this.division = division;  
29.         this.province = province;  
30.         this.dealerName = dealerName;  
31.         this.dealerCode = dealerCode;  
32.         this.location = location;  
33.         this.miles = miles;  
34.     }  
35. // 省略getter和setter方法  
36. }  

    下面来分析一下这个算法，思路很简单，就是逐条记录进行比较，发现不同后立即处理，按照从小到大的顺序，一次处理经销商，省份和事业部，取出两条相邻元素之后，首先比较的是经销商是否一致，如果一致，经销商数量加1，里程累加，不一致时，这两个量也要相应计算并放入新的对象中，加入list里，这样一个合计行就加好了，后面的省份和事业部处理也是这个思路。循环完成，我们就得到了按顺序排好的最终列表，剩下的就是遍历这个列表来生成表格了。 
    要注意我们之前填补了一条无效记录，那么在合并的时候也会多处三行合计，要把这四项排除在外，不能忘记了。 
    计算合并行是需要一些辅助变量，比如： 
Java代码  

1. // 省份合计和事业部合计时跨行的计算数据  
2. int comboProvince = 0;  
3. int comboDivision = 0;  
4. List<Integer> indexComboProvice = new ArrayList<Integer>();  
5. List<Integer> indexComboDivision = new ArrayList<Integer>();  

    它们是用来计算合并数量的，最后用在跨行数量上，因为每出一条合计，整体跨行数就要增加，那么需要将这些数据记录到List中，方便处理。我们就引入了这些辅助变量。 
    先来看经销商合并算法： 
Java代码  

1. if (csl.getTotalDealer() != 0) {  
2.     row.createCell(0).setCellStyle(style);  
3.     row.createCell(1).setCellStyle(style);  
4.     XSSFCell t_dealer = row.createCell(2);  
5.     t_dealer.setCellValue("经销商合计");  
6.     t_dealer.setCellStyle(biStyle);  
7.     sheet.addMergedRegion(new CellRangeAddress(i + 1, i + 1, 2, 4));  
8.     XSSFCell t_dealer_value = row.createCell(5);  
9.     t_dealer_value.setCellValue(csl.getTotalDealer());  
10.     t_dealer_value.setCellStyle(biStyle);  
11.     sheet.addMergedRegion(new CellRangeAddress(i  
12.             - csl.getLocationNum() + 1, i, 2, 2));  
13.     sheet.addMergedRegion(new CellRangeAddress(i  
14.             - csl.getLocationNum() + 1, i, 3, 3));  
15. }  

    这个就很简单了，因为不涉及到跨行，只是跨列而已，这都是预先已经设定好的，不难。而省份和经销商的跨行计算就略微复杂： 
Java代码  

1. if (csl.getTotalProvince() != 0) {  
2.                 XSSFCell t_province = row.createCell(1);  
3.                 row.createCell(0).setCellStyle(style);  
4.                 row.createCell(3).setCellStyle(style);  
5.                 row.createCell(4).setCellStyle(style);  
6.                 t_province.setCellValue("省份合计");  
7.                 t_province.setCellStyle(biStyle);  
8.                 sheet.addMergedRegion(new CellRangeAddress(i + 1, i + 1, 1, 4));  
9.                 XSSFCell t_province_value = row.createCell(5);  
10.                 t_province_value.setCellValue(csl.getTotalProvince());  
11.                 t_province_value.setCellStyle(biStyle);  
12.                 indexComboProvice.add(i);  
13.                 // 合并行  
14.                 if (comboProvince == 0) {  
15.                     sheet.addMergedRegion(new CellRangeAddress(1, i, 1, 1));  
16.                 } else if (comboProvince == 1) {  
17.                     sheet.addMergedRegion(new CellRangeAddress(  
18.                             indexComboProvice.get(comboProvince - 1)  
19.                                     + comboProvince + 1, i, 1, 1));  
20.                 } else {  
21.                     sheet.addMergedRegion(new CellRangeAddress(  
22.                             indexComboProvice.get(comboProvince - 1)  
23.                                     + comboProvince, i, 1, 1));  
24.   
25.                 }  
26.                 comboProvince++;  
27.             }  

    这里为了将所有单元格都加入样式，所以没有数据填充的单元格仅做样式处理即可。合并行的时候要看这是第几次合并，因为算法不同。第一次时比较简单，只需数出有第一个合计中有多少经销商即可。而后续的就需要记录上次合并出现的位置，然后再加上第二个经销商的数量，之后进行合并。那么事业部的算法也是如此。 
Java代码  

1. if (csl.getTotalDivision() != 0) {  
2.     XSSFCell t_division = row.createCell(0);  
3.     row.createCell(1).setCellStyle(style);  
4.     row.createCell(2).setCellStyle(style);  
5.     row.createCell(3).setCellStyle(style);  
6.     row.createCell(4).setCellStyle(style);  
7.     t_division.setCellValue("事业部合计");  
8.     t_division.setCellStyle(biStyle);  
9.     sheet.addMergedRegion(new CellRangeAddress(i + 1, i + 1, 0, 4));  
10.     XSSFCell t_division_value = row.createCell(5);  
11.     t_division_value.setCellValue(csl.getTotalDivision());  
12.     t_division_value.setCellStyle(biStyle);  
13.     indexComboDivision.add(i);  
14.     // 合并行  
15.     if (comboDivision == 0) {  
16.         sheet.addMergedRegion(new CellRangeAddress(1, i, 0, 0));  
17.     } else if (comboDivision == 1) {  
18.         sheet.addMergedRegion(new CellRangeAddress(  
19.                 indexComboDivision.get(comboDivision - 1)  
20.                         + comboDivision + 1, i, 0, 0));  
21.     } else {  
22.         sheet.addMergedRegion(new CellRangeAddress(  
23.                 indexComboDivision.get(comboDivision - 1)  
24.                         + comboDivision, i, 0, 0));  
25.     }  
26.     comboDivision++;  
27. }  

    最后生成文件，就得到了我们要的报表了。 
 
    综合实例就介绍完了，下一篇将结合Spring MVC来说明在Web应用程序中如何生成Excel文件并进行下载操作。

• exceltest.rar (34.1 KB)
• 下载次数: 385

• 查看图片附件