groupdocs comparison java – Java Word-Dokumentvergleich

Haben Sie schon Stunden damit verbracht, zwei Word‑Dokumente manuell zu vergleichen und jede noch so kleine Änderung zu finden? Sie sind definitiv nicht allein. Egal, ob Sie Vertragsrevisionen verwalten, Inhaltsupdates nachverfolgen oder kollaborative Bearbeitungs‑Workflows abwickeln – das manuelle Vergleichen von Dokumenten ist zeitaufwendig und fehleranfällig.

Mit groupdocs comparison java können Sie diesen mühsamen Vorgang in Sekunden automatisieren. Die Bibliothek erkennt Unterschiede, hebt Einfügungen, Löschungen und Formatierungsänderungen hervor und erzeugt einen professionellen Bericht, den Sie mit Stakeholdern teilen können.

In diesem umfassenden Leitfaden erfahren Sie genau, wie Sie die Dokumenten‑Vergleichsfunktion in Ihren Java‑Anwendungen implementieren – von der Grundkonfiguration bis zu fortgeschrittenen Szenarien – sodass Sie manuelle Prüfungen durch zuverlässige, wiederholbare Automatisierung ersetzen können.

Schnelle Antworten

  • Welche Bibliothek erledigt Word‑Diffs in Java? groupdocs comparison java
  • Kann ich DOCX‑Dateien vergleichen? Ja, nutzen Sie die java compare docx files‑Funktion
  • Benötige ich eine Lizenz für die Produktion? Eine vollständige GroupDocs.Comparison‑Lizenz ist erforderlich
  • Wie schnell ist der Vergleich? Kleine Dokumente fertig in < 1 Sekunde; große Dokumente können einige Sekunden benötigen
  • Ist es kompatibel mit Maven und Gradle? Absolut, beide Build‑Tools werden unterstützt

Was ist groupdocs comparison java?

groupdocs comparison java ist ein Java‑SDK, das zwei oder mehr Dokumente analysiert, textuelle und strukturelle Änderungen erkennt und ein hervorgehobenes Ergebnis‑Dokument erzeugt. Es arbeitet mit Word, PDF, Excel, PowerPoint und vielen anderen Formaten und liefert einen klaren visuellen Diff, den nicht‑technische Prüfer leicht verstehen können.

Warum groupdocs comparison java verwenden?

  • Geschwindigkeit: Automatisiert, was manuell Minuten oder Stunden dauern würde.
  • Genauigkeit: Erkennt selbst die kleinste Zeichenänderung.
  • Skalierbarkeit: Bewältigt die Stapelverarbeitung von Dutzenden Dokumenten.
  • Flexibilität: Funktioniert mit DOCX, PDF und über 50 weiteren Formaten.

Voraussetzungen und Was Sie benötigen

Bevor wir mit der Implementierung beginnen, stellen wir sicher, dass Ihre Entwicklungsumgebung bereit ist. Keine Sorge – die Einrichtung ist unkompliziert, und ich führe Sie durch jeden Schritt.

Essenzielle Anforderungen:

  • Java Development Kit (JDK): Version 8 oder höher (JDK 11+ empfohlen für bessere Performance)
  • Maven oder Gradle: Für das Dependency‑Management (wir verwenden Maven in den Beispielen)
  • Grundkenntnisse in Java: Verständnis von Klassen, Objekten und Dateiverarbeitung
  • GroupDocs.Comparison‑Bibliothek: Version 25.2 (neueste stabile Veröffentlichung)

Empfohlene Einrichtung:

  • IDE wie IntelliJ IDEA oder Eclipse für ein besseres Entwicklungserlebnis
  • Mindestens 2 GB RAM für die Verarbeitung größerer Dokumente verfügbar
  • Beispiel‑Word‑Dokumente zum Testen (wir zeigen, wie Sie Testdateien erstellen)

Schneller Umgebungs‑Check: Führen Sie java -version in Ihrem Terminal aus. Wenn Sie Version 8 oder höher sehen, sind Sie startklar!

Jetzt, wo wir die Grundlagen abgedeckt haben, integrieren wir GroupDocs.Comparison in Ihr Projekt.

GroupDocs.Comparison für Java einrichten

GroupDocs.Comparison in Ihr Projekt zu holen, ist einfacher, als Sie denken. Die Bibliothek ist über Maven verfügbar, sodass keine manuellen JAR‑Downloads oder Klassenpfad‑Probleme nötig sind.

