• 服务器端文档组件

    服务器端文档组件

    • 项目中需要使用文档组件操作文档(导入，导出)
    • 操作文档的框架有如下几种

    1.Apache POI

    1.概述

    • 1.Apache POI是用Java编写的免费开源的跨平台的 Java API
    • 2.Apache POI提供API给Java程序对Microsoft Office（Excel、WORD、PowerPoint、Visio等）格式文档读和写的功能
    • 3.POI为Poor Obfuscation Implementation的首字母缩写，意为：可怜的模糊实现

    2.功能

    • 1.操作Excel(向下兼容)
      • 1.HSSF － 提供读写Microsoft Excel(1997~2003版本)格式档案的功能(.xls)(依赖-poi)
      • 2.XSSF － 提供读写Microsoft Excel(2007版本)格式档案的功能(.xlsx)(依赖-poi-ooxml)
      • 3.SXSSF - XSSF的升级版本(POI3.8版本及以上)，支持低内存占用(.xlsx)(依赖-poi-ooxml)
      //三种方式的接口及方法
HSSF：HSSFWorkbook、HSSFSheet、HSSFRow、HSSFCell……

XSSF：XSSFWorkbook、XSSFSheet、XSSFRow、XSSFCell……

SXSSF：SXSSFWorkbook、Sheet、Row、Cell……
//SXSSF之所以是一种低内存操作方式，是因为他的构造方法SXSSFWorkbook w3= new SXSSFWorkbook(100);
//100可理解为POI操作时，内存中最多只有100行数据，当超过这个数据时，就将内存之前的数据删除，并且会在硬盘中生成临时文件，从而保证了低内存消耗。也可以将这个数字调大一点

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
    • 2.操作Word
      • 1.HWPF － 提供读写Microsoft Word DOC97格式档案的功能(.doc)(依赖-poi-scratchpad)
      • 2.XWPF － 提供读写Microsoft Word DOC2003格式档案的功能(.docx)(依赖-poi-ooxml)
    • 3.操作PowerPoint
      • HSLF － 提供读写Microsoft PowerPoint格式档案的功能(.ppt)(依赖-poi-scratchpad)
    • 4.操作Visio
      • HDGF － 提供读Microsoft Visio格式流程图的功能(.vsd)(依赖-poi-scratchpad)
    • 5.操作Publisher
      • HPBF － 提供读Microsoft Publisher格式排版设计的功能(.pub)(依赖-poi-scratchpad)
    • 6.操作Outlook
      • HSMF － 提供读Microsoft Outlook格式电子邮件的功能(.msg)(依赖-poi-scratchpad)

    3.依赖

    在这里插入图片描述
    在这里插入图片描述

    4.特点

    5.不同文档操作步骤

    1.操作Excel
    // HSSF(Horrible SpreadSheet Format)：通过HSSF可以用纯Java代码来读取、写入、修改Excel文件 
// HSSF为读取操作提供了两类API：usermodel和eventusermodel。即“用户模型”和“事件-用户模型”

1.Excel中的表单、工作表、行、单元格的关系 
// 一个Excel文件对应于一个workbook(HSSFWorkbook)
// 一个workbook可以有多个sheet（HSSFSheet）组成
// 一个sheet是由多个row（HSSFRow）组成
// 一个row是由多个cell（HSSFCell）组成

2.常用的类和方法 
//1.HSSFWorkbook：表单(代表一个excel的整个文档) 
HSSFWorkbook hssfWorkbook = new HSSFWorkbook(); //创建一个新的表单,一般用于导出 HSSFWorkbook
hssfWorkbook = new HSSFWorkbook(InputStream inputStream); //创建一个关联输入流的表单，将一个excel文件封装成表单，一般用于导入 
hssfWorkbook.close(); //关闭资源

//2.HSSFSheet：工作表(同一个表单可以创建多个工作表) 
HSSFSheet hssfSheet = hssfWorkbook.createSheet(); //创建一个默认名称的Sheet，从sheet0开始 
HSSFSheet sheetname= hssfWorkbook.createSheet(String sheetname); //创建一个指定名称的Sheet 
hssfWorkbook.setActiveSheet(int index); //设置默认选中的工作表，索引从0开始

HSSFSheet getSheet(String sheetName); //通过名称获取指定Sheet HSSFSheet
getSheetAt(int index); //通过索引获取指定Sheet，索引从0开始 
int getNumberOfSheets(); //获取当前表单的sheet总个数

//3.HSSFRow：行 
HSSFRow hssfRow = hssfSheet.createRow(int rownum);//创建行，需要指定行号，行号从0开始 short height = 2000;
hssfRow.setHeight(height); //设置行高，默认值为-1
hssfRow.setHeightInPoints(height); //以点为单位设置行高，等同于*20，默认值为-1
hssfRow.setRowNum(int rowIndex); //设置行好，range 0-65535
hssfRow.setZeroHeight(false); //设置是否显示高度为0的行
hssfRow.setRowStyle(cellStyle);  //设置行的样式，会被单元格覆盖掉 HSSFRow getRow(int index); //根据索引获取指定的行
getLastRowNum(); //获取最后的行的索引，没有行或者只有一行的时候返回0

//4.Column：列 
hssfSheet.autoSizeColumn(int column);
//设置工作表指定列的长度随内容自动调整。注意：设置自适应长度需要在设置值之后才会生效
hssfSheet.setColumnWidth(int columnIndex, int width);
//设置某一列的宽度，width=字符个数 * 256(例：20个字符的宽度就是20 * 256),最大不能超过255个字符,可以在自适应的情况下特别指定

//5.HSSFCell：单元格 
HSSFCell hssfCell = hssfRow.createCell(int column); //创建新的单元格,并指定列 
HSSFCell hssfCell = hssfRow.createCell(int column,CellType type); //创建新的单元格,并指定列和类型

hssfCell.setCellStyle(HSSFCellStyle style); //设置单元格样式，例如字体、加粗、格式化
hssfCell.setCellValue(Date value); //设置单元格的内容，有多种类型
hssfCell.setAsActiveCell(); //设置默认选中单元格 
hssfCell.setBlank(); //设置为空白单元格 
hssfCell.setCellFormula(String formula); //设置计算公式，计算的结果作为单元格的值，也提供了异常常用的函数，如求和"sum(A1,C1)"、日期函数、字符串相关函数、CountIf和SumIf函数、随机数函数等
hssfCell.setCellType(CellType cellType); //设置单元格类型，参数为CellType枚举类

HSSFCell getCell(shot index); 
HSSFCell getCell(CellReference.convertColStringToIndex(“A”)); 根据列名英文字母获取。 
short getLastCellNum(); //获取最后的单元格号，如果单元格有第一个开始算，lastCellNum就是列的个数 
String getStringCellValue(); //获取单元格中的字符串值

