σύγκριση εγγράφων σε java – Οδηγός GroupDocs API πλήρης

Εισαγωγή

Έχετε βρεθεί ποτέ να συγκρίνετε χειροκίνητα δύο έγγραφα γραμμή προς γραμμή, μόνο για να χάσετε κρίσιμες διαφορές; Δεν είστε μόνοι. compare documents in java είναι μια κοινή πρόκληση, ειδικά όταν πρέπει να διατηρήσετε τα μεταδεδομένα, να χειριστείτε αρχεία με κωδικό πρόσβασης ή να συγκρίνετε πολλά αρχεία ταυτόχρονα.

Here’s the thing: Οι περισσότεροι προγραμματιστές δυσκολεύονται επειδή είτε δημιουργούν κάτι από το μηδέν (που διαρκεί πολύ) είτε χρησιμοποιούν βασικά εργαλεία diff που αγνοούν τη μορφοποίηση, τα μεταδεδομένα και τις ρυθμίσεις ασφαλείας. Εκεί έρχεται η GroupDocs.Comparison for Java.

Σε αυτό το ολοκληρωμένο tutorial, θα ανακαλύψετε πώς να υλοποιήσετε αξιόπιστη σύγκριση εγγράφων στις Java εφαρμογές σας. Θα καλύψουμε τα πάντα, από τη βασική ρύθμιση μέχρι την προχωρημένη διαχείριση μεταδεδομένων, καθώς και παραδείγματα πραγματικού κόσμου που μπορείτε να χρησιμοποιήσετε στην παραγωγή. Στο τέλος, θα ξέρετε πώς να:

• Ρυθμίσετε το GroupDocs.Comparison στο Java project σας (είναι πιο εύκολο απ’ ό,τι νομίζετε)
• compare documents in java διατηρώντας την ακεραιότητα των μεταδεδομένων
• Διαχειριστείτε σενάρια java compare multiple files και java compare password protected
• Βελτιστοποιήσετε την απόδοση για επεξεργασία μεγάλου όγκου εγγράφων

Έτοιμοι να κάνετε τη σύγκριση εγγράφων παιχνιδάκι στις Java εφαρμογές σας; Ας ξεκινήσουμε!

Γρήγορες Απαντήσεις

• Ποια βιβλιοθήκη μου επιτρέπει να συγκρίνω έγγραφα σε java; GroupDocs.Comparison for Java
• Μπορώ να συγκρίνω πολλά αρχεία ταυτόχρονα; Ναι – προσθέστε όσον περισσότερα έγγραφα-στόχους χρειάζεστε
• Πώς διαχειρίζομαι έγγραφα με κωδικό πρόσβασης; Χρησιμοποιήστε LoadOptions με τον κωδικό του εγγράφου
• Χρειάζομαι άδεια για παραγωγή; Μια έγκυρη άδεια GroupDocs αφαιρεί τα υδατογραφήματα και τους περιορισμούς
• Ποια έκδοση Java απαιτείται; JDK 8+, προτείνεται JDK 11+

Τι είναι compare documents in java;

Η σύγκριση εγγράφων σε Java σημαίνει προγραμματιστική ανίχνευση διαφορών—αλλαγές κειμένου, επεξεργασίες μορφοποίησης ή ενημερώσεις μεταδεδομένων—μεταξύ δύο ή περισσότερων αρχείων, χρησιμοποιώντας μια βιβλιοθήκη που κατανοεί τη δομή του εγγράφου. Το GroupDocs.Comparison αφαιρεί την πολυπλοκότητα, παρέχοντάς σας ένα απλό API για τη δημιουργία ενός diff εγγράφου που επισημαίνει κάθε αλλαγή.

Γιατί να χρησιμοποιήσετε GroupDocs.Comparison for Java;