Maven‑Integration leicht gemacht

Fügen Sie diese Konfiguration zu Ihrer pom.xml‑Datei hinzu:

<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>

Warum diese Konfiguration funktioniert:

  • Die Repository‑URL verweist direkt auf das offizielle Maven‑Repository von GroupDocs
  • Version 25.2 ist die neueste stabile Veröffentlichung mit allen aktuellen Bug‑Fixes
  • Die Dependency zieht automatisch alle erforderlichen Unter‑Dependencies nach

Gradle‑Nutzer

Falls Sie Gradle bevorzugen, hier die entsprechende Konfiguration:

repositories {
    maven { url 'https://releases.groupdocs.com/comparison/java/' }
}
dependencies {
    implementation 'com.groupdocs:groupdocs-comparison:25.2'
}

Lizenzoptionen (Wichtig für den Produktionseinsatz)

GroupDocs.Comparison bietet flexible Lizenzierungsmodelle:

  • Kostenlose Testversion: Perfekt für die Evaluierung – beinhaltet die volle Funktionalität mit geringen Einschränkungen
  • Temporäre Lizenz: Ideal für erweiterte Testphasen oder Proof‑of‑Concept‑Entwicklungen
  • Vollständige Lizenz: Für Produktionsanwendungen erforderlich – entfernt alle Beschränkungen

Pro‑Tipp: Beginnen Sie mit der kostenlosen Testversion, um sich mit der API vertraut zu machen. Die Funktionalität ist identisch zur Vollversion, sodass Ihre Entwicklungsarbeit nicht umsonst ist.

Sobald Ihre Dependencies aufgelöst sind und Ihr Projekt erfolgreich gebaut wird, können Sie die Dokumenten‑Vergleichsfunktion implementieren.

Schritt‑für‑Schritt‑Implementierungs‑Leitfaden

Jetzt kommt der spannende Teil – das eigentliche Vergleichen von Dokumenten! Ich führe Sie durch jeden Schritt mit ausführlichen Erklärungen, sodass Sie nicht nur das „Wie“, sondern auch das „Warum“ jeder Entscheidung verstehen.

Schritt 1: Comparer‑Objekt initialisieren

Jeder Dokumentenvergleich beginnt mit der Erstellung eines Comparer‑Objekts. Betrachten Sie dies als das Einrichten Ihres Arbeitsbereichs, bevor Sie mit dem eigentlichen Vergleich starten.

import com.groupdocs.comparison.Comparer;

public class CompareDocuments {
    public static void main(String[] args) throws Exception {
        // Initialize the Comparer with a source document
        try (Comparer comparer = new Comparer("YOUR_DOCUMENT_DIRECTORY/source.docx")) {
            // The rest of our code will go here
        }
    }
}

Was hier passiert:

  • Wir verwenden einen try‑with‑resources‑Block, um eine ordnungsgemäße Ressourcen‑Bereinigung sicherzustellen
  • Das Quell‑Dokument dient als „Baseline“ – alle Änderungen werden relativ zu diesem gemessen
  • Ersetzen Sie "YOUR_DOCUMENT_DIRECTORY" durch den tatsächlichen Pfad zu Ihren Dokumenten

Häufiges Stolper‑Problem: Achten Sie darauf, dass Ihre Dateipfade korrekt sind! Verwenden Sie absolute Pfade, wenn Sie unsicher sind, oder prüfen Sie, dass Ihre relativen Pfade vom Arbeitsverzeichnis Ihrer Anwendung aus stimmen.

Schritt 2: Ziel‑Dokument(e) zum Vergleich hinzufügen

Als Nächstes geben wir an, welches Dokument bzw. welche Dokumente wir mit unserem Quell‑Dokument vergleichen wollen. Hier beginnt die Magie!

// Add a target document for comparison
comparer.add("YOUR_DOCUMENT_DIRECTORY/target1.docx");

Warum dieser Schritt wichtig ist:

  • Das Ziel‑Dokument enthält die Änderungen, die Sie identifizieren möchten
  • Sie können bei Bedarf mehrere Ziel‑Dokumente hinzufügen (ideal für den Vergleich mehrerer Versionen)
  • Die Bibliothek analysiert die Unterschiede zwischen dem Quell‑ und allen Ziel‑Dokumenten

