Jak porównać pliki Excel w Javie przy użyciu GroupDocs Document Comparison API

W wielu przedsiębiorstwach musisz porównywać pliki Excel w Javie, aby wykrywać zmiany w raportach finansowych, audytować korekty danych lub weryfikować wyniki migracji. Ręczne otwieranie dwóch skoroszytów i przeglądanie komórka po komórce jest podatne na błędy i marnuje cenny czas. Ten samouczek pokazuje dokładnie jak porównać Excel programowo przy użyciu GroupDocs.Comparison dla Javy, dostarczając raporty różnic w pikselach w ciągu kilku sekund.

Szybkie odpowiedzi

  • Czy GroupDocs może porównywać pliki Excel w Javie? Tak – wystarczy załadować pliki .xlsx przy użyciu klasy Comparer i wywołać compare.
  • Jak pominąć nagłówki/stopki? Ustaw setHeaderFootersComparison(false) w CompareOptions.
  • Co z dużymi plikami PDF? Zwiększ przydział pamięci JVM, włącz tryb strumieniowy i użyj opcji zoptymalizowanych pod kątem pamięci.
  • Czy mogę porównywać zabezpieczone hasłem pliki PDF? Podaj hasło przy tworzeniu obiektu Comparer.
  • Czy istnieje sposób zmiany kolorów podświetlenia? Użyj StyleSettings dla wstawionych, usuniętych i zmienionych elementów.

Co to jest porównywanie plików Excel w Javie?

Porównywanie plików Excel w Javie oznacza programowe wykrywanie każdej dodanej, usuniętej lub zmodyfikowanej komórki pomiędzy dwoma skoroszytami .xlsx oraz generowanie wizualnego raportu różnic, który podświetla te zmiany. Silnik GroupDocs.Comparison ładuje każdy arkusz do pamięci, ocenia formuły, style i struktury arkuszy, a następnie renderuje raport PDF/HTML obok siebie lub jako nakładkę, który programiści mogą osadzać w pulpitach nawigacyjnych lub wysyłać e‑mailem do interesariuszy.

Dlaczego warto używać API do porównywania dokumentów w Javie?

Automatyzacja generowania różnic eliminuje błąd ludzki, który odpowiada za około 20 % pominiętych zmian w ręcznych przeglądach, zapewniając spójne i wiarygodne wyniki. GroupDocs zapewnia wysoką precyzję wykrywania każdej modyfikacji, szybkie czasy przetwarzania oraz jednolite formatowanie wyjść, co razem zwiększa produktywność zespołów finansowych, prawnych i zarządzania treścią.

Obsługiwane formaty plików i możliwości

GroupDocs.Comparison dla Javy obsługuje ponad 50 formatów wejściowych i wyjściowych, w tym:

  • Dokumenty: DOCX, DOC, PDF, RTF, ODT
  • Arkusze kalkulacyjne: XLSX, XLS, CSV, ODS
  • Prezentacje: PPTX, PPT, ODP
  • Tekst: TXT, HTML, XML, MD
  • Obrazy: PNG, JPEG, BMP, GIF (porównanie wizualne)

Zaawansowane możliwości obejmują obsługę dokumentów zabezpieczonych hasłem, wykrywanie wielu języków, niestandardową czułość w zależności od typu dokumentu, przetwarzanie wsadowe oraz opcje wdrożenia zarówno w chmurze, jak i lokalnie.

Wymagania wstępne i konfiguracja

Wymagania systemowe

  1. Java Development Kit (JDK): 8 lub wyższy (zalecany JDK 11+)
  2. Narzędzie budowania: Maven 3.6+ lub Gradle 6.0+
  3. Pamięć: Minimum 4 GB RAM dla dużych plików
  4. Przestrzeń dyskowa: Co najmniej 500 MB wolnego miejsca na tymczasowe dane porównania

Konfiguracja Maven

Dodaj repozytorium GroupDocs i zależność do pliku pom.xml. To zapewnia pobranie oficjalnego wydania:

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

Konfiguracja licencji

Do rozwoju i testów

Do produkcji

Zainicjalizuj licencję przy uruchamianiu aplikacji:

// License initialization - do this once at application startup
com.groupdocs.comparison.License license = new com.groupdocs.comparison.License();
license.setLicense("path/to/your/license/file.lic");

Wskazówka: Przechowuj plik licencji w folderze zasobów i wczytuj go za pomocą getClass().getResourceAsStream() dla przenośnych wdrożeń.

