Объедините несколько рабочих книг с несколькими рабочими листами в основную рабочую книгу, используя Apache poi

Question

• Мне нужен метод copysheets, который объединит несколько рабочих книг, содержащих несколько рабочих листов.

• Имя каждой вкладки / листа в рабочей книге идентично именам листов других рабочих книг, которые я хотел бы объединить.

• Я хотел бы объединить содержимое (рабочая тетрадь1, лист1), (рабочая тетрадь2, лист1), (рабочая тетрадь3, лист1) в лист1 новой основной рабочей книги, а затем (рабочая книга1, лист2) ), (рабочая тетрадь2, лист2), рабочая тетрадь3, лист2) на лист2 новой основной рабочей книги. и так далее, в новую мастер-книгу.

• Я бы хотел, чтобы данные вставлялись одна под другой, например, первые 10 строк из sheet1, затем следующие из 10 из sheet2 и т. Д.

Вывод будет копировать только первое содержимое листа, добавляемое снова и снова. Я получаю следующую ошибку:

 Exception in thread "main" java.lang.IllegalArgumentException: The workbook already contains a sheet named 'Sheet1'
at org.apache.poi.xssf.usermodel.XSSFWorkbook.validateSheetName(XSSFWorkbook.java:890)
at org.apache.poi.xssf.usermodel.XSSFWorkbook.createSheet(XSSFWorkbook.java:843)
at MergeMultipleXlsFilesInDifferentSheet.mergeExcelFiles(MergeMultipleXlsFilesInDifferentSheet.java:121)
at MergeMultipleXlsFilesInDifferentSheet.main(MergeMultipleXlsFilesInDifferentSheet.java:316)

