Comment diviser un PDF en Java

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

Fendre un PDF en Java est simple avec IronPDF, qui fournit les méthodes copyPage, copyPages et splitBy de la classe PdfDocument pour extraire des pages individuelles, extraire des plages de pages ou diviser un document à une limite. Chaque méthode renvoie un nouveau PdfDocument que vous économisez indépendamment de l'original.

Démarrage rapide : Diviser un PDF en Java

  1. Installez IronPDF for Java via Maven ou Gradle
  2. Définissez votre clé de licence avec License.setLicenseKey()
  3. Charger le PDF avec PdfDocument.fromFile()
  4. Utilisez copyPage() pour extraire une seule page
  5. Économisez le résultat avec saveAs()

```java :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 { // Définir la clé de licence avant d'appeler toute méthode IronPDF License.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01") ;

    // Charger le PDF source depuis le disque
    PdfDocument pdf = PdfDocument.fromFile(Path.of("source.pdf"));

    // Extraire la première page (index basé sur zéro 0) dans un nouveau document
    PdfDocument firstPage = pdf.copyPage(0);

    // Enregistrer la page extraite en tant que PDF autonome
    firstPage.saveAs(Path.of("page-one.pdf"));
}

}


La division de PDF est une exigence courante lors de la production de documents de manière programmatique. Un rapport généré en tant que fichier unique peut avoir besoin d'être fragmenté en sections individuelles avant la distribution. Les workflows d'archivage nécessitent souvent de stocker chaque chapitre ou facture comme un fichier séparé. Les scénarios de partage sélectif, comme l'envoi d'une plage de pages spécifique à un client, bénéficient de l'extraction exacte des pages requises plutôt que de l'envoi de l'intégralité du document.

IronPDF gère les trois modèles de fractionnement via une API cohérente dans la classe `PdfDocument`. La même classe utilisée pour générer des PDFs à partir de HTML ou charger des fichiers existants expose les méthodes d'extraction de pages, de sorte que la division s'intègre naturellement dans tout workflow IronPDF existant. Pour la configuration et la configuration des dépendances, référez-vous à la [vue d'ensemble de démarrage](https://ironpdf.com/java/docs/).

Tous les index de pages dans IronPDF sont basés sur zéro. Si votre document source comporte dix pages, les index valides vont de 0 à 9. Cela s'applique à `copyPage`, aux deux limites de `copyPages` et à l'argument de limite de `splitBy`. Le passage d'un index hors limites provoquera une exception lors de l'exécution ; veillez donc à valider le nombre de pages par rapport à `pdf.getPageCount()` lorsque vous travaillez avec des documents de longueur variable.

<div class="hsg-featured-snippet">
    <h2>Comment diviser un PDF en Java</h2>
    <ol>
        <li><a href="https://ironpdf.com/java/#download-modal">Installez la bibliothèque Java pour diviser des PDFs</a></li>
        <li>Utilisez la classe <strong>PdfDocument</strong> pour charger le PDF source</li>
        <li>Utilisez <code>copyPage</code> pour extraire une seule page dans un nouveau document</li>
        <li>Utilisez <code>copyPages</code> pour extraire une plage de pages</li>
        <li>Utilisez <code>splitBy</code> pour diviser le PDF à une limite de page spécifique</li>
        <li>Enregistrez chaque document résultant avec <code>saveAs</code></li>
    </ol>
</div>

## De quoi ai-je besoin avant de commencer?

Avant de diviser des PDFs, confirmez qu'IronPDF est ajouté à votre projet Java en tant que dépendance Maven ou Gradle. La bibliothèque nécessite Java 8 ou supérieur. Ajoutez l'artefact IronPDF de Maven Central à votre fichier de compilation :

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

Pour les projets Gradle, ajoutez la ligne équivalente implementation à votre build.gradle. Les instructions complètes de dépendance et de configuration sont disponibles dans la vue d'ensemble de démarrage.

Une clé de licence valide est requise. Réglez-la au démarrage de l'application avant d'appeler toute méthode IronPDF :

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

Pour les options de licence et les clés d'essai, visitez le guide des clés de licence.

ConseilsTous les indices de page dans IronPDF utilisent une numérotation basée sur zéro. Page 1 de votre document est l'indice 0, la page 2 est l'indice 1, et ainsi de suite.

Comment extraire une seule page d'un PDF ?

La méthode copyPage(int pageIndex) extrait une page d'un PdfDocument et la renvoie sous la forme d'un nouveau PdfDocument indépendant. Le document original n'est pas modifié. L'argument pageIndex est indexé à partir de zéro : passez 0 pour la première page, 1 pour la deuxième, et ainsi de suite.

Cette méthode est appropriée lorsque votre flux de travail nécessite d'isoler une page spécifique, telle que l'extraction d'une page de couverture, d'une page de signature signée, ou d'une facture unique d'un document généré par lot.

//: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 {
        // Définir la clé de licence avant d'appeler toute méthode IronPDF
        License.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01") ;

        // Charger le PDF source depuis le disque
        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);

        // Enregistrer la page extraite en tant que PDF autonome
        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 {
        // Définir la clé de licence avant d'appeler toute méthode IronPDF
        License.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01") ;

        // Charger le PDF source depuis le disque
        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);

        // Enregistrer la page extraite en tant que PDF autonome
        thirdPage.saveAs(Path.of("third-page.pdf"));
    }
}
JAVA

Le PdfDocument renvoyé est totalement indépendant de la source. Vous pouvez appliquer d'autres transformations, ajouter des annotations, ou le fusionner avec d'autres documents avant de l'enregistrer.

Comment extraire une plage de pages d'un PDF ?

La méthode copyPages(int fromIndex, int toIndex) extrait une plage contiguë de pages et les renvoie sous la forme d'un nouveau PdfDocument. fromIndex et toIndex sont tous deux indexés à partir de zéro et inclusifs : l'application de copyPages(1, 4) à un document de dix pages extrait les pages 2, 3, 4 et 5 (index 1 à 4).

L'extraction de plages de pages convient aux scénarios tels que l'extraction d'un chapitre d'un rapport à plusieurs chapitres, l'extraction d'une annexe multipage, ou l'isolement d'un ensemble de diapositives à partir d'une présentation exportée en 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 {
        // Définir la clé de licence avant d'appeler toute méthode 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 com.ironsoftware.IronPdf.License;
import com.ironsoftware.ironpdf.PdfDocument ;

public class Main {
public static void main(String[] args) throws IOException {
        // Définir la clé de licence avant d'appeler toute méthode 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

Si le document source comporte moins de pages que le nombre demandé toIndex, IronPDF lèvera une exception. Vérifiez pdf.getPageCount() avant d'appeler copyPages lorsque vous travaillez avec des documents dont le nombre de pages peut varier.

Comment diviser un PDF en deux documents ?

La méthode splitBy(int splitAfterPageIndex) divise un PDF à une limite et renvoie un List<PdfDocument> contenant exactement deux éléments. Le premier élément contient les pages de l'index 0 à splitAfterPageIndex (inclus). Le deuxième élément contient toutes les pages restantes, de splitAfterPageIndex + 1 jusqu'à la fin du document.

Par exemple, l'appel de splitBy(2) sur un document de dix pages produit :

  • parts.get(0) : pages 0, 1, 2 (les trois premières pages)
  • parts.get(1) : pages 3 à 9 (les sept pages restantes)

Cette méthode convient pour diviser un document à une limite connue : séparer une feuille de couverture du corps, diviser un document à une rupture de section, ou couper un fichier de lot en deux moitiés pour un traitement parallèle.

//: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 {
        // Définir la clé de licence avant d'appeler toute méthode IronPDF
        License.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01") ;

        // Charger le PDF source depuis le disque
        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 {
        // Définir la clé de licence avant d'appeler toute méthode IronPDF
        License.setLicenseKey("IronPDF-MYLICENSE-KEY-1EF01") ;

        // Charger le PDF source depuis le disque
        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

Veuillez notersplitBy renvoie toujours une liste contenant exactement deux éléments. Si splitAfterPageIndex correspond à l'index de la dernière page du document, le deuxième élément sera un document vide. Vérifiez la limite de fractionnement par rapport à pdf.getPageCount() - 1 lorsque le point de fractionnement est calculé dynamiquement.

Quelles sont les prochaines étapes pour diviser des PDFs en Java ?

Les méthodes copyPage, copyPages et splitBy d'IronPDF couvrent l'ensemble des besoins en matière de fractionnement de PDF sous Java, de l'extraction d'une seule page au fractionnement par plage en passant par la division par limites. Chaque méthode renvoie un PdfDocument indépendant, prêt à être manipulé ou enregistré immédiatement.

Pour continuer à travailler avec des documents PDF en Java, explorez ces ressources connexes :

Commencez votre essai gratuit pour ajouter le découpage de PDF à votre flux de travail Java. Pour acheter une licence pour une utilisation en production, consultez les options de licence.

Questions Fréquemment Posées

Comment diviser un PDF en Java avec IronPDF?

Chargez votre PDF avec PdfDocument.fromFile(), puis appelez copyPage(index) pour extraire une seule page, copyPages(from, to) pour extraire une plage, ou splitBy(index) pour diviser le document en deux parties. Enregistrez chaque résultat avec saveAs().

Quelle est la différence entre copyPage, copyPages, et splitBy?

copyPage(index) extrait une seule page par index de base zéro. copyPages(fromIndex, toIndex) extrait une plage contiguë où les deux bornes sont inclusives. splitBy(index) divise le document à une limite et renvoie une List avec deux éléments: les pages 0 jusqu'à l'index de limite, et toutes les pages restantes.

Les indexes de pages dans IronPDF sont-ils basés sur zéro ou sur un?

Les indexes de pages dans IronPDF sont basés sur zéro. La première page d'un document est l'index 0, la seconde est l'index 1, et ainsi de suite. Cela s'applique à copyPage, copyPages, et splitBy.

Que renvoie splitBy?

splitBy(splitAfterPageIndex) renvoie une List avec exactement deux éléments. Le premier élément contient les pages 0 jusqu'à l'index de division (inclus). Le deuxième élément contient toutes les pages restantes. Si l'index de division est la dernière page, le deuxième élément sera un document vide.

Quels sont les prérequis pour diviser des PDF en Java avec IronPDF?

Vous avez besoin de Java 8 ou plus, de la bibliothèque IronPDF ajoutée en tant que dépendance Maven ou Gradle, et d'une clé de licence valide définie avec License.setLicenseKey() avant tout appel à IronPDF.

Comment extraire les pages 2 à 5 d'un PDF en Java?

Utilisez pdf.copyPages(1, 4) pour extraire les pages 2 à 5. IronPDF utilise des index de base zéro, donc la page 2 est l'index 1 et la page 5 est l'index 4. Les deux bornes sont incluses. Enregistrez le résultat avec saveAs().

Darrius Serrant
Ingénieur logiciel Full Stack (WebOps)

Darrius Serrant est titulaire d'un baccalauréat en informatique de l'université de Miami et travaille comme ingénieur marketing WebOps Full Stack chez Iron Software. Attiré par le codage dès son plus jeune âge, il a vu l'informatique comme à la fois mystérieuse et accessible, en faisant le ...

Lire la suite
Prêt à commencer?
Version : 2026.5 just released
Still Scrolling Icon

Vous faites encore défiler ?

Vous voulez une preuve rapidement ?
exécuter un échantillon Regardez votre code HTML se transformer en PDF.