Dividir archivos PDF en Java

Aspose.PDF for Java soporta varios patrones de división más allá de la salida de una página por archivo.

Dividir un PDF en archivos de una sola página

Utilice este enfoque cuando cada página de origen deba convertirse en un documento de salida separado.

Abra el PDF de origen Document.
Cree un nuevo PDF Document para cada Page quiere exportar.
Agregue lo seleccionado Page al nuevo documento.
Guarde cada PDF de salida Document.

public static void splitDocuments(Path inputFile, Path outputDir) {
    try (Document document = new Document(inputFile.toString())) {
        for (int pageNumber = 1; pageNumber <= document.getPages().size(); pageNumber++) {
            try (Document newDocument = new Document()) {
                newDocument.getPages().add(document.getPages().get_Item(pageNumber));
                newDocument.save(outputDir.resolve("Page_" + pageNumber + ".pdf").toString());
            }
        }
    }
}

Dividir un PDF en dos partes

Este ejemplo divide el documento de origen en dos archivos de salida secuenciales basados en el punto medio.

Abra el PDF de origen Document.
Calcule el punto medio de la colección Page disponible.
Copie la primera mitad de las páginas en un documento de salida y las páginas restantes en otro.
Guarde ambos documentos resultantes.

public static void splitDocumentsIntoTwoParts(Path inputFile, Path outputDir) {
    try (Document document = new Document(inputFile.toString())) {
        int totalPages = document.getPages().size();
        int midPoint = totalPages / 2;

        try (Document firstDocument = new Document()) {
            for (int pageNumber = 1; pageNumber <= midPoint; pageNumber++) {
                firstDocument.getPages().add(document.getPages().get_Item(pageNumber));
            }
            firstDocument.save(outputDir.resolve("Part_1.pdf").toString());
        }

        try (Document secondDocument = new Document()) {
            for (int pageNumber = midPoint + 1; pageNumber <= totalPages; pageNumber++) {
                secondDocument.getPages().add(document.getPages().get_Item(pageNumber));
            }
            secondDocument.save(outputDir.resolve("Part_2.pdf").toString());
        }
    }
}

Dividir un PDF en grupos de páginas de tamaño fijo

Utilice este patrón cuando cada archivo de salida debe contener el mismo número de páginas, excepto posiblemente la última parte.

Abra el PDF de origen Document.
Recorra la colección Page en grupos de pagesPerPart.
Cree un nuevo documento de salida para cada grupo y copie el rango de páginas calculado en él.
Guarde cada parte con un nombre de archivo generado.

public static void splitDocumentsEveryNPages(Path inputFile, Path outputDir, int pagesPerPart) {
    try (Document document = new Document(inputFile.toString())) {
        int totalPages = document.getPages().size();
        int partIndex = 1;

        for (int startPage = 1; startPage <= totalPages; startPage += pagesPerPart) {
            int endPage = Math.min(startPage + pagesPerPart - 1, totalPages);
            try (Document partDocument = new Document()) {
                for (int pageNumber = startPage; pageNumber <= endPage; pageNumber++) {
                    partDocument.getPages().add(document.getPages().get_Item(pageNumber));
                }
                partDocument.save(outputDir.resolve("Every_" + pagesPerPart + "_Part_" + partIndex + ".pdf").toString());
            }
            partIndex++;
        }
    }
}

Dividir un PDF por rangos de páginas personalizados

Este ejemplo le permite definir páginas de inicio y fin explícitas para cada documento de salida.

Abra el PDF de origen Document.
Defina lo requerido Page rangos en una matriz o en otra colección.
Valide cada rango contra el recuento de páginas de origen y copie las páginas coincidentes en un nuevo documento.
Guarde cada archivo de salida basado en rangos.

public static void splitDocumentsByPageRanges(Path inputFile, Path outputDir) {
    try (Document document = new Document(inputFile.toString())) {
        int totalPages = document.getPages().size();
        Integer[][] ranges = {{1, 3}, {4, 6}, {7, null}};

        for (int index = 0; index < ranges.length; index++) {
            int startPage = ranges[index][0];
            Integer endPage = ranges[index][1];
            if (startPage > totalPages) {
                continue;
            }

            int effectiveEnd = endPage == null ? totalPages : Math.min(endPage, totalPages);
            if (startPage > effectiveEnd) {
                continue;
            }

            try (Document rangeDocument = new Document()) {
                for (int pageNumber = startPage; pageNumber <= effectiveEnd; pageNumber++) {
                    rangeDocument.getPages().add(document.getPages().get_Item(pageNumber));
                }
                rangeDocument.save(outputDir.resolve(
                        "Range_" + (index + 1) + "_" + startPage + "_to_" + effectiveEnd + ".pdf").toString());
            }
        }
    }
}

Dividir la primera página y las páginas restantes

Utilice este enfoque cuando la página de portada deba exportarse por separado del resto del documento.

Abra el PDF de origen Document y confirme que contiene páginas.
Cree un documento de salida para el primero Page.
Cree otro documento para el rango de páginas restante cuando haya más de una página disponible.
Guarde ambos resultados.

public static void splitDocumentsFirstPageAndRest(Path inputFile, Path outputDir) {
    try (Document document = new Document(inputFile.toString())) {
        int totalPages = document.getPages().size();
        if (totalPages == 0) {
            return;
        }

        try (Document firstPageDocument = new Document()) {
            firstPageDocument.getPages().add(document.getPages().get_Item(1));
            firstPageDocument.save(outputDir.resolve("First_Page.pdf").toString());
        }

        if (totalPages == 1) {
            return;
        }

        try (Document remainingPagesDocument = new Document()) {
            for (int pageNumber = 2; pageNumber <= totalPages; pageNumber++) {
                remainingPagesDocument.getPages().add(document.getPages().get_Item(pageNumber));
            }
            remainingPagesDocument.save(outputDir.resolve("Remaining_Pages.pdf").toString());
        }
    }
}