Вот мой код:

    public class MergeMultipleXlsFilesInDifferentSheet{
      public static void mergeExcelFiles(File file) throws IOException {
          XSSFWorkbook book = new XSSFWorkbook();
          System.out.println(file.getName());
    String directoryName = "C:Documents\\File.xlsx";
    File directory = new File(directoryName);
        File[] fList = directory.listFiles();
    for (File file1 : fList){
        if (file1.isFile()){
         String ParticularFile = file1.getName();
         FileInputStream fin = new FileInputStream(new File(directoryName+"\\"+ParticularFile));
        XSSFWorkbook b = new XSSFWorkbook(fin);
        for (int i = 0; i < b.getNumberOfSheets(); i++) { 
        for(int worksheetIndex = 0; worksheetIndex<b.getNumberOfSheets(); worksheetIndex++)
        {
        XSSFSheet sheet = book.createSheet(b.getSheetName(worksheetIndex));
        String worksheetName = b.getSheetName(worksheetIndex);
        System.out.println("test " + worksheetName);
        copySheets(book.createSheet(), b.getSheetAt(i));
        System.out.println("Copying..");
      }
          }
    }
    try {

     writeFile(book, file);
    }catch(Exception e) {
        e.printStackTrace();
    }
   }
  }

        protected static void writeFile(XSSFWorkbook book, File file) throws Exception {



    FileOutputStream out = new FileOutputStream(file);
    book.write(out);
    out.close();
    System.out.println(file+ " is written successfully..");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


  private static void copySheets(XSSFSheet newSheet, XSSFSheet sheet){     

      copySheets( newSheet, sheet, true);
  }     

//  private static void copySheets(XSSFWorkbook newWorkbook, XSSFSheet newSheet, XSSFSheet sheet, boolean copyStyle){ 
  private static void copySheets( XSSFSheet newSheet, XSSFSheet sheet, boolean copyStyle){     
    int newRownumber = newSheet.getLastRowNum();
    int maxColumnNum = 0;     
    Map<Integer, XSSFCellStyle> styleMap = (copyStyle) ? new HashMap<Integer, XSSFCellStyle>() : null;    

    for (int i = sheet.getFirstRowNum(); i <= sheet.getLastRowNum(); i++) {     
      XSSFRow srcRow = sheet.getRow(i);     
      XSSFRow destRow = newSheet.createRow(i + newRownumber);     
      if (srcRow != null) {     
        //copyRow(newWorkbook, sheet, newSheet, srcRow, destRow, styleMap);  
          copyRow(sheet, newSheet, srcRow, destRow, styleMap); 
        if (srcRow.getLastCellNum() > maxColumnNum) {     
            maxColumnNum = srcRow.getLastCellNum();     
        }     
      }     
    }     
    for (int i = 0; i <= maxColumnNum; i++) {     
      newSheet.setColumnWidth(i, sheet.getColumnWidth(i));     
    }     
  }     


  public static void copyRow( XSSFSheet srcSheet, XSSFSheet destSheet, XSSFRow srcRow, XSSFRow destRow, Map<Integer, XSSFCellStyle> styleMap) { 
  destRow.setHeight(srcRow.getHeight());
    Set<CellRangeAddress> mergedRegions = new TreeSet<CellRangeAddress>();
  //  for (int j = srcRow.getFirstCellNum(); j <= srcRow.getLastCellNum(); j++) { 


    int deltaRows = destRow.getRowNum()-srcRow.getRowNum();


int j = srcRow.getFirstCellNum(); 
    if(j<0){j=0;} 
    for (; j <= srcRow.getLastCellNum(); j++) { 

      XSSFCell oldCell = srcRow.getCell(j);
      XSSFCell newCell = destRow.getCell(j);
      if (oldCell != null) {     
        if (newCell == null) {     
          newCell = destRow.createCell(j);     
        }     

        copyCell( oldCell, newCell, styleMap);CellRangeAddress mergedRegion = getMergedRegion( srcSheet, srcRow.getRowNum(), (short)oldCell.getColumnIndex());
        if (mergedRegion != null) {

            CellRangeAddress newMergedRegion = new CellRangeAddress(mergedRegion.getFirstRow()+deltaRows, mergedRegion.getLastRow()+deltaRows, mergedRegion.getFirstColumn(),  mergedRegion.getLastColumn());
            //System.out.println("New merged region: " + newMergedRegion.toString());

            if (isNewMergedRegion( newMergedRegion, mergedRegions)) {
                mergedRegions.add(newMergedRegion);
                destSheet.addMergedRegion(newMergedRegion);
            }
        }


      }     
    }                
  }


  public static void copyCell( XSSFCell oldCell, XSSFCell newCell, Map<Integer, XSSFCellStyle> styleMap) { 
  if(styleMap != null) {     
      int stHashCode = oldCell.getCellStyle().hashCode();     
      XSSFCellStyle newCellStyle = styleMap.get(stHashCode);     
      if(newCellStyle == null){     
        //newCellStyle = newWorkbook.createCellStyle(); 
          newCellStyle = newCell.getSheet().getWorkbook().createCellStyle();
        newCellStyle.cloneStyleFrom(oldCell.getCellStyle());     
        styleMap.put(stHashCode, newCellStyle);     
      }     
      newCell.setCellStyle(newCellStyle);   
    }     
    switch(oldCell.getCellType()) {     
      case XSSFCell.CELL_TYPE_STRING:     
        newCell.setCellValue(oldCell.getRichStringCellValue());     
        break;     
      case XSSFCell.CELL_TYPE_NUMERIC:     
        newCell.setCellValue(oldCell.getNumericCellValue());     
        break;     
      case XSSFCell.CELL_TYPE_BLANK:     
        newCell.setCellType(XSSFCell.CELL_TYPE_BLANK);     
        break;     
      case XSSFCell.CELL_TYPE_BOOLEAN:     
        newCell.setCellValue(oldCell.getBooleanCellValue());     
        break;     
      case XSSFCell.CELL_TYPE_ERROR:     
        newCell.setCellErrorValue(oldCell.getErrorCellValue());     
        break;     
      case XSSFCell.CELL_TYPE_FORMULA:     
        newCell.setCellFormula(oldCell.getCellFormula());     
        break;     
      default:     
        break;     
    }
  }


         public static CellRangeAddress getMergedRegion( XSSFSheet sheet, int rowNum, short cellNum) {
            for (int i = 0; i < sheet.getNumMergedRegions(); i++) {
          CellRangeAddress merged = (CellRangeAddress) sheet.getMergedRegion(i);
               if (merged.isInRange(rowNum, cellNum)) {
              return merged;
          }
      }
      return null;
  }




  private static boolean isNewMergedRegion(CellRangeAddress newMergedRegion, Collection<CellRangeAddress> mergedRegions) {
      return !mergedRegions.contains(newMergedRegion);
  } 


  public static void main(String[] args) {
      try {
        mergeExcelFiles(new File("C:\\Documents\\test.xlsx"));
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
}