Przewodnik po implementacji podstawowej

Funkcja 1: pomijanie porównywania nagłówka i stopki

Metoda setHeaderFootersComparison wyłącza porównywanie treści nagłówka i stopki, zapobiegając pojawianiu się nieistotnych różnic w raporcie.

Dlaczego to ważne: Nagłówki i stopki często zawierają znaczniki czasu lub numery stron, które zmieniają się między wersjami, ale nie są częścią istotnej treści. Pominięcie ich redukuje szum i przyspiesza przetwarzanie.

Scenariusz z życia wzięty: Dwa projekty umów zawierają różne daty generowania w stopce; interesują Cię tylko zmiany w klauzulach.

import com.groupdocs.comparison.Comparer;
import com.groupdocs.comparison.options.CompareOptions;
import java.io.FileOutputStream;

public class IgnoreHeaderFooterExample {
    public static void main(String[] args) throws Exception {
        String outputFileName = "YOUR_OUTPUT_DIRECTORY/IgnoreHeaderFooter_result.docx";

        try (OutputStream resultStream = new FileOutputStream(outputFileName);
             Comparer comparer = new Comparer("YOUR_DOCUMENT_DIRECTORY/source_with_footer.docx")) {

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

            // Set comparison options to ignore headers and footers
            CompareOptions compareOptions = new CompareOptions.Builder()
                    .setHeaderFootersComparison(false)
                    .build();

            final Path resultPath = comparer.compare(resultStream, new SaveOptions(), compareOptions);
        }
    }
}

Kluczowe korzyści: czystsze wyniki różnic, mniej fałszywych alarmów oraz szybsze wykonanie, ponieważ te sekcje są pomijane.

Funkcja 2: ustawienie rozmiaru papieru wyjściowego dla raportów profesjonalnych

Enum PaperSize definiuje standardowe wymiary stron, które będzie używał generowany PDF.

Kontekst biznesowy: Zespoły prawne często potrzebują drukowalnych raportów porównawczych w określonym rozmiarze papieru do składania w sądzie lub dostarczania klientom.

Jak zastosować: Użyj enumu PaperSize w CompareOptions, aby określić docelowy rozmiar.

import com.groupdocs.comparison.Comparer;
import com.groupdocs.comparison.options.CompareOptions;
import com.groupdocs.comparison.options.enums.PaperSize;

public class SetOutputPaperSizeExample {
    public static void main(String[] args) throws Exception {
        String outputFileName = "YOUR_OUTPUT_DIRECTORY/SetOutputPaperSize_result.docx";

        try (OutputStream resultStream = new FileOutputStream(outputFileName);
             Comparer comparer = new Comparer("YOUR_DOCUMENT_DIRECTORY/source_word.docx")) {

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

            // Set the paper size to A6
            CompareOptions compareOptions = new CompareOptions.Builder()
                    .setPaperSize(PaperSize.A6)
                    .build();

            final Path resultPath = comparer.compare(resultStream, compareOptions);
        }
    }
}

Obsługiwane rozmiary obejmują A0‑A10, Letter, Legal, Tabloid oraz wymiary niestandardowe. Wybierz A4 dla klientów europejskich lub Letter dla partnerów z USA.

Funkcja 3: precyzyjne dostrojenie czułości porównania

Metoda setSensitivityOfComparison dostosowuje, jak szczegółowo silnik porównania ocenia zmiany, od dużych edycji strukturalnych po różnice pojedynczych znaków.

Wyzwanie: Różne kategorie dokumentów wymagają różnej szczegółowości. Umowy prawne wymagają precyzji na poziomie znaków, podczas gdy materiały marketingowe mogą wymagać zmian na poziomie akapitu.

Skala czułości (0‑100):

  • 0‑25: Tylko duże zmiany (dodanie/usunięcie akapitu)
  • 26‑50: Średnie zmiany (edycje zdań)
  • 51‑75: Szczegółowe zmiany (poziom słowa)
  • 76‑100: Granularne zmiany (poziom znaku)
import com.groupdocs.comparison.Comparer;
import com.groupdocs.comparison.options.CompareOptions;

public class AdjustComparisonSensitivityExample {
    public static void main(String[] args) throws Exception {
        String outputFileName = "YOUR_OUTPUT_DIRECTORY/AdjustComparisonSensitivity_result.docx";

        try (OutputStream resultStream = new FileOutputStream(outputFileName);
             Comparer comparer = new Comparer("YOUR_DOCUMENT_DIRECTORY/source_word.docx")) {

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

            // Set sensitivity to 100 for maximum detail
            CompareOptions compareOptions = new CompareOptions.Builder()
                    .setSensitivityOfComparison(100)
                    .build();

            final Path resultPath = comparer.compare(resultStream, compareOptions);
        }
    }
}