Erweiterte Nutzung: Müssen Sie gegen mehrere Dokumente vergleichen? Kein Problem:

comparer.add("YOUR_DOCUMENT_DIRECTORY/target1.docx");
comparer.add("YOUR_DOCUMENT_DIRECTORY/target2.docx");
// Add as many as needed

Schritt 3: Vergleich ausführen und Ergebnisse erzeugen

Hier findet die eigentliche Schwer­arbeit statt. Die Bibliothek analysiert beide Dokumente und erstellt einen umfassenden Vergleichs‑Report.

// Compare documents and output the result
final Path resultPath = comparer.compare("YOUR_OUTPUT_DIRECTORY/compare_result.docx");

Was Sie erhalten:

  • Ein neues Word‑Dokument, das alle Unterschiede hervorgehoben anzeigt
  • Gelöschter Text wird klar markiert (in der Regel durch Durchstreichen)
  • Hinzugefügter Text wird hervorgehoben (typischerweise in einer anderen Farbe)
  • Modifizierte Abschnitte werden deutlich gekennzeichnet

Das erzeugte Vergleichsdokument ist mehr als ein einfacher Diff – es ist ein professioneller Report, den Sie mit Stakeholdern teilen, in Dokumentationen einbinden oder für Auditzwecke nutzen können.

Vollständiges funktionierendes Beispiel

Hier die komplette Implementierung, die Sie kopieren und ausführen können:

import com.groupdocs.comparison.Comparer;
import java.nio.file.Path;

