Comment diviser un PDF en Java
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
- Installez IronPDF for Java via Maven ou Gradle
- Définissez votre clé de licence avec
License.setLicenseKey() - Charger le PDF avec
PdfDocument.fromFile() - Utilisez
copyPage()pour extraire une seule page - É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");
Pour les options de licence et les clés d'essai, visitez le guide des clés de licence.
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"));
}
}
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"));
}
}
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"));
}
}
splitBy 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 :
- Fusionner des PDF en Java : combinez plusieurs fichiers PDF ou parties extraites en un seul document
- Supprimer des pages PDF en Java : retirez des pages indésirables d'un PDF existant sans extraire le reste
- Compresser des PDF en Java : réduisez la taille des fichiers des documents découpés avant le stockage ou la transmission
- Tutoriels Java PDF : exemples supplémentaires de bout en bout pour les flux de travail PDF courants
- Exemples IronPDF for Java : copiez-collez des exemples de code pour l'API Java complète d'IronPDF
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().