• Υποστήριξη πλούσιων μορφών – DOCX, PDF, XLSX, PPTX, TXT, και άλλα
• Διαχείριση μεταδεδομένων – επιλέξτε πηγή, στόχο ή χωρίς μεταδεδομένα για το αποτέλεσμα
• Υποστήριξη κωδικού – ανοίξτε προστατευμένα αρχεία χωρίς χειροκίνητη αποκρυπτογράφηση
• Κλιμακούμενη απόδοση – επεξεργασία παρτίδων, ασύγχρονη εκτέλεση και σχεδίαση με αποδοτική χρήση μνήμης

Προαπαιτούμενα

• Περιβάλλον Java: JDK 8+ (συνιστάται JDK 11+), IDE της επιλογής σας, Maven (ή Gradle)
• Βιβλιοθήκη GroupDocs.Comparison: Έκδοση 25.2 ή νεότερη (πάντα πάρτε την πιο πρόσφατη)
• Άδεια: Δωρεάν δοκιμή, προσωρινή άδεια 30 ημερών, ή εμπορική άδεια

Ρύθμιση GroupDocs.Comparison στο Έργο Σας

Διαμόρφωση Maven

Πρώτα απ’ όλα – προσθέστε το αποθετήριο GroupDocs και την εξάρτηση στο pom.xml. Αυτό είναι το σημείο όπου τα περισσότερα tutorials γίνονται περιττά πολύπλοκα, αλλά στην πραγματικότητα είναι αρκετά απλό:

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

Pro tip: Πάντα ελέγχετε τον πιο πρόσφατο αριθμό έκδοσης στη GroupDocs releases page. Οι νέες εκδόσεις συχνά περιλαμβάνουν βελτιώσεις απόδοσης και διορθώσεις σφαλμάτων που μπορούν να σας εξοικονομήσουν πολύτιμο χρόνο.

Απόκτηση Άδειας

Εδώ είναι κάτι που οι περισσότεροι προγραμματιστές δεν συνειδητοποιούν: μπορείτε να ξεκινήσετε τη δοκιμή του GroupDocs.Comparison αμέσως με τη δωρεάν δοκιμή τους. Δεν απαιτείται πιστωτική κάρτα, χωρίς δεσμεύσεις.

Your options:

1. Δωρεάν Δοκιμή – ιδανική για δοκιμές και μικρά έργα. Απλώς κατεβάστε και αρχίστε τον κώδικα!
2. Προσωρινή Άδεια – χρειάζεστε περισσότερο χρόνο για αξιολόγηση; Πάρτε μια προσωρινή άδεια 30 ημερών εδώ
3. Εμπορική Άδεια – έτοιμοι για παραγωγή; Δείτε τις τιμές εδώ

Η δωρεάν δοκιμή περιλαμβάνει όλες τις λειτουργίες αλλά προσθέτει υδατογράφημα στα αρχεία εξόδου. Για ανάπτυξη και δοκιμές, αυτό είναι συνήθως αποδεκτό.

Υλοποίηση Σύγκρισης Εγγράφων: Ο Πλήρης Οδηγός

Τώρα για το κύριο γεγονός! Θα δημιουργήσουμε μια πλήρη λύση σύγκρισης εγγράφων βήμα προς βήμα. Μην ανησυχείτε – θα εξηγήσουμε όχι μόνο το «πώς», αλλά και το «γιατί» πίσω από κάθε απόφαση.

Κατανόηση Πηγών Μεταδεδομένων (Αυτό είναι Σημαντικό!)

Πριν ξεκινήσουμε τον κώδικα, ας μιλήσουμε για κάτι που αποπροσανατολίζει πολλούς προγραμματιστές: τις πηγές μεταδεδομένων. Όταν compare documents in java, πρέπει να αποφασίσετε ποια μεταδεδομένα εγγράφου (συγγραφέας, ημερομηνία δημιουργίας, προσαρμοσμένες ιδιότητες κ.λπ.) θα διατηρηθούν στο αποτέλεσμα.

Το GroupDocs.Comparison σας δίνει τρεις επιλογές:

