一、直接上程式碼：

package com.cycares.crm.utils.ExcelUtil;


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檔案操作工具類，包括讀、寫、合併等功能 
 * 建立時間：2016-7-27
 * @author Jibaole
 */
public class ReadExcelUtil {  
    
  //%%%%%%%%-------常量部分 開始----------%%%%%%%%%  
  /** 
   * 預設的開始讀取的行位置為第一行（索引值為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 ReadExcelUtil(){}  
  
    
  public ReadExcelUtil(String excelPath){  
      this.excelPath = excelPath;  
  }  
    
  /** 
   * 還原設定（其實是重新new一個新的物件並返回） 
   * @return 
   */  
  public ReadExcelUtil RestoreSettings(){  
      ReadExcelUtil instance = new  ReadExcelUtil(this.excelPath);  
      return instance;  
  }  
    
  /** 
   * 自動根據副檔名，呼叫對應的讀取方法 
   *  
   * @Title: writeExcel 
   * @Date : 2016-7-27 下午01:50:38 
   * @param xlsPath 
   * @throws IOException 
   */  
  public List<Row> readExcel() throws IOException{  
      return readExcel(this.excelPath);  
  }  

  /** 
   * 自動根據副檔名，呼叫對應的讀取方法 
   *  
   * @Title: writeExcel 
   * @Date : 2016-7-27 下午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 : 2016-7-27 下午01:50:38 
   * @param rowList 
   * @throws IOException 
   */  
  public void writeExcel(List<Row> rowList) throws IOException{  
      writeExcel(rowList,excelPath);  
  }  
    
  /** 
   * 自動根據副檔名，呼叫對應的寫入方法 
   *  
   * @Title: writeExcel 
   * @Date : 2016-7-27 下午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 : 2016-7-27 下午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 : 2016-7-27 下午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 : 2016-7-27 下午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 : 2016-7-27 下午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 : 2016-7-27 上午11:43:11 
   * @return 
   * @throws IOException 
   */  
  public List<Row> readExcel_xlsx() throws IOException {  
      return readExcel_xlsx(excelPath);  
  }  

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

  /*** 
   * 讀取Excel(97-03版，xls格式) 
   *  
   * @throws Exception 
   *  
   * @Title: readExcel 
   * @Date : 2016-7-27 上午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 : 2016-7-27 上午10:52:07 
   * @param cell 
   * @return 
   */  
  public static 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 : 2016-7-27 上午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 : 2016-7-27 下午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 : 2016-7-27 下午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 static void main(String[] args) {  
      ReadExcelUtil eu = new ReadExcelUtil();  
        
      //從第一行開始讀取  
      eu.setStartReadPos(1);  
        
      String src_xlspath = "D:\\SEM業務統計報表.xls";  
     //String dist_xlsPath = "D:\\2.xls";  
      List<Row> rowList = null;  
      try {  
          rowList = eu.readExcel(src_xlspath);  
        //eu.writeExcel_xls(rowList, src_xlspath, dist_xlsPath);  
      } catch (IOException e) {  
          e.printStackTrace();  
      }  
      System.out.println("開始時間 | 截止時間 | 賬號名稱 | 計劃名稱 | 展現數 ");
      for(int i=1;i<rowList.size();i++){
    	  Row obj=rowList.get(i);
    	  System.out.println(""+getCellValue(obj.getCell(0))+"|"+getCellValue(obj.getCell(1))+"|"+getCellValue(obj.getCell(2))+"|"+getCellValue(obj.getCell(3))+"|"+getCellValue(obj.getCell(4)));
          }  
      
      
  }  
    
 
}