Ustawienia zalecane: Dokumenty prawne 90‑100, treści marketingowe 40‑60, specyfikacje techniczne 70‑80.

Funkcja 4: dostosowanie stylów zmian dla lepszej komunikacji wizualnej

Obiekt StyleSettings pozwala definiować kolory, czcionki, obramowania i inne wskazówki wizualne dla wstawionych, usuniętych i zmodyfikowanych treści.

Dlaczego niestandardowe style mają znaczenie: Domyślne podświetlenie może kolidować z identyfikacją wizualną firmy lub wytycznymi dostępności. Dostosowanie kolorów, czcionek i obramowań sprawia, że różnice są od razu zrozumiałe.

Przykład: Czerwone tło dla usunięć, zielone dla wstawek, niebieskie dla modyfikacji.

import com.groupdocs.comparison.Comparer;
import com.groupdocs.comparison.options.CompareOptions;
import com.groupdocs.comparison.options.save.SaveOptions;
import com.groupdocs.comparison.options.style.StyleSettings;

import java.awt.Color;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

public class CustomizeChangesStylesStreamExample {
    public static void main(String[] args) throws Exception {
        String outputFileName = "YOUR_OUTPUT_DIRECTORY/CustomizeChangesStylesStream_result.docx";

        try (InputStream sourceFile = new FileInputStream("YOUR_DOCUMENT_DIRECTORY/source_word.docx");
             InputStream targetFile = new FileInputStream("YOUR_DOCUMENT_DIRECTORY/target1_word.docx");
             OutputStream resultStream = new FileOutputStream(outputFileName);
             Comparer comparer = new Comparer(sourceFile)) {

            comparer.add(targetFile);

            // Customize change styles for professional appearance
            StyleSettings insertedStyle = new StyleSettings();
            insertedStyle.setHighlightColor(Color.GREEN); // Green for additions
            StyleSettings deletedStyle = new StyleSettings();
            deletedStyle.setHighlightColor(Color.RED); // Red for deletions
            StyleSettings changedStyle = new StyleSettings();
            changedStyle.setHighlightColor(Color.BLUE); // Blue for modifications

            CompareOptions compareOptions = new CompareOptions.Builder()
                    .setInsertedItemStyle(insertedStyle)
                    .setDeletedItemStyle(deletedStyle)
                    .setChangedItemStyle(changedStyle)
                    .build();

            final Path resultPath = comparer.compare(resultStream, compareOptions);
        }
    }
}

Zaawansowane opcje pozwalają modyfikować grubość czcionki, rozmiar, przezroczystość tła, styl obramowania oraz zachowanie przekreślenia.

Jak ustawić rozmiar papieru w raportach porównania w Javie

Comparer jest główną klasą, która koordynuje operacje porównywania dokumentów. Załaduj instancję Comparer z źródłowym skoroszytem, skonfiguruj obiekt CompareOptions i wywołaj setPaperSize używając żądanej wartości enum PaperSize. To pojedyncze ustawienie definiuje wymiary strony generowanego PDF, zapewniając prawidłowe drukowanie bez ręcznego skalowania.

import com.groupdocs.comparison.Comparer;
import com.groupdocs.comparison.options.CompareOptions;
import com.groupdocs.comparison.options.enums.PaperSize;

public class SetOutputPaperSizeExample {
    public static void main(String[] args) throws Exception {
        String outputFileName = "YOUR_OUTPUT_DIRECTORY/SetOutputPaperSize_result.docx";

        try (OutputStream resultStream = new FileOutputStream(outputFileName);
             Comparer comparer = new Comparer("YOUR_DOCUMENT_DIRECTORY/source_word.docx")) {

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

            // Set the paper size to A6
            CompareOptions compareOptions = new CompareOptions.Builder()
                    .setPaperSize(PaperSize.A6)
                    .build();

            final Path resultPath = comparer.compare(resultStream, compareOptions);
        }
    }
}

Możesz połączyć to ustawienie z niestandardowymi marginesami i flagami orientacji, aby uzyskać układ spełniający wytyczne Twojej organizacji dotyczące składania dokumentów, gwarantując profesjonalny wygląd za każdym razem.