• SOURCE – χρήση μεταδεδομένων από το αρχικό έγγραφο
• TARGET – χρήση μεταδεδομένων από το έγγραφο με το οποίο συγκρίνετε
• NONE – αφαίρεση όλων των μεταδεδομένων από το αποτέλεσμα

Για τις περισσότερες επιχειρηματικές εφαρμογές, θα θέλετε να χρησιμοποιήσετε SOURCE για να διατηρήσετε τη συνέπεια.

Υλοποίηση Βήμα‑Βήμα

Θα δημιουργήσουμε ένα επαναχρησιμοποιήσιμο utility που μπορείτε να ενσωματώσετε σε οποιοδήποτε project.

Βήμα 1: Εισαγωγή των Απαιτούμενων Κλάσεων

import com.groupdocs.comparison.Comparer;
import com.groupdocs.comparison.options.enums.MetadataType;
import com.groupdocs.comparison.options.save.SaveOptions;
import java.nio.file.Path;
import java.io.IOException;

Βήμα 2: Δημιουργία του Αντικειμένου Comparer

Εδώ αρχίζει η μαγεία. Η κλάση Comparer είναι το κύριο σημείο εισόδου για όλες τις λειτουργίες σύγκρισης:

try (Comparer comparer = new Comparer("YOUR_DOCUMENT_DIRECTORY/source.docx")) {
    // All our comparison logic goes here
}

Why use try‑with‑resources? Η κλάση Comparer υλοποιεί το AutoCloseable, πράγμα που σημαίνει ότι καθαρίζει σωστά τους πόρους όταν τελειώσετε. Αυτό αποτρέπει διαρροές μνήμης – ιδιαίτερα σημαντικό όταν επεξεργάζεστε πολλά έγγραφα.

Βήμα 3: Προσθήκη Εγγράφων-Στόχων για Σύγκριση

comparer.add("YOUR_DOCUMENT_DIRECTORY/target1.docx");

Here’s something cool: μπορείτε πραγματικά να προσθέσετε πολλαπλά έγγραφα-στόχους και να τα συγκρίνετε όλα έναντι του πηγής σε μία λειτουργία. Απλώς καλέστε add() πολλές φορές:

comparer.add("YOUR_DOCUMENT_DIRECTORY/target1.docx");
comparer.add("YOUR_DOCUMENT_DIRECTORY/target2.docx");
comparer.add("YOUR_DOCUMENT_DIRECTORY/target3.docx");

Βήμα 4: Διαμόρφωση Διαχείρισης Μεταδεδομένων και Εκτέλεση Σύγκρισης

Εδώ ρυθμίζουμε την πηγή μεταδεδομένων και εκτελούμε τη σύγκριση:

final Path resultPath = comparer.compare("output/comparison_result.docx",
        new SaveOptions.Builder()
                .setCloneMetadataType(MetadataType.SOURCE)
                .build());

What’s happening here? Λέμε στο GroupDocs να:

1. Συγκρίνει όλα τα προστιθέμενα έγγραφα έναντι της πηγής
2. Αποθηκεύει το αποτέλεσμα στη διαδρομή που ορίσαμε
3. Χρησιμοποιεί τα μεταδεδομένα του εγγράφου SOURCE στο τελικό αποτέλεσμα

Πλήρες Παράδειγμα Λειτουργίας

Ας τα ενώσουμε όλα σε μια μέθοδο που μπορείτε πραγματικά να χρησιμοποιήσετε:

public class DocumentComparison {
    
    public static Path compareDocumentsWithMetadata(
            String sourcePath, 
            String targetPath, 
            String outputPath) throws IOException {
        
        try (Comparer comparer = new Comparer(sourcePath)) {
            // Add the target document
            comparer.add(targetPath);
            
            // Configure comparison options
            SaveOptions saveOptions = new SaveOptions.Builder()
                    .setCloneMetadataType(MetadataType.SOURCE)
                    .build();
            
            // Execute comparison and return result path
            return comparer.compare(outputPath, saveOptions);
        }
    }
}

