criar tabelas em documentos do Word usando Java

O Microsoft Word é um aplicativo popular de processamento de texto usado para criar vários tipos de documentos. Esses documentos podem conter vários tipos de elementos, incluindo texto, imagens, tabelas e gráficos. Quando se trata de automatizar a criação e manipulação de documentos em Java, você pode precisar de uma solução fácil para criar tabelas em documentos do Word. Portanto, nesta postagem do blog, exploraremos como criar tabelas em documentos do Word em um aplicativo Java.

Biblioteca Java para criar tabelas em documentos do Word

Aspose.Words for Java é uma API que permite aos desenvolvedores Java trabalhar com documentos do Microsoft Word de forma programática. Ele fornece uma ampla gama de recursos para criar, modificar e manipular documentos do Word, tornando-o uma ferramenta valiosa para automatizar tarefas de geração e processamento de documentos. Usaremos esta biblioteca para inserir tabelas em um documento Word.

Você pode baixar a biblioteca ou instalá-la usando as seguintes configurações do 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>

Crie uma tabela em um documento do Word em Java

Existem duas maneiras de criar tabelas em documentos do Word usando Aspose.Words for Java:

  • Usando o DocumentBuilder
  • Usando DOM (modelo de objeto de documento)

Você pode escolher o método que melhor atende às suas necessidades. Então, vamos explorar cada um desses métodos em detalhes.

Criar tabela usando DocumentBuilder

A classe DocumentBuilder fornece uma maneira rápida e fácil de criar documentos dinâmicos do zero ou processar documentos existentes. Ele oferece uma gama de funções para inserir vários elementos de conteúdo, como texto, caixas de seleção, objetos OLE, parágrafos, listas, tabelas, imagens e muito mais.

A seguir estão as etapas que usam a classe DocumentBuilder para criar uma tabela em um documento do Word em Java.

  • Crie um objeto da classe Document para carregar ou criar o documento Word.
  • Crie um objeto da classe DocumentBuilder.
  • Inicie uma tabela usando o método DocumentBuilder.startTable().
  • Insira uma célula usando o método DocumentBuilder.insertCell().
  • (Opcional) Aplique formatação à célula, como fonte e alinhamento.
  • Insira texto na célula usando o método DocumentBuilder.write().
  • Repita a inserção de células e texto nas células conforme necessário.
  • Encerre uma linha ao concluir a inserção de células usando o método DocumentBuilder.endRow().
  • Finalize a tabela quando você tiver inserido todas as linhas usando o método DocumentBuilder.endTable().
  • Salve o documento do Word usando o método Document.save().

O trecho de código a seguir mostra como criar uma tabela em um documento do Word usando Java.

// Crie ou carregue documento.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

// Crie uma nova tabela e insira a célula.
Table table = builder.startTable();
builder.insertCell();

// A formatação de toda a tabela deve ser aplicada depois que pelo menos uma linha estiver presente na tabela.
table.setLeftIndent(20.0);

// Defina a altura e defina a regra de altura para a linha do cabeçalho.
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");

// Não precisamos especificar a largura desta célula porque ela é herdada da célula 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);

// Redefina a altura e defina uma regra de altura diferente para o corpo da tabela.
builder.getRowFormat().setHeight(30.0);
builder.getRowFormat().setHeightRule(HeightRule.AUTO);
builder.insertCell();
        
// Redefinir a formatação da fonte.
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();

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

A seguir está a captura de tela da tabela que criamos usando o exemplo de código acima.

Tabela em um documento do Word

Criar tabela usando DOM

O Document Object Model (DOM) é uma representação na memória de um documento do Word que permite ler, manipular e modificar programaticamente o conteúdo e a formatação de um documento do Word. As etapas a seguir demonstram como criar uma tabela em um documento do Word usando DOM.

  • Crie um objeto da classe Document para carregar ou criar o documento Word.
  • Crie um objeto da classe Table e insira a tabela no documento usando o método Document.getFirstSection().getBody().appendChild(Table).
  • Crie um objeto da classe Row e insira-o na tabela usando o método Table.appendChild(Row).
  • Crie um objeto da classe Cell, defina opções de formatação e adicione texto à célula.
  • Insira a célula na linha usando o método Row.appendChild(Cell).
  • Repita o processo para quantas linhas desejar.
  • Salve o documento do Word usando o método Document.save().

