Como Dividir um PDF em Java

This article was translated from English: Does it need improvement?
Translated
View the article in English

Dividir um PDF em Java é simples com o IronPDF, que fornece os métodos copyPage, copyPages e splitBy na classe PdfDocument para extrair páginas individuais, obter intervalos de páginas ou dividir um documento em um limite. Cada método retorna um novo PdfDocument que você salva independentemente do original.

Quickstart: Dividir um PDF em Java

  1. Instalar o IronPDF for Java via Maven ou Gradle
  2. Defina sua chave de licença com License.setLicenseKey()
  3. Carregue o PDF com PdfDocument.fromFile()
  4. Use copyPage() para extrair uma única página.
  5. Salve o resultado com saveAs()

```java :title=Início Rápido //:path=/static-assets/ironpdf-java/content-code-examples/how-to/java-split-pdf-tutorial/quickstart.java import java.io.IOException; import java.nio.file.Path; import IronPDF; import IronPDF;

public class Main { public static void main(String[] args) throws IOException { // Defina a chave de licença antes de chamar qualquer método do IronPDF License.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01");

    // Carregue o PDF de origem do disco
    PdfDocument pdf = PdfDocument.fromFile(Path.of("source.pdf"));

// Extraia a primeira página (índice baseado em zero 0) em um novo documento PdfDocument firstPage = pdf.copyPage(0);

// Salve a página extraída como um PDF independente firstPage.saveAs(Path.of("page-one.pdf")); } }


A divisão de PDF é um requisito comum ao produzir documentos programaticamente. Um relatório gerado como um único arquivo pode precisar ser dividido em seções individuais antes da distribuição. Os workflows de arquivamento geralmente exigem armazenar cada capítulo ou fatura como um arquivo separado. Cenários de compartilhamento seletivo, como enviar apenas um intervalo de páginas específico para um cliente, se beneficiam de extrair exatamente as páginas necessárias em vez de enviar o documento inteiro.

O IronPDF lida com todos os três padrões de divisão por meio de uma API consistente na classe `PdfDocument`. A mesma classe usada para gerar PDFs a partir de HTML ou carregar arquivos existentes expõe os métodos de extração de página, de modo que a divisão se integra naturalmente a qualquer fluxo de trabalho do IronPDF existente. Para configuração e dependências, consulte a [Visão Geral de Introdução](https://ironpdf.com/java/docs/).

Todos os índices de página no IronPDF são baseados em zero. Se o seu documento de origem tiver dez páginas, os índices válidos vão de 0 a 9. Isso se aplica a `copyPage`, aos dois limites de `copyPages` e ao argumento de limite de `splitBy`. Passar um índice fora do intervalo lançará uma exceção em tempo de execução, portanto, valide a contagem de páginas em relação a `pdf.getPageCount()` ao trabalhar com documentos de comprimento variável.

<div class="hsg-featured-snippet">
    <h2>Como Dividir um PDF em Java</h2>
    <ol>
        <li><a href="https://ironpdf.com/java/#download-modal">Instale a biblioteca Java para dividir PDFs</a></li>
        <li>Use a classe <strong>PdfDocument</strong> para carregar o PDF de origem</li>
        <li>Use <code>copyPage</code> para extrair uma única página em um novo documento</li>
        <li>Use <code>copyPages</code> para extrair um intervalo de páginas</li>
        <li>Use <code>splitBy</code> para dividir o PDF em um limite de página específico</li>
        <li>Salve cada documento resultante com <code>saveAs</code></li>
    </ol>
</div>

## O que preciso antes de começar?

Antes de dividir PDFs, confirme que o IronPDF foi adicionado ao seu projeto Java como uma dependência do Maven ou Gradle. A biblioteca requer Java 8 ou superior. Adicione o artefato IronPDF do Maven Central ao seu arquivo de build:

```xml
<dependency>
    <groupId>com.ironsoftware</groupId>
    <artifactId>ironpdf</artifactId>
    <version>2024.9.1</version>
</dependency>

Para projetos Gradle, adicione a linha equivalente implementation ao seu build.gradle. Instruções completas de dependência e configuração estão disponíveis na Visão Geral de Introdução.

Uma chave de licença válida é necessária. Defina-a ao iniciar o aplicativo antes de chamar qualquer método IronPDF:

License.setLicenseKey("IRONPDF-MYLICENSE-KEY-1EF01");
License.setLicenseKey("IRONPDF-MYLICENSE-KEY-1EF01");
JAVA

Para opções de licenciamento e chaves de teste, visite o guia de chaves de licença.

PontasTodos os índices de página no IronPDF usam numeração baseada em zero. A página 1 do seu documento é o índice 0, a página 2 é o índice 1, e assim por diante.

Como Extraio uma Página Única de um PDF?

O método copyPage(int pageIndex) extrai uma página de um PdfDocument e a retorna como um novo PdfDocument independente. O documento original não é modificado. O argumento pageIndex começa em zero: passe 0 para a primeira página, 1 para a segunda e assim por diante.

