自己封装的poi操作Excel工具类

淩亂°似流年 2022-05-14 16:18 286阅读 0赞

该工具类主要完成的功能是：读取Excel、汇总Excel的功能。在读取时，可以设定开始和结束读取的位置、设定是否读取多个sheet、设定读取那个或者那些sheet等。在汇总时，如设定是否覆盖目标文件、设定是否比较检查重复内容、设定检查重复的列索引等功能。具体来演示一下吧：

工具类源码：

package com.tgb.ccl.excel.util;
         
        import java.io.File;
        import java.io.FileInputStream;
        import java.io.FileOutputStream;
        import java.io.IOException;
        import java.util.ArrayList;
        import java.util.List;
         
        import org.apache.poi.hssf.usermodel.HSSFWorkbook;
        import org.apache.poi.ss.usermodel.Cell;
        import org.apache.poi.ss.usermodel.CellStyle;
        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.ss.util.CellRangeAddress;
        import org.apache.poi.xssf.usermodel.XSSFWorkbook;
         
        /**
         * Excel文件操作工具类，包括读、写、合并等功能
         *
         */
        public class ExcelUtil {
            
            //%%%%%%%%-------常量部分 开始----------%%%%%%%%%
            /**
             * 默认的开始读取的行位置为第一行（索引值为0）
             */
            private final static int READ_START_POS = 0;
            
            /**
             * 默认结束读取的行位置为最后一行（索引值=0，用负数来表示倒数第n行）
             */
            private final static int READ_END_POS = 0;
            
            /**
             * 默认Excel内容的开始比较列位置为第一列（索引值为0）
             */
            private final static int COMPARE_POS = 0;
            
            /**
             * 默认多文件合并的时需要做内容比较（相同的内容不重复出现）
             */
            private final static boolean NEED_COMPARE = true;
            
            /**
             * 默认多文件合并的新文件遇到名称重复时，进行覆盖
             */
            private final static boolean NEED_OVERWRITE = true;
            
            /**
             * 默认只操作一个sheet
             */
            private final static boolean ONLY_ONE_SHEET = true;
            
            /**
             * 默认读取第一个sheet中（只有当ONLY_ONE_SHEET = true时有效）
             */
            private final static int SELECTED_SHEET = 0;
            
            /**
             * 默认从第一个sheet开始读取（索引值为0）
             */
            private final static int READ_START_SHEET= 0;
            
            /**
             * 默认在最后一个sheet结束读取（索引值=0，用负数来表示倒数第n行）
             */
            private final static int READ_END_SHEET = 0;
            
            /**
             * 默认打印各种信息
             */
            private final static boolean PRINT_MSG = true;
            
            //%%%%%%%%-------常量部分 结束----------%%%%%%%%%
            
         
            //%%%%%%%%-------字段部分 开始----------%%%%%%%%%
            /**
             * Excel文件路径
             */
            private String excelPath = "data.xlsx";
         
            /**
             * 设定开始读取的位置，默认为0
             */
            private int startReadPos = READ_START_POS;
         
            /**
             * 设定结束读取的位置，默认为0，用负数来表示倒数第n行
             */
            private int endReadPos = READ_END_POS;
            
            /**
             * 设定开始比较的列位置，默认为0
             */
            private int comparePos = COMPARE_POS;
         
            /**
             *  设定汇总的文件是否需要替换，默认为true
             */
            private boolean isOverWrite = NEED_OVERWRITE;
            
            /**
             *  设定是否需要比较，默认为true(仅当不覆写目标内容是有效，即isOverWrite=false时有效)
             */
            private boolean isNeedCompare = NEED_COMPARE;
            
            /**
             * 设定是否只操作第一个sheet
             */
            private boolean onlyReadOneSheet = ONLY_ONE_SHEET;
            
            /**
             * 设定操作的sheet在索引值
             */
            private int selectedSheetIdx =SELECTED_SHEET;
            
            /**
             * 设定操作的sheet的名称
             */
            private String selectedSheetName = "";
            
            /**
             * 设定开始读取的sheet，默认为0
             */
            private int startSheetIdx = READ_START_SHEET;
         
            /**
             * 设定结束读取的sheet，默认为0，用负数来表示倒数第n行    
             */
            private int endSheetIdx = READ_END_SHEET;
            
            /**
             * 设定是否打印消息
             */
            private boolean printMsg = PRINT_MSG;
            
            
            //%%%%%%%%-------字段部分 结束----------%%%%%%%%%
            
         
            public static void main(String[] args) {
                ExcelUtil eu = new ExcelUtil();
                
                //从第一行开始读取
                eu.setStartReadPos(1);
                
                String src_xlspath = "D:\\2.xls";
                String dist_xlsPath = "D:\\1.xls";
                List<Row> rowList;
                try {
                    rowList = eu.readExcel(src_xlspath);
                    //eu.writeExcel_xls(rowList, src_xlspath, dist_xlsPath);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            
            public ExcelUtil(){
                
            }
            
            public ExcelUtil(String excelPath){
                this.excelPath = excelPath;
            }
            
            /**
             * 还原设定（其实是重新new一个新的对象并返回）
             * @return
             */
            public ExcelUtil RestoreSettings(){
                ExcelUtil instance = new  ExcelUtil(this.excelPath);
                return instance;
            }
            
            /**
             * 自动根据文件扩展名，调用对应的读取方法
             *
             * @Title: writeExcel
             * @param xlsPath
             * @throws IOException
             */
            public List<Row> readExcel() throws IOException{
                return readExcel(this.excelPath);
            }
         
            /**
             * 自动根据文件扩展名，调用对应的读取方法
             *
             * @Title: writeExcel
             * @param xlsPath
             * @throws IOException
             */
            public List<Row> readExcel(String xlsPath) throws IOException{
                
                //扩展名为空时，
                if (xlsPath.equals("")){
                    throw new IOException("文件路径不能为空！");
                }else{
                    File file = new File(xlsPath);
                    if(!file.exists()){
                        throw new IOException("文件不存在！");
                    }
                }
                
                //获取扩展名
                String ext = xlsPath.substring(xlsPath.lastIndexOf(".")+1);
                
                try {
                    
                    if("xls".equals(ext)){                //使用xls方式读取
                        return readExcel_xls(xlsPath);
                    }else if("xlsx".equals(ext)){        //使用xlsx方式读取
                        return readExcel_xlsx(xlsPath);
                    }else{                                    //依次尝试xls、xlsx方式读取
                        out("您要操作的文件没有扩展名，正在尝试以xls方式读取...");
                        try{
                            return readExcel_xls(xlsPath);
                        } catch (IOException e1) {
                            out("尝试以xls方式读取，结果失败！，正在尝试以xlsx方式读取...");
                            try{
                                return readExcel_xlsx(xlsPath);
                            } catch (IOException e2) {
                                out("尝试以xls方式读取，结果失败！\n请您确保您的文件是Excel文件，并且无损，然后再试。");
                                throw e2;
                            }
                        }
                    }
                } catch (IOException e) {
                    throw e;
                }
            }
            
            /**
             * 自动根据文件扩展名，调用对应的写入方法
             *
             * @Title: writeExcel
             * @param rowList
             * @throws IOException
             */
            public void writeExcel(List<Row> rowList) throws IOException{
                writeExcel(rowList,excelPath);
            }
            
            /**
             * 自动根据文件扩展名，调用对应的写入方法
             *
             * @Title: writeExcel
             * @param rowList
             * @param xlsPath
             * @throws IOException
             */
            public void writeExcel(List<Row> rowList, String xlsPath) throws IOException {
         
                //扩展名为空时，
                if (xlsPath.equals("")){
                    throw new IOException("文件路径不能为空！");
                }
                
                //获取扩展名
                String ext = xlsPath.substring(xlsPath.lastIndexOf(".")+1);
                
                try {
                    
                    if("xls".equals(ext)){                //使用xls方式写入
                        writeExcel_xls(rowList,xlsPath);
                    }else if("xlsx".equals(ext)){        //使用xlsx方式写入
                        writeExcel_xlsx(rowList,xlsPath);
                    }else{                                    //依次尝试xls、xlsx方式写入
                        out("您要操作的文件没有扩展名，正在尝试以xls方式写入...");
                        try{
                            writeExcel_xls(rowList,xlsPath);
                        } catch (IOException e1) {
                            out("尝试以xls方式写入，结果失败！，正在尝试以xlsx方式读取...");
                            try{
                                writeExcel_xlsx(rowList,xlsPath);
                            } catch (IOException e2) {
                                out("尝试以xls方式写入，结果失败！\n请您确保您的文件是Excel文件，并且无损，然后再试。");
                                throw e2;
                            }
                        }
                    }
                } catch (IOException e) {
                    throw e;
                }
            }
            
            /**
             * 修改Excel（97-03版，xls格式）
             *
             * @Title: writeExcel_xls
             * @param rowList
             * @param dist_xlsPath
             * @throws IOException
             */
            public void writeExcel_xls(List<Row> rowList, String dist_xlsPath) throws IOException {
                writeExcel_xls(rowList, excelPath,dist_xlsPath);
            }
         
            /**
             * 修改Excel（97-03版，xls格式）
             *
             * @Title: writeExcel_xls
             * @param rowList
             * @param src_xlsPath
             * @param dist_xlsPath
             * @throws IOException
             */
            public void writeExcel_xls(List<Row> rowList, String src_xlsPath, String dist_xlsPath) throws IOException {
         
                // 判断文件路径是否为空
                if (dist_xlsPath == null || dist_xlsPath.equals("")) {
                    out("文件路径不能为空");
                    throw new IOException("文件路径不能为空");
                }
                // 判断文件路径是否为空
                if (src_xlsPath == null || src_xlsPath.equals("")) {
                    out("文件路径不能为空");
                    throw new IOException("文件路径不能为空");
                }
         
                // 判断列表是否有数据，如果没有数据，则返回
                if (rowList == null || rowList.size() == 0) {
                    out("文档为空");
                    return;
                }
         
                try {
                    HSSFWorkbook wb = null;
         
                    // 判断文件是否存在
                    File file = new File(dist_xlsPath);
                    if (file.exists()) {
                        // 如果复写，则删除后
                        if (isOverWrite) {
                            file.delete();
                            // 如果文件不存在，则创建一个新的Excel
                            // wb = new HSSFWorkbook();
                            // wb.createSheet("Sheet1");
                            wb = new HSSFWorkbook(new FileInputStream(src_xlsPath));
                        } else {
                            // 如果文件存在，则读取Excel
                            wb = new HSSFWorkbook(new FileInputStream(file));
                        }
                    } else {
                        // 如果文件不存在，则创建一个新的Excel
                        // wb = new HSSFWorkbook();
                        // wb.createSheet("Sheet1");
                        wb = new HSSFWorkbook(new FileInputStream(src_xlsPath));
                    }
         
                    // 将rowlist的内容写到Excel中
                    writeExcel(wb, rowList, dist_xlsPath);
         
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
         
            /**
             * 修改Excel（97-03版，xls格式）
             *
             * @Title: writeExcel_xls
             * @param rowList
             * @param dist_xlsPath
             * @throws IOException
             */
            public void writeExcel_xlsx(List<Row> rowList, String dist_xlsPath) throws IOException {
                writeExcel_xls(rowList, excelPath , dist_xlsPath);
            }
         
            /**
             * 修改Excel（2007版，xlsx格式）
             *
             * @Title: writeExcel_xlsx
             * @param rowList
             * @param xlsPath
             * @throws IOException
             */
            public void writeExcel_xlsx(List<Row> rowList, String src_xlsPath, String dist_xlsPath) throws IOException {
         
                // 判断文件路径是否为空
                if (dist_xlsPath == null || dist_xlsPath.equals("")) {
                    out("文件路径不能为空");
                    throw new IOException("文件路径不能为空");
                }
                // 判断文件路径是否为空
                if (src_xlsPath == null || src_xlsPath.equals("")) {
                    out("文件路径不能为空");
                    throw new IOException("文件路径不能为空");
                }
         
                // 判断列表是否有数据，如果没有数据，则返回
                if (rowList == null || rowList.size() == 0) {
                    out("文档为空");
                    return;
                }
         
                try {
                    // 读取文档
                    XSSFWorkbook wb = null;
         
                    // 判断文件是否存在
                    File file = new File(dist_xlsPath);
                    if (file.exists()) {
                        // 如果复写，则删除后
                        if (isOverWrite) {
                            file.delete();
                            // 如果文件不存在，则创建一个新的Excel
                            // wb = new XSSFWorkbook();
                            // wb.createSheet("Sheet1");
                            wb = new XSSFWorkbook(new FileInputStream(src_xlsPath));
                        } else {
                            // 如果文件存在，则读取Excel
                            wb = new XSSFWorkbook(new FileInputStream(file));
                        }
                    } else {
                        // 如果文件不存在，则创建一个新的Excel
                        // wb = new XSSFWorkbook();
                        // wb.createSheet("Sheet1");
                        wb = new XSSFWorkbook(new FileInputStream(src_xlsPath));
                    }
                    // 将rowlist的内容添加到Excel中
                    writeExcel(wb, rowList, dist_xlsPath);
         
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
         
            /**
             * //读取Excel 2007版，xlsx格式
             *
             * @Title: readExcel_xlsx
             * @return
             * @throws IOException
             */
            public List<Row> readExcel_xlsx() throws IOException {
                return readExcel_xlsx(excelPath);
            }
         
            /**
             * //读取Excel 2007版，xlsx格式
             *
             * @Title: readExcel_xlsx
             * @return
             * @throws Exception
             */
            public List<Row> readExcel_xlsx(String xlsPath) throws IOException {
                // 判断文件是否存在
                File file = new File(xlsPath);
                if (!file.exists()) {
                    throw new IOException("文件名为" + file.getName() + "Excel文件不存在！");
                }
         
                XSSFWorkbook wb = null;
                List<Row> rowList = new ArrayList<Row>();
                try {
                    FileInputStream fis = new FileInputStream(file);
                    // 去读Excel
                    wb = new XSSFWorkbook(fis);
         
                    // 读取Excel 2007版，xlsx格式
                    rowList = readExcel(wb);
         
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return rowList;
            }
         
            /***
             * 读取Excel(97-03版，xls格式)
             *
             * @throws IOException
             *
             * @Title: readExcel
             */
            public List<Row> readExcel_xls() throws IOException {
                return readExcel_xls(excelPath);
            }
         
            /***
             * 读取Excel(97-03版，xls格式)
             *
             * @throws Exception
             *
             * @Title: readExcel
             */
            public List<Row> readExcel_xls(String xlsPath) throws IOException {
         
                // 判断文件是否存在
                File file = new File(xlsPath);
                if (!file.exists()) {
                    throw new IOException("文件名为" + file.getName() + "Excel文件不存在！");
                }
         
                HSSFWorkbook wb = null;// 用于Workbook级的操作，创建、删除Excel
                List<Row> rowList = new ArrayList<Row>();
         
                try {
                    // 读取Excel
                    wb = new HSSFWorkbook(new FileInputStream(file));
         
                    // 读取Excel 97-03版，xls格式
                    rowList = readExcel(wb);
         
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return rowList;
            }
         
            /***
             * 读取单元格的值
             *
             * @Title: getCellValue
             * @param cell
             * @return
             */
            private String getCellValue(Cell cell) {
                Object result = "";
                if (cell != null) {
                    switch (cell.getCellType()) {
                    case Cell.CELL_TYPE_STRING:
                        result = cell.getStringCellValue();
                        break;
                    case Cell.CELL_TYPE_NUMERIC:
                        result = cell.getNumericCellValue();
                        break;
                    case Cell.CELL_TYPE_BOOLEAN:
                        result = cell.getBooleanCellValue();
                        break;
                    case Cell.CELL_TYPE_FORMULA:
                        result = cell.getCellFormula();
                        break;
                    case Cell.CELL_TYPE_ERROR:
                        result = cell.getErrorCellValue();
                        break;
                    case Cell.CELL_TYPE_BLANK:
                        break;
                    default:
                        break;
                    }
                }
                return result.toString();
            }
         
            /**
             * 通用读取Excel
             *
             * @Title: readExcel
             * @return
             */
            private List<Row> readExcel(Workbook wb) {
                List<Row> rowList = new ArrayList<Row>();
                
                int sheetCount = 1;//需要操作的sheet数量
                
                Sheet sheet = null;
                if(onlyReadOneSheet){    //只操作一个sheet
                    // 获取设定操作的sheet(如果设定了名称，按名称查，否则按索引值查)
                    sheet =selectedSheetName.equals("")? wb.getSheetAt(selectedSheetIdx):wb.getSheet(selectedSheetName);
                }else{                            //操作多个sheet
                    sheetCount = wb.getNumberOfSheets();//获取可以操作的总数量
                }
                
                // 获取sheet数目
                for(int t=startSheetIdx; t<sheetCount+endSheetIdx;t++){
                    // 获取设定操作的sheet
                    if(!onlyReadOneSheet) {
                        sheet =wb.getSheetAt(t);
                    }
                    
                    //获取最后行号
                    int lastRowNum = sheet.getLastRowNum();
         
                    if(lastRowNum>0){    //如果>0，表示有数据
                        out("\n开始读取名为【"+sheet.getSheetName()+"】的内容：");
                    }
                    
                    Row row = null;
                    // 循环读取
                    for (int i = startReadPos; i <= lastRowNum + endReadPos; i++) {
                        row = sheet.getRow(i);
                        if (row != null) {
                            rowList.add(row);
                            out("第"+(i+1)+"行：",false);
                             // 获取每一单元格的值
                             for (int j = 0; j < row.getLastCellNum(); j++) {
                                 String value = getCellValue(row.getCell(j));
                                 if (!value.equals("")) {
                                     out(value + " | ",false);
                                 }
                             }
                             out("");
                        }
                    }
                }
                return rowList;
            }
         
            /**
             * 修改Excel，并另存为
             *
             * @Title: WriteExcel
             * @param rowList
             * @param xlsPath
             */
            private void writeExcel(Workbook wb, List<Row> rowList, String xlsPath) {
         
                if (wb == null) {
                    out("操作文档不能为空！");
                    return;
                }
         
                Sheet sheet = wb.getSheetAt(0);// 修改第一个sheet中的值
         
                // 如果每次重写，那么则从开始读取的位置写，否则果获取源文件最新的行。
                int lastRowNum = isOverWrite ? startReadPos : sheet.getLastRowNum() + 1;
                int t = 0;//记录最新添加的行数
                out("要添加的数据总条数为："+rowList.size());
                for (Row row : rowList) {
                    if (row == null) continue;
                    // 判断是否已经存在该数据
                    int pos = findInExcel(sheet, row);
         
                    Row r = null;// 如果数据行已经存在，则获取后重写，否则自动创建新行。
                    if (pos >= 0) {
                        sheet.removeRow(sheet.getRow(pos));
                        r = sheet.createRow(pos);
                    } else {
                        r = sheet.createRow(lastRowNum + t++);
                    }
                    
                    //用于设定单元格样式
                    CellStyle newstyle = wb.createCellStyle();
                    
                    //循环为新行创建单元格
                    for (int i = row.getFirstCellNum(); i < row.getLastCellNum(); i++) {
                        Cell cell = r.createCell(i);// 获取数据类型
                        cell.setCellValue(getCellValue(row.getCell(i)));// 复制单元格的值到新的单元格
                        // cell.setCellStyle(row.getCell(i).getCellStyle());//出错
                        if (row.getCell(i) == null) continue;
                        copyCellStyle(row.getCell(i).getCellStyle(), newstyle); // 获取原来的单元格样式
                        cell.setCellStyle(newstyle);// 设置样式
                        // sheet.autoSizeColumn(i);//自动跳转列宽度
                    }
                }
                out("其中检测到重复条数为:" + (rowList.size() - t) + " ，追加条数为："+t);
                
                // 统一设定合并单元格
                setMergedRegion(sheet);
                
                try {
                    // 重新将数据写入Excel中
                    FileOutputStream outputStream = new FileOutputStream(xlsPath);
                    wb.write(outputStream);
                    outputStream.flush();
                    outputStream.close();
                } catch (Exception e) {
                    out("写入Excel时发生错误！ ");
                    e.printStackTrace();
                }
            }
         
            /**
             * 查找某行数据是否在Excel表中存在，返回行数。
             *
             * @Title: findInExcel
             * @param sheet
             * @param row
             * @return
             */
            private int findInExcel(Sheet sheet, Row row) {
                int pos = -1;
         
                try {
                    // 如果覆写目标文件，或者不需要比较，则直接返回
                    if (isOverWrite || !isNeedCompare) {
                        return pos;
                    }
                    for (int i = startReadPos; i <= sheet.getLastRowNum() + endReadPos; i++) {
                        Row r = sheet.getRow(i);
                        if (r != null && row != null) {
                            String v1 = getCellValue(r.getCell(comparePos));
                            String v2 = getCellValue(row.getCell(comparePos));
                            if (v1.equals(v2)) {
                                pos = i;
                                break;
                            }
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return pos;
            }
         
            /**
             * 复制一个单元格样式到目的单元格样式
             *
             * @param fromStyle
             * @param toStyle
             */
            public static void copyCellStyle(CellStyle fromStyle, CellStyle toStyle) {
                toStyle.setAlignment(fromStyle.getAlignment());
                // 边框和边框颜色
                toStyle.setBorderBottom(fromStyle.getBorderBottom());
                toStyle.setBorderLeft(fromStyle.getBorderLeft());
                toStyle.setBorderRight(fromStyle.getBorderRight());
                toStyle.setBorderTop(fromStyle.getBorderTop());
                toStyle.setTopBorderColor(fromStyle.getTopBorderColor());
                toStyle.setBottomBorderColor(fromStyle.getBottomBorderColor());
                toStyle.setRightBorderColor(fromStyle.getRightBorderColor());
                toStyle.setLeftBorderColor(fromStyle.getLeftBorderColor());
         
                // 背景和前景
                toStyle.setFillBackgroundColor(fromStyle.getFillBackgroundColor());
                toStyle.setFillForegroundColor(fromStyle.getFillForegroundColor());
         
                // 数据格式
                toStyle.setDataFormat(fromStyle.getDataFormat());
                toStyle.setFillPattern(fromStyle.getFillPattern());
                // toStyle.setFont(fromStyle.getFont(null));
                toStyle.setHidden(fromStyle.getHidden());
                toStyle.setIndention(fromStyle.getIndention());// 首行缩进
                toStyle.setLocked(fromStyle.getLocked());
                toStyle.setRotation(fromStyle.getRotation());// 旋转
                toStyle.setVerticalAlignment(fromStyle.getVerticalAlignment());
                toStyle.setWrapText(fromStyle.getWrapText());
         
            }
         
            /**
             * 获取合并单元格的值
             *
             * @param sheet
             * @param row
             * @param column
             * @return
             */
            public void setMergedRegion(Sheet sheet) {
                int sheetMergeCount = sheet.getNumMergedRegions();
         
                for (int i = 0; i < sheetMergeCount; i++) {
                    // 获取合并单元格位置
                    CellRangeAddress ca = sheet.getMergedRegion(i);
                    int firstRow = ca.getFirstRow();
                    if (startReadPos - 1 > firstRow) {// 如果第一个合并单元格格式在正式数据的上面，则跳过。
                        continue;
                    }
                    int lastRow = ca.getLastRow();
                    int mergeRows = lastRow - firstRow;// 合并的行数
                    int firstColumn = ca.getFirstColumn();
                    int lastColumn = ca.getLastColumn();
                    // 根据合并的单元格位置和大小，调整所有的数据行格式，
                    for (int j = lastRow + 1; j <= sheet.getLastRowNum(); j++) {
                        // 设定合并单元格
                        sheet.addMergedRegion(new CellRangeAddress(j, j + mergeRows, firstColumn, lastColumn));
                        j = j + mergeRows;// 跳过已合并的行
                    }
         
                }
            }
            
         
            /**
             * 打印消息，
             * @param msg 消息内容
             * @param tr 换行
             */
            private void out(String msg){
                if(printMsg){
                    out(msg,true);
                }
            }
            /**
             * 打印消息，
             * @param msg 消息内容
             * @param tr 换行
             */
            private void out(String msg,boolean tr){
                if(printMsg){
                    System.out.print(msg+(tr?"\n":""));
                }
            }
         
            public String getExcelPath() {
                return this.excelPath;
            }
         
            public void setExcelPath(String excelPath) {
                this.excelPath = excelPath;
            }
         
            public boolean isNeedCompare() {
                return isNeedCompare;
            }
         
            public void setNeedCompare(boolean isNeedCompare) {
                this.isNeedCompare = isNeedCompare;
            }
         
            public int getComparePos() {
                return comparePos;
            }
         
            public void setComparePos(int comparePos) {
                this.comparePos = comparePos;
            }
         
            public int getStartReadPos() {
                return startReadPos;
            }
         
            public void setStartReadPos(int startReadPos) {
                this.startReadPos = startReadPos;
            }
         
            public int getEndReadPos() {
                return endReadPos;
            }
         
            public void setEndReadPos(int endReadPos) {
                this.endReadPos = endReadPos;
            }
         
            public boolean isOverWrite() {
                return isOverWrite;
            }
         
            public void setOverWrite(boolean isOverWrite) {
                this.isOverWrite = isOverWrite;
            }
         
            public boolean isOnlyReadOneSheet() {
                return onlyReadOneSheet;
            }
         
            public void setOnlyReadOneSheet(boolean onlyReadOneSheet) {
                this.onlyReadOneSheet = onlyReadOneSheet;
            }
         
            public int getSelectedSheetIdx() {
                return selectedSheetIdx;
            }
         
            public void setSelectedSheetIdx(int selectedSheetIdx) {
                this.selectedSheetIdx = selectedSheetIdx;
            }
         
            public String getSelectedSheetName() {
                return selectedSheetName;
            }
         
            public void setSelectedSheetName(String selectedSheetName) {
                this.selectedSheetName = selectedSheetName;
            }
         
            public int getStartSheetIdx() {
                return startSheetIdx;
            }
         
            public void setStartSheetIdx(int startSheetIdx) {
                this.startSheetIdx = startSheetIdx;
            }
         
            public int getEndSheetIdx() {
                return endSheetIdx;
            }
         
            public void setEndSheetIdx(int endSheetIdx) {
                this.endSheetIdx = endSheetIdx;
            }
         
            public boolean isPrintMsg() {
                return printMsg;
            }
         
            public void setPrintMsg(boolean printMsg) {
                this.printMsg = printMsg;
            }
        }

以上就是工具类的全部代码，现在演示一下读取的功能：

public void testRead() {
                try {
                    
                    ExcelUtil eu = new ExcelUtil();
                    eu.setExcelPath("d:\\2.xls");
                    
                    System.out.println("=======测试Excel 默认 读取========");
                    eu.readExcel();
                    
                    System.out.println("\n=======测试Excel 从第四行读取，倒数第二行结束========");
                    eu = eu.RestoreSettings();//还原设定
                    eu.setStartReadPos(3);
                    eu.setEndReadPos(-1);
                    eu.readExcel();
                    
                    System.out.println("\n=======测试Excel 读取第二个sheet========");
                    eu = eu.RestoreSettings();//还原设定
                    eu.setSelectedSheetIdx(1);
                    eu.readExcel();
                    
                    System.out.println("\n=======测试Excel 读取所有的sheet========");
                    eu = eu.RestoreSettings();//还原设定
                    eu.setOnlyReadOneSheet(false);
                    eu.readExcel();
                    
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

操作的Excel文件内容如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 1][]  
执行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 3][]  
上面代码的提示和结果已经解释的很清楚了，我就不在这里过多介绍。

现在演示多个Excel的汇总合并功能，把上面的Excel内容合并到另一个Excel表中，这个Excel内容如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 4][]  
测试代码如下：

public void testMerge(){
                try {
                    ExcelUtil eu1 = new ExcelUtil();//用来读取源xls
                    ExcelUtil eu2 = new ExcelUtil();//用来读取目标xls，用于演示合并结果
                    eu1.setExcelPath("d:\\2.xls");
                    eu2.setExcelPath("d:\\1.xls");
                    
                    System.out.println("\n=======修改前，1.xls中的内容========");
                    eu2.readExcel();
                    
                    System.out.println("\n=======读取源文件2.xls中的内容========");
                    eu1.setStartReadPos(3);
                    //eu1.setOverWrite(false);//是否覆写目标文件（默认覆写）
                    //eu1.setComparePos(1);//设定比较哪一列内容（默认为0，比较第一列内容）
                    //eu1.setNeedCompare(false);//设定是否比较（默认值是true）。只有当不覆盖目标文件时，设置检查重复才有效。
                    
                    eu1.writeExcel(eu1.readExcel(), "d:\\1.xls");//将读取到的2.xls中的数据合并到1.xls中
                    System.out.println("\n=======修改后，1.xls中的内容========");
                    eu2.readExcel();//读取合并后的1.xls的数据
                    
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

执行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 5][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 6][]  
明明有重复的，为什么提示重复为0呢？这是因为默认对目标文件进行了覆写，直接把源文件的数据覆盖到目标文件中。所以只会显示源文件的内容。

如果把上段测试代码的13、14、15行换成下面的内容，手动还原1.xls，再测试一下：

eu1.setOverWrite(false);//是否覆写目标文件（默认覆写）
            //eu1.setComparePos(1);//设定比较哪一列内容（默认为0，比较第一列内容）
            //eu1.setNeedCompare(false);//设定是否比较（默认值是true）。只有当不覆盖目标文件时，设置检查重复才有效。

执行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 7][]  
这次把覆写给取消了，在合并的时候，默认会比较第一列的数据，存在的则不再追加，所以1.xls中的张三保留了，李四追加到了后面。对比上面的覆盖，可以看到，覆写时跟2.xls的顺序一致（李四在张三前面），而不覆写，则在文档的最后执行追加操作。

我们再次修改测试代码：

eu1.setOverWrite(false);//是否覆写目标文件（默认覆写）
            eu1.setComparePos(1);//设定比较哪一列内容（默认为0，比较第一列内容）
            //eu1.setNeedCompare(false);//设定是否比较（默认值是true）。只有当不覆盖目标文件时，设置检查重复才有效。

同时手动把1.xls中的内容修改如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 8][]  
执行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 9][]  
大家可以看到，比较的对象变到的第二列，由于张三所在行的第二列与添加的内容不相同，所以张三被追加到了文档的和面。

最后再次修改测试代码，并且手动还原1.xls为原始状态。

eu1.setOverWrite(false);//是否覆写目标文件（默认覆写）
            //eu1.setComparePos(1);//设定比较哪一列内容（默认为0，比较第一列内容）
            eu1.setNeedCompare(false);//设定是否比较（默认值是true）。只有当不覆盖目标文件时，设置检查重复才有效。

执行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 10][]  
这次把覆写和自动比较都取消了，结果就是直接在目标文件的后面进行追加操作。

代码有点多，大家可能看的有点累了，不过写这个工具类消耗了我n多脑细胞，还是希望对大家可以有所帮助。如果有什么问题，欢迎大家批评指正。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70]: /images/20220503/4ddf72c73faf4967b59b825d70da06bb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 1]: /images/20220503/d59104a33ef74bbf8043524792198ce3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 2]: /images/20220503/65db92fc1d494cbb9ade34f3a830ccbe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 3]: /images/20220503/08128555cb4c4bffa51ebd375cc24a27.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 4]: /images/20220503/9393ad9ef8544c32b86267bccd7fbb00.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 5]: /images/20220503/fdb59a488680490d995e027c647b2880.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 6]: /images/20220503/527bcded7fe647e5912a1fd5059cbe22.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 7]: /images/20220503/7e10980071ac4d6da22f0dfbccd3507b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 8]: /images/20220503/9107d91725ae4f5e96e39bc51ad9c142.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 9]: /images/20220503/95662cff730c4692a331a513124c721b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FfQmxhY2tNb29u_size_27_color_FFFFFF_t_70 10]: /images/20220503/84d4d6b66d8f4b29bdb033ef6be733f3.png