Dividir la última página y las páginas anteriores

Este ejemplo separa la última página del resto del documento, lo que es útil para extraer páginas de resumen o de firma.

Abra el PDF de origen Document y verifique que no esté vacío.
Copie el último Page en un nuevo documento de salida.
Elimine esa página del documento original cuando aún quedan páginas anteriores.
Guarde la última página y las páginas restantes como archivos separados.

public static void splitDocumentsLastPageAndRest(Path inputFile, Path outputDir) {
    try (Document document = new Document(inputFile.toString())) {
        int totalPages = document.getPages().size();
        if (totalPages == 0) {
            return;
        }

        try (Document lastPageDocument = new Document()) {
            lastPageDocument.getPages().add(document.getPages().get_Item(totalPages));
            lastPageDocument.save(outputDir.resolve("Last_Page.pdf").toString());
        }

        if (totalPages == 1) {
            return;
        }

        document.getPages().delete(totalPages);
        document.save(outputDir.resolve("Previous_Pages.pdf").toString());
    }
}

Dividir un PDF en tres partes

Utilice este patrón cuando el documento debe dividirse en tres secciones consecutivas de tamaño aproximadamente igual.

Abra el PDF de origen Document y determine el número total de páginas.
Calcule el tamaño aproximado de cada parte de salida.
Cree hasta tres documentos y copie lo correspondiente Page rangos.
Guarde cada parte generada.

public static void splitDocumentsIntoThreeParts(Path inputFile, Path outputDir) {
    try (Document document = new Document(inputFile.toString())) {
        int totalPages = document.getPages().size();
        if (totalPages == 0) {
            return;
        }

        int partSize = Math.max(1, (totalPages + 2) / 3);
        for (int partIndex = 0; partIndex < 3; partIndex++) {
            int startPage = partIndex * partSize + 1;
            int endPage = Math.min((partIndex + 1) * partSize, totalPages);
            if (startPage > totalPages) {
                break;
            }

            try (Document partDocument = new Document()) {
                for (int pageNumber = startPage; pageNumber <= endPage; pageNumber++) {
                    partDocument.getPages().add(document.getPages().get_Item(pageNumber));
                }
                partDocument.save(outputDir.resolve("Three_Parts_" + (partIndex + 1) + ".pdf").toString());
            }
        }
    }
}

Dividir un PDF en grupos de páginas personalizados

Este ejemplo muestra cómo crear archivos de salida a partir de conjuntos de páginas no secuenciales en lugar de rangos continuos.

Abra el PDF de origen Document.
Defina grupos personalizados de Page números.
Cree un nuevo documento de salida para cada grupo y añada solo las páginas válidas de ese grupo.
Guarde cada documento de grupo que no esté vacío.

public static void splitDocumentsCustomPageGroups(Path inputFile, Path outputDir) {
    try (Document document = new Document(inputFile.toString())) {
        int totalPages = document.getPages().size();
        List<List<Integer>> groups = List.of(
                List.of(1, 2, 5),
                List.of(3, 4, 6, 7));

        int groupIndex = 1;
        for (List<Integer> group : groups) {
            try (Document groupDocument = new Document()) {
                for (Integer pageNumber : group) {
                    if (pageNumber >= 1 && pageNumber <= totalPages) {
                        groupDocument.getPages().add(document.getPages().get_Item(pageNumber));
                    }
                }
                if (groupDocument.getPages().size() > 0) {
                    groupDocument.save(outputDir.resolve("Custom_Group_" + groupIndex + ".pdf").toString());
                }
            }
            groupIndex++;
        }
    }
}

Dividir un PDF en páginas individuales con nombres de archivo estables

Utilice esta versión cuando los nombres de salida deban permanecer ordenables léxicamente, por ejemplo en canalizaciones automatizadas.

Abra el PDF de origen Document.
Cree un documento de salida para cada Page.
Guarde cada archivo con un número de página rellenado con ceros.

public static void splitDocumentsWithStableFilenames(Path inputFile, Path outputDir) {
    try (Document document = new Document(inputFile.toString())) {
        for (int pageNumber = 1; pageNumber <= document.getPages().size(); pageNumber++) {
            try (Document newDocument = new Document()) {
                newDocument.getPages().add(document.getPages().get_Item(pageNumber));
                newDocument.save(outputDir.resolve(String.format("Page_%03d.pdf", pageNumber)).toString());
            }
        }
    }
}

Dividir un PDF en páginas impares y pares

Este ejemplo crea dos salidas separando las páginas según la paridad de su número de página.

Abra el PDF de origen Document.
Cree un documento de salida para impares Page números y otro para los números de página pares.
Itere a través de las páginas de origen con el incremento requerido para cada documento de salida.
Guarde los resultados de páginas impares y pares por separado.

public static void splitDocumentsOddEvenPages(Path inputFile, Path outputDir) {
    try (Document document = new Document(inputFile.toString())) {
        int totalPages = document.getPages().size();

        try (Document oddDocument = new Document()) {
            for (int pageNumber = 1; pageNumber <= totalPages; pageNumber += 2) {
                oddDocument.getPages().add(document.getPages().get_Item(pageNumber));
            }
            oddDocument.save(outputDir.resolve("Odd_Pages.pdf").toString());
        }

        try (Document evenDocument = new Document()) {
            for (int pageNumber = 2; pageNumber <= totalPages; pageNumber += 2) {
                evenDocument.getPages().add(document.getPages().get_Item(pageNumber));
            }
            evenDocument.save(outputDir.resolve("Even_Pages.pdf").toString());
        }
    }
}

Combinar archivos PDF en Java