//6.HSSFCellStyle：单元格样式(可以为行设置样式，也可以为单元格设置样式，行样式会被单元格覆盖，所以一般设置单元格样式) 
HSSFCellStyle cellStyle = hssfWorkbook.createCellStyle(); //创建单元格样式 
cellStyle.setFillBackgroundColor(short bg); //设置背景色，.xls中该设置不生效
cellStyle.setFillForegroundColor(short bg); //设置填充前景色，该设置生效，其中参数使用IndexedColors.RED.getIndex() 
cellStyle.setFillPattern(FillPatternType fp); //设置填充样式，其中参数使用FillPatternType.FINE_DOTS
cellStyle.setFont(HSSFFont hf); //设置字体样式 
cellStyle.setAlignment(HorizontalAlignment align); //设置水平对齐方式 HorizontalAlignment.CENTER 居中对齐
cellStyle.setVerticalAlignment(VerticalAlignment align); //设置垂直对齐方式 VerticalAlignment.BOTTOM 设置底部对齐
cellStyle.setVerticalAlignment(VerticalAlignment align); //设置垂直对齐方式
cellStyle.setBorderTop(BorderStyle border); //设置用于单元格顶部边框的边框类型
cellStyle.setBorderBottom(BorderStyle border); //设置用于单元格底部边框的边框类型 BorderStyle.DOTTED 点类型
cellStyle.setBorderLeft(BorderStyle border); //设置用于单元格左部边框的边框类型 
cellStyle.setBorderRight(BorderStyle border); //设置用于单元格右部边框的边框类型
cellStyle.setTopBorderColor(IndexedColors.RED.getIndex()); //设置用于单元格顶部边框的边框颜色
cellStyle.setBottomBorderColor(IndexedColors.BLUE.getIndex()); //设置用于单元格底部边框的边框颜色
cellStyle.setLeftBorderColor(IndexedColors.PINK.getIndex()); //设置用于单元格左部边框的边框颜色
cellStyle.setRightBorderColor(IndexedColors.CORAL.getIndex()); //设置用于单元格右部边框的边框颜色
cellStyle.setHidden(false); //是否隐藏单元格，测试没出效果 short
indention = 2; cellStyle.setIndention(indention); //缩进单元格文本空格数
cellStyle.setLocked(true); //锁定该单元格，测试没出效果 short rotation = 80;
cellStyle.setRotation(rotation); //设置内容旋转度数 HSSF为-90~90，XHSSF为0~180
cellStyle.setShrinkToFit(false); //设置单元格是否自动调整大小，以便内容过长时缩小以适应，测试没出效果
cellStyle.setQuotePrefixed(false); //是否打开样式前缀 short order = 2;
cellStyle.setReadingOrder(order); //设置文本的读取顺序，0为默认，1为从左到右，2为从右到左，测试没出效果
cellStyle.setUserStyleName("测试"); //设置样式名称，测试没出效果
cellStyle.setWrapText(true); //设置文本是否换行，测试没出效果

HSSFDataFormat hssfDataFormat = hssfWorkbook.createDataFormat(); //创建表单数据格式 
short format = hssfDataFormat.getFormat("@"); //设置数据格式为文本
cellStyle.setDataFormat(format); //设置数据格式

HSSFDataFormat hssfDataFormat = hssfWorkbook.createDataFormat(); //创建表单数据格式 
short format = hssfDataFormat.getFormat("yyyy年m月d日"); //设置数据格式为日期 
cellStyle.setDataFormat(format); //设置数据格式

HSSFDataFormat hssfDataFormat = hssfWorkbook.createDataFormat(); //创建表单数据格式 
short format = HSSFDataFormat.getBuiltinFormat("0.00"); //设置数据保留两位小数 其余设置可参考
BuiltinFormats cellStyle.setDataFormat(format); //设置数据格式

HSSFDataFormat hssfDataFormat = hssfWorkbook.createDataFormat(); //创建表单数据格式 
short format = hssfDataFormat.getFormat("¥#,##0"); //设置货币模式 其余设置可参考BuiltinFormats 
cellStyle.setDataFormat(format); //设置数据格式

HSSFDataFormat hssfDataFormat = hssfWorkbook.createDataFormat(); //创建表单数据格式 
short format = hssfDataFormat.getFormat("[DbNum2][$-804]0"); //设置数字-中文大写格式
cellStyle.setDataFormat(format); //设置数据格式

//7.Merge：合并单元格 
hssfSheet.addMergedRegion(CellRangeAddress region);  //合并单元格
new CellRangeAddress(int firstRow, int lastRow, int firstCol, int lastCol); //单元格范围, 用于合并单元格，需要指定要合并的首行、最后一行、首列、最后一列
//合并单元格
CellRangeAddress创建新的单元格范围。索引从零开始（开始行，结束行，开始列，结束列）
hssfSheet.addMergedRegion(new CellRangeAddress(0, 0, 0, 2));
hssfSheet.addMergedRegion(new CellRangeAddress(1, 2, 0, 0));

//8.write：导出 
write(); //java.lang.IllegalStateException: Newly created Document, cannot save in-place 
write(File newFile); //导出到一个文件中
write(OutputStream stream); //导出到输入流中