public class DocumentComparisonDemo {
    public static void main(String[] args) {
        try {
            // Set up your document paths
            String sourceDoc = "path/to/your/source.docx";
            String targetDoc = "path/to/your/target.docx";
            String outputDoc = "path/to/your/output/comparison_result.docx";
            
            // Perform the comparison
            try (Comparer comparer = new Comparer(sourceDoc)) {
                comparer.add(targetDoc);
                Path resultPath = comparer.compare(outputDoc);
                
                System.out.println("Comparison completed successfully!");
                System.out.println("Result saved to: " + resultPath.toString());
            }
            
        } catch (Exception e) {
            System.err.println("Error during comparison: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Fehlersuche bei gängigen Problemen

Problem: FileNotFoundException
Lösung: Überprüfen Sie Ihre Dateipfade und stellen Sie sicher, dass die Dokumente existieren. Nutzen Sie File.exists(), um vor dem Vergleich zu prüfen.

Problem: OutOfMemoryError bei großen Dokumenten
Lösung: Erhöhen Sie den JVM‑Heap‑Speicher mit -Xmx2g oder höher in Ihrer Laufzeitkonfiguration.

Problem: Unerwartete Vergleichsergebnisse
Lösung: Stellen Sie sicher, dass beide Dokumente gültige Word‑Dateien und nicht beschädigt sind. Öffnen Sie sie zuerst in Microsoft Word, um die Integrität zu prüfen.

Jetzt, wo Sie den Basis‑Vergleich zum Laufen gebracht haben, schauen wir uns an, wo diese Funktionalität in realen Anwendungen besonders glänzt.

Praxis‑Anwendungen und Anwendungsfälle

Der Dokumentenvergleich ist nicht nur ein nettes Feature – er verändert viele Geschäftsszenarien grundlegend. Im Folgenden einige praktische Anwendungen, die Stunden manueller Arbeit einsparen.

1. Vertrags‑Management und juristische Prüfung

Die Herausforderung: Anwaltskanzleien und Unternehmen müssen Änderungen über Vertragsrevisionen hinweg nachverfolgen, um sicherzustellen, dass nichts Wichtiges übersehen oder versehentlich geändert wird.

Wie GroupDocs hilft:

  • Automatisches Hervorheben aller Änderungen zwischen Vertragsversionen
  • Erstellung professioneller Reports für die Kunden‑Review
  • Reduktion der juristischen Prüfungszeit um 70‑80 %
  • Ausschluss menschlicher Fehler bei der Änderungserkennung

Implementierungstipp: Erstellen Sie ein Batch‑Verarbeitungssystem, das mehrere Vertragsversionen automatisch vergleicht, sobald neue Entwürfe hochgeladen werden.

2. Content‑Management und Publishing‑Workflows

Das Szenario: Redaktionsteams müssen Inhaltsupdates vor der Veröffentlichung prüfen, um Qualität und Konsistenz zu gewährleisten.

Vorteile:

  • Optimierung des redaktionellen Prüfprozesses
  • Nachverfolgung von Beitrags‑Änderungen in kollaborativen Projekten
  • Aufrechterhaltung von Qualitätsstandards für Inhalte
  • Automatisierung von Vor‑Veröffentlichungs‑Checks

3. Versionskontrolle für nicht‑technische Teams

Das Problem: Nicht jeder nutzt Git oder versteht technische Versionskontrolle, dennoch müssen Dokumenten‑Änderungen nachverfolgt werden.

Die Lösung:

  • Visuelle, leicht verständliche Änderungsverfolgung bereitstellen
  • Nicht‑technischen Stakeholdern die Überprüfung von Modifikationen ermöglichen
  • Audit‑Trails für Compliance‑Anforderungen erzeugen
  • Genehmigungs‑Workflows vereinfachen

4. Qualitätssicherung in der Dokumentation

Anwendungsfall: Technische Schreibteams, die Benutzerhandbücher, API‑Dokumentationen oder Compliance‑Dokumente pflegen.

Mehrwert:

  • Sicherstellung der Genauigkeit bei Dokumenten‑Updates
  • Konsistenz technischer Terminologie wahren
  • Beschleunigung von Review‑Zyklen
  • Reduktion von Dokumentations‑Fehlern

Integrationsmöglichkeiten

Erwägen Sie die Einbindung des Dokumentenvergleichs in:

  • Document Management Systeme: Automatischer Vergleich von Versionen beim Hochladen neuer Dateien
  • Workflow‑Automatisierung: Auslösen von Vergleichs‑Reports als Teil von Genehmigungsprozessen
  • Benachrichtigungs‑Systeme: Stakeholder informieren, wenn signifikante Änderungen erkannt werden
  • Compliance‑Monitoring: Änderungen für regulatorische Berichte nachverfolgen

Die Vielseitigkeit des programmatischen Dokumentenvergleichs eröffnet unzählige Möglichkeiten zur Optimierung von Geschäftsprozessen.

Performance‑Optimierung und Best Practices

In Produktionsumgebungen ist die Performance entscheidend. Hier bewährte Strategien, um sicherzustellen, dass Ihre Implementierung auch bei hoher Last reibungslos läuft.

Speicherverwaltung für große Dokumente

Herausforderung: Große Word‑Dokumente (50+ Seiten) können während des Vergleichs erheblichen Speicher verbrauchen.

Lösungen:

  • JVM‑Tuning: Ausreichend Heap‑Speicher zuweisen, z. B. -Xmx4g oder mehr
  • Streaming‑Verarbeitung: Sehr große Dokumente in Abschnitte aufteilen
  • Garbage Collection: G1‑GC für besseres Speicher‑Management einsetzen

Code‑Beispiel für speicherschonenden Vergleich:

// Configure JVM options for better performance
// -Xmx4g -XX:+UseG1GC -XX:MaxGCPauseMillis=200

try (Comparer comparer = new Comparer(sourceDocument)) {
    comparer.add(targetDocument);
    
    // Process comparison with explicit memory management
    System.gc(); // Suggest garbage collection before intensive operation
    Path result = comparer.compare(outputDocument);
    
    // Clear references to help garbage collection
    comparer = null;
    System.gc();
}

Batch‑Verarbeitungs‑Strategien

Beim Vergleich mehrerer Dokumentpaare:

Sequentielle Verarbeitung (einfach, aber langsamer):

for (DocumentPair pair : documentPairs) {
    try (Comparer comparer = new Comparer(pair.getSource())) {
        comparer.add(pair.getTarget());
        comparer.compare(pair.getOutputPath());
    }
}

Parallele Verarbeitung (schneller, aber speicherintensiver):

documentPairs.parallelStream().forEach(pair -> {
    try (Comparer comparer = new Comparer(pair.getSource())) {
        comparer.add(pair.getTarget());
        comparer.compare(pair.getOutputPath());
    } catch (Exception e) {
        // Handle exceptions appropriately
        logger.error("Comparison failed for: " + pair.getSource(), e);
    }
});

Tipps zur Performance‑Überwachung

Wichtige Kennzahlen:

  • Vergleichszeit pro Dokumentgröße
  • Speicherverbrauchsmuster
  • Erfolgs‑/Fehlerraten
  • Warteschlangen‑Verarbeitungszeiten (bei asynchroner Verarbeitung)

Implementierungs‑Beispiel:

long startTime = System.currentTimeMillis();
long startMemory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();

try (Comparer comparer = new Comparer(sourceDoc)) {
    comparer.add(targetDoc);
    Path result = comparer.compare(outputDoc);
    
    long endTime = System.currentTimeMillis();
    long endMemory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
    
    System.out.println("Comparison completed in: " + (endTime - startTime) + "ms");
    System.out.println("Memory used: " + (endMemory - startMemory) / 1024 / 1024 + "MB");
}

Bibliotheks‑Updates und Wartung

Bleiben Sie aktuell: GroupDocs veröffentlicht regelmäßig Updates mit Performance‑Verbesserungen und Bug‑Fixes. Aktualisieren Sie Ihre Dependency mindestens vierteljährlich:

<!-- Check for updates regularly -->
<dependency>
    <groupId>com.groupdocs</groupId>
    <artifactId>groupdocs-comparison</artifactId>
    <version>25.2</version> <!-- Keep this current -->
</dependency>

Durch die Befolgung dieser Praktiken bleibt Ihr Dokumentenvergleichssystem schnell und zuverlässig, selbst wenn das Nutzungsszenario skaliert.

Erweiterte Konfiguration und Anpassung

Während die Grund‑Vergleichsfunktion sofort einsatzbereit ist, bietet GroupDocs.Comparison leistungsstarke Anpassungsoptionen, mit denen Sie das Verhalten exakt auf Ihre Bedürfnisse zuschneiden können.

Vergleichseinstellungen anpassen

Warum anpassen? Unterschiedliche Anwendungsfälle erfordern unterschiedliche Empfindlichkeiten. Juristische Dokumente benötigen mehr Feingefühl als lockere Inhalts‑Reviews.

Beispiel – Hoch‑sensitiver Vergleich:

import com.groupdocs.comparison.options.CompareOptions;
import com.groupdocs.comparison.options.style.DetalisationLevel;

CompareOptions compareOptions = new CompareOptions();
compareOptions.setDetalisationLevel(DetalisationLevel.High);
compareOptions.setShowDeletedContent(true);
compareOptions.setShowInsertedContent(true);

try (Comparer comparer = new Comparer("source.docx")) {
    comparer.add("target.docx");
    comparer.compare("detailed_result.docx", compareOptions);
}

Optionen für die Ausgabeformatierung

Steuern Sie, wie Unterschiede in Ihrem Ergebnis‑Dokument erscheinen:

  • Farb‑Schemata: Hervorhebungs‑Farben anpassen
  • Änderungs‑Indikatoren: Festlegen, wie Einfügungen und Löschungen markiert werden
  • Zusammenfassungs‑Reports: Statistische Zusammenfassungen der Änderungen einbinden

Best Practices für Fehlerbehandlung

Robustes Fehler‑Handling‑Beispiel:

public class DocumentComparisonService {
    
    public ComparisonResult compareDocuments(String source, String target, String output) {
        try {
            validateInputs(source, target);
            
            try (Comparer comparer = new Comparer(source)) {
                comparer.add(target);
                Path resultPath = comparer.compare(output);
                
                return new ComparisonResult(true, resultPath.toString(), "Success");
            }
            
        } catch (FileNotFoundException e) {
            return new ComparisonResult(false, null, "Document not found: " + e.getMessage());
        } catch (Exception e) {
            return new ComparisonResult(false, null, "Comparison failed: " + e.getMessage());
        }
    }
    
    private void validateInputs(String source, String target) throws IllegalArgumentException {
        if (!new File(source).exists()) {
            throw new IllegalArgumentException("Source document does not exist: " + source);
        }
        if (!new File(target).exists()) {
            throw new IllegalArgumentException("Target document does not exist: " + target);
        }
    }
}

Dieser Ansatz sorgt dafür, dass Ihre Anwendung Fehler elegant verarbeitet und den Benutzern sinnvolles Feedback liefert.

Häufig gestellte Fragen

Kann ich mehr als zwei Dokumente gleichzeitig vergleichen?

Absolut! GroupDocs.Comparison unterstützt mehrere Ziel‑Dokumente gegenüber einem einzigen Quell‑Dokument. Rufen Sie einfach comparer.add() mehrfach auf:

try (Comparer comparer = new Comparer("source.docx")) {
    comparer.add("version1.docx");
    comparer.add("version2.docx");
    comparer.add("version3.docx");
    comparer.compare("multi_comparison_result.docx");
}

Das ist besonders nützlich, um Änderungen über mehrere Versionen hinweg zu verfolgen oder Beiträge verschiedener Teammitglieder zu vergleichen.

Welche Dateiformate unterstützt GroupDocs.Comparison neben Word‑Dokumenten?

GroupDocs.Comparison arbeitet mit über 50 Formaten, darunter:

  • Dokumente: DOCX, DOC, PDF, RTF, TXT
  • Tabellen: XLSX, XLS, CSV
  • Präsentationen: PPTX, PPT
  • Bilder: PNG, JPEG, BMP, TIFF
  • Web: HTML, MHT
  • E‑Mail: EML, MSG

Die API bleibt über alle Formate hinweg konsistent, sodass sich das erlernte Wissen leicht übertragen lässt.

Wie gehe ich mit passwortgeschützten Dokumenten um?

GroupDocs.Comparison kann mit passwortgeschützten Dokumenten arbeiten, indem das Passwort bei der Initialisierung angegeben wird:

LoadOptions loadOptions = new LoadOptions();
loadOptions.setPassword("your_password");

try (Comparer comparer = new Comparer("protected_source.docx", loadOptions)) {
    // Add target document (also protected)
    LoadOptions targetOptions = new LoadOptions();
    targetOptions.setPassword("target_password");
    comparer.add("protected_target.docx", targetOptions);
    
    comparer.compare("comparison_result.docx");
}

Wie wirkt sich die Größe großer Dokumente auf die Performance aus?

Die Performance variiert je nach Dokumentgröße und Komplexität:

  • Kleine Dokumente (< 10 Seiten): Vergleich in unter einer Sekunde
  • Mittlere Dokumente (10‑50 Seiten): typischerweise 2‑10 Sekunden
  • Große Dokumente (50+ Seiten): können 30 Sekunden oder mehr benötigen und zusätzlichen Speicher benötigen

Optimierungstipps:

  • Genügend JVM‑Heap‑Speicher zuweisen (4 GB+ für große Dokumente)
  • SSD‑Speicher für schnellere I/O nutzen
  • Dokumente bei sehr großen Dateien segmentieren

Kann ich das mit Spring Boot oder anderen Java‑Frameworks integrieren?

Definitiv! GroupDocs.Comparison lässt sich nahtlos in jedes Java‑Framework einbinden. Hier ein Spring Boot‑Service‑Beispiel:

@Service
public class DocumentComparisonService {
    
    @Autowired
    private DocumentRepository documentRepository;
    
    public String compareDocuments(Long sourceId, Long targetId) {
        Document source = documentRepository.findById(sourceId).orElseThrow();
        Document target = documentRepository.findById(targetId).orElseThrow();
        
        try (Comparer comparer = new Comparer(source.getFilePath())) {
            comparer.add(target.getFilePath());
            String outputPath = generateOutputPath(sourceId, targetId);
            comparer.compare(outputPath);
            return outputPath;
        } catch (Exception e) {
            throw new DocumentComparisonException("Failed to compare documents", e);
        }
    }
}

Wie passe ich das Aussehen der Vergleichsergebnisse an?

GroupDocs bietet umfangreiche Styling‑Optionen:

CompareOptions options = new CompareOptions();
options.setInsertedItemStyle(new StyleSettings());
options.getInsertedItemStyle().setFontColor(Color.BLUE);
options.getInsertedItemStyle().setHighlightColor(Color.LIGHT_GRAY);

options.setDeletedItemStyle(new StyleSettings());
options.getDeletedItemStyle().setFontColor(Color.RED);
options.getDeletedItemStyle().setStrikethrough(true);

comparer.compare("styled_result.docx", options);

Damit können Sie die Dokumentenstandards Ihrer Organisation einhalten oder thematisierte Vergleichs‑Reports erstellen.

Weitere Ressourcen

Zuletzt aktualisiert: 2026-02-16
Getestet mit: GroupDocs.Comparison 25.2 für Java
Autor: GroupDocs