Microsoft Word è una popolare applicazione di elaborazione testi utilizzata per creare vari tipi di documenti. Questi documenti possono contenere diversi tipi di elementi tra cui testo, immagini, tabelle e grafici. Quando si tratta di automatizzare la creazione e la manipolazione di documenti in Java, potrebbe essere necessaria una soluzione semplice per creare tabelle all’interno di documenti Word. Quindi in questo post del blog esploreremo come creare tabelle nei documenti Word in un’applicazione Java.
- Libreria Java per creare tabelle in documenti Word
- Creare una tabella in un documento di Word
- Inserisci una tabella nidificata nei documenti di Word
- Crea una tabella da HTML
Libreria Java per creare tabelle in documenti Word
Aspose.Words for Java è un’API che consente agli sviluppatori Java di lavorare con documenti Microsoft Word a livello di codice. Fornisce un’ampia gamma di funzionalità per creare, modificare e manipolare documenti Word, rendendolo uno strumento prezioso per automatizzare la generazione di documenti e le attività di elaborazione. Utilizzeremo questa libreria per inserire tabelle in un documento Word.
Puoi scaricare la libreria o installarla utilizzando le seguenti configurazioni Maven.
<repository>
<id>AsposeJavaAPI</id>
<name>Aspose Java API</name>
<url>https://repository.aspose.com/repo/</url>
</repository>
<dependency>
<groupId>com.aspose</groupId>
<artifactId>aspose-words</artifactId>
<version>23.10</version>
<classifier>jdk17</classifier>
</dependency>
Creare una tabella in un documento Word in Java
Esistono due modi per creare tabelle nei documenti di Word utilizzando Aspose.Words for Java:
- Utilizzando DocumentBuilder
- Utilizzo del DOM (modello oggetto documento)
Puoi scegliere il metodo più adatto alle tue esigenze. Esploriamo quindi ciascuno di questi metodi in dettaglio.
Crea tabella utilizzando DocumentBuilder
La classe DocumentBuilder fornisce un modo semplice e veloce per creare documenti dinamici da zero o elaborare documenti esistenti. Offre una gamma di funzioni per l’inserimento di vari elementi di contenuto come testo, caselle di controllo, oggetti OLE, paragrafi, elenchi, tabelle, immagini e altro.
Di seguito sono riportati i passaggi che utilizzano la classe DocumentBuilder per creare una tabella in un documento Word in Java.
- Crea un oggetto della classe Document per caricare o creare il documento Word.
- Crea un oggetto della classe DocumentBuilder.
- Avvia una tabella utilizzando il metodo DocumentBuilder.startTable().
- Inserisci una cella utilizzando il metodo DocumentBuilder.insertCell().
- (Facoltativo) Applica la formattazione alla cella, come carattere e allineamento.
- Inserisci il testo nella cella utilizzando il metodo DocumentBuilder.write().
- Ripeti l’inserimento di celle e testo nelle celle come richiesto.
- Termina una riga quando completi l’inserimento delle celle utilizzando il metodo DocumentBuilder.endRow().
- Termina la tabella quando hai inserito tutte le righe utilizzando il metodo DocumentBuilder.endTable().
- Salva il documento di Word utilizzando il metodo Document.save().
Il seguente frammento di codice mostra come creare una tabella in un documento Word utilizzando Java.
// Crea o carica un documento.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
// Crea una nuova tabella e inserisci la cella.
Table table = builder.startTable();
builder.insertCell();
// La formattazione estesa della tabella deve essere applicata dopo che nella tabella è presente almeno una riga.
table.setLeftIndent(20.0);
// Imposta l'altezza e definisci la regola dell'altezza per la riga di intestazione.
builder.getRowFormat().setHeight(40.0);
builder.getRowFormat().setHeightRule(HeightRule.AT_LEAST);
builder.getCellFormat().getShading().setBackgroundPatternColor(new Color((198), (217), (241)));
builder.getParagraphFormat().setAlignment(ParagraphAlignment.CENTER);
builder.getFont().setSize(16.0);
builder.getFont().setName("Arial");
builder.getFont().setBold(true);
builder.getCellFormat().setWidth(100.0);
builder.write("Header Row,\n Cell 1");
// Non è necessario specificare la larghezza di questa cella perché è ereditata dalla cella precedente.
builder.insertCell();
builder.write("Header Row,\n Cell 2");
builder.insertCell();
builder.getCellFormat().setWidth(200.0);
builder.write("Header Row,\n Cell 3");
builder.endRow();
builder.getCellFormat().getShading().setBackgroundPatternColor(Color.WHITE);
builder.getCellFormat().setWidth(100.0);
builder.getCellFormat().setVerticalAlignment(CellVerticalAlignment.CENTER);
// Reimposta l'altezza e definisci una regola di altezza diversa per il corpo della tabella.
builder.getRowFormat().setHeight(30.0);
builder.getRowFormat().setHeightRule(HeightRule.AUTO);
builder.insertCell();
// Reimposta la formattazione dei caratteri.
builder.getFont().setSize(12.0);
builder.getFont().setBold(false);
builder.write("Row 1, Cell 1 Content");
builder.insertCell();
builder.write("Row 1, Cell 2 Content");
builder.insertCell();
builder.getCellFormat().setWidth(200.0);
builder.write("Row 1, Cell 3 Content");
builder.endRow();
builder.insertCell();
builder.getCellFormat().setWidth(100.0);
builder.write("Row 2, Cell 1 Content");
builder.insertCell();
builder.write("Row 2, Cell 2 Content");
builder.insertCell();
builder.getCellFormat().setWidth(200.0);
builder.write("Row 2, Cell 3 Content.");
builder.endRow();
// Tavolino.
builder.endTable();
// Salva documento.
doc.save("table.docx");
Quello che segue è lo screenshot della tabella che abbiamo creato utilizzando l’esempio di codice sopra.
Crea tabella utilizzando DOM
Il Document Object Model (DOM) è una rappresentazione in memoria di un documento Word che consente di leggere, manipolare e modificare a livello di codice il contenuto e la formattazione di un documento Word. I passaggi seguenti dimostrano come creare una tabella in un documento di Word utilizzando DOM.
- Crea un oggetto della classe Document per caricare o creare il documento Word.
- Crea un oggetto della classe Table e inserisci la tabella nel documento utilizzando il metodo Document.getFirstSection().getBody().appendChild(Table).
- Crea un oggetto della classe Row e inseriscilo nella tabella utilizzando il metodo Table.appendChild(Row).
- Crea un oggetto della classe Cell, imposta le opzioni di formattazione e aggiungi testo alla cella.
- Inserisci la cella nella riga utilizzando il metodo Row.appendChild(Cell).
- Ripeti il procedimento per tutte le righe che desideri.
- Salva il documento di Word utilizzando il metodo Document.save().
Il seguente frammento di codice mostra come creare una tabella in un documento Word in Java.
// Crea o carica un documento.
Document doc = new Document();
// Iniziamo creando l'oggetto tabella. Nota che dobbiamo passare l'oggetto document
// al costruttore di ciascun nodo. Questo perché ogni nodo che creiamo deve appartenere
// a qualche documento.
Table table = new Table(doc);
doc.getFirstSection().getBody().appendChild(table);
// Qui potremmo chiamare GuaranteeMinimum per creare le righe e le celle per noi. Questo metodo viene utilizzato
// per garantire che il nodo specificato sia valido. In questo caso, una tabella valida dovrebbe avere almeno una riga e una cella.
// Gestiremo invece la creazione della riga e della tabella da soli.
// Questo sarebbe il modo migliore per farlo se stessimo creando una tabella all'interno di un algoritmo.
Row row = new Row(doc);
row.getRowFormat().setAllowBreakAcrossPages(true);
table.appendChild(row);
// Ora possiamo applicare qualsiasi impostazione di adattamento automatico.
table.autoFit(AutoFitBehavior.FIXED_COLUMN_WIDTHS);
Cell cell = new Cell(doc);
cell.getCellFormat().getShading().setBackgroundPatternColor(Color.BLUE);
cell.getCellFormat().setWidth(80.0);
cell.appendChild(new Paragraph(doc));
cell.getFirstParagraph().appendChild(new Run(doc, "Row 1, Cell 1 Text"));
row.appendChild(cell);
// Dovremmo quindi ripetere il processo per le altre celle e righe della tabella.
// Possiamo anche velocizzare il tutto clonando celle e righe esistenti.
row.appendChild(cell.deepClone(false));
row.getLastCell().appendChild(new Paragraph(doc));
row.getLastCell().getFirstParagraph().appendChild(new Run(doc, "Row 1, Cell 2 Text"));
// Salva documento.
doc.save("table.docx");
Inserisci una tabella nidificata nei documenti di Word
Potrebbe anche verificarsi il caso in cui sia necessario creare una tabella nidificata, che si trova all’interno di una cella della tabella padre. Puoi farlo senza passare attraverso un processo complesso. Innanzitutto, crea una tabella padre e quindi chiama il metodo DocumentBuilder.moveTo(Cell.getFirstParagraph()) per spostare il controllo all’interno della cella desiderata della tabella padre. Una volta terminato, crea una nuova tabella allo stesso modo.
Il seguente frammento di codice mostra come creare una tabella nidificata in un documento Word utilizzando Java.
// Crea o carica un documento.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
// Inserisci cella.
Cell cell = builder.insertCell();
builder.writeln("Outer Table Cell 1");
builder.insertCell();
builder.writeln("Outer Table Cell 2");
// Questa chiamata è importante per creare una tabella nidificata all'interno della prima tabella.
// Senza questa chiamata, le celle inserite di seguito verranno aggiunte alla tabella esterna.
builder.endTable();
// Passa alla prima cella della tabella esterna.
builder.moveTo(cell.getFirstParagraph());
// Costruisci il tavolo interno.
builder.insertCell();
builder.writeln("Inner Table Cell 1");
builder.insertCell();
builder.writeln("Inner Table Cell 2");
builder.endTable();
// Salva documento.
doc.save("table.docx");
Quello che segue è lo screenshot della tabella nidificata che abbiamo creato sopra.
Crea una tabella di parole da HTML in Java
Puoi anche creare una tabella in un documento Word utilizzando una stringa HTML ed ecco i passaggi da seguire.
- Crea un oggetto della classe Document per caricare o creare il documento Word.
- Crea un oggetto della classe DocumentBuilder.
- Inserisci la stringa HTML della tabella nel documento utilizzando il metodo DocumentBuilder.insertHtml(String).
- Infine, salva il documento utilizzando il metodo Document.save().
Di seguito è riportato lo snippet di codice per generare una tabella Word da una stringa HTML.
// Crea o carica un documento.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
// Tieni presente che AutoFitSettings non si applica alle tabelle inserite da HTML.
builder.insertHtml("<table>" +
"<tr>" +
"<td>Row 1, Cell 1</td>" +
"<td>Row 1, Cell 2</td>" +
"</tr>" +
"<tr>" +
"<td>Row 2, Cell 2</td>" +
"<td>Row 2, Cell 2</td>" +
"</tr>" +
"</table>");
// Salva documento.
doc.save("table.docx");
Ottieni una licenza gratuita
Puoi ottenere una licenza temporanea per utilizzare Aspose.Words for Java senza limitazioni di valutazione.
Conclusione
In questo post del blog, abbiamo esplorato come creare tabelle nei documenti Word utilizzando Java. Hai visto come creare una tabella utilizzando il generatore di documenti o DOM, creare una tabella nidificata e creare una tabella da una stringa HTML. Installando la libreria e seguendo le linee guida, puoi facilmente integrare la funzionalità di creazione di tabelle nella tua applicazione Java.
Aspose.Words for Java offre numerose altre funzionalità e opzioni di formattazione, consentendoti di creare facilmente documenti ricchi e complessi. Per saperne di più su Aspose.Words for Java, esplora la sua vasta documentazione e esempi. In caso di domande, non esitate a farcelo sapere tramite il nostro forum.