Este método é apropriado quando seu workflow requer isolar uma página específica, como extrair uma página de capa, uma página de assinatura assinada ou uma única fatura de um documento gerado em lote.

//:path=/static-assets/ironpdf-java/content-code-examples/how-to/java-split-pdf-tutorial/copy-single-page.java
import java.io.IOException;
import java.nio.file.Path;
import IronPDF;
import IronPDF;

public class Main {
    public static void main(String[] args) throws IOException {
        // Defina a chave de licença antes de chamar qualquer método do IronPDF
        License.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01");

        // Carregue o PDF de origem do disco
        PdfDocument pdf = PdfDocument.fromFile(Path.of(&quot;source.pdf&quot;));

        // Extract the third page (zero-based index 2) into a new document
        PdfDocument thirdPage = pdf.copyPage(2);

// Salve a página extraída como um PDF independente
        thirdPage.saveAs(Path.of("third-page.pdf"));
    }
}
//:path=/static-assets/ironpdf-java/content-code-examples/how-to/java-split-pdf-tutorial/copy-single-page.java
import java.io.IOException;
import java.nio.file.Path;
import IronPDF;
import IronPDF;

public class Main {
    public static void main(String[] args) throws IOException {
        // Defina a chave de licença antes de chamar qualquer método do IronPDF
        License.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01");

        // Carregue o PDF de origem do disco
        PdfDocument pdf = PdfDocument.fromFile(Path.of(&quot;source.pdf&quot;));

        // Extract the third page (zero-based index 2) into a new document
        PdfDocument thirdPage = pdf.copyPage(2);

// Salve a página extraída como um PDF independente
        thirdPage.saveAs(Path.of("third-page.pdf"));
    }
}
JAVA

O código retornado PdfDocument é totalmente independente da fonte. Você pode aplicar transformações adicionais, adicionar anotações ou mesclá-lo com outros documentos antes de salvar.

Como Extraio um Intervalo de Páginas de um PDF?

O método copyPages(int fromIndex, int toIndex) extrai um intervalo contíguo de páginas e as retorna como um novo PdfDocument. Tanto fromIndex quanto toIndex são baseados em zero e inclusivos: ao passar copyPages(1, 4) em um documento de dez páginas, são extraídas as páginas 2, 3, 4 e 5 (índices de 1 a 4).

A extração do intervalo de páginas se adapta a cenários como puxar um capítulo de um relatório de vários capítulos, extrair um anexo multipágina ou isolar um conjunto de slides de uma apresentação exportada como PDF.

//:path=/static-assets/ironpdf-java/content-code-examples/how-to/java-split-pdf-tutorial/copy-page-range.java
import java.io.IOException;
import java.nio.file.Path;
import IronPDF;
import IronPDF;

public class Main {
    public static void main(String[] args) throws IOException {
        // Defina a chave de licença antes de chamar qualquer método do IronPDF
        License.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01");

        // Load a multi-page source PDF
        PdfDocument pdf = PdfDocument.fromFile(Path.of("multi-page-report.pdf"));

        // Extract pages 2 through 5 (zero-based indexes 1 through 4, inclusive)
        PdfDocument chapter = pdf.copyPages(1, 4);

        // Save the extracted page range as a standalone document
        chapter.saveAs(Path.of("chapter-pages-2-to-5.pdf"));
    }
}
//:path=/static-assets/ironpdf-java/content-code-examples/how-to/java-split-pdf-tutorial/copy-page-range.java
import java.io.IOException;
import java.nio.file.Path;
import IronPDF;
import IronPDF;

public class Main {
    public static void main(String[] args) throws IOException {
        // Defina a chave de licença antes de chamar qualquer método do IronPDF
        License.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01");

        // Load a multi-page source PDF
        PdfDocument pdf = PdfDocument.fromFile(Path.of("multi-page-report.pdf"));

        // Extract pages 2 through 5 (zero-based indexes 1 through 4, inclusive)
        PdfDocument chapter = pdf.copyPages(1, 4);

        // Save the extracted page range as a standalone document
        chapter.saveAs(Path.of("chapter-pages-2-to-5.pdf"));
    }
}
JAVA

Se o documento de origem tiver menos páginas do que o solicitado toIndex, o IronPDF lançará uma exceção. Verifique pdf.getPageCount() antes de chamar copyPages ao trabalhar com documentos cujo número de páginas pode variar.

Como Divido um PDF em Dois Documentos?

O método splitBy(int splitAfterPageIndex) divide um PDF em um limite e retorna um List<PdfDocument> contendo exatamente dois elementos. O primeiro elemento contém páginas do índice 0 até splitAfterPageIndex (inclusive). O segundo elemento contém todas as páginas restantes de splitAfterPageIndex + 1 até o final do documento.

Por exemplo, chamar splitBy(2) em um documento de dez páginas produz o seguinte resultado:

  • parts.get(0): páginas 0, 1, 2 (as três primeiras páginas)
  • parts.get(1): páginas 3 a 9 (as sete páginas restantes)