Συνηθισμένα Πόδια και Πώς να τα Αποφύγετε

Αφού βοήθησα εκατοντάδες προγραμματιστές να υλοποιήσουν σύγκριση εγγράφων, έχω δει τα ίδια προβλήματα να εμφανίζονται ξανά και ξανά. Εδώ είναι τα πιο συχνά (και πώς να τα διορθώσετε):

Προβλήματα Διαδρομής Αρχείων

Problem: FileNotFoundException παρόλο που το αρχείο υπάρχει
Solution: Πάντα χρησιμοποιείτε απόλυτες διαδρομές ή επιλύετε σωστά τις σχετικές διαδρομές

// Instead of this:
String sourcePath = "documents/source.docx";

// Do this:
String sourcePath = Paths.get("documents", "source.docx").toAbsolutePath().toString();

Προβλήματα Διαχείρισης Μνήμης

Problem: Σφάλματα έλλειψης μνήμης όταν συγκρίνονται μεγάλα έγγραφα
Solution: Αυξήστε το μέγεθος heap του JVM και χρησιμοποιήστε σωστή διαχείριση πόρων

# Add these JVM arguments when running your application
-Xmx4g -XX:+UseG1GC

Λανθασμένη Διαχείριση Μεταδεδομένων

Problem: Απώλεια σημαντικών μεταδεδομένων εγγράφου κατά τη σύγκριση
Solution: Πάντα ορίζετε ρητά τον τύπο μεταδεδομένων – μην βασίζεστε στις προεπιλογές

// Always be explicit about metadata handling
SaveOptions saveOptions = new SaveOptions.Builder()
        .setCloneMetadataType(MetadataType.SOURCE)  // Be explicit!
        .build();

Προβλήματα Ρύθμισης Άδειας

Problem: Εμφάνιση υδατογραφημάτων στην παραγωγή
Solution: Επαληθεύστε ότι η άδεια έχει φορτωθεί σωστά πριν δημιουργήσετε στιγμιότυπα Comparer

// Load license at application startup
License license = new License();
license.setLicense("path/to/your/license.lic");

Καλές Πρακτικές για Χρήση σε Παραγωγή

Με βάση την πραγματική εμπειρία, αυτές είναι οι πρακτικές που διαχωρίζουν τις ερασιτεχνικές υλοποιήσεις από τις έτοιμες για παραγωγή λύσεις:

Διαχείριση Σφαλμάτων που Πραγματικά Βοηθά

Μην πιάνετε μόνο τις εξαιρέσεις – χειριστείτε τες με νόημα:

public ComparisonResult compareDocuments(String source, String target) {
    try (Comparer comparer = new Comparer(source)) {
        comparer.add(target);
        Path result = comparer.compare("output.docx", 
            new SaveOptions.Builder()
                .setCloneMetadataType(MetadataType.SOURCE)
                .build());
        
        return new ComparisonResult(true, result.toString(), null);
        
    } catch (IOException e) {
        logger.error("File access error during comparison", e);
        return new ComparisonResult(false, null, "Unable to access document files");
        
    } catch (Exception e) {
        logger.error("Unexpected error during document comparison", e);
        return new ComparisonResult(false, null, "Document comparison failed");
    }
}

Βελτιστοποίηση Απόδοσης

Για σενάρια υψηλού όγκου, εξετάστε τις εξής βελτιστοποιήσεις:

1. Reuse Comparer instances όταν είναι δυνατόν (αλλά προσέξτε το thread safety)
2. Process documents in batches για να αποφύγετε την υπερφόρτωση των πόρων του συστήματος
3. Use asynchronous processing για μεγάλα έγγραφα
4. Monitor memory usage και ρυθμίστε τις παραμέτρους του JVM ανάλογα

Σκέψεις Ασφάλειας

Κατά τη διαχείριση ευαίσθητων εγγράφων:

• Validate file types πριν από την επεξεργασία
• Implement proper access controls
• Clean up temporary files αμέσως μετά τη χρήση
• Consider encrypting τα αποτελέσματα σύγκρισης

