crear tablas en documentos de Word usando Java

Microsoft Word es una popular aplicación de procesamiento de textos que se utiliza para crear varios tipos de documentos. Estos documentos pueden contener varios tipos de elementos, incluidos texto, imágenes, tablas y gráficos. Cuando se trata de automatizar la creación y manipulación de documentos en Java, es posible que necesite una solución sencilla para crear tablas dentro de documentos de Word. Entonces, en esta publicación de blog, exploraremos cómo crear tablas en documentos de Word en una aplicación Java.

Biblioteca Java para crear tablas en documentos de Word

Aspose.Words for Java es una API que permite a los desarrolladores de Java trabajar con documentos de Microsoft Word mediante programación. Proporciona una amplia gama de funciones para crear, modificar y manipular documentos de Word, lo que la convierte en una herramienta valiosa para automatizar las tareas de generación y procesamiento de documentos. Usaremos esta biblioteca para insertar tablas en un documento de Word.

Puede descargar la biblioteca o instalarla usando las siguientes configuraciones de 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>

Crear una tabla en un documento de Word en Java

Hay dos formas de crear tablas en documentos de Word usando Aspose.Words for Java:

  • Usando el generador de documentos
  • Usando DOM (modelo de objetos de documento)

Podrás elegir el método que mejor se adapte a tus necesidades. Entonces, exploremos cada uno de estos métodos en detalle.

Crear tabla usando DocumentBuilder

La clase DocumentBuilder le proporciona una forma rápida y sencilla de crear documentos dinámicos desde cero o procesar documentos existentes. Ofrece una variedad de funciones para insertar varios elementos de contenido, como texto, casillas de verificación, objetos OLE, párrafos, listas, tablas, imágenes y más.

Los siguientes son los pasos que utilizan la clase DocumentBuilder para crear una tabla en un documento de Word en Java.

  • Crea un objeto de la clase Document para cargar o crear el documento de Word.
  • Crea un objeto de la clase DocumentBuilder.
  • Inicie una tabla usando el método DocumentBuilder.startTable().
  • Inserte una celda usando el método DocumentBuilder.insertCell().
  • (Opcional) Aplique formato a la celda, como fuente y alineación.
  • Inserte texto en la celda usando el método DocumentBuilder.write().
  • Repita la inserción de celdas y texto en las celdas según sea necesario.
  • Finalice una fila cuando complete la inserción de celdas utilizando el método DocumentBuilder.endRow().
  • Finalice la tabla cuando haya insertado todas las filas utilizando el método DocumentBuilder.endTable().
  • Guarde el documento de Word utilizando el método Document.save().

El siguiente fragmento de código muestra cómo crear una tabla en un documento de Word usando Java.

// Crear o cargar documento.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

// Cree una nueva tabla e inserte la celda.
Table table = builder.startTable();
builder.insertCell();

// El formato para toda la tabla se debe aplicar después de que al menos una fila esté presente en la tabla.
table.setLeftIndent(20.0);

// Establezca la altura y defina la regla de altura para la fila del encabezado.
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");

// No necesitamos especificar el ancho de esta celda porque se hereda de la celda anterior.
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);

// Restablezca la altura y defina una regla de altura diferente para el cuerpo de la tabla.
builder.getRowFormat().setHeight(30.0);
builder.getRowFormat().setHeightRule(HeightRule.AUTO);
builder.insertCell();
        
// Restablecer el formato de fuente.
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();

// Mesa final.
builder.endTable();

// Guardar documento.
doc.save("table.docx");

La siguiente es la captura de pantalla de la tabla que hemos creado usando el ejemplo de código anterior.

Tabla en un documento de Word

Crear tabla usando DOM

El Modelo de objetos de documento (DOM) es una representación en memoria de un documento de Word que le permite leer, manipular y modificar mediante programación el contenido y el formato de un documento de Word. Los siguientes pasos demuestran cómo crear una tabla en un documento de Word usando DOM.

  • Crea un objeto de la clase Document para cargar o crear el documento de Word.
  • Cree un objeto de la clase Tabla e inserte la tabla en el documento usando el método Document.getFirstSection().getBody().appendChild(Table).
  • Cree un objeto de la clase Row e insértelo en la tabla usando el método Table.appendChild(Row).
  • Cree un objeto de la clase Celda, establezca opciones de formato y agregue texto a la celda.
  • Inserte la celda en la fila usando el método Row.appendChild(Cell).
  • Repite el proceso para tantas filas como quieras.
  • Guarde el documento de Word utilizando el método Document.save().

