Apache POI组件操作Excel

2023-11-19

    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(032 * 80);// 对A列设置宽度为80像素  
  8.         sheet.setColumnWidth(132 * 80);  
  9.         sheet.setColumnWidth(232 * 80);  
  10.         sheet.setColumnWidth(332 * 80);  
  11.         sheet.setColumnWidth(432 * 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(1433));  

    这是对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(032 * 80);// 对A列设置宽度为80像素  
  8.         sheet.setColumnWidth(132 * 80);  
  9.         sheet.setColumnWidth(232 * 80);  
  10.         sheet.setColumnWidth(332 * 80);  
  11.         sheet.setColumnWidth(432 * 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(1433));  

    这是对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 + 124));  
  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, 22));  
  13.     sheet.addMergedRegion(new CellRangeAddress(i  
  14.             - csl.getLocationNum() + 1, i, 33));  
  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 + 114));  
  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, 11));  
  16.                 } else if (comboProvince == 1) {  
  17.                     sheet.addMergedRegion(new CellRangeAddress(  
  18.                             indexComboProvice.get(comboProvince - 1)  
  19.                                     + comboProvince + 1, i, 11));  
  20.                 } else {  
  21.                     sheet.addMergedRegion(new CellRangeAddress(  
  22.                             indexComboProvice.get(comboProvince - 1)  
  23.                                     + comboProvince, i, 11));  
  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 + 104));  
  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, 00));  
  17.     } else if (comboDivision == 1) {  
  18.         sheet.addMergedRegion(new CellRangeAddress(  
  19.                 indexComboDivision.get(comboDivision - 1)  
  20.                         + comboDivision + 1, i, 00));  
  21.     } else {  
  22.         sheet.addMergedRegion(new CellRangeAddress(  
  23.                 indexComboDivision.get(comboDivision - 1)  
  24.                         + comboDivision, i, 00));  
  25.     }  
  26.     comboDivision++;  
  27. }  

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

本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)