Πραγματικές Εφαρμογές και Περιπτώσεις Χρήσης

Ας δούμε πώς οι προγραμματιστές χρησιμοποιούν πραγματικά το GroupDocs.Comparison στην παραγωγή:

Νομική Ανασκόπηση Εγγράφων

Οι νομικές εταιρείες χρησιμοποιούν τη σύγκριση εγγράφων για την παρακολούθηση αλλαγών σε συμβόλαια και νομικές συμφωνίες. Η δυνατότητα διατήρησης μεταδεδομένων είναι κρίσιμη, καθώς χρειάζεται να διατηρείται η προέλευση του εγγράφου.

// Typical legal document comparison workflow
public void reviewContractChanges(String originalContract, String revisedContract) {
    try (Comparer comparer = new Comparer(originalContract)) {
        comparer.add(revisedContract);
        
        SaveOptions options = new SaveOptions.Builder()
                .setCloneMetadataType(MetadataType.SOURCE)  // Preserve original metadata
                .build();
        
        Path result = comparer.compare("contract_review.docx", options);
        
        // Send result to legal team for review
        notifyLegalTeam(result);
    }
}

Συστήματα Διαχείρισης Περιεχομένου

Οι πλατφόρμες CMS χρησιμοποιούν τη σύγκριση εγγράφων για έλεγχο εκδόσεων και παρακολούθηση αλλαγών:

public class CMSDocumentVersioning {
    
    public VersionComparisonResult compareVersions(
            DocumentVersion current, 
            DocumentVersion previous) {
        
        try (Comparer comparer = new Comparer(current.getFilePath())) {
            comparer.add(previous.getFilePath());
            
            String outputName = String.format("comparison_%s_vs_%s.docx", 
                current.getVersionNumber(), 
                previous.getVersionNumber());
            
            Path result = comparer.compare(outputName, 
                new SaveOptions.Builder()
                    .setCloneMetadataType(MetadataType.SOURCE)
                    .build());
            
            return new VersionComparisonResult(result, current, previous);
        }
    }
}

Ανάλυση Χρηματοοικονομικών Εγγράφων

Οι χρηματοοικονομικοί οργανισμοί το χρησιμοποιούν για συμμόρφωση με κανονισμούς και δημιουργία αρχείων ελέγχου:

public AuditResult auditFinancialDocument(String originalReport, String submittedReport) {
    // Compare submitted report against original
    // Metadata preservation is critical for audit compliance
    try (Comparer comparer = new Comparer(originalReport)) {
        comparer.add(submittedReport);
        
        Path auditResult = comparer.compare("audit_comparison.docx",
            new SaveOptions.Builder()
                .setCloneMetadataType(MetadataType.SOURCE)
                .build());
        
        return generateAuditReport(auditResult);
    }
}

Βελτιστοποίηση Απόδοσης και Κλιμάκωση

Όταν είστε έτοιμοι να διαχειριστείτε σοβαρούς όγκους εγγράφων, αυτές οι στρατηγικές θα κρατήσουν την εφαρμογή σας ανταποκρινόμενη:

Διαχείριση Μνήμης

Τα μεγάλα έγγραφα μπορούν γρήγορα να καταναλώσουν τη διαθέσιμη μνήμη. Εδώ είναι πώς να τα διαχειριστείτε αποδοτικά:

public class OptimizedDocumentProcessor {
    
    private final ExecutorService executor = Executors.newFixedThreadPool(
        Runtime.getRuntime().availableProcessors());
    
    public CompletableFuture<Path> compareDocumentsAsync(
            String source, 
            String target, 
            String output) {
        
        return CompletableFuture.supplyAsync(() -> {
            try (Comparer comparer = new Comparer(source)) {
                comparer.add(target);
                return comparer.compare(output, 
                    new SaveOptions.Builder()
                        .setCloneMetadataType(MetadataType.SOURCE)
                        .build());
            }
        }, executor);
    }
}