El siguiente fragmento de código muestra cómo crear una tabla en un documento de Word en Java.

// Crear o cargar documento.
Document doc = new Document();
        
// Empezamos creando el objeto tabla. Tenga en cuenta que debemos pasar el objeto del documento.
// al constructor de cada nodo. Esto se debe a que cada nodo que creemos debe pertenecer
// a algún documento.
Table table = new Table(doc);
doc.getFirstSection().getBody().appendChild(table);

// Aquí podríamos llamar a GuaranteeMinimum para crear las filas y celdas por nosotros. Este método se utiliza
// para garantizar que el nodo especificado sea válido. En este caso, una tabla válida debe tener al menos una fila y una celda.

// En su lugar, nos encargaremos de crear la fila y la tabla nosotros mismos.
// Esta sería la mejor manera de hacerlo si estuviéramos creando una tabla dentro de un algoritmo.
Row row = new Row(doc);
row.getRowFormat().setAllowBreakAcrossPages(true);
table.appendChild(row);

// Ahora podemos aplicar cualquier configuración de ajuste automático.
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);

// Luego repetiríamos el proceso para las otras celdas y filas de la tabla.
// También podemos acelerar las cosas clonando celdas y filas existentes.
row.appendChild(cell.deepClone(false));
row.getLastCell().appendChild(new Paragraph(doc));
row.getLastCell().getFirstParagraph().appendChild(new Run(doc, "Row 1, Cell 2 Text"));

// Guardar documento.
doc.save("table.docx");

Insertar una tabla anidada en documentos de Word

También podría darse el caso de que necesite crear una tabla anidada, que se encuentra dentro de una celda de la tabla principal. Puedes hacerlo sin pasar por un proceso complejo. Primero, cree una tabla principal y luego llame al método DocumentBuilder.moveTo(Cell.getFirstParagraph()) para mover el control dentro de la celda deseada de la tabla principal. Una vez hecho esto, crea una nueva tabla de la misma manera.

El siguiente fragmento de código muestra cómo crear una tabla anidada en un documento de Word usando Java.

// Crear o cargar documento.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

// Insertar celda.
Cell cell = builder.insertCell();
builder.writeln("Outer Table Cell 1");

builder.insertCell();
builder.writeln("Outer Table Cell 2");

// Esta llamada es importante para crear una tabla anidada dentro de la primera tabla. 
// Sin esta llamada, las celdas insertadas a continuación se agregarán a la tabla exterior.
builder.endTable();

// Vaya a la primera celda de la tabla exterior.
builder.moveTo(cell.getFirstParagraph());

// Construye la mesa interior.
builder.insertCell();
builder.writeln("Inner Table Cell 1");
builder.insertCell();
builder.writeln("Inner Table Cell 2");
builder.endTable();

// Guardar documento.
doc.save("table.docx");

La siguiente es la captura de pantalla de la tabla anidada que hemos creado anteriormente.

Nested Table in a Word Document

Crear una tabla de Word desde HTML en Java

También puedes crear una tabla en un documento de Word usando una cadena HTML y estos son los pasos a seguir.

  • Crea un objeto de la clase Document para cargar o crear el documento de Word.
  • Crea un objeto de la clase DocumentBuilder.
  • Inserte la cadena HTML de la tabla en el documento utilizando el método DocumentBuilder.insertHtml(String).
  • Finalmente, guarde el documento usando el método Document.save().

A continuación se muestra el fragmento de código para generar una tabla de Word a partir de una cadena HTML.

// Crear o cargar documento.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

// Tenga en cuenta que AutoFitSettings no se aplica a tablas insertadas desde 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>");

// Guardar documento.
doc.save("table.docx");

Obtenga una licencia gratuita

Puede obtener una licencia temporal para utilizar Aspose.Words for Java sin limitaciones de evaluación.

Conclusión

En esta publicación de blog, exploramos cómo crear tablas en documentos de Word usando Java. Ha visto cómo crear una tabla usando el generador de documentos o DOM, crear una tabla anidada y crear una tabla a partir de una cadena HTML. Al instalar la biblioteca y seguir las pautas, puede integrar fácilmente la función de creación de tablas en su aplicación Java.

Aspose.Words for Java proporciona muchas otras funciones y opciones de formato, lo que le permite crear documentos ricos y complejos con facilidad. Para obtener más información sobre Aspose.Words for Java, explore su extensa documentación y ejemplos. En caso de tener alguna pregunta, no dude en hacérnoslo saber a través de nuestro foro.

Ver también