Apache POI组件操作Excel 的相关文章

  • 集合框架集-List

    1 UML 统一建模语言 例如 类图 用例图等等 2 Collection接口 1 1 集合框架的顶级接口 1 2 是Set和List的父接口 1 3 但不是Map的父接口 集合中只能添加引用类型数据 Collection接口 是集合框架的
  • java调用dll

    本文转自 http www blog edu cn user4 jjj250 archives 2007 1722308 shtml Jawin Java Win32 是一个免费的 开放源代码的体系结构 用于 Java 组件和通过 Wind
  • 边界类、控制类、实体类

    UML中类有三种主要的版型 边界类 控制类和实体类 引入边界类 控制类及实体类的概念有助于分析和设计人员确定系统中的类 边界类位于系统与外界的交界处 窗体 报表 以及表示通讯协议的类 直接与外部设备交互的类 直接与外部系统交互的类等都是边界
  • Jacob处理Word文档的方法

    7 4 使用Jacob来处理Word文档 Word或Excel程序是以一种COM组件形式存在的 如果能够在Java中调用Word的COM组件 就能使用它的方法来获取Word文档中的文本信息 目前网上有许多提供这样的工具 7 4 1 Jaco
  • 架构师进阶之路

    选择的范围太广 可以读的书太多 往往容易无所适从 我想就我自己读过的技术书籍中挑选出来一些 按照学习的先后顺序 推荐给大家 特别是那些想不断提高自己技术水平的Java程序员们 一 Java编程入门类 对于没有Java编程经验的程序员要入门
  • 三英战SQL:解析NoSQL的可靠性及扩展操作

    摘要 NoSQL的高性能 易扩展及可靠性一直深受数据工作者的喜爱 然而对比传统关系型数据库NoSQL的优势究竟又在何处 Esen Sagynov在DZone上发布了一篇文章 从运行方面分析Cassandra HBase以及MongoDB产品
  • JXL(JExcelApi)相关资源

    1 主页 2 下载页面 Download JExcelApi 3 JXL API Online 4 全面挖掘Java Excel API 使用方法 1 5 全面挖掘Java Excel API 使用方法 2 6 使用JAVA透過JXL JE
  • Tomcat-JDBC源码解析及优化

    数据库连接池 连接池是常见的一种资源复用的技术 利用连接池 可以将那些创建开销较大的资源汇聚到一个池子里缓存起来 需要使用的时候只需要从连接池里取出来就可以了 中间省去了频繁的创建和销毁的过程 数据库连接池就是其中的典型应用 深入Tomca
  • javaRebel(jRebel)使用手记

    想必大家对项目开发中 调试类文件修改时 容器自动重新加载漫长的过程早已厌倦 我今天闲来无事 于是 想试试javaRebel jRebel 这个东西 javaRebel jRebel 现在是收费软件 不过在网上可以下载到确解版的 在网上查了一
  • 一个码稿人自述:什么样的文档产品适合我?|深度吐槽

    关注ITValue 看企业级最新鲜 最价值报道 图片来源 Unsplash 钛媒体打工人 媒体相关从业经验4 5年 文档使用重度患者 今天以我曾经用过的 和现在主流的一些文档产品为例 来谈谈我的使用体验 以及什么样的文档适合我 一 我与文档
  • mybatis中批量插入的两种方式(高效插入)

    MyBatis简介 MyBatis是一个支持普通SQL查询 存储过程和高级映射的优秀持久层框架 MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索封装 MyBatis可以使用简单的XML或注解用于配置和原始映射 将
  • struts2配置commons-fileupload的问题

    这个问题主要出现在上传文件时parseRequest 的值为空 原因是struts2的Filter拦截了 ServletFileUpload sfu new ServletFileUpload factory List fileList s
  • 基于Jfinal实现的权限管理系统 JfinalUIB

    JfinalUIB 是 Jfinal charisma beetl postgresql 同时支持MySQL ehcache ztree druid bcprov 实现的用户权限管理系统 项目用到了众多的开源组件 还有一些是分享的学习代码片
  • SSM框架搭建,及遇到的问题

    SSM框架搭建 及遇到的问题 1 基本概念 1 1 Spring Spring是一个开源框架 Spring是于2003 年兴起的一个轻量级的Java 开发框架 由Rod Johnson 在其著作Expert One On One J2EE
  • Netty 4.0 实现心跳检测和断线重连

    一 实现心跳检测 原理 当服务端每隔一段时间就会向客户端发送心跳包 客户端收到心跳包后同样也会回一个心跳包给服务端 一般情况下 客户端与服务端在指定时间内没有任何读写请求 就会认为连接是idle 空闲的 的 此时 客户端需要向服务端发送心跳
  • 重命名文件或目录(renameTo)

    File or directory with old name File file new File oldname File or directory with new name File file2 new File newname R
  • Java实现PDU编码

    代码一 package com zte test import java io UnsupportedEncodingException PDU编码实现 7bit 8bit 以及UCS2编码 代码主体是网上来源 Url我忘记了 很遗憾 自己
  • 在 JBuilder 中生成嵌套 JSON 数组

    我在 ruby on Rails 中有这个模型 分支模型 has many menus class Branch lt ActiveRecord Base belongs to place belongs to city has many
  • Rabl、Jbuilder 或手动 json 构建 api?

    要为大规模应用程序构建 api 就性能而言 哪种方法更好 我应该使用 Rabl Jbuilder 还是手动构建 json 对象 我正在为移动应用程序构建 api endpoints 在性能方面 您应该尝试创建一些基本的性能测试 并对它们进行
  • Jbuilder Rails 缓存速度较慢

    我尝试将缓存与集合一起使用 使用多种解决方案 问题是每当我尝试缓存时 响应都会变慢 考虑以下集合示例 该集合为其中的每个项目 大约 25 个项目 呈现 2 个部分 json data do json array organizations

