Como Dividir um PDF em Java
Dividir um PDF em Java é direto com o IronPDF, que fornece métodos copyPage, copyPages e splitBy na classe PdfDocument para extrair páginas individuais, puxar 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
- Instalar o IronPDF for Java via Maven ou Gradle
- Defina sua chave de licença com
License.setLicenseKey() - Carregue o PDF com
PdfDocument.fromFile() - Use
copyPage()para extrair uma única página - Salve o resultado com
saveAs()
:title=Quickstart
//: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 com.ironsoftware.ironpdf.License;
import com.ironsoftware.ironpdf.PdfDocument;
public class Main {
public static void main(String[] args) throws IOException {
// Set the license key before calling any IronPDF methods
License.setLicenseKey("IRONPDF-MYLICENSE-KEY-1EF01");
// Load the source PDF from disk
PdfDocument pdf = PdfDocument.fromFile(Path.of("source.pdf"));
// Extract the first page (zero-based index 0) into a new document
PdfDocument firstPage = pdf.copyPage(0);
// Save the extracted page as a standalone PDF
firstPage.saveAs(Path.of("page-one.pdf"));
}
}
:title=Quickstart
//: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 com.ironsoftware.ironpdf.License;
import com.ironsoftware.ironpdf.PdfDocument;
public class Main {
public static void main(String[] args) throws IOException {
// Set the license key before calling any IronPDF methods
License.setLicenseKey("IRONPDF-MYLICENSE-KEY-1EF01");
// Load the source PDF from disk
PdfDocument pdf = PdfDocument.fromFile(Path.of("source.pdf"));
// Extract the first page (zero-based index 0) into a new document
PdfDocument firstPage = pdf.copyPage(0);
// Save the extracted page as a standalone PDF
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.
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.
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 variam de 0 a 9. Isso se aplica a copyPage, ambos os limites de copyPages e o argumento limite de splitBy. Passar um índice fora do intervalo lançará uma exceção em tempo de execução, portanto valide contagens de páginas contra pdf.getPageCount() ao trabalhar com documentos de comprimento variável.
Como Dividir um PDF em Java
- Instale a biblioteca Java para dividir PDFs
- Use a classe PdfDocument para carregar o PDF de origem
- Use
copyPagepara extrair uma única página em um novo documento - Use
copyPagespara extrair um intervalo de páginas - Use
splitBypara dividir o PDF em um limite de página específico - Salve cada documento resultante com
saveAs
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:
<dependency>
<groupId>com.ironsoftware</groupId>
<artifactId>ironpdf</artifactId>
<version>2024.9.1</version>
</dependency>
<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");
Para opções de licenciamento e chaves de teste, visite o guia de chaves de licença.
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 é baseado 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 com.ironsoftware.ironpdf.License;
import com.ironsoftware.ironpdf.PdfDocument;
public class Main {
public static void main(String[] args) throws IOException {
// Set the license key before calling any IronPDF methods
License.setLicenseKey("IRONPDF-MYLICENSE-KEY-1EF01");
// Load the source PDF from disk
PdfDocument pdf = PdfDocument.fromFile(Path.of("source.pdf"));
// Extract the third page (zero-based index 2) into a new document
PdfDocument thirdPage = pdf.copyPage(2);
// Save the extracted page as a standalone PDF
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 com.ironsoftware.ironpdf.License;
import com.ironsoftware.ironpdf.PdfDocument;
public class Main {
public static void main(String[] args) throws IOException {
// Set the license key before calling any IronPDF methods
License.setLicenseKey("IRONPDF-MYLICENSE-KEY-1EF01");
// Load the source PDF from disk
PdfDocument pdf = PdfDocument.fromFile(Path.of("source.pdf"));
// Extract the third page (zero-based index 2) into a new document
PdfDocument thirdPage = pdf.copyPage(2);
// Save the extracted page as a standalone PDF
thirdPage.saveAs(Path.of("third-page.pdf"));
}
}
O PdfDocument retornado é totalmente independente da fonte. Você pode aplicar transformações adicionais, adicionar anotações ou mesclá-lo com outros documentos antes de salvar.
O IronSuite desempenha um papel crucial nas nossas operações. Estas são ferramentas que aumentam a eficiência no negócio, incluindo a criação de plantas baixas e melhoria na gestão de inventário.
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: passar copyPages(1, 4) em um documento de dez páginas extrai as páginas 2, 3, 4 e 5 (índices 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 com.ironsoftware.ironpdf.License;
import com.ironsoftware.ironpdf.PdfDocument;
public class Main {
public static void main(String[] args) throws IOException {
// Set the license key before calling any IronPDF methods
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 com.ironsoftware.ironpdf.License;
import com.ironsoftware.ironpdf.PdfDocument;
public class Main {
public static void main(String[] args) throws IOException {
// Set the license key before calling any IronPDF methods
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"));
}
}
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 ao splitAfterPageIndex (inclusivo). O segundo elemento contém todas as páginas restantes do splitAfterPageIndex + 1 até o final do documento.
Por exemplo, chamar splitBy(2) em um documento de dez páginas produz:
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 com.ironsoftware.ironpdf.License;
import com.ironsoftware.ironpdf.PdfDocument;
public class Main {
public static void main(String[] args) throws IOException {
// Set the license key before calling any IronPDF methods
License.setLicenseKey("IRONPDF-MYLICENSE-KEY-1EF01");
// Load the source PDF from disk
PdfDocument pdf = PdfDocument.fromFile(Path.of("source.pdf"));
// 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 com.ironsoftware.ironpdf.License;
import com.ironsoftware.ironpdf.PdfDocument;
public class Main {
public static void main(String[] args) throws IOException {
// Set the license key before calling any IronPDF methods
License.setLicenseKey("IRONPDF-MYLICENSE-KEY-1EF01");
// Load the source PDF from disk
PdfDocument pdf = PdfDocument.fromFile(Path.of("source.pdf"));
// 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"));
}
}
splitBy sempre retorna uma lista com exatamente dois elementos. Se splitAfterPageIndex for igual ao último índice de 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 é calculado dinamicamente.Quais são os próximos passos para dividir PDFs em Java?
Os métodos copyPage, copyPages e splitBy do IronPDF cobrem toda a gama de requisitos de divisão de PDF no Java, desde a extração de uma única página até a divisão baseada em intervalo e divisão baseada em limite. Cada método retorna um PdfDocument independente pronto para manipulação adicional ou salvamento imediato.
Para continuar trabalhando com documentos PDF em Java, explore estes recursos relacionados:
- Mesclar PDFs em Java: combine vários arquivos PDF ou partes extraídas em um único documento
- Excluir Páginas de PDF em Java: remova páginas indesejadas de um PDF existente sem extrair o resto
- Comprimir PDFs em Java: reduza o tamanho do arquivo de documentos divididos antes do armazenamento ou transmissão
- Tutoriais de Java PDF: exemplos adicionais de ponta a ponta para fluxos de trabalho comuns de PDF
- Exemplos de IronPDF for Java: amostras de código para copiar e colar para toda a API Java do IronPDF
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<PdfDocument> 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<PdfDocument> 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().