O trecho de código a seguir mostra como criar uma tabela em um documento do Word em Java.

// Crie ou carregue documento.
Document doc = new Document();
        
// Começamos criando o objeto tabela. Observe que devemos passar o objeto document
// ao construtor de cada nó. Isso ocorre porque cada nó que criamos deve pertencer
// para algum documento.
Table table = new Table(doc);
doc.getFirstSection().getBody().appendChild(table);

// Aqui poderíamos chamar GaranteMinimum para criar as linhas e células para nós. Este método é usado
// para garantir que o nó especificado seja válido. Neste caso, uma tabela válida deve ter pelo menos uma linha e uma célula.

// Em vez disso, nós mesmos cuidaremos da criação da linha e da tabela.
// Esta seria a melhor maneira de fazer isso se estivéssemos criando uma tabela dentro de um algoritmo.
Row row = new Row(doc);
row.getRowFormat().setAllowBreakAcrossPages(true);
table.appendChild(row);

// Agora podemos aplicar quaisquer configurações 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);

// Repetiríamos então o processo para as outras células e linhas da tabela.
// Também podemos acelerar as coisas clonando células e linhas existentes.
row.appendChild(cell.deepClone(false));
row.getLastCell().appendChild(new Paragraph(doc));
row.getLastCell().getFirstParagraph().appendChild(new Run(doc, "Row 1, Cell 2 Text"));

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

Insira uma tabela aninhada em documentos do Word

Também pode ser o caso quando você precisa criar uma tabela aninhada, localizada dentro de uma célula da tabela pai. Você pode fazer isso sem passar por um processo complexo. Primeiro, crie uma tabela pai e, em seguida, chame o método DocumentBuilder.moveTo(Cell.getFirstParagraph()) para mover o controle dentro da célula desejada da tabela pai. Feito isso, crie uma nova tabela da mesma maneira.

O trecho de código a seguir mostra como criar uma tabela aninhada em um documento do Word usando Java.

// Crie ou carregue documento.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

// Insira a célula.
Cell cell = builder.insertCell();
builder.writeln("Outer Table Cell 1");

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

// Esta chamada é importante para criar uma tabela aninhada na primeira tabela. 
// Sem esta chamada, as células inseridas abaixo serão anexadas à tabela externa.
builder.endTable();

// Vá para a primeira célula da tabela externa.
builder.moveTo(cell.getFirstParagraph());

// Construa a mesa interna.
builder.insertCell();
builder.writeln("Inner Table Cell 1");
builder.insertCell();
builder.writeln("Inner Table Cell 2");
builder.endTable();

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

A seguir está a captura de tela da tabela aninhada que criamos acima.

Nested Table in a Word Document

Crie uma tabela do Word a partir de HTML em Java

Você também pode criar uma tabela em um documento Word usando string HTML e aqui estão os passos a serem seguidos.

  • Crie um objeto da classe Document para carregar ou criar o documento Word.
  • Crie um objeto da classe DocumentBuilder.
  • Insira a string HTML da tabela no documento usando o método DocumentBuilder.insertHtml(String).
  • Finalmente, salve o documento usando o método Document.save().

Abaixo está o trecho de código para gerar uma tabela do Word a partir de uma string HTML.

// Crie ou carregue documento.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

// Observe que AutoFitSettings não se aplica a tabelas inseridas de 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>");

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

Obtenha uma licença gratuita

Você pode obter uma licença temporária para usar Aspose.Words for Java sem limitações de avaliação.

Conclusão

Nesta postagem do blog, exploramos como criar tabelas em documentos do Word usando Java. Você viu como criar uma tabela usando o construtor de documentos ou DOM, criar uma tabela aninhada e criar uma tabela a partir de uma string HTML. Ao instalar a biblioteca e seguir as diretrizes, você pode integrar facilmente o recurso de criação de tabela ao seu aplicativo Java.

Aspose.Words for Java oferece vários outros recursos e opções de formatação, permitindo criar documentos ricos e complexos com facilidade. Para saber mais sobre Aspose.Words for Java, explore sua extensa documentação e exemplos. Em caso de dúvidas, sinta-se à vontade para nos informar através do nosso fórum.

Veja também