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

Posted 2020-08-24 喜欢虫子的码笼

 该工具类主要完成的功能是：读取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文件操作工具类，包括读、写、合并等功能  *  * @author  : 龙轩  * @group   : tgb8  * @Version : 1.00  * @Date    : 2014-10-29 上午12:40:44  */ 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   * @Date : 2014-9-11 下午01:50:38   * @param xlsPath   * @throws IOException   */  public List<Row> readExcel() throws IOException{   return readExcel(this.excelPath);  }

 

 /**   * 自动根据文件扩展名，调用对应的读取方法   *   * @Title: writeExcel   * @Date : 2014-9-11 下午01:50:38   * @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   * @Date : 2014-9-11 下午01:50:38   * @param rowList   * @throws IOException   */  public void writeExcel(List<Row> rowList) throws IOException{   writeExcel(rowList,excelPath);  }    /**   * 自动根据文件扩展名，调用对应的写入方法   *   * @Title: writeExcel   * @Date : 2014-9-11 下午01:50:38   * @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   * @Date : 2014-9-11 下午01:50:38   * @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   * @Date : 2014-9-11 下午01:50:38   * @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   * @Date : 2014-9-11 下午01:50:38   * @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   * @Date : 2014-9-11 下午01:50:38   * @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   * @Date : 2014-9-11 上午11:43:11   * @return   * @throws IOException   */  public List<Row> readExcel_xlsx() throws IOException {   return readExcel_xlsx(excelPath);  }

 

 /**   * //读取Excel 2007版，xlsx格式   *   * @Title: readExcel_xlsx   * @Date : 2014-9-11 上午11:43:11   * @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   * @Date : 2014-9-11 上午09:53:21   */  public List<Row> readExcel_xls() throws IOException {   return readExcel_xls(excelPath);  }

 

 /***   * 读取Excel(97-03版，xls格式)   *   * @throws Exception   *   * @Title: readExcel   * @Date : 2014-9-11 上午09:53:21   */  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   * @Date : 2014-9-11 上午10:52:07   * @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   * @Date : 2014-9-11 上午11:26:53   * @param wb   * @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   * @Date : 2014-9-11 下午01:33:59   * @param wb   * @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   * @Date : 2014-9-11 下午02:23:12   * @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文件内容如下：

 

执行结果如下：

 

 

 

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

 

 

 

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

 

 

       测试代码如下：

 

 

 

[java] view plain copy

 

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

       执行结果如下：

 

 

 

 

 

 

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

 

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

 

 

 

[java] view plain copy

 

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

 

        执行结果如下：

 

 

 

 

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

 

 

 

       我们再次修改测试代码：

 

[java] view plain copy

 

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

 

 

 

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

 

 

       执行结果如下：

 

 

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

 

 

 

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

 

[java] view plain copy

 

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

 

 

 

        执行结果如下：