# Gerenciar Tabelas de Apresentação em Java

> Crie e edite tabelas em slides do PowerPoint com Aspose.Slides para Java. Descubra exemplos de código simples para otimizar seus fluxos de trabalho com tabelas.

Source: https://docs.aspose.com/slides/pt/java/manage-table/
Updated: 2026-06-10

## **Introdução**

Uma tabela no PowerPoint é uma maneira eficiente de exibir e apresentar informações. As informações em uma grade de células (organizadas em linhas e colunas) são simples e fáceis de entender.

Aspose.Slides fornece a classe [Table](https://reference.aspose.com/slides/pt/java/com.aspose.slides/Table), a interface [ITable](https://reference.aspose.com/slides/pt/java/com.aspose.slides/ITable), a classe [Cell](https://reference.aspose.com/slides/pt/java/com.aspose.slides/cell/), a interface [ICell](https://reference.aspose.com/slides/pt/java/com.aspose.slides/icell/) e outros tipos que permitem criar, atualizar e gerenciar tabelas em todos os tipos de apresentações. 

## **Criar uma Tabela do Zero**

1. Crie uma instância da classe [Presentation](https://reference.aspose.com/slides/pt/java/com.aspose.slides/Presentation).
2. Obtenha a referência de um slide por meio do seu índice. 
3. Defina um array de `columnWidth`.
4. Defina um array de `rowHeight`.
5. Adicione um objeto [ITable](https://reference.aspose.com/slides/pt/java/com.aspose.slides/ITable) ao slide usando o método [addTable](https://reference.aspose.com/slides/pt/java/com.aspose.slides/IShapeCollection#addTable-float-float-double:A-double:A-).
6. Itere por cada [ICell](https://reference.aspose.com/slides/pt/java/com.aspose.slides/icell/) para aplicar formatação nas bordas superior, inferior, direita e esquerda.
7. Mescle as duas primeiras células da primeira linha da tabela. 
8. Acesse o [TextFrame](https://reference.aspose.com/slides/pt/java/com.aspose.slides/textframe/) de um [ICell](https://reference.aspose.com/slides/pt/java/com.aspose.slides/icell/). 
9. Adicione algum texto ao [TextFrame](https://reference.aspose.com/slides/pt/java/com.aspose.slides/textframe/).
10. Salve a apresentação modificada.

Este código Java mostra como criar uma tabela em uma apresentação:

```java
// Instancia uma classe Presentation que representa um arquivo PPTX
Presentation pres = new Presentation();
try {
    // Acessa o primeiro slide
    ISlide sld = pres.getSlides().get_Item(0);

    // Define colunas com larguras e linhas com alturas
    double[] dblCols = {50, 50, 50};
    double[] dblRows = {50, 30, 30, 30, 30};

    // Adiciona uma forma de tabela ao slide
    ITable tbl = sld.getShapes().addTable(100, 50, dblCols, dblRows);

    // Define o formato de borda para cada célula
    for (int row = 0; row < tbl.getRows().size(); row++)
    {
        for (int cell = 0; cell < tbl.getRows().get_Item(row).size(); cell++)
        {
            ICellFormat cellFormat = tbl.getRows().get_Item(row).get_Item(cell).getCellFormat();
            
            cellFormat.getBorderTop().getFillFormat().setFillType(FillType.Solid);
            cellFormat.getBorderTop().getFillFormat().getSolidFillColor().setColor(Color.RED);
            cellFormat.getBorderTop().setWidth(5);

            cellFormat.getBorderBottom().getFillFormat().setFillType(FillType.Solid);
            cellFormat.getBorderBottom().getFillFormat().getSolidFillColor().setColor(Color.RED);
            cellFormat.getBorderBottom().setWidth(5);

            cellFormat.getBorderLeft().getFillFormat().setFillType(FillType.Solid);
            cellFormat.getBorderLeft().getFillFormat().getSolidFillColor().setColor(Color.RED);
            cellFormat.getBorderLeft().setWidth(5);

            cellFormat.getBorderRight().getFillFormat().setFillType(FillType.Solid);
            cellFormat.getBorderRight().getFillFormat().getSolidFillColor().setColor(Color.RED);
            cellFormat.getBorderRight().setWidth(5);
        }
    }
    // Mescla as células 1 e 2 da linha 1
    tbl.mergeCells(tbl.getRows().get_Item(0).get_Item(0), tbl.getRows().get_Item(1).get_Item(1), false);

    // Adiciona algum texto à célula mesclada
    tbl.getRows().get_Item(0).get_Item(0).getTextFrame().setText("Merged Cells");

    // Salva a apresentação no disco
    pres.save("table.pptx", SaveFormat.Pptx);
} finally {
    if (pres != null) pres.dispose();
}
```

## **Numeração em uma Tabela Padrão**

Em uma tabela padrão, a numeração das células é simples e baseada em zero. A primeira célula de uma tabela tem o índice 0,0 (coluna 0, linha 0). 

Por exemplo, as células em uma tabela com 4 colunas e 4 linhas são numeradas assim:

| (0, 0) | (1, 0) | (2, 0) | (3, 0) |
| :----- | :----- | :----- | :----- |
| (0, 1) | (1, 1) | (2, 1) | (3, 1) |
| (0, 2) | (1, 2) | (2, 2) | (3, 2) |
| (0, 3) | (1, 3) | (2, 3) | (3, 3) |

Este código Java mostra como especificar a numeração das células em uma tabela:

```java
// Instancia uma classe Presentation que representa um arquivo PPTX
Presentation pres = new Presentation();
try {
    // Acessa o primeiro slide
    ISlide sld = pres.getSlides().get_Item(0);

    // Define colunas com larguras e linhas com alturas
    double[] dblCols = { 70, 70, 70, 70 };
    double[] dblRows = { 70, 70, 70, 70 };

    // Adiciona uma forma de tabela ao slide
    ITable tbl = sld.getShapes().addTable(100, 50, dblCols, dblRows);

    // Define o formato de borda para cada célula
    for (IRow row : tbl.getRows())
    {
        for (ICell cell : row)
        {
            cell.getCellFormat().getBorderTop().getFillFormat().setFillType(FillType.Solid);
            cell.getCellFormat().getBorderTop().getFillFormat().getSolidFillColor().setColor(Color.RED);
            cell.getCellFormat().getBorderTop().setWidth(5);

            cell.getCellFormat().getBorderBottom().getFillFormat().setFillType(FillType.Solid);
            cell.getCellFormat().getBorderBottom().getFillFormat().getSolidFillColor().setColor(Color.RED);
            cell.getCellFormat().getBorderBottom().setWidth(5);

            cell.getCellFormat().getBorderLeft().getFillFormat().setFillType(FillType.Solid);
            cell.getCellFormat().getBorderLeft().getFillFormat().getSolidFillColor().setColor(Color.RED);
            cell.getCellFormat().getBorderLeft().setWidth(5);

            cell.getCellFormat().getBorderRight().getFillFormat().setFillType(FillType.Solid);
            cell.getCellFormat().getBorderRight().getFillFormat().getSolidFillColor().setColor(Color.RED);
            cell.getCellFormat().getBorderRight().setWidth(5);
        }
    }

    // Salva a apresentação no disco
    pres.save("StandardTables_out.pptx", SaveFormat.Pptx);
} finally {
    if (pres != null) pres.dispose();
}
```

## **Acessar uma Tabela Existente**

1. Crie uma instância da classe [Presentation](https://reference.aspose.com/slides/pt/java/com.aspose.slides/Presentation).

2. Obtenha uma referência ao slide que contém a tabela por meio do seu índice. 

3. Crie um objeto [ITable](https://reference.aspose.com/slides/pt/java/com.aspose.slides/ITable) e defina‑o como null.

4. Itere por todos os objetos [IShape](https://reference.aspose.com/slides/pt/java/com.aspose.slides/ishape/) até que a tabela seja encontrada.

   Se você suspeitar que o slide em questão contém uma única tabela, pode simplesmente verificar todas as formas que ele contém. Quando uma forma é identificada como uma tabela, você pode convertê‑la para um objeto [Table](https://reference.aspose.com/slides/pt/java/com.aspose.slides/Table). Mas se o slide contém várias tabelas, é melhor pesquisar a tabela necessária usando seu método [setAlternativeText(String value)](https://reference.aspose.com/slides/pt/java/com.aspose.slides/ishape/#setAlternativeText-java.lang.String-).

5. Use o objeto [ITable](https://reference.aspose.com/slides/pt/java/com.aspose.slides/ITable) para trabalhar com a tabela. No exemplo abaixo, adicionamos uma nova linha à tabela.

6. Salve a apresentação modificada.

Este código Java mostra como acessar e trabalhar com uma tabela existente:

```java
// Instancia a classe Presentation que representa um arquivo PPTX
Presentation pres = new Presentation("UpdateExistingTable.pptx");
try {

    // Acessa o primeiro slide
    ISlide sld = pres.getSlides().get_Item(0);

    // Inicializa TableEx nulo
    ITable tbl = null;

    // Itera pelas formas e define uma referência para a tabela encontrada
    for (IShape shp : sld.getShapes()) 
    {
        if (shp instanceof ITable) 
        {
            tbl = (ITable) shp;
            // Define o texto para a primeira coluna da segunda linha
            tbl.get_Item(0, 1).getTextFrame().setText("New");
        }
    }
    
    // Salva a apresentação modificada no disco
    pres.save("table1_out.pptx", SaveFormat.Pptx);
} finally {
    if (pres != null) pres.dispose();
}
```

## **Alinhar Texto em uma Tabela**

1. Crie uma instância da classe [Presentation](https://reference.aspose.com/slides/pt/java/com.aspose.slides/Presentation).
2. Obtenha a referência de um slide por seu índice. 
3. Adicione um objeto [ITable](https://reference.aspose.com/slides/pt/java/com.aspose.slides/ITable) ao slide. 
4. Acesse um objeto [ITextFrame](https://reference.aspose.com/slides/pt/java/com.aspose.slides/itextframe/) a partir da tabela. 
5. Acesse o [ITextFrame](https://reference.aspose.com/slides/pt/java/com.aspose.slides/itextframe/) [IParagraph](https://reference.aspose.com/slides/pt/java/com.aspose.slides/iparagraph/).
6. Alinhe o texto verticalmente.
7. Salve a apresentação modificada.

Este código Java mostra como alinhar o texto em uma tabela:

```java
// Cria uma instância da classe Presentation
Presentation pres = new Presentation();
try {
    // Obtém o primeiro slide
    ISlide slide = pres.getSlides().get_Item(0);
    
    // Define colunas com larguras e linhas com alturas
    double[] dblCols = { 120, 120, 120, 120 };
    double[] dblRows = { 100, 100, 100, 100 };
    
    // Adiciona a forma de tabela ao slide
    ITable tbl = slide.getShapes().addTable(100, 50, dblCols, dblRows);
    tbl.get_Item(1, 0).getTextFrame().setText("10");
    tbl.get_Item(2, 0).getTextFrame().setText("20");
    tbl.get_Item(3, 0).getTextFrame().setText("30");
    
    // Acessa o quadro de texto
    ITextFrame txtFrame = tbl.get_Item(0, 0).getTextFrame();
    
    // Cria o objeto Paragraph para o quadro de texto
    IParagraph paragraph = txtFrame.getParagraphs().get_Item(0);
    
    // Cria o objeto Portion para o parágrafo
    IPortion portion = paragraph.getPortions().get_Item(0);
    portion.setText("Text here");
    portion.getPortionFormat().getFillFormat().setFillType(FillType.Solid);
    portion.getPortionFormat().getFillFormat().getSolidFillColor().setColor(Color.BLACK);
    
    // Alinha o texto verticalmente
    ICell cell = tbl.get_Item(0, 0);
    cell.setTextAnchorType(TextAnchorType.Center);
    cell.setTextVerticalType(TextVerticalType.Vertical270);
    
    // Salva a apresentação no disco
    pres.save("Vertical_Align_Text_out.pptx", SaveFormat.Pptx);
} finally {
    if (pres != null) pres.dispose();
}
```

## **Definir Formatação de Texto no Nível da Tabela**

1. Crie uma instância da [Presentation](https://reference.aspose.com/slides/pt/java/com.aspose.slides/Presentation).
2. Obtenha a referência de um slide por seu índice. 
3. Acesse um objeto [ITable](https://reference.aspose.com/slides/pt/java/com.aspose.slides/ITable) a partir do slide.
4. Defina o [setFontHeight(float value)](https://reference.aspose.com/slides/pt/java/com.aspose.slides/baseportionformat/#setFontHeight-float-) para o texto. 
5. Defina o [setAlignment(int value)](https://reference.aspose.com/slides/pt/java/com.aspose.slides/iparagraphformat/#setAlignment-int-) e o [setMarginRight(float value)](https://reference.aspose.com/slides/pt/java/com.aspose.slides/iparagraphformat/#setMarginRight-float-). 
6. Defina o [setTextVerticalType(byte value)](https://reference.aspose.com/slides/pt/java/com.aspose.slides/textframeformat/#setTextVerticalType-byte-).
7. Salve a apresentação modificada. 

Este código Java mostra como aplicar suas opções de formatação preferidas ao texto em uma tabela:

```java
// Cria uma instância da classe Presentation
Presentation pres = new Presentation("simpletable.pptx");
try {
    // Vamos supor que a primeira forma no primeiro slide seja uma tabela
    ITable someTable = (ITable) pres.getSlides().get_Item(0).getShapes().get_Item(0);
    
    // Define a altura da fonte das células da tabela
    PortionFormat portionFormat = new PortionFormat();
    portionFormat.setFontHeight(25);
    someTable.setTextFormat(portionFormat);
    
    // Define o alinhamento de texto e a margem direita das células da tabela em uma única chamada
    ParagraphFormat paragraphFormat = new ParagraphFormat();
    paragraphFormat.setAlignment(TextAlignment.Right);
    paragraphFormat.setMarginRight(20);
    someTable.setTextFormat(paragraphFormat);
    
    // Define o tipo de orientação vertical do texto das células da tabela
    TextFrameFormat textFrameFormat = new TextFrameFormat();
    textFrameFormat.setTextVerticalType(TextVerticalType.Vertical);
    someTable.setTextFormat(textFrameFormat);
    
    pres.save("result.pptx", SaveFormat.Pptx);
} finally {
    if (pres != null) pres.dispose();
}
```

## **Obter Propriedades de Estilo da Tabela**

Aspose.Slides permite recuperar as propriedades de estilo de uma tabela para que você possa usar esses detalhes em outra tabela ou em outro local. Este código Java mostra como obter as propriedades de estilo de um estilo de tabela predefinido:

```java
Presentation pres = new Presentation();
try {
    ITable table = pres.getSlides().get_Item(0).getShapes().addTable(10, 10, new double[] { 100, 150 }, new double[] { 5, 5, 5 });
    table.setStylePreset(TableStylePreset.DarkStyle1); // alterar o tema padrão do preset de estilo
    pres.save("table.pptx", SaveFormat.Pptx);
} finally {
    if (pres != null) pres.dispose();
}
```

## **Bloquear Proporção da Tabela**

A proporção de um objeto geométrico é a relação de seus tamanhos em diferentes dimensões. O Aspose.Slides fornece a propriedade [**setAspectRatioLocked**](https://reference.aspose.com/slides/pt/java/com.aspose.slides/GraphicalObjectLock#setAspectRatioLocked-boolean-) para permitir bloquear a configuração de proporção para tabelas e outras formas. 

Este código Java mostra como bloquear a proporção para uma tabela:

```java
Presentation pres = new Presentation("pres.pptx");
try {
    ITable table = (ITable)pres.getSlides().get_Item(0).getShapes().get_Item(0);
    System.out.println("Lock aspect ratio set: " + table.getGraphicalObjectLock().getAspectRatioLocked());

    table.getGraphicalObjectLock().setAspectRatioLocked(!table.getGraphicalObjectLock().getAspectRatioLocked()); // inverter

    System.out.println("Lock aspect ratio set: " + table.getGraphicalObjectLock().getAspectRatioLocked());

    pres.save("pres-out.pptx", SaveFormat.Pptx);
} finally {
    if (pres != null) pres.dispose();
}
```

## **FAQ**

**Posso habilitar a direção de leitura da direita para a esquerda (RTL) para uma tabela inteira e o texto em suas células?**

Sim. A tabela expõe o método [setRightToLeft](https://reference.aspose.com/slides/pt/java/com.aspose.slides/table/#setRightToLeft-boolean-), e os parágrafos têm [ParagraphFormat.setRightToLeft](https://reference.aspose.com/slides/pt/java/com.aspose.slides/paragraphformat/#setRightToLeft-byte-). Usar ambos garante a ordem RTL correta e a renderização dentro das células.

**Como impedir que usuários movam ou redimensionem uma tabela no arquivo final?**

Use [shape locks](/slides/pt/java/applying-protection-to-presentation/) para desabilitar mover, redimensionar, selecionar etc. Esses bloqueios se aplicam às tabelas também.

**É suportado inserir uma imagem dentro de uma célula como plano de fundo?**

Sim. Você pode definir um [picture fill](https://reference.aspose.com/slides/pt/java/com.aspose.slides/picturefillformat/) para uma célula; a imagem cobrirá a área da célula de acordo com o modo escolhido (esticar ou repetir).