Επεξεργασία Παρτίδων

Για πολλαπλές συγκρίσεις εγγράφων, η επεξεργασία παρτίδων είναι ο φίλος σας:

public List<ComparisonResult> processBatch(List<DocumentPair> documentPairs) {
    return documentPairs.parallelStream()
        .map(this::compareDocumentPair)
        .collect(Collectors.toList());
}

private ComparisonResult compareDocumentPair(DocumentPair pair) {
    try (Comparer comparer = new Comparer(pair.getSourcePath())) {
        comparer.add(pair.getTargetPath());
        Path result = comparer.compare(pair.getOutputPath(),
            new SaveOptions.Builder()
                .setCloneMetadataType(MetadataType.SOURCE)
                .build());
        return new ComparisonResult(pair, result, true);
    } catch (Exception e) {
        return new ComparisonResult(pair, null, false, e.getMessage());
    }
}

Οδηγός Επίλυσης Προβλημάτων

Όταν τα πράγματα πάθουν στραβά (και μερικές φορές συμβαίνει), αυτός είναι ο κατάλογος ελέγχου εντοπισμού σφαλμάτων:

Σφάλματα «Comparison Failed»

Most common causes:

1. Μη υποστηριζόμενη μορφή αρχείου
2. Κατεστραμμένα πηγαία έγγραφα
3. Ανεπαρκής μνήμη
4. Προβλήματα δικαιωμάτων αρχείου

Debugging steps:

// Add comprehensive logging to identify the issue
logger.debug("Starting comparison: source={}, target={}", sourcePath, targetPath);

try (Comparer comparer = new Comparer(sourcePath)) {
    logger.debug("Comparer initialized successfully");
    
    comparer.add(targetPath);
    logger.debug("Target document added successfully");
    
    Path result = comparer.compare(outputPath, saveOptions);
    logger.info("Comparison completed successfully: result={}", result);
    
    return result;
} catch (Exception e) {
    logger.error("Comparison failed", e);
    throw new DocumentComparisonException("Failed to compare documents", e);
}

Προβλήματα Απόδοσης

Αν οι συγκρίσεις διαρκούν πολύ:

1. Check document size – αρχεία πάνω από 100 MB μπορεί να χρειάζονται ειδική διαχείριση
2. Monitor memory usage – αυξήστε το μέγεθος heap αν χρειάζεται
3. Verify file I/O performance – αργός αποθηκευτικός χώρος μπορεί να δημιουργεί bottleneck
4. Consider document format – ορισμένες μορφές είναι πιο πολύπλοκες στην επεξεργασία

Διαρροές Μνήμης

Σημάδια ότι μπορεί να έχετε διαρροές μνήμης:

• Η απόδοση της εφαρμογής μειώνεται με το χρόνο
• OutOfMemoryError μετά την επεξεργασία πολλών εγγράφων
• Υψηλή δραστηριότητα garbage collection

Solution: Πάντα χρησιμοποιείτε try‑with‑resources και παρακολουθείτε την εφαρμογή σας με εργαλεία profiling.

Διαχείριση Αρχείων με Κωδικό Πρόσβασης

Αν χρειάζεται να java compare password protected έγγραφα, χρησιμοποιήστε το LoadOptions κατά το άνοιγμα του πηγής ή του στόχου:

LoadOptions loadOptions = new LoadOptions("your_password");
try (Comparer comparer = new Comparer("protected_document.docx", loadOptions)) {
    // Process password‑protected document
}

Πώς να συγκρίνετε σε java έγγραφα με κωδικό πρόσβασης

Τα αρχεία με κωδικό πρόσβασης είναι συχνά σε κανονιστικά περιβάλλοντα. Με τη μεταβίβαση του κωδικού μέσω LoadOptions, διατηρείτε την ροή σύγκρισης αμετάβλητη ενώ εξασφαλίζετε ότι η βιβλιοθήκη μπορεί να αποκρυπτογραφήσει το αρχείο με ασφάλεια. Θυμηθείτε ποτέ να μην κωδικοποιείτε σκληρά τους κωδικούς· αποθηκεύστε τους σε ασφαλές vault ή μεταβλητή περιβάλλοντος και ενσωματώστε τους κατά την εκτέλεση.

