Java comparer des fichiers PDF – API master GroupDocs.Comparison
Dans ce guide, vous apprendrez comment java compare pdf files efficacement avec GroupDocs.Comparison pour Java. Que vous construisiez un portail de révision de contrats, un système de contrôle de version ou un vérificateur de papiers académiques, la capacité à détecter le moindre changement dans les documents PDF est essentielle. Nous parcourrons la configuration, la logique principale de comparaison, la génération d’aperçus, la gestion des mots de passe, l’intégration cloud et les meilleures pratiques optimisées pour la performance — afin que vous puissiez déployer une solution fiable en quelques minutes.
Réponses rapides
- Que fait GroupDocs Comparison Java ? Il compare deux documents ou plus, met en évidence chaque modification et peut générer des aperçus visuels pour une révision rapide.
- Quels formats de fichiers sont pris en charge ? Word, PDF, Excel, PowerPoint, images, HTML et bien d’autres.
- Ai‑je besoin d’une licence pour la production ? Oui – une licence GroupDocs valide supprime les filigranes et débloque l’ensemble des fonctionnalités.
- Puis‑je gérer de gros documents ? Oui – avec une gestion correcte de la mémoire et la pagination des aperçus, vous pouvez traiter des PDF de plusieurs centaines de pages.
- Où trouver la dernière dépendance Maven ? Sur le dépôt GroupDocs – vérifiez la version la plus récente avant de l’ajouter.
Qu’est‑ce que java compare pdf files ?
java compare pdf files désigne le processus programmatique de chargement de deux versions PDF, de détection des différences textuelles, de mise en forme et graphiques, et éventuellement de production d’un document résultat qui marque visuellement ces changements. GroupDocs.Comparison implémente cela avec un appel API unique, éliminant le besoin d’une logique de diff manuelle.
Pourquoi utiliser GroupDocs.Comparison dans les projets Java ?
GroupDocs.Comparison offre une détection précise des changements sur plus de 50 formats pris en charge, traite des PDF de jusqu’à 200 pages en moins de 5 secondes sur une JVM standard de 8 Go, et inclut la génération d’aperçus intégrée. Ses artefacts prêts pour Maven facilitent l’intégration, et la bibliothèque s’étend horizontalement lorsque vous suivez les modèles de gestion de mémoire recommandés.
Prérequis : Ce dont vous avez besoin pour commencer
Avant de plonger dans le code, vérifiez que votre environnement répond à ces exigences :
- Java Development Kit : JDK 8 ou plus récent ; JDK 11 ou ultérieur est recommandé pour de meilleures performances de collecte des déchets.
- Outil de construction : Maven ou Gradle pour la résolution des dépendances.
- IDE : IntelliJ IDEA, Eclipse ou VS Code – tout IDE Java moderne fonctionne.
- Connaissances de base en Java : Vous devez être à l’aise avec les classes, les méthodes et les I/O de fichiers.
- Accès réseau : Pour télécharger l’artefact Maven GroupDocs et, si vous utilisez le stockage cloud, accéder à votre point de terminaison de stockage.
Ajout de GroupDocs.Comparison à votre projet
Ajoutez la dépendance suivante à votre pom.xml (remplacez X.Y.Z par la version la plus récente disponible sur le site GroupDocs) :
<dependency>
<groupId>com.groupdocs</groupId>
<artifactId>groupdocs-comparison</artifactId>
<version>X.Y.Z</version>
</dependency>
Astuce : Consultez les notes de version GroupDocs pour les corrections de bugs spécifiques à chaque version et le support de nouveaux formats avant de mettre à jour.
Licence (ne sautez pas cette étape !)
Une licence d’essai vous permet d’évaluer l’API, mais les déploiements en production nécessitent une licence permanente pour supprimer les filigranes et activer l’ensemble des fonctionnalités.
- Essai gratuit : Téléchargez depuis GroupDocs
- Licence temporaire : Obtenez une licence temporaire pour des tests prolongés
- Licence complète : Achetez‑la sur le GroupDocs Store
Configuration initiale : préparer GroupDocs.Comparison
Initialisation de base
La classe Comparer est le point d’entrée pour toutes les opérations de comparaison. Elle orchestre le chargement des documents, le calcul du diff et la génération du résultat.
<repositories>
<repository>
<id>repository.groupdocs.com</id>
<name>GroupDocs Repository</name>
<url>https://releases.groupdocs.com/comparison/java/</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>com.groupdocs</groupId>
<artifactId>groupdocs-comparison</artifactId>
<version>25.2</version>
</dependency>
</dependencies>
Ce que fait le fragment : Il crée une instance de Comparer, applique une licence (si vous en avez une) et prépare le moteur pour les appels de comparaison ultérieurs.
Guide d’implémentation étape par étape
Partie 1 : configuration de la comparaison de documents
Étape 1 : initialiser votre comparateur
L’objet Comparer est le composant central qui exécute l’algorithme de diff. Il conserve la configuration telle que les options de comparaison et les informations de licence.
import com.groupdocs.comparison.Comparer;
import com.groupdocs.comparison.examples.SampleFiles;
// Initialize the comparer with a source document
Comparer comparer = new Comparer(SampleFiles.SOURCE_WORD);
Pourquoi c’est important : Le document source que vous fournissez devient la référence ; chaque modification est mesurée par rapport à celui‑ci.
Étape 2 : ajouter les documents cibles
Vous pouvez comparer la source avec un ou plusieurs fichiers cibles. Dans un scénario de gestion de contrats, la source est l’accord original et la cible est la version révisée par l’équipe juridique.
// Initialize comparer with the source document
Comparer comparer = new Comparer(SampleFiles.SOURCE_WORD);
Partie 2 : génération d’aperçus de pages
Étape 1 : configurer la création du flux de sortie
Le modèle de délégation d’aperçu vous donne le contrôle total sur l’endroit où les images d’aperçu sont stockées — disque local, bucket cloud ou base de données.
// Add a target document for comparison
comparer.add(SampleFiles.TARGET1_WORD);
Étape 2 : configurer les options d’aperçu
Ne générez des aperçus que pour les pages réellement nécessaires ; cela réduit l’utilisation du CPU jusqu’à 60 % pour les gros PDF.
import com.groupdocs.comparison.common.delegates.Delegates;
import java.io.FileOutputStream;
import java.io.OutputStream;
Delegates.CreatePageStream createPageStream = new Delegates.CreatePageStream() {
@Override
public OutputStream invoke(int pageNumber) {
String pagePath = "YOUR_OUTPUT_DIRECTORY" + "/result-GetPagePreviewsForTargetDocument_" + pageNumber + ".png";
try {
return new FileOutputStream(pagePath);
} catch (FileNotFoundException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
};
Étape 3 : générer les aperçus
L’API rend chaque page demandée en PNG (sans perte) ou JPEG (taille réduite). Le PNG est recommandé pour les documents juridiques où la fidélité pixel‑par‑pixel est cruciale.
import com.groupdocs.comparison.options.PreviewOptions;
import com.groupdocs.comparison.options.enums.PreviewFormats;
// Set preview options
PreviewOptions previewOptions = new PreviewOptions.Builder(createPageStream)
.setPreviewFormat(PreviewFormats.PNG) // High-quality images
.setPageNumbers(new int[]{1, 2}) // Only generate what you need
.build();
Formats de fichiers pris en charge
GroupDocs.Comparison fonctionne avec plus de 50 formats d’entrée et de sortie, notamment :
- Microsoft Office : DOCX, DOC, XLSX, XLS, PPTX, PPT
- PDF : Toutes les versions PDF‑1.x, PDF chiffrés et PDF avec polices intégrées
- Texte & balisage : TXT, RTF, HTML, MHTML
- Images : JPEG, PNG, BMP, GIF
- OpenDocument : ODT, ODS, ODP
Ces larges capacités vous permettent de comparer un contrat stocké en fichier Word avec une version PDF scannée, le tout via un seul appel API.
Problèmes courants et solutions
Problème 1 : FileNotFoundException lors de la génération d’aperçu
Si le répertoire de sortie n’existe pas ou que l’application n’a pas les droits d’écriture, le délégué d’aperçu lève cette exception.
// Generate page previews
comparer.getTargets().get(0).generatePreview(previewOptions);
Solution : Vérifiez le chemin, créez les dossiers manquants par programme et accordez les droits d’accès au système de fichiers au processus Java.
Problème 2 : Problèmes de mémoire avec de gros documents
Le traitement d’un PDF de 300 pages peut dépasser le tas par défaut de 512 Mo, entraînant un OutOfMemoryError.
Delegates.CreatePageStream createPageStream = new Delegates.CreatePageStream() {
@Override
public OutputStream invoke(int pageNumber) {
String outputDir = "previews";
File directory = new File(outputDir);
if (!directory.exists()) {
directory.mkdirs(); // Create directory if it doesn't exist
}
String pagePath = outputDir + "/preview_page_" + pageNumber + ".png";
try {
return new FileOutputStream(pagePath);
} catch (FileNotFoundException e) {
System.err.println("Failed to create output file: " + pagePath);
throw new RuntimeException("Cannot create preview file", e);
}
}
};
Solution : Augmentez le tas JVM (-Xmx2g ou plus) et traitez le document par plages de pages plus petites en utilisant la pagination de PreviewOptions.
Problème 3 : Problèmes de licence
Lorsqu’un fichier de licence est absent ou mal formé, l’API ajoute un filigrane à chaque sortie et désactive certaines options avancées.
// Process fewer pages at a time
PreviewOptions previewOptions = new PreviewOptions.Builder(createPageStream)
.setPreviewFormat(PreviewFormats.PNG)
.setPageNumbers(new int[]{1, 2, 3}) // Limit page range
.build();
// Always dispose of the comparer when done
try (Comparer comparer = new Comparer(sourceDocument)) {
comparer.add(targetDocument);
comparer.getTargets().get(0).generatePreview(previewOptions);
} // Automatic cleanup
Solution : Placez le fichier de licence à un emplacement connu et chargez‑le avec License.setLicense("path/to/license.lic") avant tout appel de comparaison.
Conseils de performance et meilleures pratiques (java comparison best practices)
- Limiter la génération d’aperçus – ne demander que les pages nécessaires ; utilisez
pageNumberspour ignorer les sections non pertinentes. - Choisir le bon format d’image – PNG pour les documents juridiques sans perte, JPEG pour les miniatures où la taille compte.
- Implémenter le cache – stocker les résultats de comparaison (par ex. le hachage de source + cible) afin d’éviter le retraitement de fichiers inchangés.
- Gérer la mémoire – encapsuler l’utilisation de
Comparerdans un bloc try‑with‑resources et appelerclose()à la fin. - Libérer les objets comparateur – libérez toujours les ressources natives pour garder l’empreinte JVM faible.
Modèle de code prêt pour la production
Voici le cycle de vie recommandé pour une tâche de comparaison dans un micro‑service.
// Apply license at the start of your application
License license = new License();
license.setLicense("path/to/your/license.lic");
Exemples d’implémentation réels
Exemple 1 : système de gestion de contrats
Un service juridique téléverse le contrat original (source) et la version révisée (cible). Le service renvoie un PDF surligné et un ensemble de PNG d’aperçu de pages pour une inspection visuelle rapide.
public class DocumentComparisonService {
private static final String OUTPUT_DIR = "document-previews/";
public ComparisonResult compareDocuments(String sourcePath, String targetPath) {
try (Comparer comparer = new Comparer(sourcePath)) {
comparer.add(targetPath);
// Perform comparison
String resultPath = OUTPUT_DIR + "comparison-result.docx";
comparer.compare(resultPath);
// Generate previews if needed
generatePreviews(comparer, 3); // First 3 pages only
return new ComparisonResult(resultPath, true);
} catch (Exception e) {
log.error("Document comparison failed", e);
return new ComparisonResult(null, false);
}
}
private void generatePreviews(Comparer comparer, int maxPages) {
// Implementation details...
}
}
Exemple 2 : révision de papiers académiques
Des chercheurs soumettent des manuscrits révisés. Le système compare le nouveau PDF avec la version précédente, signale les citations modifiées et génère des images d’aperçu pour le tableau de bord des réviseurs.
public class ContractVersionManager {
public void reviewContractChanges(String originalContract, String revisedContract) {
try (Comparer comparer = new Comparer(originalContract)) {
comparer.add(revisedContract);
// Generate comparison document
String comparisonResult = "contracts/comparison-" + System.currentTimeMillis() + ".docx";
comparer.compare(comparisonResult);
// Create preview for stakeholder review
generatePreviewsForReview(comparer);
}
}
}
Comment java compare pdf files avec protection par mot de passe
LoadOptions est une classe qui vous permet de spécifier des paramètres de chargement tels que les mots de passe pour les documents chiffrés. Pour comparer un PDF protégé, créez une instance de LoadOptions avec le mot de passe, transmettez‑la au Comparer lors du chargement du document, puis lancez la comparaison comme d’habitude. La bibliothèque déchiffre le fichier en mémoire, garantissant qu’aucun texte en clair n’est écrit sur le disque, et toutes les opérations suivantes – génération d’aperçus et calcul du diff – fonctionnent de façon transparente.
public class AcademicDocumentReview {
public void compareResearchDrafts(String draft1, String draft2) {
try (Comparer comparer = new Comparer(draft1)) {
comparer.add(draft2);
// Focus on specific sections (first 10 pages typically contain main content)
PreviewOptions options = new PreviewOptions.Builder(createPageStream)
.setPageNumbers(IntStream.rangeClosed(1, 10).toArray())
.setPreviewFormat(PreviewFormats.PNG)
.build();
comparer.getTargets().get(0).generatePreview(options);
}
}
}
Comparaison de documents stockés dans le cloud
Si votre source et votre cible résident dans Amazon S3, Azure Blob ou Google Cloud Storage, fournissez simplement un InputStream obtenu via le SDK cloud au lieu d’un chemin de fichier local.
LoadOptions loadOptions = new LoadOptions();
loadOptions.setPassword("your-password");
Comparer comparer = new Comparer("protected-document.docx", loadOptions);
Questions fréquentes
Q : Comment gérer les documents protégés par mot de passe ?
R : Utilisez LoadOptions pour fournir le mot de passe lors de la création de l’instance Comparer, comme illustré ci‑dessus.
Q : Puis‑je comparer des documents stockés dans le cloud ?
R : Oui – il suffit de fournir les flux d’entrée provenant de votre fournisseur cloud au Comparer.
Q : Quelle est la taille maximale de fichier que GroupDocs.Comparison peut gérer ?
R : Il n’y a pas de limite stricte, mais pour des fichiers supérieurs à 100 Mo il est recommandé d’augmenter le tas JVM ou de traiter le document par morceaux afin d’éviter OutOfMemoryError.
Q : Quelle est la précision de l’algorithme de comparaison ?
R : La bibliothèque utilise des algorithmes de diff avancés qui détectent les changements de texte, de mise en forme, d’images, de tableaux et d’objets incorporés, offrant des résultats visuels quasi‑pixel‑par‑pixel.
Q : Puis‑je personnaliser les types de changements détectés ?
R : Absolument. Configurez CompareOptions pour activer ou désactiver la détection de texte, de mise en forme, d’images, de tableaux, etc.
Q : L’API prend‑elle en charge la génération d’aperçus uniquement pour des pages sélectionnées ?
R : Oui – configurez PreviewOptions avec un tableau pageNumbers spécifique pour limiter la sortie aux pages nécessaires.
Conclusion
Vous disposez maintenant d’un guide complet et prêt pour la production afin de java compare pdf files avec GroupDocs.Comparison. En suivant les étapes de configuration, en appliquant les recommandations de performance et en tirant parti des extraits de gestion des mots de passe et d’intégration cloud, vous pouvez intégrer des capacités robustes de comparaison de documents dans n’importe quelle application Java — que ce soit un portail de révision de contrats, un flux de travail de papiers académiques ou un système d’archivage de documents à grande échelle.
Dernière mise à jour : 2026-11-01
Testé avec : GroupDocs.Comparison 25.2
Auteur : GroupDocs
InputStream sourceStream = getDocumentFromCloud("source-doc-id");
InputStream targetStream = getDocumentFromCloud("target-doc-id");
Comparer comparer = new Comparer(sourceStream);
comparer.add(targetStream);
