POI使用介绍

Posted 2020-11-28 lyle-liu

POI介绍：

    1.什么是POI？
        Apache POI是用Java编写的免费开源的跨平台的Java API，Apache POI提供API给Java程序对Microsoft Office格式档案读和写的功能，
        其中使用最多的就是使用POI操作Excel文件。
        
    2.POI的使用：
        1.导入依赖：
            <dependency>
              <groupId>org.apache.poi</groupId>
              <artifactId>poi</artifactId>
              <version>3.14</version>
            </dependency>
            <dependency>
              <groupId>org.apache.poi</groupId>
              <artifactId>poi-ooxml</artifactId>
              <version>3.14</version>
            </dependency>
            
        2.POI结构：
            HSSF － 提供读写Microsoft Excel XLS格式档案的功能
            XSSF － 提供读写Microsoft Excel OOXML XLSX格式档案的功能（2007版以后的Excel）
            HWPF － 提供读写Microsoft Word DOC格式档案的功能
            HSLF － 提供读写Microsoft PowerPoint格式档案的功能
            HDGF － 提供读Microsoft Visio格式档案的功能
            HPBF － 提供读Microsoft Publisher格式档案的功能
            HSMF － 提供读Microsoft Outlook格式档案的功能
            
        3.入门：
            1.读取Excel文件：
                步骤：
                    1：创建工作簿对象
                    2：获得工作表对象
                    3：遍历工作表对象 获得行对象
                    4：遍历行对象 获得单元格（列）对象
                    5：获得数据
                    6：关闭
                代码演示：
                    注：
                        XSSFWorkbook：工作簿
                        XSSFSheet：工作表
                        XSSFRow：行
                        XSSFCell：单元格
                        
                    方式1：
                    @Test
                    public void exportExcel() throws IOException {
                        //创建工作簿
                        XSSFWorkbook workbook = new XSSFWorkbook("D:\hello.xlsx");
                        //获取工作表，既可以根据工作表的顺序获取，也可以根据工作表的名称获取
                        XSSFSheet sheet = workbook.getSheetAt(0);
                        //遍历工作表获得行对象
                        for (Row row : sheet) {
                            //遍历行对象获取单元格对象
                            for (Cell cell : row) {
                                //获得单元格中的值
                                String value = cell.getStringCellValue();
                                System.out.println(value);
                            }
                        }
                        workbook.close();
                    }
                    
                    方式2：
                    // 导出excel，获取最后一行
                    @Test
                    public void exportExcel_lastRow() throws IOException {
                        //创建工作簿
                        XSSFWorkbook workbook = new XSSFWorkbook("D:\hello.xlsx");
                        //获取工作表，既可以根据工作表的顺序获取，也可以根据工作表的名称获取
                        XSSFSheet sheet = workbook.getSheetAt(0);
                        //获取当前工作表最后一行的行号，行号从0开始
                        int lastRowNum = sheet.getLastRowNum();
                        for(int i=0;i<=lastRowNum;i++){
                            //根据行号获取行对象
                            XSSFRow row = sheet.getRow(i);
                            short lastCellNum = row.getLastCellNum();
                            for(short j=0;j<lastCellNum;j++){
                                String value = row.getCell(j).getStringCellValue();
                                System.out.println(value);
                            }
                        }
                        workbook.close();
                    }
            
            2.向Excel文件写入数据：
                1.步骤：
                    1.创建工作簿对象
                    2.创建工作表对象
                    3.创建行对象
                    4.创建列(单元格)对象, 设置内容
                    5.通过输出流将workbook对象下载到磁盘
                2.代码演示：
                    @Test
                    public void importExcel() throws IOException {
                        //在内存中创建一个Excel文件
                        XSSFWorkbook workbook = new XSSFWorkbook();
                        //创建工作表，指定工作表名称
                        XSSFSheet sheet = workbook.createSheet("华为");

                        //创建行，0表示第一行
                        XSSFRow row = sheet.createRow(0);
                        //创建单元格，0表示第一个单元格
                        row.createCell(0).setCellValue("编号");
                        row.createCell(1).setCellValue("姓名");
                        row.createCell(2).setCellValue("年龄");

                        XSSFRow row1 = sheet.createRow(1);
                        row1.createCell(0).setCellValue("1");
                        row1.createCell(1).setCellValue("小明");
                        row1.createCell(2).setCellValue("10");

                        XSSFRow row2 = sheet.createRow(2);
                        row2.createCell(0).setCellValue("2");
                        row2.createCell(1).setCellValue("小王");
                        row2.createCell(2).setCellValue("20");

                        //通过输出流将workbook对象下载到磁盘
                        FileOutputStream out = new FileOutputStream("D:\itcast.xlsx");
                        workbook.write(out);
                        out.flush();//刷新
                        out.close();//关闭
                        workbook.close();
                    }
        
        4.POI工具类：
            import org.apache.poi.hssf.usermodel.HSSFWorkbook;
            import org.apache.poi.ss.usermodel.Cell;
            import org.apache.poi.ss.usermodel.Row;
            import org.apache.poi.ss.usermodel.Sheet;
            import org.apache.poi.ss.usermodel.Workbook;
            import org.apache.poi.xssf.usermodel.XSSFWorkbook;
            import org.springframework.web.multipart.MultipartFile;

            import java.io.FileNotFoundException;
            import java.io.IOException;
            import java.io.InputStream;
            import java.text.SimpleDateFormat;
            import java.util.ArrayList;
            import java.util.List;

            public class POIUtils {
                private final static String xls = "xls";
                private final static String xlsx = "xlsx";
                private final static String DATE_FORMAT = "yyyy/MM/dd";
                /**
                 * 读入excel文件，解析后返回
                 * @param file
                 * @throws IOException
                 */
                public static List<String[]> readExcel(MultipartFile file) throws IOException {
                    //检查文件
                    checkFile(file);
                    //获得Workbook工作薄对象
                    Workbook workbook = getWorkBook(file);
                    //创建返回对象，把每行中的值作为一个数组，所有行作为一个集合返回
                    List<String[]> list = new ArrayList<String[]>();
                    if(workbook != null){
                        for(int sheetNum = 0;sheetNum < workbook.getNumberOfSheets();sheetNum++){
                            //获得当前sheet工作表
                            Sheet sheet = workbook.getSheetAt(sheetNum);
                            if(sheet == null){
                                continue;
                            }
                            //获得当前sheet的开始行
                            int firstRowNum  = sheet.getFirstRowNum();
                            //获得当前sheet的结束行
                            int lastRowNum = sheet.getLastRowNum();
                            //循环除了第一行的所有行
                            for(int rowNum = firstRowNum+1;rowNum <= lastRowNum;rowNum++){
                                //获得当前行
                                Row row = sheet.getRow(rowNum);
                                if(row == null){
                                    continue;
                                }
                                //获得当前行的开始列
                                int firstCellNum = row.getFirstCellNum();
                                //获得当前行的列数
                                int lastCellNum = row.getPhysicalNumberOfCells();
                                String[] cells = new String[row.getPhysicalNumberOfCells()];
                                //循环当前行
                                for(int cellNum = firstCellNum; cellNum < lastCellNum;cellNum++){
                                    Cell cell = row.getCell(cellNum);
                                    cells[cellNum] = getCellValue(cell);
                                }
                                list.add(cells);
                            }
                        }
                        workbook.close();
                    }
                    return list;
                }

                //校验文件是否合法
                public static void checkFile(MultipartFile file) throws IOException{
                    //判断文件是否存在
                    if(null == file){
                        throw new FileNotFoundException("文件不存在！");
                    }
                    //获得文件名
                    String fileName = file.getOriginalFilename();
                    //判断文件是否是excel文件
                    if(!fileName.endsWith(xls) && !fileName.endsWith(xlsx)){
                        throw new IOException(fileName + "不是excel文件");
                    }
                }
                public static Workbook getWorkBook(MultipartFile file) {
                    //获得文件名
                    String fileName = file.getOriginalFilename();
                    //创建Workbook工作薄对象，表示整个excel
                    Workbook workbook = null;
                    try {
                        //获取excel文件的io流
                        InputStream is = file.getInputStream();
                        //根据文件后缀名不同(xls和xlsx)获得不同的Workbook实现类对象
                        if(fileName.endsWith(xls)){
                            //2003
                            workbook = new HSSFWorkbook(is);
                        }else if(fileName.endsWith(xlsx)){
                            //2007
                            workbook = new XSSFWorkbook(is);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    return workbook;
                }
                public static String getCellValue(Cell cell){
                    String cellValue = "";
                    if(cell == null){
                        return cellValue;
                    }
                    //如果当前单元格内容为日期类型，需要特殊处理
                    String dataFormatString = cell.getCellStyle().getDataFormatString();
                    if(dataFormatString.equals("m/d/yy")){
                        cellValue = new SimpleDateFormat(DATE_FORMAT).format(cell.getDateCellValue());
                        return cellValue;
                    }
                    //把数字当成String来读，避免出现1读成1.0的情况
                    if(cell.getCellType() == Cell.CELL_TYPE_NUMERIC){
                        cell.setCellType(Cell.CELL_TYPE_STRING);
                    }
                    //判断数据的类型
                    switch (cell.getCellType()){
                        case Cell.CELL_TYPE_NUMERIC: //数字
                            cellValue = String.valueOf(cell.getNumericCellValue());
                            break;
                        case Cell.CELL_TYPE_STRING: //字符串
                            cellValue = String.valueOf(cell.getStringCellValue());
                            break;
                        case Cell.CELL_TYPE_BOOLEAN: //Boolean
                            cellValue = String.valueOf(cell.getBooleanCellValue());
                            break;
                        case Cell.CELL_TYPE_FORMULA: //公式
                            cellValue = String.valueOf(cell.getCellFormula());
                            break;
                        case Cell.CELL_TYPE_BLANK: //空值
                            cellValue = "";
                            break;
                        case Cell.CELL_TYPE_ERROR: //故障
                            cellValue = "非法字符";
                            break;
                        default:
                            cellValue = "未知类型";
                            break;
                    }
                    return cellValue;
                }
            }