Typowe problemy i rozwiązywanie

Zarządzanie pamięcią dla dużych dokumentów

Problem: OutOfMemoryError podczas porównywania plików większych niż 50 MB.
Rozwiązanie: Zwiększ przydział pamięci JVM (-Xmx8g) i włącz tryb strumieniowy.

# Increase heap size for large document processing
java -Xmx4g -XX:MaxMetaspaceSize=512m YourComparisonApp

Obsługa uszkodzonych lub zabezpieczonych hasłem plików

PasswordRequiredException jest zgłaszany, gdy API napotyka zaszyfrowany dokument bez podanego hasła.

Problem: Porównanie nie powodzi się przy zablokowanych dokumentach.
Zapobieganie: Podaj hasło przy tworzeniu obiektu Comparer i przechwyć PasswordRequiredException.

// Check document accessibility before comparison
try {
    Comparer comparer = new Comparer(sourceFile, "password123");
    // Document loaded successfully, proceed with comparison
} catch (PasswordRequiredException ex) {
    // Handle password‑protected documents
    log.error("Document requires password: " + sourceFile);
} catch (CorruptedFileException ex) {
    // Handle corrupted files gracefully
    log.error("File corruption detected: " + sourceFile);
}

Optymalizacja wydajności przy przetwarzaniu wsadowym

Wyzwanie: Efektywne przetwarzanie ponad 100 par dokumentów.
Rozwiązanie: Użyj puli wątków o stałym rozmiarze i zgłaszaj każde porównanie jako osobne zadanie.

ExecutorService executor = Executors.newFixedThreadPool(4);
List<Future<ComparisonResult>> futures = new ArrayList<>();

for (DocumentPair pair : documentPairs) {
    futures.add(executor.submit(() -> compareDocuments(pair)));
}

// Wait for all comparisons to complete
for (Future<ComparisonResult> future : futures) {
    ComparisonResult result = future.get();
    // Process results
}
executor.shutdown();

Problemy specyficzne dla formatów

  • Skanowane PDF: Zastosuj wstępne przetwarzanie OCR przed porównaniem.
  • Dokumenty Word: Wyłącz istniejącą funkcję „Track Changes”, aby uniknąć fałszywych różnic.
  • Obiekty osadzone: Wyodrębnij i porównaj je osobno dla dokładności.

Najlepsze praktyki i wskazówki dotyczące wydajności

1. wstępne przetwarzanie dokumentu

Usuń niepotrzebne metadane i ujednolic czcionki przed porównaniem, aby poprawić szybkość i dokładność.

// Example preprocessing workflow
public void preprocessDocument(String filePath) {
    // Remove comments and tracked changes
    // Standardize formatting
    // Extract text‑only version for pure content comparison
}

2. optymalne profile konfiguracji

Utwórz wielokrotnego użytku szablony CompareOptions dla każdego typu dokumentu (prawny, marketingowy, techniczny) i używaj ich w całym pipeline.

public class ComparisonProfiles {
    public static CompareOptions getLegalDocumentProfile() {
        return new CompareOptions.Builder()
                .setSensitivityOfComparison(95)
                .setHeaderFootersComparison(false)
                .setShowRevisions(true)
                .build();
    }
    
    public static CompareOptions getMarketingContentProfile() {
        return new CompareOptions.Builder()
                .setSensitivityOfComparison(45)
                .setIgnoreFormatting(true)
                .setFocusOnContent(true)
                .build();
    }
}

3. solidna obsługa błędów i logowanie

ComparisonException wskazuje na błąd podczas procesu porównywania i dostarcza szczegółowe informacje diagnostyczne. Otaczaj wywołania porównania blokami try‑catch, loguj szczegóły ComparisonException i w razie potrzeby przechodź do bezpiecznej wartości domyślnej.

public ComparisonResult safeCompareDocuments(String source, String target) {
    try {
        return performComparison(source, target);
    } catch (Exception ex) {
        logger.error("Comparison failed for {} vs {}: {}", source, target, ex.getMessage());
        return ComparisonResult.failure(ex.getMessage());
    }
}

4. buforowanie i inteligentne ponowne użycie

  • Buforuj wyniki różnic dla identycznych par plików.
  • Przechowuj odciski dokumentów (hashe), aby pomijać niezmienione pliki.
  • Używaj asynchronicznych kolejek dla niekrytycznych porównań, aby interfejs był responsywny.

Scenariusze integracji w praktyce