Πώς να διαχειριστείτε μεγάλα έγγραφα σε java

Όταν τα έγγραφα υπερβαίνουν μερικές εκατοντάδες megabytes, μπορεί να αντιμετωπίσετε αργή επεξεργασία ή υψηλότερη κατανάλωση μνήμης. Για να το μετριάσετε:

• Increase JVM heap (-Xmx), ειδικά για εργασίες παρτίδας.
• Enable streaming όπου είναι δυνατόν – το GroupDocs.Comparison επεξεργάζεται τα αρχεία σε τμήματα εσωτερικά, αλλά μπορείτε να μειώσετε περαιτέρω την πίεση μνήμης αποφεύγοντας τη φόρτωση ολόκληρων αρχείων στη μνήμη.
• Run comparisons asynchronously (δείτε το async παράδειγμα παραπάνω) για να διατηρήσετε το UI ανταποκρινόμενο.
• Split very large PDFs σε λογικά τμήματα πριν τη σύγκριση, αν η επιχειρηματική λογική το επιτρέπει.

Ενσωμάτωση με Spring Boot

Για προγραμματιστές που δημιουργούν μικροϋπηρεσίες, τυλίξτε τη λογική σύγκρισης σε ένα Spring service bean:

@Service
public class DocumentComparisonService {
    
    public ComparisonResult compareDocuments(String source, String target) {
        try (Comparer comparer = new Comparer(source)) {
            comparer.add(target);
            Path result = comparer.compare("output.docx",
                new SaveOptions.Builder()
                    .setCloneMetadataType(MetadataType.SOURCE)
                    .build());
            return new ComparisonResult(result);
        }
    }
}

Συχνές Ερωτήσεις

Q: Μπορώ να συγκρίνω περισσότερα από δύο έγγραφα ταυτόχρονα;
A: Απόλυτα! Προσθέστε πολλαπλά έγγραφα-στόχους με comparer.add() πριν εκτελέσετε τη σύγκριση.

Q: Ποιες μορφές αρχείων υποστηρίζει το GroupDocs.Comparison;
A: Υποστηρίζει DOCX, PDF, XLSX, PPTX, TXT και πολλές άλλες. Δείτε τη πλήρη λίστα στην επίσημη τεκμηρίωση.

Q: Πώς διαχειρίζομαι έγγραφα με κωδικό πρόσβασης;
A: Χρησιμοποιήστε την κλάση LoadOptions για να περάσετε τον κωδικό κατά τη δημιουργία του αντικειμένου Comparer (δείτε το παράδειγμα παραπάνω).

Q: Είναι το GroupDocs.Comparison thread‑safe;
A: Ένα μοναδικό αντικείμενο Comparer δεν είναι thread‑safe, αλλά μπορείτε να χρησιμοποιήσετε πολλαπλά αντικείμενα ταυτόχρονα σε παράλληλα νήματα.

Q: Πώς μπορώ να βελτιώσω την απόδοση για μεγάλα έγγραφα;
A: Αυξήστε το heap του JVM (-Xmx), επεξεργαστείτε τα αρχεία ασύγχρονα, κάντε batch processing και επαναχρησιμοποιήστε αντικείμενα Comparer όταν είναι εφικτό.

Πρόσθετοι Πόροι

• GroupDocs.Comparison Documentation – ολοκληρωμένη αναφορά API και παραδείγματα
• GroupDocs Community Forum – λάβετε βοήθεια από άλλους προγραμματιστές

Τελευταία Ενημέρωση: 2026-02-23
Δοκιμάστηκε Με: GroupDocs.Comparison 25.2
Συγγραφέας: GroupDocs