//9.HSSFFont：字体， 
HSSFCellStyle cellFontStyle = hssfWorkbook.createCellStyle(); //样式 
HSSFFont hssfFont = hssfWorkbook.createFont();
hssfFont.setColor(IndexedColors.BLUE.getIndex()); //字体颜色
hssfFont.setBold(true); //是否粗体 
hssfFont.setCharSet(); //设置字符集
hssfFont.setFontHeight(); //设置字体高度 
hssfFont.setFontHeightInPoints(); //设置字体高度，标准值10, 12, 14 etc.. 
hssfFont.setFontName("楷体"); //根据名称设置字体类型
hssfFont.setItalic(true); //是否斜体 
hssfFont.setStrikeout(true); //设置是否在文本中使用消线水平线(会覆盖掉下划线) 
hssfFont.setTypeOffset(Font.SS_SUPER); //设置字体类型，是上标或下标 
hssfFont.setUnderline(Font.U_SINGLE_ACCOUNTING); //下划线 U_SINGLE_ACCOUNTING单下划线

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    2.从Excel读取数据
    • 1.读取普通数据
      	@Test
    public void TestExcelRead() throws IOException {
        //1.指定读取Excel的位置(绝对位置或相对位置)
        String filePath = "E:\\Apache POI\\template.xls";

        //2.转换为文件输入流
        FileInputStream fileInputStream = new FileInputStream(filePath);

        //3.通过输入流创建表单
        HSSFWorkbook hssfWorkbook = new HSSFWorkbook(fileInputStream);

        //4.通过下标读取表单中的工作表
        HSSFSheet hssfSheet = hssfWorkbook.getSheetAt(0);

        //5.获取表单的列数和行数
        int lastRowNum = hssfSheet.getLastRowNum(); //最后一行
        short lastCellNum = hssfSheet.getRow(0).getLastCellNum(); //最后一列

        //6.双层循环遍历获取单元格的值 或者 使用迭代器
//        for (int r = 0; r <= lastRowNum; r++) {
//            HSSFRow row = hssfSheet.getRow(r);
//            for (int c = 0; c < lastCellNum; c++) {
//                HSSFCell cell = row.getCell(c);
//                switch (cell.getCellType()) {
//                    case STRING:
//                        System.out.print(cell.getStringCellValue());
//                        break;
//                    case NUMERIC:
//                        System.out.print(cell.getNumericCellValue());
//                        break;
//                    case BOOLEAN:
//                        System.out.print(cell.getBooleanCellValue());
//                        break;
//                }
//                System.out.print(" -- ");
//            }
//            System.out.println();
//        }

        Iterator<Row> iterator = hssfSheet.iterator();
        while (iterator.hasNext()) {
           HSSFRow row = (HSSFRow) iterator.next();
            Iterator<Cell> cellIterator = row.cellIterator();
            while (cellIterator.hasNext()) {
                HSSFCell cell = (HSSFCell) cellIterator.next();
                switch (cell.getCellType()) {
                    case STRING:
                        System.out.print(cell.getStringCellValue());
                        break;
                    case NUMERIC:
                        System.out.print(cell.getNumericCellValue());
                        break;
                    case BOOLEAN:
                        System.out.print(cell.getBooleanCellValue());
                        break;
                }
                System.out.print(" -- ");
            }
            System.out.println();
        }
    }

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
    • 2.读取带有公式计算的数据
       @Test
    public void read2() throws IOException {
        FileInputStream fileInputStream = new FileInputStream(".\\datafiles\\readformula.xls");

        HSSFWorkbook hssfWorkbook = new HSSFWorkbook(fileInputStream);

        HSSFSheet sheet = hssfWorkbook.getSheetAt(0);

        int rows = sheet.getLastRowNum();
        short cols = sheet.getRow(0).getLastCellNum();

        for (int r = 0; r < rows; r++) {
            HSSFRow row = sheet.getRow(r);

            for (int c = 0; c < cols; c++) {
                HSSFCell cell = row.getCell(c);

                switch (cell.getCellType()) {
                    case STRING:
                        System.out.print(cell.getStringCellValue());
                        break;
                    case NUMERIC:
                        System.out.print(cell.getNumericCellValue());
                        break;
                    case BOOLEAN:
                        System.out.print(cell.getBooleanCellValue());
                        break;
                    case FORMULA:
                        System.out.println(cell.getNumericCellValue());
                        break;
                }
                System.out.print(" -- ");
            }
            System.out.println();
        }
    }

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
    • 3.读取带有密码的Excel
      @Test
 public void read2() throws IOException {
     FileInputStream fileInputStream = new FileInputStream(".\\datafiles\\employee.xls");
     String password = "123456";

     HSSFWorkbook hssfWorkbook = (HSSFWorkbook) HSSFWorkbookFactory.create(fileInputStream, password);

     HSSFSheet sheet = hssfWorkbook.getSheetAt(0);

     int rows = sheet.getLastRowNum();
     short cols = sheet.getRow(0).getLastCellNum();

     for (int r = 0; r < rows; r++) {
         HSSFRow row = sheet.getRow(r);

         for (int c = 0; c < cols; c++) {
             HSSFCell cell = row.getCell(c);

             switch (cell.getCellType()) {
                 case STRING:
                     System.out.print(cell.getStringCellValue());
                     break;
                 case NUMERIC:
                     System.out.print(cell.getNumericCellValue());
                     break;
                 case BOOLEAN:
                     System.out.print(cell.getBooleanCellValue());
                     break;
                 case FORMULA:
                     System.out.println(cell.getNumericCellValue());
                     break;
             }
             System.out.print(" -- ");
         }
         System.out.println();
     }

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
    • 4.将Excel数据读取到Map中
      @Test
 public void read3() throws IOException {
     FileInputStream fileInputStream = new FileInputStream(".\\datafiles\\student.xls");

     HSSFWorkbook hssfWorkbook = (HSSFWorkbook) HSSFWorkbookFactory.create(fileInputStream);

     HSSFSheet sheet = hssfWorkbook.getSheetAt(0);

     int rows = sheet.getLastRowNum();

     HashMap<String, String> data = new HashMap<>();

     for (int r = 0; r < rows; r++) {
         String key = sheet.getRow(r).getCell(0).getStringCellValue();
         String value = sheet.getRow(r).getCell(1).getStringCellValue();
         data.put(key,value);
     }

     for (Map.Entry<String, String> entry : data.entrySet()) {
         System.out.println(entry.getKey() + ":" + entry.getValue());
     }
 }

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
    3.向Excel写入数据
    • 1.写入数据接口案例
      @Test
public void TestExcelWrite(){
     //1.设置文件名
     String fileName = "TestExcelWrite";

   //2.设置导出目录
     String filePath = "E:\\Apache POI\\"+ fileName +".xls";

     //3.创建Excel表单
     HSSFWorkbook hssfWorkbook = new HSSFWorkbook();

     //4.设置单元格样式
     HSSFCellStyle cellBGStyle = hssfWorkbook.createCellStyle(); //背景样式
     cellBGStyle.setAlignment(HorizontalAlignment.CENTER); //设置居中对齐
     cellBGStyle.setVerticalAlignment(VerticalAlignment.BOTTOM); //设置底部对齐
     cellBGStyle.setBorderTop(BorderStyle.HAIR); //设置用于单元格顶部边框的边框类型
     cellBGStyle.setBorderBottom(BorderStyle.DOTTED); //设置用于单元格底部边框的边框类型 BorderStyle.DOTTED 点类型
     cellBGStyle.setBorderLeft(BorderStyle.DOUBLE); //设置用于单元格左部边框的边框类型
     cellBGStyle.setBorderRight(BorderStyle.DASH_DOT); //设置用于单元格右部边框的边框类型
     cellBGStyle.setTopBorderColor(IndexedColors.RED.getIndex()); //设置用于单元格顶部边框的边框颜色
     cellBGStyle.setBottomBorderColor(IndexedColors.BLUE.getIndex()); //设置用于单元格底部边框的边框颜色
     cellBGStyle.setLeftBorderColor(IndexedColors.PINK.getIndex()); //设置用于单元格左部边框的边框颜色
     cellBGStyle.setRightBorderColor(IndexedColors.CORAL.getIndex()); //设置用于单元格右部边框的边框颜色

     HSSFDataFormat hssfDataFormat = hssfWorkbook.createDataFormat(); //创建表单数据格式 //       
   hssfDataFormat.getFormat("@"); //设置数据格式为文本 @是text的别名 //        
   short format = hssfDataFormat.getFormat("yyyy年m月d日"); //设置数据格式为日期      
   short format = HSSFDataFormat.getBuiltinFormat("0.00"); //设置数据保留两位小数，其余设置可参考BuiltinFormats 
//      short format = hssfDataFormat.getFormat("¥#,##0"); //设置货币模式 其余设置可参考BuiltinFormats 
// 		short format = HSSFDataFormat.getBuiltinFormat("0.00%"); //设置百分比格式 
// 		short format = hssfDataFormat.getFormat("[DbNum2][$-804]0"); //设置数字-中文大写格式
     short format = HSSFDataFormat.getBuiltinFormat("0.00E+00"); //设置计数法
     cellBGStyle.setDataFormat(format); //设置数据格式

//      cellBGStyle.setHidden(false); //是否隐藏单元格，测试没出效果
     short indention = 2;
     cellBGStyle.setIndention(indention); //缩进单元格文本空格数 
//      cellBGStyle.setLocked(true); //锁定该单元格，测试没出效果
     short rotation = 80; 
//      cellBGStyle.setRotation(rotation); //设置内容旋转度数 HSSF为-90~90，XHSSF为0~180 
//      cellBGStyle.setShrinkToFit(false); //设置单元格是否自动调整大小，以便内容过长时缩小以适应，测试没出效果
     cellBGStyle.setQuotePrefixed(false); //是否打开样式前缀
     short order = 2;
     cellBGStyle.setReadingOrder(order); //设置文本的读取顺序，0为默认，1为从左到右，2为从右到左，测试没出效果
     cellBGStyle.setUserStyleName("测试"); //设置样式名称，测试没出效果
     cellBGStyle.setWrapText(true); //设置文本是否换行
     cellBGStyle.setFillForegroundColor(IndexedColors.RED.getIndex()); //设置前景色
     cellBGStyle.setFillPattern(FillPatternType.FINE_DOTS); //设置颜色填充样式

     HSSFCellStyle cellFontStyle = hssfWorkbook.createCellStyle(); //字体样式
     HSSFFont hssfFont = hssfWorkbook.createFont();
     hssfFont.setColor(IndexedColors.BLUE.getIndex()); //字体颜色
     hssfFont.setBold(true); //是否粗体 
//      hssfFont.setCharSet(); 设置字符集 
//      hssfFont.setFontHeight(); //设置字体高度 
//      hssfFont.setFontHeightInPoints(); 设置字体高度，标准值10, 12,14 etc..
     hssfFont.setFontName("楷体"); //根据名称设置字体类型
     hssfFont.setItalic(true); //是否斜体 
//      hssfFont.setStrikeout(true); //设置是否在文本中使用消线水平线(会覆盖掉下划线) 
//      hssfFont.setTypeOffset(Font.SS_SUPER); 设置字体类型，是上标或下标
     hssfFont.setUnderline(Font.U_SINGLE_ACCOUNTING); //下划线 U_SINGLE_ACCOUNTING单下划线
     cellFontStyle.setFont(hssfFont);

     //5.创建Sheet工作表
     HSSFSheet hssfSheet = hssfWorkbook.createSheet();  //创建工作表，默认从sheet0开始
     HSSFSheet test = hssfWorkbook.createSheet("test"); //创建工作表，并指定表名
     HSSFHeader header = hssfSheet.getHeader();
     header.setCenter("人员权限信息"); //测试没出效果

   //合并单元格,CellRangeAddress创建新的单元格范围。索引从零开始（开始行，结束行，开始列，结束列）
    hssfSheet.addMergedRegion(new CellRangeAddress(0, 0, 0, 2));
    hssfSheet.addMergedRegion(new CellRangeAddress(1, 2, 0, 0));

     //6.设置默认选中工作表
     hssfWorkbook.setActiveSheet(1);

     //7.记录列数
     int colNum = 0;
     for (int i=0; i<9; i++) {
         //8.创建行
         HSSFRow hssfRow = hssfSheet.createRow(i);
         short height = 2000;
         hssfRow.setHeight(height); //设置行高，默认值为-1 
//          hssfRow.setHeightInPoints(height); //以点为单位设置行高，等同于*20，默认值为-1 //       
//   		hssfRow.setRowNum(int rowIndex); //设置行好，range 0-65535          
// 			hssfRow.setZeroHeight(false); //设置是否显示高度为0的行 //           
// 			hssfRow.setRowStyle(cellStyle);  设置行的样式，会被单元格覆盖掉
         for(int j=0; j<=i; j++){
             //9.创建单元格
             HSSFCell hssfCell = hssfRow.createCell(j);
             if(i%2==0){
                 hssfCell.setCellStyle(cellBGStyle);
                 hssfCell.setAsActiveCell(); //设置默认选中单元格

             }else {
                 hssfCell.setCellStyle(cellFontStyle);                     
//                  hssfCell.setBlank(); //设置为空白单元格 
//                  hssfCell.setCellFormula(String formula); //设置单元格公式 
//                  hssfCell.setCellType(); //设置单元格类型，参数位CellType枚举类
             }
             hssfCell.setCellValue(new Date());
             colNum = j;
         }
     }

     //10.设置工作表指定列的长度随内容自动调整
     for(int col=0; col<=colNum; col++){
         hssfSheet.autoSizeColumn(col);
     }

     //11.导出文件
     try {
         hssfWorkbook.write(new FileOutputStream(filePath));
     } catch (IOException e) {
         log.error("路径错误{} {}",filePath,new Date());
         e.printStackTrace();
     }

     //12.关闭
     try {
         hssfWorkbook.close();
     } catch (IOException e) {
         log.error("Excel表单关闭错误{}", new Date());
         e.printStackTrace();
     }
 } 

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      • 95
      • 96
      • 97
      • 98
      • 99
      • 100
      • 101
      • 102
      • 103
      • 104
      • 105
      • 106
      • 107
      • 108
      • 109
      • 110
      • 111
      • 112
      • 113
      • 114
      • 115
      • 116
      • 117
      • 118
      • 119
      • 120
      • 121
      • 122
      • 123
      • 124
      • 125
      • 126
    • 2.写入数据标准模板
      @Test
    public void write3() throws IOException {
        HSSFWorkbook hssfWorkbook = new HSSFWorkbook();
        HSSFSheet hssfSheet = hssfWorkbook.createSheet("Emp Info");

        HSSFCellStyle cellStyle = hssfWorkbook.createCellStyle();
        cellStyle.setAlignment(HorizontalAlignment.CENTER);

        Object empData[][] = {
                                {"EmpID","Name","Job"},
                                {101,"David","Java"},
                                {102,"Smith","Manager"},
                                {103,"Son","Analyst"}
                             };

//        ArrayList empData = new ArrayList<>();
//        empData.add(new Object[]{"EmpID","Name","Job"});
//        empData.add(new Object[]{101,"David","Java"});
//        empData.add(new Object[]{102,"Smith","Manager"});
//        empData.add(new Object[]{103,"Son","Analyst"});

//        int rows = empData.length;
//        int clos = empData[0].length;
//
//        for (int r = 0; r < rows; r++) {
//            HSSFRow row = hssfSheet.createRow(r);
//
//            for (int c = 0; c < clos; c++) {
//                HSSFCell cell = row.createCell(c);
//                cell.setCellStyle(cellStyle);
//                Object value = empData[r][c];
//
//                if(value instanceof String)
//                    cell.setCellValue((String)value);
//                if(value instanceof Integer)
//                    cell.setCellValue((Integer)value);
//                if(value instanceof Boolean)
//                    cell.setCellValue((Boolean)value);
//            }
//        }

        int rowCount = 0;

        for (Object emp[]:empData) {
            HSSFRow row = hssfSheet.createRow(rowCount++);
            int colCount = 0;
            for (Object value : emp) {
                HSSFCell cell = row.createCell(colCount++);

                if(value instanceof String)
                    cell.setCellValue((String)value);
                if(value instanceof Integer)
                    cell.setCellValue((Integer)value);
                if(value instanceof Boolean)
                    cell.setCellValue((Boolean)value);
            }
        }

        String filePath = ".\\datafiles\\employee.xls";
        FileOutputStream fileOutputStream = new FileOutputStream(filePath);
        hssfWorkbook.write(fileOutputStream);

        System.out.println("Employee.xls file written successfully");
    }

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
       
    • 3.向桌面写入数据
      @Test
public void write1() throws IOException {
     // 获取桌面路径
     FileSystemView fsv = FileSystemView.getFileSystemView();
     String desktop = fsv.getHomeDirectory().getPath();
     String filePath = desktop + "/template.xls";

     File file = new File(filePath);
     OutputStream outputStream = new FileOutputStream(file);
     HSSFWorkbook workbook = new HSSFWorkbook();
     HSSFSheet sheet = workbook.createSheet("Sheet1");
     HSSFRow row = sheet.createRow(0);
     row.createCell(0).setCellValue("id");
     row.createCell(1).setCellValue("订单号");
     row.createCell(2).setCellValue("下单时间");
     row.createCell(3).setCellValue("个数");
     row.createCell(4).setCellValue("单价");
     row.createCell(5).setCellValue("订单金额");
     row.setHeightInPoints(30); // 设置行的高度

     HSSFRow row1 = sheet.createRow(1);
     row1.createCell(0).setCellValue("1");
     row1.createCell(1).setCellValue("NO00001");

     // 日期格式化
     HSSFCellStyle cellStyle2 = workbook.createCellStyle();
     HSSFCreationHelper creationHelper = workbook.getCreationHelper();
     cellStyle2.setDataFormat(creationHelper.createDataFormat().getFormat("yyyy-MM-dd HH:mm:ss"));
     sheet.setColumnWidth(2, 20 * 256); // 设置列的宽度

     HSSFCell cell2 = row1.createCell(2);
     cell2.setCellStyle(cellStyle2);
     cell2.setCellValue(new Date());

     row1.createCell(3).setCellValue(2);

     // 保留两位小数
     HSSFCellStyle cellStyle3 = workbook.createCellStyle();
     cellStyle3.setDataFormat(HSSFDataFormat.getBuiltinFormat("0.00"));
     HSSFCell cell4 = row1.createCell(4);
     cell4.setCellStyle(cellStyle3);
     cell4.setCellValue(29.5);

     // 货币格式化
     HSSFCellStyle cellStyle4 = workbook.createCellStyle();
     HSSFFont font = workbook.createFont();
     font.setFontName("华文行楷");
     font.setFontHeightInPoints((short)15);
     font.setColor(IndexedColors.RED.getIndex());
     cellStyle4.setFont(font);

     HSSFCell cell5 = row1.createCell(5);
     cell5.setCellFormula("D2*E2");  // 设置计算公式

     // 获取计算公式的值
     HSSFFormulaEvaluator e = new HSSFFormulaEvaluator(workbook);
     cell5 = e.evaluateInCell(cell5);
     System.out.println(cell5.getNumericCellValue());


     workbook.setActiveSheet(0);
     workbook.write(outputStream);
     outputStream.close();
 }

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
       
    • 4.写入带有公式的表格
       @Test
  public void write3() throws IOException {
      HSSFWorkbook hssfWorkbook = new HSSFWorkbook();
      HSSFSheet sheet = hssfWorkbook.createSheet("Numbers");

      HSSFRow row = sheet.createRow(0);

      row.createCell(0).setCellValue(10);
      row.createCell(1).setCellValue(20);
      row.createCell(2).setCellValue(30);

      row.createCell(3).setCellFormula("A1*B1*C1");
//     row.createCell(3).setCellFormula("SUM(C2:C6)"); 计算从C2一直到C6的和

      FileOutputStream fileOutputStream = new FileOutputStream(".\\datafiles\\calc.xlsx");

      hssfWorkbook.write(fileOutputStream);

      fileOutputStream.close();
      hssfWorkbook.close();

      System.out.println("calc.xlsx created with formula cell...");
  } 

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
       
    • 5.将Map中的数据写入表格
      @Test
 public void write4() throws IOException {
     HSSFWorkbook hssfWorkbook = new HSSFWorkbook();
     HSSFSheet sheet = hssfWorkbook.createSheet("Student data");

     Map<String, String> data = new HashMap<>();
     data.put("101","李四");
     data.put("102","张三");
     data.put("103","赵六");
     data.put("104","王五");

     int rowCount = 0;

     for (Map.Entry<String, String> entry : data.entrySet()) {
         HSSFRow row = sheet.createRow(rowCount++);

         row.createCell(0).setCellValue((String)entry.getKey());
         row.createCell(1).setCellValue((String)entry.getValue());
     }

     FileOutputStream fileOutputStream = new FileOutputStream(".\\datafiles\\student.xlsx");

     hssfWorkbook.write(fileOutputStream);

     hssfWorkbook.close();
     fileOutputStream.close();

     System.out.println("student.xlsx created...");
 }

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
       
    • 6.将数据库中的数据写入表单中
      @Test
 public void write5() throws SQLException, IOException {
     Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis_plus","root","root");
     Statement statement = connection.createStatement();
     ResultSet resultSet = statement.executeQuery("select * from t_user");

     HSSFWorkbook hssfWorkbook = new HSSFWorkbook();
     HSSFSheet sheet = hssfWorkbook.createSheet("User Data");
     HSSFCellStyle cellStyle = hssfWorkbook.createCellStyle();
     cellStyle.setAlignment(HorizontalAlignment.CENTER);

     String[] str = new String[]{"id","name","age","email"};
     
     HSSFRow row1 = sheet.createRow(0);
     for (int c = 0; c < str.length; c++) {
         HSSFCell cell = row1.createCell(c);
         cell.setCellValue(str[c]);
         cell.setCellStyle(cellStyle);
     }

     int rowCount = 1;
     while (resultSet.next()) {
         int id = resultSet.getInt("id");
         String name = resultSet.getString("name");
         int age = resultSet.getInt("age");
         String email = resultSet.getString("email");

         HSSFRow row = sheet.createRow(rowCount++);
         HSSFCell cell = row.createCell(0);
         HSSFCell cell1 = row.createCell(1);
         HSSFCell cell2 = row.createCell(2);
         HSSFCell cell3 = row.createCell(3);
         cell.setCellValue(id);
         cell.setCellStyle(cellStyle);
         cell1.setCellValue(name);
         cell1.setCellStyle(cellStyle);
         cell2.setCellValue(age);
         cell2.setCellStyle(cellStyle);
         cell3.setCellValue(email);
         cell3.setCellStyle(cellStyle);
     }

     sheet.autoSizeColumn(3);//注意，设置自适应长度需要在设置值之后才会生效

     FileOutputStream fileOutputStream = new FileOutputStream(".\\datafiles\\User.xls");

     hssfWorkbook.write(fileOutputStream);

     hssfWorkbook.close();
     fileOutputStream.close();
     connection.close();

     System.out.println("Success");
 }

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
       
      •  
 

       
 
      2.操作Word
       
 
      1.Word文档中范围，小节，段落，文本的关系(HWPFDocument)
//Range：它表示一个范围，这个范围可以是整个文档，也可以是里面的某一小节（Section），也可以是某一个段落（Paragraph），还可以是拥有共同属性的一段文本（CharacterRun）(以下属性都继承自Range)
//Section：Word文档的一个小节，一个Word文档可以有多个小节构成(分页符是指将一页内容分成两页，但分离后的两页仍属于同一节；分节符则是将一节内容分成两节，分离后的两节可以在同一页，也可以不在同一页)
//Paragraph：Word文档的一个段落，一个小节可以由多个段落构成
//CharacterRun：具有相同属性的一段文本，一个段落可以由多个CharacterRun组成(同个段落可能有多种属性，例：加粗，斜体等)
//Table：Word文档的一个表格
//TableRow：表格对应的行
//TableCell：表格对应的单元格

2.常用类和方法
//HWPF支持 Word (97-2003)，支持读写Word文档，但是写功能目前只实现一部分
//XWPF支持 Word 2007+ 的 Java组件，提供简单文件的读写功能
//1.HWPFDocument: word文档(XWPFDocument不向下兼容)
HWPFDocument doc = newHWPFDocument(InputStream istream) //该方法必须需要参数，即必须先创建一个文件，XWPFDocument可以直接创建不需要参数

//2.Range: 范围
Range range = doc.getRange(); //返回整个文档，但不包括任何页眉和页脚的范围，实际调用私有方法的getRange(SubdocumentType.MAIN)
Range overallRange = hwpfDocument.getOverallRange(); //获取整体范围，实际调用构造方法new Range(0, _text.length(), this)
Range headerStoryRange = hwpfDocument.getHeaderStoryRange(); //返回覆盖所有“Header Stories”的范围。Header Stories包含页眉、页脚、结束注释分隔符和脚注分隔符
Range footnoteRange = hwpfDocument.getFootnoteRange(); //返回包含所有脚注的范围
Range mainTextboxRange = hwpfDocument.getMainTextboxRange(); //返回包含所有文本框的范围
Range commentsRange = hwpfDocument.getCommentsRange(); //返回包含所有注释的范围
Range endnoteRange = hwpfDocument.getEndnoteRange(); //返回包含所有尾注的范围
String text = range.text(); //获取对应范围的内容


//3.Section：小节
Section section = range.getSection(int index); //获取对应范围的小节,对应Word文档中的分节符
int sectionsNum = range.numSections(); //获取对应范围内一个有多少个小节
String text = Section.text(); //获取对应小节的内容

// 4.Paragraph: 段落
Paragraph paragraph = section.getParagraph(int index); //获取对应小节的段落
int paragraphsNum = section.numParagraphs(); //获取对应小节内有多少个段落
String text = paragraph.text(); //获取对应段落的内容

//5.CharacterRun: 具有相同属性的文本(粗体，斜体...)
CharacterRun characterRun = paragraph.getCharacterRun(int index); //获取对应段落的相同属性的文本
int characterRuns = paragraph.numCharacterRuns(); //获取对应的段落有多少相同属性的文本
String text = characterRun.text(); //获取具有相同属性的的内容
characterRun.setBold(true); //将对应的文本设置为粗体
characterRun.setFontSize(100); //设置对应的文本字体大小
characterRun.setItalic(true); //将对应的文本设置为斜体

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
       
 
      1.Word文档中的段落，文本，表格关系(XWPFDocument)
//XWPFDocument: 表示一个Wrod文档
//XWPFParagraph: 表示一个段落，一个文档包含多个段落
//XWPFRun：表示一个文本/区域(具有相同属性的一段文本)，一个段落包含多个区域
//XWPFFooter：表示页脚
//XWPFFootnote: 表示脚注
//XWPFHeader: 表示页眉
//XWPFPictureData: 表示图片
//XWPFStyles: 表示样式
//XWPFTable：Word文档的一个表格，一个文档包含多个表格，一个表格包含多行
//XWPFTableRow：表格对应的行，一行包含多格
//XWPFTableCell：表格对应的单元格，每一格的内容相当于一个完整的文档

2.常用类和方法
//HWPF支持 Word (97-2003)，支持读写Word文档，但是写功能目前只实现一部分
//XWPF支持 Word 2007+ 的 Java组件，提供简单文件的读写功能
//1.XWPFDocument : word文档
XWPFDocument doc = new XWPFDocument(); //创建word文档，可以直接直接创建，不传入参数
XWPFChart chart = doc.createChart(); //创建图表
XWPFEndnote endnote = doc.createEndnote(); //创建一个新的结束注释并将其添加到文档中
XWPFFooter footer = doc.createFooter(HeaderFooterType type); //创建给定类型的页脚，参数为HeaderFooterType
XWPFFootnote footnote = doc.createFootnote(); // 创建一个新的脚注并将其添加到文档中
XWPFHeader header = doc.createHeader(HeaderFooterType type); //创建给定类型的标头
XWPFHeaderFooterPolicy headerFooterPolicy = doc.createHeaderFooterPolicy(); //创建页眉和页脚的策略，这也提供了获取它们的方法
XWPFNumbering numbering = doc.createNumbering(); //创建编号，如果编号不存在，则创建空编号，并设置编号成员
XWPFParagraph paragraph = doc.createParagraph(); //创建新段落
XWPFStyles styles = doc.createStyles(); //如果文档不存在样式，则为文档创建空样式

//2.XWPFParagraph：段落
XWPFParagraph paragraph = doc.createParagraph(); //创建段落

//3.XWPFRun: 文本/区域
XWPFRun run = paragraph.createRun(); //创建区域

//4.XWPFTable: 表格
XWPFTable table = doc.createTable(); //创建表格

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
       

       

       
 
      1.从Word读取数据
       
 
      • 1.从Word文档中读取指定节点指定段落的内容
         @Test
 public void wordWrite3() throws IOException {
     //1.获取桌面文件路径
     FileSystemView fsv = FileSystemView.getFileSystemView();
     String desktop = fsv.getHomeDirectory().getPath();
     String filePath = desktop + "/readContext.doc";

     //2.将文件转换为输入流
     FileInputStream fis = new FileInputStream(filePath);

     //3.通过输入流将Word文件转换为HWPFDocument
     HWPFDocument doc = new HWPFDocument(fis);

     //4.获取区域
     Range range = doc.getRange(); //返回整个文档，但不包括任何页眉和页脚的范围，实际调用私有方法的getRange(SubdocumentType.MAIN)

     int sectionsNum = range.numSections();
     System.out.println("sectionsNum:" + sectionsNum);

     for (int i = 0; i < sectionsNum; i++) {
         //5.获取对应范围的小节
         Section section = range.getSection(i);

         int paragraphsNum = section.numParagraphs();
         System.out.println("paragraphsNum:" + paragraphsNum);

         for (int j = 0; j < paragraphsNum; j++) {
             //6.获取对应小节的段落
             Paragraph paragraph = section.getParagraph(j);
             //7.获取段落内容
             String text = paragraph.text();
             System.out.println("小节:" + (i+1) + ",段落:" + (j+1) + ",内容:" + text);
         }
     }   
     
     FileOutputStream out = new FileOutputStream(".\\datafiles\\test.doc");
     out.flush();
     doc.write(out);

     fis.close();
     out.close();
     doc.close();
 }

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
        • 31
        • 32
        • 33
        • 34
        • 35
        • 36
        • 37
        • 38
        • 39
        • 40
        • 41
        • 42
        • 43
         
      • 2.从Word文档中读取图片并写入到指定位置
        @Slf4j
public class PoiUtil {
	/**
     * 根据文件获取文件前缀(文件名)
     * @param file 文件
     * @return String 文件名
     */
    public static String getFilePrefix(File file){
        //1.获取完整文件名
        String wholeFileName = file.getName();
        //2.获取最后一个点的下标
        int lastPointIndex = wholeFileName.lastIndexOf(".");
        //3.截取字符串
        return wholeFileName.substring(0, lastPointIndex);
    }

    /**
     * 根据文件获取文件后缀/文件类型
     * @param file 文件
     * @return String 文件后缀
     */
    public static String getFileSuffix(File file){
        //1.获取文件名
        String fileName = file.getName();
        return getFileType(fileName);
    }

    /**
     * 根据文件名获取文件类型
     * @param fileName 文件名
     * @return String 文件类型
     */
    public static String getFileType(String fileName) {
        //1.将文件名根据\\.切割
        String[] strArray = fileName.split("\\.");
        //2.获取最后一个数组下标
        int suffixIndex = strArray.length -1;
        return strArray[suffixIndex];
    }

    /**
     * 从Word文档中取出图片导入到目的路径
     * @param wordFile word文件
     * @param targetPath 目的路径
     */
    public synchronized static void fetchPictureFromWord(File wordFile, String targetPath) {
        //1.获取文件的绝对路径
        String absolutePath = wordFile.getAbsolutePath();
        //2.根据word完整路径获取文件类型
        String fileType = POIUtil.getFileType(absolutePath);
        //3.获取文件名
        String fileName = getFilePrefix(wordFile);

        //4.记录提取次数
        int numberId=1;

        //5.根据文件类型做不同的处理
        switch (fileType.toLowerCase()){
            case "doc":
                try(HWPFDocument hwpfDocument = new HWPFDocument(new FileInputStream(absolutePath))){
                    //1.从文档中提取所有图片
                    PicturesTable picturesTable = hwpfDocument.getPicturesTable();
                    List<Picture> pictures = picturesTable.getAllPictures();

                    for (Picture picture : pictures) {
                        //2.输出图片到磁盘(目标路径+"/"+numberId+".后缀名")
                        String pictureFiePath = targetPath + File.separator + fileName + numberId +"."+ picture.suggestFileExtension();
                        log.info("doc pictureFiePath:" + pictureFiePath);

                        try(OutputStream out = new FileOutputStream(pictureFiePath)){
                            picture.writeImageContent(out);
                        }
                        numberId++;
                    }
                }catch (IOException e) {
                    log.error("错误的文件:{}",e);
                    log.error("出错文件路径",absolutePath);
                }
                break;
            case "docx":
                try(XWPFDocument xwpfDocument=new XWPFDocument(new FileInputStream(absolutePath))){
                    //1.获取所有图片
                    List<XWPFPictureData> xwpfPictureDataList = xwpfDocument.getAllPictures();
                    //2.如果存在图片
                    if(null!=xwpfPictureDataList && xwpfPictureDataList.size()>0){
                        for (XWPFPictureData item:xwpfPictureDataList) {
                            //3.获取图片的字节流
                            byte[] bytes = item.getData();
                            String pictureFiePath = targetPath + File.separator + fileName + numberId + "." + item.suggestFileExtension();
                            log.info("docx pictureFiePath:" + pictureFiePath);
                            //4.写入文件
                            File file=new File(pictureFiePath);
                            if(file.exists()){
                                file.delete();
                            }
                            try(FileOutputStream fos = new FileOutputStream(pictureFiePath)){
                                fos.write(bytes);
                            }
                            numberId++;
                        }
                    }
                } catch (IOException e) {
                    log.error("错误的文件:{}",e);
                    log.error("出错文件路径",absolutePath);
                }
                break;
            default:
                log.error("{}无效的文件格式:{}",wordFile,fileType);
                break;
        }
    }
}

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
        • 31
        • 32
        • 33
        • 34
        • 35
        • 36
        • 37
        • 38
        • 39
        • 40
        • 41
        • 42
        • 43
        • 44
        • 45
        • 46
        • 47
        • 48
        • 49
        • 50
        • 51
        • 52
        • 53
        • 54
        • 55
        • 56
        • 57
        • 58
        • 59
        • 60
        • 61
        • 62
        • 63
        • 64
        • 65
        • 66
        • 67
        • 68
        • 69
        • 70
        • 71
        • 72
        • 73
        • 74
        • 75
        • 76
        • 77
        • 78
        • 79
        • 80
        • 81
        • 82
        • 83
        • 84
        • 85
        • 86
        • 87
        • 88
        • 89
        • 90
        • 91
        • 92
        • 93
        • 94
        • 95
        • 96
        • 97
        • 98
        • 99
        • 100
        • 101
        • 102
        • 103
        • 104
        • 105
        • 106
        • 107
        • 108
        • 109
        • 110
        • 111
        • 112
         
        @Test
 public void test(){
     //1.获取桌面路径+文件
     FileSystemView fsv = FileSystemView.getFileSystemView();
     String desktop = fsv.getHomeDirectory().getPath();
     String filePath = desktop + "/template.doc";

     //2.新建文件
     File wordFile = new File(filePath);

     //3.获取图片导入目录
     String targetPath = wordFile.getParentFile().getPath();

     //4.从指定文件导出Word图片到目标目录中
     POIUtil.fetchPictureFromWord(wordFile,targetPath);
 }

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
         
       

       

       
 
      2.向Word写入数据
       
 
      • (XWPF支持读写功能，HWPF对于写功能只实现一部分)
      • 1.向Word文档写入List数据
        public static void writeDataToWord(String fileName, List<String> data) throws IOException {
        try(FileOutputStream out = new FileOutputStream(fileName)){
            //创建一个文档
            XWPFDocument xwpfDocument=new XWPFDocument();
            //创建一个段落
            XWPFParagraph xwpfParagraph;
            //创建一片区域
            XWPFRun run;
            for (String lineData:data) {
                xwpfParagraph= xwpfDocument.createParagraph();
                run = xwpfParagraph.createRun();
                run.setText(lineData);
            }
            xwpfDocument.write(out);
            xwpfDocument.close();
        }
}

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
         
        @Test
 public void test() throws IOException {
     FileSystemView fsv = FileSystemView.getFileSystemView();
     String desktop = fsv.getHomeDirectory().getPath();
     String filePath = desktop + "/template.doc";

     ArrayList<String> data = new ArrayList<>();
     data.add("你是猪");
     data.add("you are pig");
     data.add("我是帅哥");
     data.add("I am coolMan");

     POIUtil.writeDataToWord(filePath,data);
 }

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
         
      • 2.向Word文档中写入简单表格
        @Test
 public void wordWrite4() throws IOException {
     //1.获取桌面文件路径
     FileSystemView fsv = FileSystemView.getFileSystemView();
     String desktop = fsv.getHomeDirectory().getPath();
     String filePath = desktop + "/write.doc";

     //2.创建一个文档
     XWPFDocument doc = new XWPFDocument();

     //3.创建一个表格
     XWPFTable table = doc.createTable();
     for (int i = 0; i < 9; i++) {
         //4.创建行
         XWPFTableRow row = table.createRow();
         for (int j = 0; j <= i; j++) {
             //4.创建单元格
             XWPFTableCell cell = row.createCell();
             cell.setText((j+1) + "*" + (i+1) + "=" + (j+1)*(i+1));
             cell.setWidth("1024");
         }
     }

     FileOutputStream out = new FileOutputStream(filePath);
     out.flush();
     doc.write(out);

     out.close();
     doc.close();
 }

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
         
       

       

       
 
      6.Java Web文档操作
       

       

       
 
      1.导入
       

       

       
 
      1.依赖
       
 
       

<dependency>
    <groupId>org.apache.poigroupId>
    <artifactId>poiartifactId>
    <version>4.0.0version>
dependency>

<dependency>
    <groupId>org.apache.poigroupId>
    <artifactId>poi-ooxmlartifactId>
    <version>4.0.0version>
dependency>
 
<dependency>
	<groupId>commons-iogroupId>
	<artifactId>commons-ioartifactId>
	<version>1.4version> 
dependency> 
<dependency>
	<groupId>commons-fileuploadgroupId>
	<artifactId>commons-fileuploadartifactId>
	<version>1.3.1version> 
dependency> 

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
       
 
      • 没有导入commons依赖会报下列错误
       
 
      Caused by: org.springframework.beans.BeanInstantiationException: 
Failed to instantiate [org.springframework.web.multipart.commons.CommonsMultipartResolver]:
Factory method 'getCommonsMultipartResolver' threw exception; nested
exception is java.lang.NoClassDefFoundError: 
org/apache/commons/fileupload/disk/DiskFileItemFactory

      • 1
      • 2
      • 3
      • 4
      • 5
       

       

       
 
      2.配置类
       
 
      package com.wd.config;

import org.springframework.context.annotation.Bean; import
org.springframework.context.annotation.Configuration; import
org.springframework.web.multipart.commons.CommonsMultipartResolver;

@Configuration public class ImportConfig {

    @Bean
    public CommonsMultipartResolver getCommonsMultipartResolver(){
        return new CommonsMultipartResolver();
    } }

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
       

       

       
 
      3.导入接口
       
 
      	@SuppressWarnings("resource")
    @RequestMapping("/import")
    //注意此处需要@RestController(类)或者@RequestBody注解
    public void importExcel(@RequestParam("file") MultipartFile file) throws Exception{

        System.out.println(file);
        InputStream inputStream = file.getInputStream();
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
        POIFSFileSystem fileSystem = new POIFSFileSystem(bufferedInputStream);
        HSSFWorkbook workbook = new HSSFWorkbook(fileSystem);
        //HSSFWorkbook workbook = new HSSFWorkbook(file.getInputStream());
        HSSFSheet sheet = workbook.getSheetAt(0);
        System.out.println(sheet);

        int lastRowNum = sheet.getLastRowNum();
        System.out.println(lastRowNum);
        for (int i = 2; i <= lastRowNum; i++) {
            HSSFRow row = sheet.getRow(i);
            int id = (int) row.getCell(0).getNumericCellValue();
            String name = row.getCell(1).getStringCellValue();
            int age = (int) row.getCell(2).getNumericCellValue();

            System.out.println(id + "-" + name + "-" + age);
        }
    }

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
       

       

       
 
      2.导出
       

       

       
 
      1.依赖
       
 
       

<dependency>
    <groupId>org.apache.poigroupId>
    <artifactId>poiartifactId>
    <version>4.0.0version>
dependency>

<dependency>
    <groupId>org.apache.poigroupId>
    <artifactId>poi-ooxmlartifactId>
    <version>4.0.0version>
dependency>

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
       

       

       
 
      2.接口
       
 
      @SuppressWarnings("resource")
    @RequestMapping("/export")
    public void exportExcel(HttpServletResponse response, HttpSession session, String name) throws Exception {

        String[] tableHeaders = {"id", "姓名", "年龄"};

        HSSFWorkbook workbook = new HSSFWorkbook();
        HSSFSheet sheet = workbook.createSheet("Sheet1");
        HSSFCellStyle cellStyle = workbook.createCellStyle();
        cellStyle.setAlignment(HorizontalAlignment.CENTER);
        cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);

        Font font = workbook.createFont();
        font.setColor(IndexedColors.RED.getIndex());
        font.setBold(true);
        cellStyle.setFont(font);

        // 将第一行的三个单元格给合并
        sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, 2));
        HSSFRow row = sheet.createRow(0);
        HSSFCell beginCell = row.createCell(0);
        beginCell.setCellValue("通讯录");
        beginCell.setCellStyle(cellStyle);

        row = sheet.createRow(1);
        // 创建表头
        for (int i = 0; i < tableHeaders.length; i++) {
            HSSFCell cell = row.createCell(i);
            cell.setCellValue(tableHeaders[i]);
            cell.setCellStyle(cellStyle);
        }

        List<User> users = new ArrayList<>();
        users.add(new User(1, "张三", 20));
        users.add(new User(2, "李四", 21));
        users.add(new User(3, "王五", 22));

        for (int i = 0; i < users.size(); i++) {
            row = sheet.createRow(i + 2);

            User user = users.get(i);
            row.createCell(0).setCellValue(user.getId());
            row.createCell(1).setCellValue(user.getName());
            row.createCell(2).setCellValue(user.getAge());
        }

        OutputStream outputStream = response.getOutputStream();
        response.reset();
        response.setContentType("application/vnd.ms-excel");
        response.setHeader("Content-disposition", "attachment;filename=template.xls");

        workbook.write(outputStream);
        outputStream.flush();
        outputStream.close();
    }

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
       

       

       
 
      3.前端JSP
       
 
      <%--
 Created by IntelliJ IDEA.
 User: 32929
 Date: 2022/11/26
 Time: 13:09
 To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
   <title>测试</title>
