Se sei uno sviluppatore di applicazioni Java che lavora con Excel all’interno delle tue applicazioni Java, saresti interessato a fornire la funzionalità di manipolare i dati Excel nella tua applicazione. Excel consente di formattare lo stile delle celle, impostare il tipo di cella su diversi tipi di dati, riempire una cella con colori diversi e così via. Apache Poi funge da ponte tra Java ed Excel, offrendo strumenti per manipolare a livello di livello Excel file xlsx. In questa serie di blog, sveleremo l’arte della manipolazione cellulare Excel usando Apache Poi in Java. Ci immeriamo e scopriamo la sinergia del codice e dei fogli di calcolo!

Table of Sommone

In tutto il blog, esamineremo campioni di codice e spiegazione dello stesso per quanto segue:

  1. Creazione di celle nel file Excel
  2. Crea celle di data in Excel
  3. Lavorare con diversi tipi di cellule
  4. Impostazione dell’aspetto cellulare

Lavorare con le celle nel file Excel in java

Creazione di celle nel file Excel

//Create Cells
XSSFWorkbook wb = new XSSFWorkbook();
XSSFCreationHelper createHelper = wb.getCreationHelper();
XSSFSheet sheet = wb.createSheet("new sheet");
// Create a row and put some cells in it. Rows are 0 based.
Row row = sheet.createRow(0);
// Create a cell and put a value in it.
Cell cell = row.createCell(0);
cell.setCellValue(1);
row.createCell(1).setCellValue(1.2);
row.createCell(2).setCellValue(createHelper.createRichTextString("This is a string"));
row.createCell(3).setCellValue(true);
// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}

Lo snippet di codice Java sopra mostra l’uso dell’API Apache POI per funzionare con le celle in una cartella di lavoro di Excel. Il codice crea una nuova cartella di lavoro di Excel (\ **xssfworkbook** \), inizializza un foglio all’interno della cartella di lavoro e quindi popola le celle con vari tipi di dati. Innanzitutto, il codice crea un nuovo foglio chiamato " Nuovo foglio “. Genera quindi una riga all’indice 0 sul foglio e procede a riempire le celle all’interno di quella riga. Alla prima cella (indice 0) viene assegnato un valore intero di 1 utilizzando il metodo \ **setCellValue** \. Al contrario, la seconda cella (indice 1) è impostata su un valore decimale di 1.2 direttamente all’interno del metodo \ **CreateCell** \. La terza cella (indice 2) contiene un valore di stringa “questa è una stringa” creata utilizzando il metodo \ **CREATERICHTEXTString** \ dall’istanza \ **xssfcreationhelper** \. Infine, la quarta cella (indice 3) è popolata con il valore booleano “vero”. Dopo che i valori della cella sono stati impostati, il codice scrive la cartella di lavoro risultante in un file Excel chiamato “Workbook.xlsx” utilizzando un \ **FileOutputStream** \.

Creazione del tipo di data cella

XSSFWorkbook wb = new XSSFWorkbook();
//Workbook wb = new XSSFWorkbook();
CreationHelper createHelper = wb.getCreationHelper();
org.apache.poi.ss.usermodel.Sheet sheet = wb.createSheet("new sheet");
// Create a row and put some cells in it. Rows are 0 based.
Row row = sheet.createRow(0);
// Create a cell and put a date value in it.  The first cell is not styled
// as a date.
Cell cell = row.createCell(0);
cell.setCellValue(new Date());
// we style the second cell as a date (and time).  It is important to
// create a new cell style from the workbook otherwise you can end up
// modifying the built in style and effecting not only this cell but other cells.
CellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(
    createHelper.createDataFormat().getFormat("m/d/yy h:mm"));
cell = row.createCell(1);
cell.setCellValue(new Date());
cell.setCellStyle(cellStyle);
//you can also set date as java.util.Calendar
cell = row.createCell(2);
cell.setCellValue(Calendar.getInstance());
cell.setCellStyle(cellStyle);
// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}

Questo frammento di codice Java mette in mostra l’uso dell’API Apache POI per lavorare con le celle di tipo data in una cartella di lavoro di Excel. Il codice inizia creando una nuova cartella di lavoro di Excel (\ **xssfworkbook** \). La prima cella (indice 0) ha lo scopo di contenere un valore della data. Una data \ * ***\ che rappresenta la data e l’ora corrente è impostata come valore della cella usando il metodo \ ** setCellValue**\. Questa cella non è esplicitamente disegnata come una data. Per la seconda cella (indice 1), un nuovo stile cellulare (\ cellstyle \) viene creato utilizzando il metodo \ CreateCellStyle \ della cartella di lavoro. Questo stile è quindi configurato per avere un formato di data e ora specifico utilizzando il metodo \ setDataFormat \. Il processo \ createATataFormat (). GetFormat (" M/D/YY H: MM ") \ crea un formato di date personalizzato con un modello di formato di “M/D/YY H: MM”. Alla seconda cella viene assegnata la data corrente e il valore di tempo e lo stile cellulare appena creato viene applicato ad esso utilizzando il metodo \ setCellStyle \. La terza cella (indice 2) dimostra un metodo alternativo per popolare le celle di tipo data usando \ java.util.calendar \. Simile alla seconda cella, lo stile cella personalizzato viene applicato anche a questa cella.

lavorando con diversi tipi di celle

XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet sheet = wb.createSheet("new sheet");
Row row = sheet.createRow(2);
row.createCell(0).setCellValue(1.1);
row.createCell(1).setCellValue(new Date());
row.createCell(2).setCellValue(Calendar.getInstance());
row.createCell(3).setCellValue("a string");
row.createCell(4).setCellValue(true);
row.createCell(5).setCellType(CellType.ERROR);		// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}

In questo campione di codice, diversi stili di celle vengono applicati alle celle in un file Excel usando l’API Apache POI come spiegato nelle seguenti fasi.

  1. Una riga viene creata all’indice 2 sul foglio utilizzando \ **Creatrow** (2) \. Le celle vengono quindi popolate in questa riga con i seguenti dati.
  2. Alla prima cella (indice 0) viene assegnato un valore decimale di 1.1 usando il metodo \ **setCellValue** \.
  3. Nella seconda cella (indice 1), la data e l’ora corrente sono inserite usando un oggetto \ data \ tramite il metodo \ **setCellValue** \.
  4. La terza cella (indice 2) contiene la data e l’ora da un’istanza \ calendario \, imposta usando il metodo \ **setCellValue** \.
  5. La quarta cella (indice 3) contiene il testo “una stringa”.
  6. La quinta cella (indice 4) è designata per un valore booleano “vero”.
  7. Andando avanti, un tipo di cella specifico viene assegnato alla sesta cella (indice 5) invocando il metodo \ **setCellType** \. Questa cella è configurata come una cella di errore utilizzando l’enumerazione \ **celltype.error** \, che indica che visualizzerà un valore di errore. Infine, la cartella di lavoro modificata è scritta in un file chiamato “Workbook.xlsx” utilizzando un \ **fileoutputstream** \. In sintesi, questo esempio di codice dimostra come stabilire una cartella di lavoro di Excel, applicare diversi stili di celle per adattarsi a vari tipi di dati e, infine, salvare la cartella di lavoro modificata in un file. Questa pratica illustrazione mostra le capacità della libreria Apache Poi per lavorare con i file Excel in Java.

Impostazione dell’aspetto della cella

XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet sheet = wb.createSheet("new sheet");
// Create a row and put some cells in it. Rows are 0 based.
Row row = sheet.createRow(1);
// Aqua background
CellStyle style = wb.createCellStyle();
style.setFillBackgroundColor(IndexedColors.AQUA.getIndex());
style.setFillPattern(FillPatternType.BIG_SPOTS);
Cell cell = row.createCell(1);
cell.setCellValue("X");
cell.setCellStyle(style);
// Orange "foreground", foreground being the fill foreground not the font color.
style = wb.createCellStyle();
style.setFillForegroundColor(IndexedColors.ORANGE.getIndex());
style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
cell = row.createCell(2);
cell.setCellValue("X");
cell.setCellStyle(style);
// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}
wb.close();

Questo frammento di codice dimostra come manipolare l’aspetto delle celle in un file Excel usando la libreria Apache Poi in Java. Ciò si ottiene utilizzando i seguenti passaggi.

  1. Una riga viene creata all’indice 1 sul foglio utilizzando \ Careatrow (1) \. Le seguenti modifiche vengono apportate alle celle all’interno di questa riga.
  2. Per la prima cella (indice 1), viene creato uno stile di cella personalizzato usando \ wb.createcellstyle () \. Questo stile è configurato con un colore di sfondo Aqua usando \ setFillBackGroundColor \ e \ indicedColors.aqua.getIndex () \. Il modello per lo sfondo è impostato su “Big Spots” usando \ setFillPattern (FillPatternType.Big_Spots) \. Una cella viene creata in questa riga all’indice 1 e riempita con il valore “x”. Lo stile precedentemente creato viene applicato a questa cella usando \ setCellStyle \.
  3. Per la seconda cella (indice 2), viene creato un nuovo stile cellulare. Questo stile è progettato con un colore in primo piano arancione usando \ setFillforegroundColor \ e \ indicedColors.orange.getIndex () \. Il pattern di riempimento è impostato su “Firshipro solido” usando \ setFillPattern (FillPatternType.Solid_foreground) \. Un’altra cella viene creata all’indice 2 nella stessa riga e popolata con il valore “x”. Lo stile appena generato viene quindi assegnato a questa cella usando \ setCellStyle \. Dopo aver configurato le apparenze di cella, la cartella di lavoro modificata viene scritta in un file chiamato “Workbook.xlsx” utilizzando un \ fileoutputstream \. In sintesi, questo esempio di codice mostra come utilizzare la libreria Apache Poi per manipolare le apparenze delle celle in un file Excel. Le tecniche dimostrate prevedono la creazione di stili cellulari personalizzati per controllare lo sfondo e i colori in primo piano, nonché i motivi di riempimento, fornendo flessibilità nella personalizzazione visiva di fogli di calcolo Excel usando Java.

conclusione

In tutti gli esempi di Java di cui sopra per la libreria Apache Poi, abbiamo dimostrato come lavorare con i contenuti del file di Excel all’interno della tua applicazione Java. I campioni di codice hanno mostrato come creare celle in un file Excel, impostare l’aspetto di questi, impostare lo stile di cella su diversi tipi di dati come stringa, numerico, decimale, ecc. E come impostare il tipo di cella sul tipo di cella. Aggiungeremo altri esempi per lavorare con i file Excel usando Apache Poi per Java, quindi rimanete sintonizzati.

vedi anche