zoukankan      html  css  js  c++  java

  • 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的方法就是改改对象的名称，很简单，这里不再贴出了。 
  • 相关阅读:
    实验四
    密码破解技术
    222
    111
    6
    5
    4
    第三次
    第二次
    第一次
  • 原文地址：https://www.cnblogs.com/huangcongcong/p/4753951.html
Copyright © 2011-2022 走看看