</head>
<body>
<a href="http://localhost:8989/springboot_test/export">导出</a> <br/>

<form action="http://localhost:8989/springboot_test/import" enctype="multipart/form-data" method="post">
   <input type="file" name="file"/><br/>
   <input type="submit" value="导入Excel"/>
</form>
</body>
</html>

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
       

       

       
 
      2.JXL
       
 
      • Java Excel是一开放源码项目，通过它Java开发人员可以读取Excel文件的内容、创建新的Excel文件、更新已经存在的Excel文件。jxl 由于其小巧 易用的特点, 逐渐已经取代了 POI-excel的地位, 成为了越来越多的java开发人员生成excel文件的首选。
       

       

       
 
      3.excelPOI
       

       

       
 
      4.easyExcel
       

       

       
 
      5.GrapeCity Documents
       

      
                
                    
                

                
    • 

                    相关阅读:
      
                    
企业微信接入芋道SpringBoot项目                            
      
【LeetCode每日一题】——445.两数相加 II                            
      
智能合约检测：新一代区块链技术的安全守护                            
      
Mac 一键禁用自带键盘 使用外接键盘                            
      
Q&A特辑 | 看了这场直播，我找到了设备指纹“从不说谎”的原因                            
      
从零开始的Docker Desktop使用,Docker快速上手 （￣︶￣） Docker介绍和基础使用                            
      
C++:无法查找或打开 PDB 文件?? 如何解决呢？以及产生原因是什么？                            
      
Ai-WB2系列的固件烧录指导                            
      
yolov7训练数据集详细流程bike-car-person                            
      
Visual Studio 和 VSCode 哪个好？                            
      
                          
                
      • 
                
    • 
                    原文地址：https://blog.csdn.net/wu246051/article/details/128034266
                
      •