Cómo dividir un PDF en Java

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

Dividir un PDF en Java es sencillo con IronPDF, que proporciona métodos copyPage, copyPages y splitBy en la clase PdfDocument para extraer páginas individuales, extraer rangos de páginas o dividir un documento en un límite. Cada método devuelve un nuevo PdfDocument que guardas independientemente del original.

Inicio rápido: Dividir un PDF en Java

  1. Instale IronPDF for Java a través de Maven o Gradle
  2. Configura tu clave de licencia con License.setLicenseKey()
  3. Carga el PDF con PdfDocument.fromFile()
  4. Usa copyPage() para extraer una sola página
  5. Guarda el resultado con saveAs()

```java :title=Quickstart //:path=/static-assets/ironpdf-java/content-code-examples/how-to/java-split-pdf-tutorial/quickstart.java importar java.io.IOException; import java.nio.file.Path; import com.ironsoftware.ironpdf.License; importar com.ironsoftware.ironpdf IronPDF;

public class Main { public static void main(String[] args) lanza IOException { // Configure la clave de licencia antes de llamar a cualquier método de IronPDF Licencia.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01");

    // Cargue el PDF de origen desde el disco

PdfDocument pdf = PdfDocument.fromFile(Path.of("source.pdf"));

    // Extrae la primera página (índice basado en cero 0) en un nuevo documento
    PdfDocument firstPage = pdf.copyPage(0);

    // Guarda la página extraída como un PDF independiente
    firstPage.saveAs(Path.of("page-one.pdf"));
}

}


La división de PDF es un requisito común al producir documentos de manera programática. Un informe generado como un solo archivo puede necesitar dividirse en secciones individuales antes de la distribución. Los flujos de trabajo de archivo a menudo requieren almacenar cada capítulo o factura como un archivo separado. Escenarios de compartición selectiva, como enviar solo un rango de páginas específico a un cliente, se benefician extrayendo exactamente las páginas necesarias en lugar de enviar el documento completo.

IronPDF maneja los tres patrones de división a través de una API consistente en la clase `PdfDocument`. La misma clase utilizada para generar PDFs desde HTML o cargar archivos existentes expone los métodos de extracción de páginas, por lo que la división se integra naturalmente en cualquier flujo de trabajo IronPDF existente. Para la configuración y la configuración de dependencias, consulta la [Descripción general para comenzar](https://ironpdf.com/java/docs/).

Todos los índices de páginas en IronPDF están basados en cero. Si tu documento fuente tiene diez páginas, los índices válidos van de 0 a 9. Esto se aplica a `copyPage`, ambos límites de `copyPages` y el argumento de límite de `splitBy`. Pasar un índice fuera de rango lanzará una excepción en tiempo de ejecución, por lo que debes validar los conteos de páginas contra `pdf.getPageCount()` al trabajar con documentos de longitud variable.

<div class="hsg-featured-snippet">
    <h2>Cómo dividir un PDF en Java</h2>
    <ol>
        <li><a href="https://ironpdf.com/java/#download-modal">Instala la biblioteca Java para dividir PDFs</a></li>
        <li>Usa la clase <strong>PdfDocument</strong> para cargar el PDF fuente</li>
        <li>Usa <code>copyPage</code> para extraer una sola página en un nuevo documento</li>
        <li>Usa <code>copyPages</code> para extraer un rango de páginas</li>
        <li>Usa <code>splitBy</code> para dividir el PDF en un límite de página específico</li>
        <li>Guarda cada documento resultante con <code>saveAs</code></li>
    </ol>
</div>

## ¿Qué necesito antes de empezar?

Antes de dividir PDFs, confirma que IronPDF está agregado a tu proyecto Java como una dependencia de Maven o Gradle. La biblioteca requiere Java 8 o superior. Agrega el artefacto IronPDF de Maven Central a tu archivo de construcción:

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

Para proyectos Gradle, añade la línea equivalente implementation a tu build.gradle. Las instrucciones completas de dependencia y configuración están disponibles en la Descripción general para comenzar.

Se requiere una clave de licencia válida. Establecerla al inicio de la aplicación antes de llamar a cualquier método de IronPDF:

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

Para opciones de licencia y claves de prueba, visita la guía de claves de licencia.

ConsejosTodos los índices de página en IronPDF utilizan numeración basada en cero. La página 1 de tu documento es el índice 0, la página 2 es el índice 1, y así sucesivamente.

¿Cómo extraigo una sola página de un PDF?

El método copyPage(int pageIndex) extrae una página de un PdfDocument y la devuelve como un nuevo PdfDocument independiente. El documento original no se modifica. El argumento pageIndex es basado en cero: pasa 0 para la primera página, 1 para la segunda, y así sucesivamente.

Este método es apropiado cuando tu flujo de trabajo requiere aislar una página específica, como extraer una portada, una página de firma firmada o una sola factura de un documento generado en lotes.

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

public class Main {
    public static void main(String[] args) lanza IOException {
        // Configure la clave de licencia antes de llamar a cualquier método de IronPDF
        Licencia.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01");

        // Cargue el PDF de origen desde el disco
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);

        // Guarda la página extraída como un PDF independiente
        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
importar java.io.IOException;
import java.nio.file.Path;
import com.ironsoftware.ironpdf.License;
importar com.ironsoftware.ironpdf IronPDF;

public class Main {
    public static void main(String[] args) lanza IOException {
        // Configure la clave de licencia antes de llamar a cualquier método de IronPDF
        Licencia.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01");

        // Cargue el PDF de origen desde el disco
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);

        // Guarda la página extraída como un PDF independiente
        thirdPage.saveAs(Path.of("third-page.pdf"));
    }
}
JAVA

El PdfDocument devuelto es completamente independiente de la fuente. Puedes aplicar más transformaciones, añadir anotaciones o fusionarlo con otros documentos antes de guardarlo.

¿Cómo extraigo un rango de páginas de un PDF?

El método copyPages(int fromIndex, int toIndex) extrae un rango contiguo de páginas y las devuelve como un nuevo PdfDocument. Ambos fromIndex y toIndex son basados en cero e inclusivos: pasar copyPages(1, 4) en un documento de diez páginas extrae las páginas 2, 3, 4 y 5 (índices 1 a 4).

La extracción de rangos de páginas se adecúa a escenarios como extraer un capítulo de un informe con varios capítulos, extraer un apéndice de varias páginas o aislar un conjunto de diapositivas de una presentación exportada como PDF.

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

public class Main {
    public static void main(String[] args) lanza IOException {
        // Configure la clave de licencia antes de llamar a cualquier método de IronPDF
        Licencia.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
importar java.io.IOException;
import java.nio.file.Path;
import com.ironsoftware.ironpdf.License;
importar com.ironsoftware.ironpdf IronPDF;

public class Main {
    public static void main(String[] args) lanza IOException {
        // Configure la clave de licencia antes de llamar a cualquier método de IronPDF
        Licencia.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

Si el documento fuente tiene menos páginas que las solicitadas toIndex, IronPDF lanzará una excepción. Revisa pdf.getPageCount() antes de llamar a copyPages al trabajar con documentos cuyo conteo de páginas puede variar.

¿Cómo divido un PDF en dos documentos?

El método splitBy(int splitAfterPageIndex) divide un PDF en un límite y devuelve un List<PdfDocument> que contiene exactamente dos elementos. El primer elemento contiene páginas desde el índice 0 hasta splitAfterPageIndex (inclusive). El segundo elemento contiene todas las páginas restantes desde splitAfterPageIndex + 1 hasta el final del documento.

Por ejemplo, llamar a splitBy(2) en un documento de diez páginas produce:

  • parts.get(0): páginas 0, 1, 2 (las tres primeras páginas)
  • parts.get(1): páginas 3 a 9 (las siete páginas restantes)

Este método se adapta a dividir un documento en un límite conocido: separar una hoja de portada del cuerpo, dividir un documento en una ruptura de sección o dividir un archivo por lotes en dos mitades para el procesamiento paralelo.

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

public class Main {
    public static void main(String[] args) lanza IOException {
        // Configure la clave de licencia antes de llamar a cualquier método de IronPDF
        Licencia.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01");

        // Cargue el PDF de origen desde el disco
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
importar java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import com.ironsoftware.ironpdf.License;
importar com.ironsoftware.ironpdf IronPDF;

public class Main {
    public static void main(String[] args) lanza IOException {
        // Configure la clave de licencia antes de llamar a cualquier método de IronPDF
        Licencia.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01");

        // Cargue el PDF de origen desde el disco
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"));
    }
}
JAVA

Por favor notasplitBy siempre devuelve una lista con exactamente dos elementos. Si splitAfterPageIndex es igual al índice de la última página del documento, el segundo elemento será un documento vacío. Valida el límite de división contra pdf.getPageCount() - 1 cuando el punto de división se calcula dinámicamente.

¿Cuáles son los siguientes pasos para dividir PDFs en Java?

Los métodos copyPage, copyPages e splitBy de IronPDF cubren toda la gama de requisitos de división de PDF en Java, desde la extracción de una sola página hasta la división basada en rangos y en límites. Cada método devuelve un PdfDocument independiente listo para una mayor manipulación o para guardar inmediatamente.

Para continuar trabajando con documentos PDF en Java, explora estos recursos relacionados:

Comienza tu prueba gratuita para agregar división de PDF a tu flujo de trabajo Java. Para comprar una licencia para uso en producción, ver opciones de licencia.

Preguntas Frecuentes

¿Cómo divido un PDF en Java con IronPDF?

Cargue su PDF con PdfDocument.fromFile(), luego llame a copyPage(index) para extraer una sola página, copyPages(from, to) para extraer un rango, o splitBy(index) para dividir el documento en dos partes. Guarde cada resultado con saveAs().

¿Cuál es la diferencia entre copyPage, copyPages y splitBy?

copyPage(index) extrae una sola página por índice basado en cero. copyPages(fromIndex, toIndex) extrae un rango contiguo donde ambos límites son inclusivos. splitBy(index) divide el documento en un límite y devuelve una List con dos elementos: páginas 0 a través del índice de límite, y todas las páginas restantes.

¿Los índices de página en IronPDF son basados en cero o en uno?

Los índices de página en IronPDF son basados en cero. La primera página de un documento es el índice 0, la segunda es el índice 1, y así sucesivamente. Esto se aplica a copyPage, copyPages y splitBy.

¿Qué devuelve splitBy?

splitBy(splitAfterPageIndex) devuelve una List con exactamente dos elementos. El primer elemento contiene páginas 0 a través del índice de división (inclusivo). El segundo elemento contiene todas las páginas restantes. Si el índice de división es la última página, el segundo elemento será un documento vacío.

¿Cuáles son los requisitos previos para dividir PDFs en Java con IronPDF?

Necesita Java 8 o superior, la biblioteca IronPDF añadida como una dependencia Maven o Gradle, y una clave de licencia válida configurada con License.setLicenseKey() antes de cualquier llamada a IronPDF.

¿Cómo extraigo las páginas 2 a 5 de un PDF en Java?

Use pdf.copyPages(1, 4) para extraer las páginas 2 a 5. IronPDF usa índices basados en cero, por lo que la página 2 es el índice 1 y la página 5 es el índice 4. Ambos límites son inclusivos. Guarde el resultado con saveAs().

Darrius Serrant
Ingeniero de Software Full Stack (WebOps)

Darrius Serrant tiene una licenciatura en Ciencias de la Computación de la Universidad de Miami y trabaja como Ingeniero de Marketing WebOps Full Stack en Iron Software. Atraído por la programación desde joven, vio la computación como algo misterioso y accesible, convirtiéndolo en el ...

Leer más
¿Listo para empezar?
Versión: 2026.5 just released
Still Scrolling Icon

¿Aún desplazándote?

¿Quieres una prueba rápida?
ejecutar una muestra Mira cómo tu HTML se convierte en PDF.