Este método é adequado para dividir um documento em um limite conhecido: separar uma folha de rosto do corpo, dividir um documento em uma quebra de seção ou cortar um arquivo em lote em duas metades para processamento paralelo.

//:path=/static-assets/ironpdf-java/content-code-examples/how-to/java-split-pdf-tutorial/split-by-boundary.java
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import IronPDF;
import IronPDF;

public class Main {
    public static void main(String[] args) throws IOException {
        // Defina a chave de licença antes de chamar qualquer método do IronPDF
        License.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01");

        // Carregue o PDF de origem do disco
        PdfDocument pdf = PdfDocument.fromFile(Path.of(&quot;source.pdf&quot;));

        // Split after page index 2 -- first part: pages 0-2, second part: pages 3 to end
        List<PdfDocument> parts = pdf.splitBy(2);

        // Save the first part (pages 0 through 2)
        parts.get(0).saveAs(Path.of("part-one.pdf"));

        // Save the second part (pages 3 through end)
        parts.get(1).saveAs(Path.of("part-two.pdf"));
    }
}
//:path=/static-assets/ironpdf-java/content-code-examples/how-to/java-split-pdf-tutorial/split-by-boundary.java
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import IronPDF;
import IronPDF;

public class Main {
    public static void main(String[] args) throws IOException {
        // Defina a chave de licença antes de chamar qualquer método do IronPDF
        License.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01");

        // Carregue o PDF de origem do disco
        PdfDocument pdf = PdfDocument.fromFile(Path.of(&quot;source.pdf&quot;));

        // Split after page index 2 -- first part: pages 0-2, second part: pages 3 to end
        List<PdfDocument> parts = pdf.splitBy(2);

        // Save the first part (pages 0 through 2)
        parts.get(0).saveAs(Path.of("part-one.pdf"));

        // Save the second part (pages 3 through end)
        parts.get(1).saveAs(Path.of("part-two.pdf"));
    }
}
JAVA

ObservesplitBy sempre retorna uma lista com exatamente dois elementos. Se splitAfterPageIndex for igual ao índice da última página do documento, o segundo elemento será um documento vazio. Valide o limite de divisão em relação a pdf.getPageCount() - 1 quando o ponto de divisão for calculado dinamicamente.

Quais são os próximos passos para dividir PDFs em Java?

Os métodos copyPage, copyPages e splitBy do IronPDF abrangem toda a gama de requisitos de divisão de PDF em Java, desde a extração de páginas individuais até a divisão baseada em intervalos e a divisão baseada em limites. Cada método retorna um PdfDocument independente, pronto para manipulação posterior ou salvamento imediato.

Para continuar trabalhando com documentos PDF em Java, explore estes recursos relacionados:

Inicie seu teste gratuito para adicionar divisão de PDF ao seu fluxo de trabalho Java. Para adquirir uma licença para uso em produção, veja as opções de licenciamento.

Perguntas frequentes

Como divido um PDF em Java com IronPDF?

Carregue seu PDF com PdfDocument.fromFile(), então chame copyPage(index) para extrair uma página única, copyPages(from, to) para extrair um intervalo, ou splitBy(index) para dividir o documento em duas partes. Salve cada resultado com saveAs().

Qual é a diferença entre copyPage, copyPages e splitBy?

copyPage(index) extrai uma única página por índice baseado em zero. copyPages(fromIndex, toIndex) extrai um intervalo contíguo onde ambos os limites são inclusivos. splitBy(index) divide o documento em um limite e retorna uma List com dois elementos: páginas 0 até o índice de limite, e todas as páginas restantes.

Os índices de página no IronPDF são baseados em zero ou em um?

Os índices de página no IronPDF são baseados em zero. A primeira página de um documento é o índice 0, a segunda é o índice 1 e assim por diante. Isso se aplica a copyPage, copyPages e splitBy.

O que splitBy retorna?

splitBy(splitAfterPageIndex) retorna uma List com exatamente dois elementos. O primeiro elemento contém páginas 0 até o índice de divisão (inclusivo). O segundo elemento contém todas as páginas restantes. Se o índice de divisão for a última página, o segundo elemento será um documento vazio.

Quais são os pré-requisitos para dividir PDFs em Java com IronPDF?

Você precisa do Java 8 ou superior, da biblioteca IronPDF adicionada como uma dependência Maven ou Gradle, e uma chave de licença válida configurada com License.setLicenseKey() antes de qualquer chamada ao IronPDF.

Como extraio as páginas de 2 a 5 de um PDF em Java?

Use pdf.copyPages(1, 4) para extrair as páginas de 2 a 5. O IronPDF usa índices baseados em zero, então a página 2 é o índice 1 e a página 5 é o índice 4. Ambos os limites são inclusivos. Salve o resultado com saveAs().

Curtis Chau
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais
Pronto para começar?
Versão: 2026.5 just released
Still Scrolling Icon

Ainda está rolando a tela?

Quer provas rápidas?
executar um exemplo Veja seu HTML se transformar em um PDF.