2009-05-11 96 views
21

Qualcuno sa di un mezzo per copiare un foglio di lavoro da una cartella di lavoro a un'altra utilizzando POI? La classe Cartella di lavoro ha un metodo cloneSheet, ma sembra che non sia possibile inserire un foglio clonato in una nuova cartella di lavoro?Copia fogli di lavoro Excel nel POI

Se non c'è un'API per farlo facilmente, qualcuno ha il codice per copiare tutti i dati (stili, larghezze di colonna, dati, ecc.) Da un foglio all'altro?

Il jxls ha metodi per copiare i fogli, ma non funzionano quando si copia tra le cartelle di lavoro.

+1

questo [link] (http://www.coderanch.com/t/420958/open-source/Copying-sheet-excel-file-another) dovrebbe essere utile: – hkansal

+0

@hkansal che link ho trovato quando stavo cercando su google. Ho affrontato un problema con il codice indicato in quel collegamento, quando la cella è raggruppata come colonna A1: A4 mostra un errore come sovrapposizione Regione unita, non posso pubblicare una risposta in quel collegamento. È davvero buono. –

risposta

2

Se si utilizza la libreria PDI Java, il migliore sarebbe caricare il foglio di calcolo in memoria ,,, quindi crearne uno nuovo e scrivere ciascuno dei record che si desidera copiare .. non è il modo migliore ma compie la funzione di copia ...

1

Ho impiegato circa una settimana di sforzi per farlo con il POI (usando l'ultimo codice su coderanch) - sii avvisato che il codice è difettoso (c'è un problema con usando TreeSet dove è necessario sostituirlo con una HashMap), ma anche dopo aver corretto che si blocca sulle formule.

Anche se è possibile farlo, è una proposta spaventosa dover contare sul codice compromesso.

a seconda delle esigenze/budget si può prendere in considerazione mordere la pallottola e pagare per Aspose - http://www.aspose.com/doctest/java-components/aspose.cells-for-java/copy-move-worksheets-within-and-between-workbooks.html

It fogli copiati con successo, tra cui la formattazione, le formule, & norme di protezione. Ho fatto 300 fogli in 130 secondi. (Cartelle di lavoro da 300 x 90 kb, compilate in una cartella di lavoro da 15 MB). La demo è gratuita, mette semplicemente un foglio aggiuntivo nel libro degli esercizi per ricordarti di acquistare una licenza.

5

ho implementato alcune funzionalità con poi. si prega di consultare il codice per il vostro riferimento.

import java.io.BufferedInputStream; 
import java.io.BufferedOutputStream; 
import java.io.FileInputStream; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import org.apache.poi.hssf.usermodel.HSSFCell; 
import org.apache.poi.hssf.usermodel.HSSFRow; 
import org.apache.poi.hssf.usermodel.HSSFSheet; 
import org.apache.poi.hssf.usermodel.HSSFWorkbook; 

public class ExcelReadAndWrite { 

    public static void main(String[] args) throws IOException { 
     ExcelReadAndWrite excel = new ExcelReadAndWrite(); 
     excel.process("D:/LNN/My Workspace/POI/src/tables.xls"); 
    } 

    public void process(String fileName) throws IOException { 
     BufferedInputStream bis = new BufferedInputStream(new FileInputStream(fileName)); 
     HSSFWorkbook workbook = new HSSFWorkbook(bis); 
     HSSFWorkbook myWorkBook = new HSSFWorkbook(); 
     HSSFSheet sheet = null; 
     HSSFRow row = null; 
     HSSFCell cell = null; 
     HSSFSheet mySheet = null; 
     HSSFRow myRow = null; 
     HSSFCell myCell = null; 
     int sheets = workbook.getNumberOfSheets(); 
     int fCell = 0; 
     int lCell = 0; 
     int fRow = 0; 
     int lRow = 0; 
     for (int iSheet = 0; iSheet < sheets; iSheet++) { 
      sheet = workbook.getSheetAt(iSheet); 
      if (sheet != null) { 
       mySheet = myWorkBook.createSheet(sheet.getSheetName()); 
       fRow = sheet.getFirstRowNum(); 
       lRow = sheet.getLastRowNum(); 
       for (int iRow = fRow; iRow <= lRow; iRow++) { 
        row = sheet.getRow(iRow); 
        myRow = mySheet.createRow(iRow); 
        if (row != null) { 
         fCell = row.getFirstCellNum(); 
         lCell = row.getLastCellNum(); 
         for (int iCell = fCell; iCell < lCell; iCell++) { 
          cell = row.getCell(iCell); 
          myCell = myRow.createCell(iCell); 
          if (cell != null) { 
           myCell.setCellType(cell.getCellType()); 
           switch (cell.getCellType()) { 
           case HSSFCell.CELL_TYPE_BLANK: 
            myCell.setCellValue(""); 
            break; 

           case HSSFCell.CELL_TYPE_BOOLEAN: 
            myCell.setCellValue(cell.getBooleanCellValue()); 
            break; 

           case HSSFCell.CELL_TYPE_ERROR: 
            myCell.setCellErrorValue(cell.getErrorCellValue()); 
            break; 

           case HSSFCell.CELL_TYPE_FORMULA: 
            myCell.setCellFormula(cell.getCellFormula()); 
            break; 

           case HSSFCell.CELL_TYPE_NUMERIC: 
            myCell.setCellValue(cell.getNumericCellValue()); 
            break; 

           case HSSFCell.CELL_TYPE_STRING: 
            myCell.setCellValue(cell.getStringCellValue()); 
            break; 
           default: 
            myCell.setCellFormula(cell.getCellFormula()); 
           } 
          } 
         } 
        } 
       } 
      } 
     } 
     bis.close(); 
     BufferedOutputStream bos = new BufferedOutputStream(
       new FileOutputStream("workbook.xls", true)); 
     myWorkBook.write(bos); 
     bos.close(); 
    } 
} 
0

Questa è la mia implementazione di copia di fogli da una cartella di lavoro a un'altra. Questa soluzione funziona per me. Questo codice funzionerà se i fogli non hanno tabelle, ecc. Se i fogli contengono testo semplice (String, booleano, int ecc.), Questa soluzione funzionerà.

Workbook oldWB = new XSSFWorkbook(new FileInputStream("C:\\input.xlsx")); 
Workbook newWB = new XSSFWorkbook(); 
CellStyle newStyle = newWB.createCellStyle(); // Need this to copy over styles from old sheet to new sheet. Next step will be processed below 
Row row; 
Cell cell; 
for (int i = 0; i < oldWB.getNumberOfSheets(); i++) { 
    XSSFSheet sheetFromOldWB = (XSSFSheet) oldWB.getSheetAt(i); 
    XSSFSheet sheetForNewWB = (XSSFSheet) newWB.createSheet(sheetFromOldWB.getSheetName()); 
    for (int rowIndex = 0; rowIndex < sheetFromOldWB.getPhysicalNumberOfRows(); rowIndex++) { 
     row = sheetForNewWB.createRow(rowIndex); //create row in this new sheet 
     for (int colIndex = 0; colIndex < sheetFromOldWB.getRow(rowIndex).getPhysicalNumberOfCells(); colIndex++) { 
      cell = row.createCell(colIndex); //create cell in this row of this new sheet 
      Cell c = sheetFromOldWB.getRow(rowIndex).getCell(colIndex, Row.CREATE_NULL_AS_BLANK); //get cell from old/original WB's sheet and when cell is null, return it as blank cells. And Blank cell will be returned as Blank cells. That will not change. 
       if (c.getCellType() == Cell.CELL_TYPE_BLANK){ 
        System.out.println("This is BLANK " + ((XSSFCell) c).getReference()); 
       } 
       else { //Below is where all the copying is happening. First It copies the styles of each cell and then it copies the content.    
       CellStyle origStyle = c.getCellStyle(); 
       newStyle.cloneStyleFrom(origStyle); 
       cell.setCellStyle(newStyle);    

       switch (c.getCellTypeEnum()) { 
        case STRING:        
         cell.setCellValue(c.getRichStringCellValue().getString()); 
         break; 
        case NUMERIC: 
         if (DateUtil.isCellDateFormatted(cell)) {        
          cell.setCellValue(c.getDateCellValue()); 
         } else {        
          cell.setCellValue(c.getNumericCellValue()); 
         } 
         break; 
        case BOOLEAN: 

         cell.setCellValue(c.getBooleanCellValue()); 
         break; 
        case FORMULA: 

         cell.setCellValue(c.getCellFormula()); 
         break; 
        case BLANK: 
         cell.setCellValue("who"); 
         break; 
        default: 
         System.out.println(); 
        } 
       } 
      } 
     } 

    } 
    //Write over to the new file 
    FileOutputStream fileOut = new FileOutputStream("C:\\output.xlsx"); 
    newWB.write(fileOut); 
    oldWB.close(); 
    newWB.close(); 
    fileOut.close(); 

Se è necessario copiare fogli interi senza lasciare o aggiungere nulla. Penso che il processo di eliminazione funzioni meglio e più velocemente del codice precedente. E non dovete preoccuparvi di perdere le formule, disegni, tabelle, stili, font, ecc

XSSFWorkbook wb = new XSSFWorkbook("C:\\abc.xlsx"); 
for (int i = wb.getNumberOfSheets() - 1; i >= 0; i--) { 
     if (!wb.getSheetName(i).contentEquals("January")) //This is a place holder. You will insert your logic here to get the sheets that you want. 
      wb.removeSheetAt(i); //Just remove the sheets that don't match your criteria in the if statement above    
} 
FileOutputStream out = new FileOutputStream(new File("C:\\xyz.xlsx")); 
wb.write(out); 
out.close(); 
Problemi correlati