随机推荐

  • 分布式锁实现方案2、基于Redis的SET操作实现的分布式锁

    继上一篇文章 分布式锁实现方案1 基于Redis的SETNX操作实现的分布式锁 实现方案之后 redis又提供了更加强大的set方法 可以解决分布式锁实现方案1中提到的缺陷 直接看代码 package com alioo lock impo
  • C++Primer第五版习题答案(二)

    第二章 变量和基本类型 2 8 2 10 2 14 C Primer第五版课后习题答案目录 2 8 include
  • vue3项目实战---知乎日报----首页功能

    目录 网络请求封装 header swiper items新闻列表 home IntersectionObserver API 使用教程 性能优化 网络请求封装 GET传参格式 www baidu com info t 0 age 18 传
  • IntelliJ IDEA中代码被覆盖了怎么恢复

    在你git pull 拉去代码的时候 在IntelliJ IDEA中一不小心将你本地代码给覆盖了 这个时候 你撤回是无效的时候 是不是有点小激动 还有点小慌 辛辛苦苦写的代码没啦 被覆盖了 不要慌 只要用的是IntelliJ IDEA这个工
  • javaの日志级别

    最近几周给项目补日志 头都大了 项目开发接口时一定要同步日志 一定 首先 日志级别从低到高 all
  • 网络安全应急响应操作流程-打好应急响应保卫战

    文章目录 应急响应 应急响应目标 应急响应标准流程 事前 事中 检测 响应 处置 溯源 人的识别 核心注意事项 参考文献 应急响应 应急响应是安全工作的重点和难点 由于响应过程中压力比较大 难免出现手忙脚乱的情况 因此怎样做好应急响应工作是
  • router和route的区别

    简单理解为 route是用来获取路由信息的 router是用来操作路由的 一 router router是VueRouter的实例 通过Vue use VueRouter 和VueRouter构造函数得到一个router的实例对象 这个对象
  • List、Queue

    1 ArrayList 底层是基于动态数组的数据结构 是有存放顺序的 2 LinkedList 底层是基于双链表的数据结构 每一个存储单元 都涉及到其他两个引用 优缺点 在执行get set 时 ArrayList的效率高 LinkedLi
  • Matlab产生离散正弦信号即绘制频谱图

    假设正弦信号频率为f0 40000Hz 采样频率fs 160000Hz 注意 fs必须大于2f0 否则采到的点根本不是正弦 实际上 fs 4f0是比较合适的 Matlab程序如下 function y gensinx f0 fs n N f
  • [YOLO专题-27]:YOLO V5 小目标检测遇到的问题与常见解决办法

    作者主页 文火冰糖的硅基工坊 文火冰糖 王文兵 的博客 文火冰糖的硅基工坊 CSDN博客 本文网址 YOLO专题 27 YOLO V5 小目标检测遇到的问题与常见解决办法 文火冰糖 王文兵 的博客 CSDN博客 目录 第1章 前言 第2章
  • freeswitch二、freeswitch之注册,呼叫接听测试

    在上一篇文章中讲解了freeswitch的安装方法 安装完后测试了和数据库的交互 下面就要测试一下freeswitch的功能了 freeswitch测试 freeswitch的conf目录中有20个默认的sip账号 可以直接做简单的测试 其
  • sys用户下为其他用户的创建私有db link的案例

    文章目录 1 查询job执行情况 2 确认根因 3 重建DB LINK 3 1使用current schema方式 3 2使用procedure方式 4 重新编译失效的对象 并手动执行job 记录一下scheduler job执行失败 而不
  • 类型“ScriptManager”的控件“ScriptManager1”必须放在具有 runat=server 的窗体标记内。...

  • 表单提交Post方法、Get方法背后的秘密

    表单大家都很熟悉 上网的时候经常会遇到表单 表单用来接受用户的输入 并将用户的输入以 name value值对 集合的形式提交到服务器进行处理 那么表单是怎样将数据提交到服务器的 服务器是怎样对表单数据进行处理的 下面我将为大家揭开表单提交
  • 数据中台-让数据用起来-6

    文章目录 第六章 数据开发 数据价值提炼工厂 6 1 数据计算能力的4种类型 6 1 1 批计算 6 1 2 流计算 6 1 3 在线查询 6 1 4 即席分析 6 2 离线开发 1 作业调度 2 基线控制 3 异构存储 4 代码校验 5
  • Tomcat 服务器的使用(IDEA 2021.3)

    目录 1 Tomcat 下载和安装 2 IDEA 创建 JavaWeb 项目 3 IDEA 集成 Tomcat 并发布项目 服务器是计算机的一种 它比普通计算机运行更快 负载更高 价格更贵 服务器在网络中为其它客户机 如PC机 智能设备等
  • 精致的动画特效源代码

    动画特效 css简介 代码部分 纯css3云彩动画效果 css3放大镜动画效果 jQuery游戏图片手风琴收缩切换特效 js百叶窗图片3D旋转切换特效 纯CSS3制作飞舞的火箭动画 简单易用的纯CSS3图片墙效果 一个简单好看的纯CSS3翻
  • 【风格迁移系列三】(Adain)Arbitrary Style Transfer in Real-time with Adaptive Instance Normalization 论文解读

    最近看了这篇论文 Arbitrary Style Transfer in Real time with Adaptive Instance Normalization 由于没有详细的博客参考 还是花了一些时间来阅读论文 于是提出自己对论文的
  • 代码随想录算法训练营第一天

    Leetcode704 二分查找 题目链接 关键词 二分查找 循环不变量 区间 问题思路 二分查找的应用 关键在于循环过程中区间的维护 记住循环不变量原则 在这个问题中循环不变量是区间的定义 注意左闭右开和左开右闭的区别 class Sol
  • Apache POI组件操作Excel

    Apache的POI组件是Java操作Microsoft Office办公套件的强大API 其中对Word Excel和PowperPoint都有支持 当然使用较多的还是Excel 因为Word和PowerPoint用程序动态操作的应用较少