Scenariusz 1: zautomatyzowany pipeline przeglądu umów

@Service
public class ContractReviewService {
    
    public void processContractRevision(String originalContract, String revisedContract) {
        CompareOptions legalOptions = ComparisonProfiles.getLegalDocumentProfile();
        
        try (Comparer comparer = new Comparer(originalContract)) {
            comparer.add(revisedContract);
            Path result = comparer.compare(generateOutputPath(), legalOptions);
            
            // Send comparison report to legal team
            emailService.sendComparisonReport(result, legalTeamEmails);
            
            // Log changes for audit trail
            auditService.logDocumentChanges(extractChanges(result));
        }
    }
}

Scenariusz 2: integracja z systemem zarządzania treścią

@RestController
public class DocumentComparisonController {
    
    @PostMapping("/api/documents/compare")
    public ResponseEntity<ComparisonReport> compareDocuments(
            @RequestParam("source") MultipartFile source,
            @RequestParam("target") MultipartFile target,
            @RequestParam(value = "sensitivity", defaultValue = "75") int sensitivity) {
        
        CompareOptions options = new CompareOptions.Builder()
                .setSensitivityOfComparison(sensitivity)
                .build();
                
        ComparisonReport report = documentComparisonService.compare(source, target, options);
        return ResponseEntity.ok(report);
    }
}

Najczęściej zadawane pytania

Q: Czy mogę pominąć nagłówki i stopki podczas porównywania w GroupDocs dla Javy?
A: Tak, wywołaj setHeaderFootersComparison(false) na CompareOptions. To usuwa dynamiczny szum nagłówka/stopki z raportu różnic.

Q: Jak ustawić rozmiar papieru wyjściowego w Javie przy użyciu GroupDocs?
A: Użyj setPaperSize(PaperSize.A6) (lub innej wartości enum) w CompareOptions. To generuje gotowy do druku PDF w wybranym rozmiarze.

Q: Czy można precyzyjnie dostroić czułość porównania dla różnych typów dokumentów?
A: Oczywiście. Wywołaj setSensitivityOfComparison(85) dla umów prawnych lub setSensitivityOfComparison(45) dla projektów marketingowych, aby kontrolować szczegółowość.

Q: Czy mogę dostosować stylowanie wstawionego, usuniętego i zmienionego tekstu podczas porównania?
A: Tak. Utwórz instancję StyleSettings dla każdego typu zmiany i przypisz kolory, czcionki lub obramowania przed przekazaniem jej do CompareOptions.

Q: Jakie są wymagania wstępne, aby rozpocząć pracę z GroupDocs Comparison w Javie?
A: Potrzebujesz JDK 8+ (zalecany JDK 11+), Maven 3.6+ lub Gradle 6.0+, co najmniej 4 GB RAM oraz ważnej licencji GroupDocs (dostępna wersja próbna).

Q: Jak obsługiwać dokumenty zabezpieczone hasłem w GroupDocs.Comparison?
A: Przekaż hasło jako drugi argument przy tworzeniu Comparer: new Comparer(sourceFile, "myPassword"). Przechwyć PasswordRequiredException, aby elegancko obsłużyć błędy.

Q: Jakie formaty plików obsługuje GroupDocs.Comparison dla Javy?
A: Ponad 50 formatów, w tym DOCX, PDF, XLSX, PPTX, TXT, HTML, XML oraz popularne typy obrazów (PNG, JPEG). API automatycznie wykrywa formaty, ale możesz je jawnie określić dla zwiększenia wydajności przetwarzania wsadowego.

Zakończenie

Korzystając z GroupDocs.Comparison dla Javy, możesz zautomatyzować żmudne zadanie porównywania skoroszytów Excel — oraz dowolnego innego obsługiwanego formatu — z precyzyjną dokładnością, szybkością i spójnością. Zintegruj fragmenty kodu i wskazówki najlepszych praktyk z tego przewodnika w swoich pipeline’ach CI/CD, systemach zarządzania dokumentami lub własnych narzędziach audytowych, aby uzyskać wymierne korzyści w produktywności.

Ostatnia aktualizacja: 2026-11-01
Testowano z: GroupDocs.Comparison 25.2 for Java
Autor: GroupDocs

// Use streaming for memory efficiency
try (Comparer comparer = new Comparer(sourceStream)) {
    // Process in chunks for very large documents
    CompareOptions options = new CompareOptions.Builder()
            .setMemoryOptimization(true) // Enable memory optimization
            .build();
}

Powiązane samouczki