Java Könyvtár-összehasonlító Eszköz - Teljes Útmutató a GroupDocs.Comparison segítségével

Bevezetés

Töltöttél már órákat kézzel ellenőrizve, mely fájlok változtak két projektverzió között? Nem vagy egyedül. A könyvtár-összehasonlítás az egyik olyan fárasztó feladat, amely egész délutánodat elnyelheti — kivéve, ha automatizálod.

GroupDocs.Comparison for Java átalakítja ezt a problémát egy egyszerű API hívássá. Akár egy hatalmas kódbázis változásait követed, fájlokat szinkronizálsz környezetek között, vagy megfelelőségi auditokat végzel, ez a könyvtár elvégzi a nehéz munkát, így neked nem kell.

Ebben az útmutatóban megtanulod, hogyan állíts be automatizált könyvtár-összehasonlításokat, amelyek valóban működnek a valós helyzetekben. Mindent lefedünk az alapbeállítástól a teljesítményoptimalizálásig azokhoz a hatalmas könyvtárakhoz, amelyek több ezer fájlt tartalmaznak.

Amit elsajátítasz:

A teljes GroupDocs.Comparison beállítás (beleértve a csapdákat is)
Lépésről‑lépésre könyvtár-összehasonlítás megvalósítása
Haladó konfiguráció egyedi összehasonlítási szabályokhoz
Teljesítményoptimalizálás nagyméretű összehasonlításokhoz
Gyakori problémák hibaelhárítása (mert előfordulnak)
Valós példák különböző iparágakban

Gyors válaszok

Mi a fő könyvtár? groupdocs comparison java
Támogatott Java verzió? Java 8 vagy újabb
Átlagos beállítási idő? 10–15 perc egy alap összehasonlításhoz
Licenc követelmény? Igen – próbaverzió vagy kereskedelmi licenc szükséges
Kimeneti formátumok? HTML (alapértelmezett) vagy PDF

Miért fontos a könyvtár-összehasonlítás (Több, mint gondolnád)

Mielőtt belemerülnénk a kódba, beszéljünk arról, miért fontos ez. A könyvtár-összehasonlítás nem csak a különböző fájlok megtalálásáról szól — hanem az adat integritás fenntartásáról, a megfelelőség biztosításáról és a ravasz változások elkapásáról, amelyek tönkretehetik a termelési környezetet.

Gyakori helyzetek, ahol erre szükséged lesz:

Release Management: A staging és a production könyvtárak összehasonlítása a telepítés előtt
Data Migration: Biztosítani, hogy minden fájl helyesen került átvitelre a rendszerek között
Compliance Audits: Dokumentumváltozások nyomon követése a szabályozási követelményekhez
Backup Verification: Ellenőrizni, hogy a mentési folyamat valóban működött-e
Team Collaboration: Azonosítani, ki mit változtatott a megosztott projektkönyvtárakban

Előfeltételek és beállítási követelmények

Mielőtt elkezdenénk kódolni, győződj meg róla, hogy a környezet készen áll. Íme, mire lesz szükséged (és miért):

Alapvető követelmények:

Java 8 vagy újabb – A GroupDocs.Comparison modern Java funkciókat használ
Maven 3.6+ – Függőségkezeléshez (hidd el, ne próbálj manuális JAR kezelést)
IDE jó Java támogatással – Ajánlott IntelliJ IDEA vagy Eclipse
Legalább 2 GB RAM – A könyvtár-összehasonlítások memóriát igényelhetnek

Tudás előfeltételek:

Alap Java programozás (ciklusok, feltételek, kivételkezelés)
Fájl I/O műveletek megértése
Maven függőségkezelés ismerete
Try‑with‑resources alapvető tudása (ezt széles körben használni fogjuk)

Opcionális, de hasznos:

Tapasztalat naplózási keretrendszerekkel (SLF4J/Logback)
Többszálas koncepciók megértése
Alap HTML ismeret (a kimeneti formázáshoz)

A GroupDocs.Comparison beállítása Java-hoz

Integráljuk megfelelően ezt a könyvtárat a projektedbe. A beállítás egyszerű, de néhány csapdára érdemes figyelni.

Maven konfiguráció

Add ezt a pom.xml fájlodhoz – vedd figyelembe a tároló konfigurációt, amelyet gyakran kihagynak:

<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: Mindig a GroupDocs weboldaláról származó legújabb verziószámot használd. Az itt látható verzió nem feltétlenül a legfrissebb.

Licenc beállítása (Ne hagyd ki)

A GroupDocs nem ingyenes, de több lehetőséget kínál:

Free Trial: 30‑napos próba a teljes funkciókkal (tökéletes értékeléshez)
Temporary License: Kiterjesztett próba fejlesztéshez/teszthez
Commercial License: Gyártási használathoz

Szerezd be a licencet innen:

Vásárolj licencet production számára
Szerezz ideiglenes licencet kiterjesztett teszthez

Alap inicializálás és tesztelés

Miután a függőségek be vannak állítva, teszteld az integrációt:

import com.groupdocs.comparison.Comparer;

public class Main {
    public static void main(String[] args) {
        try {
            Comparer comparer = new Comparer();
            System.out.println("GroupDocs.Comparison initialized successfully!");
        } catch (Exception e) {
            System.err.println("Setup issue: " + e.getMessage());
        }
    }
}

Ha ez hibák nélkül fut, készen állsz a folytatásra. Ha nem, ellenőrizd a Maven konfigurációt és az internetkapcsolatot (a GroupDocs online ellenőrzi a licenceket).

Alapvető megvalósítás: Könyvtár-összehasonlítás

Most jön a fő esemény — a könyvtárak tényleges összehasonlítása. Kezdünk egy alap megvalósítással, majd hozzáadunk fejlett funkciókat.

Alap könyvtár-összehasonlítás

Ez a mindennapi megoldás, amely a legtöbb esetet lefedi:

1. lépés: Állítsd be az útvonalakat

String sourceDirectoryPath = "YOUR_DOCUMENT_DIRECTORY/source_directory";
String targetDirectoryPath = "YOUR_DOCUMENT_DIRECTORY/target_directory";
String outputFileName = "YOUR_OUTPUT_DIRECTORY/compare_result.html";

Fontos: Amikor csak lehetséges, használj abszolút útvonalakat, különösen a gyártási környezetekben. Relatív útvonalak problémákat okozhatnak attól függően, hogy hol fut az alkalmazás.

2. lépés: Konfiguráld az összehasonlítási beállításokat

import com.groupdocs.comparison.options.CompareOptions;
import com.groupdocs.comparison.options.enums.FolderComparisonExtension;

CompareOptions compareOptions = new CompareOptions();
compareOptions.setDirectoryCompare(true);
compareOptions.setFolderComparisonExtension(FolderComparisonExtension.HTML);

Miért HTML kimenet? A HTML jelentések ember által olvashatóak és bármely böngészőben megtekinthetők. Tökéletes a nem technikai érintettekkel való eredménymegosztáshoz.

3. lépés: Hajtsd végre az összehasonlítást

try (Comparer comparer = new Comparer(sourceDirectoryPath, compareOptions)) {
    comparer.add(targetDirectoryPath, compareOptions);
    comparer.compareDirectory(outputFileName, compareOptions);
    System.out.println("Directory comparison completed. Results saved to: " + outputFileName);
} catch (Exception e) {
    System.err.println("Comparison failed: " + e.getMessage());
    e.printStackTrace();
}

Miért try‑with‑resources? A GroupDocs.Comparison belsőleg kezeli a fájlkezelőket és a memóriát. A try‑with‑resources használata biztosítja a megfelelő takarítást, ami különösen fontos nagy könyvtár-összehasonlításoknál.

Haladó konfigurációs beállítások

Az alap beállítás működik, de a valós helyzetek testreszabást igényelnek. Íme, hogyan finomhangolhatod az összehasonlításokat:

Kimeneti formátumok testreszabása

CompareOptions compareOptions = new CompareOptions();
compareOptions.setDirectoryCompare(true);

// HTML for human review
compareOptions.setFolderComparisonExtension(FolderComparisonExtension.HTML);

// Or PDF for formal reports
// compareOptions.setFolderComparisonExtension(FolderComparisonExtension.PDF);

Fájlok és könyvtárak szűrése

Néha nem akarod mindent összehasonlítani. Íme, hogyan lehet szelektív:

CompareOptions compareOptions = new CompareOptions();
compareOptions.setDirectoryCompare(true);

// Skip temporary files and build directories
// Note: Exact filtering syntax may vary - check current API documentation
compareOptions.setShowDeletedContent(false); // Don't highlight deleted files
compareOptions.setShowInsertedContent(true); // Do highlight new files

Gyakori problémák és megoldások

Foglalkozzunk a valószínűleg felmerülő problémákkal (mert Murphy törvénye a kódolásra is érvényes):

Probléma 1: OutOfMemoryError nagy könyvtáraknál

Tünetek: Az alkalmazásod összeomlik heap memória hibákkal, amikor több ezer fájlt tartalmazó könyvtárakat hasonlít össze.

Megoldás: Növeld a JVM heap méretét és dolgozd fel a könyvtárakat kötegekben:

// JVM args: -Xmx4g -Xms2g

// For very large directories, consider processing subdirectories separately
String[] subdirectories = {"subdir1", "subdir2", "subdir3"};
for (String subdir : subdirectories) {
    String sourceSub = sourceDirectoryPath + "/" + subdir;
    String targetSub = targetDirectoryPath + "/" + subdir;
    // Process each subdirectory individually
}

Probléma 2: FileNotFoundException a helyes útvonalak ellenére

Tünetek: Az útvonalak helyesnek tűnnek, de fájl‑nem‑található hibákat kapsz.

Gyakori okok és javítások:

Permissions: Győződj meg róla, hogy a Java alkalmazásnak olvasási jogosultsága van a forráskönyvtárakhoz és írási jogosultsága a kimeneti helyhez
Special Characters: A szóközöket vagy speciális karaktereket tartalmazó könyvtárneveket megfelelően kell escape‑elni
Network Paths: A UNC útvonalak nem mindig működnek megfelelően — először másold a fájlokat helyi gépre

// Better path handling
Path sourcePath = Paths.get(sourceDirectoryPath).toAbsolutePath();
Path targetPath = Paths.get(targetDirectoryPath).toAbsolutePath();

if (!Files.exists(sourcePath)) {
    throw new IllegalArgumentException("Source directory doesn't exist: " + sourcePath);
}
if (!Files.exists(targetPath)) {
    throw new IllegalArgumentException("Target directory doesn't exist: " + targetPath);
}

Probléma 3: Az összehasonlítás örökké tart

Tünetek: Az összehasonlítás órákig fut, anélkül, hogy befejeződne.

Megoldások:

Szűrd ki a felesleges fájlokat az összehasonlítás előtt
Használj több szálat a független alkönyvtárakhoz
Valósíts meg előrehaladás‑követést, hogy lásd, mi történik

// Add progress monitoring
CompareOptions compareOptions = new CompareOptions();
compareOptions.setDirectoryCompare(true);

// Log progress (pseudo-code - actual implementation may vary)
long startTime = System.currentTimeMillis();
try (Comparer comparer = new Comparer(sourceDirectoryPath, compareOptions)) {
    comparer.add(targetDirectoryPath, compareOptions);
    comparer.compareDirectory(outputFileName, compareOptions);
    long duration = System.currentTimeMillis() - startTime;
    System.out.println("Comparison completed in: " + (duration / 1000) + " seconds");
}

Teljesítményoptimalizálás nagyméretű összehasonlításokhoz

Amikor több ezer fájlt tartalmazó könyvtárakkal dolgozol, a teljesítmény kritikus. Íme, hogyan optimalizálhatsz:

Memóriakezelés legjobb gyakorlatai

// Increase heap size via JVM arguments
// -Xmx8g (for 8GB max heap)
// -XX:+UseG1GC (for better garbage collection with large heaps)

// In your code, help the GC by nulling large objects
CompareOptions compareOptions = new CompareOptions();
try (Comparer comparer = new Comparer(sourceDirectoryPath, compareOptions)) {
    // ... do comparison
    comparer.compareDirectory(outputFileName, compareOptions);
} // comparer auto‑closed here
compareOptions = null; // Help GC

Kötegelt feldolgozási stratégia

Nagy könyvtárstruktúrák esetén dolgozz fel darabokban:

public void compareDirectoriesInBatches(String sourceDir, String targetDir, int batchSize) {
    try {
        File[] sourceFiles = new File(sourceDir).listFiles();
        if (sourceFiles != null) {
            for (int i = 0; i < sourceFiles.length; i += batchSize) {
                int end = Math.min(i + batchSize, sourceFiles.length);
                processBatch(sourceFiles, i, end, targetDir);
                
                // Optional: pause between batches to prevent system overload
                Thread.sleep(1000);
            }
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new RuntimeException("Batch processing interrupted", e);
    }
}

Párhuzamos feldolgozás független könyvtárakhoz

Ha több könyvtárpárt hasonlítasz össze, végezd párhuzamosan:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

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

for (DirectoryPair pair : directoryPairs) {
    Future<String> future = executor.submit(() -> {
        // Perform comparison for this pair
        return compareDirectoryPair(pair.source, pair.target);
    });
    futures.add(future);
}

// Wait for all comparisons to complete
for (Future<String> future : futures) {
    try {
        String result = future.get();
        System.out.println("Comparison result: " + result);
    } catch (Exception e) {
        System.err.println("Comparison failed: " + e.getMessage());
    }
}

executor.shutdown();

Valós példák és iparági alkalmazások

A könyvtár-összehasonlítás nem csak fejlesztői eszköz — iparágakban üzletkritikus folyamatokhoz is használják:

Szoftverfejlesztés és DevOps

Release Management: A telepítés előtt a staging és a production könyvtárak összehasonlítása a konfigurációs eltérések elkapásához:

// Automated pre-deployment check
String stagingConfig = "/app/staging/config";
String productionConfig = "/app/production/config";
String reportPath = "/reports/deployment-check-" + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE) + ".html";

CompareOptions options = new CompareOptions();
options.setDirectoryCompare(true);
options.setFolderComparisonExtension(FolderComparisonExtension.HTML);

try (Comparer comparer = new Comparer(stagingConfig, options)) {
    comparer.add(productionConfig, options);
    comparer.compareDirectory(reportPath, options);
    
    // Integration with deployment pipeline
    if (hasSignificantDifferences(reportPath)) {
        throw new RuntimeException("Deployment blocked: significant configuration differences detected");
    }
}

Pénzügy és megfelelőség

Audit Trail Maintenance: Pénzügyi intézmények könyvtár-összehasonlítást használnak a dokumentumváltozások nyomon követésére a szabályozási megfelelés érdekében:

// Monthly compliance check
String previousMonthDocs = "/compliance/2024-11/documents";
String currentMonthDocs = "/compliance/2024-12/documents";
String auditReport = "/audit/compliance-changes-december-2024.html";

// Compare and generate audit‑ready reports
performComplianceComparison(previousMonthDocs, currentMonthDocs, auditReport);

Adatkezelés és ETL folyamatok

Data Integrity Verification: Biztosítani, hogy az adatátvitel sikeresen befejeződött:

public boolean verifyDataMigration(String sourceDataDir, String migratedDataDir) {
    try {
        CompareOptions options = new CompareOptions();
        options.setDirectoryCompare(true);
        
        String tempReport = "/tmp/migration-verification.html";
        try (Comparer comparer = new Comparer(sourceDataDir, options)) {
            comparer.add(migratedDataDir, options);
            comparer.compareDirectory(tempReport, options);
        }
        
        // Custom logic to parse results and determine if migration was successful
        return analyzeComparisonResults(tempReport);
    } catch (Exception e) {
        System.err.println("Migration verification failed: " + e.getMessage());
        return false;
    }
}

Tartalomkezelés és publikálás

Version Control for Non‑Technical Teams: A marketing és tartalmi csapatok Git ismeret nélkül is nyomon követhetik a dokumentumtárak változásait:

// Weekly content audit for marketing team
String lastWeekContent = "/content/backup/week-47";
String currentContent = "/content/current";
String marketingReport = "/reports/content-changes-week-48.html";

CompareOptions options = new CompareOptions();
options.setDirectoryCompare(true);
options.setFolderComparisonExtension(FolderComparisonExtension.HTML);

// Generate human‑readable report for non‑technical stakeholders
generateContentChangeReport(lastWeekContent, currentContent, marketingReport, options);

Haladó tippek és legjobb gyakorlatok

Miután a könyvtár-összehasonlítással dolgoztál gyártási környezetben, itt van néhány keményen megtanult lecke:

Naplózás és felügyelet

Mindig valósíts meg átfogó naplózást:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

private static final Logger logger = LoggerFactory.getLogger(DirectoryComparer.class);

public void compareWithLogging(String source, String target, String output) {
    logger.info("Starting directory comparison: {} vs {}", source, target);
    long startTime = System.currentTimeMillis();
    
    try {
        CompareOptions options = new CompareOptions();
        options.setDirectoryCompare(true);
        
        try (Comparer comparer = new Comparer(source, options)) {
            comparer.add(target, options);
            comparer.compareDirectory(output, options);
        }
        
        long duration = System.currentTimeMillis() - startTime;
        logger.info("Comparison completed successfully in {}ms. Report: {}", duration, output);
        
    } catch (Exception e) {
        logger.error("Directory comparison failed for {} vs {}: {}", source, target, e.getMessage(), e);
        throw new RuntimeException("Comparison failed", e);
    }
}

Hibahelyreállítás és rugalmasság

Építs be újrapróbálkozási logikát átmeneti hibák esetén:

public void compareWithRetry(String source, String target, String output, int maxRetries) {
    int attempts = 0;
    Exception lastException = null;
    
    while (attempts < maxRetries) {
        try {
            performComparison(source, target, output);
            return; // Success!
        } catch (Exception e) {
            lastException = e;
            attempts++;
            
            if (attempts < maxRetries) {
                try {
                    Thread.sleep(1000 * attempts); // Exponential backoff
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw new RuntimeException("Retry interrupted", ie);
                }
            }
        }
    }
    
    throw new RuntimeException("Comparison failed after " + maxRetries + " attempts", lastException);
}

Konfigurációkezelés

Külső forrásból töltsd be a beállításokat, hogy újrafordítás nélkül módosíthasd őket:

// application.properties
comparison.output.format=HTML
comparison.max.retries=3
comparison.batch.size=100
comparison.parallel.threads=4

// In your code
@Value("${comparison.output.format:HTML}")
private String outputFormat;

@Value("${comparison.max.retries:3}")
private int maxRetries;

Platform‑független útvonalkezelés

// Use platform-independent path handling
Path sourcePath = Paths.get(sourceDirectory);
Path targetPath = Paths.get(targetDirectory);
Path outputPath = Paths.get(outputDirectory);

// Validate permissions before starting
if (!Files.isReadable(sourcePath)) {
    throw new IllegalStateException("Cannot read source directory: " + sourcePath);
}
if (!Files.isReadable(targetPath)) {
    throw new IllegalStateException("Cannot read target directory: " + targetPath);
}
if (!Files.isWritable(outputPath.getParent())) {
    throw new IllegalStateException("Cannot write to output directory: " + outputPath.getParent());
}

Időbélyegek figyelmen kívül hagyása, ha nem fontosak

CompareOptions options = new CompareOptions();
options.setDirectoryCompare(true);
// Configure to ignore timestamps and focus on content
// (exact options may vary - check API documentation)
options.setIgnoreWhitespaces(true);
options.setIgnoreFormatting(true);

Gyakori telepítési problémák hibaelhárítása

Fejlesztésben működik, produkcióban hibás

Tünetek: Az összehasonlítás helyben működik, de a szerveren összeomlik.

Gyökér okok:

Különböző kis‑nagybetű érzékenység (Windows vs Linux)
Szigorúbb fájlrendszer jogosultságok
Keményen kódolt útvonalelválasztók (/ vs \)

Javítás: Használd a Path és File.separator osztályokat, ahogy a Platform‑független útvonalkezelés szakaszban látható.

Inkonzisztens eredmények

Tünetek: Ugyanazt az összehasonlítást kétszer futtatva különböző kimeneteket ad.

Lehetséges okok:

A futás közben módosulnak a fájlok
Az időbélyegek különbségként kerülnek figyelembe vételre
Az alapul szolgáló fájlrendszer metaadatai eltérnek

Megoldás: Állítsd be a CompareOptions-t úgy, hogy figyelmen kívül hagyja az időbélyegeket és a tényleges tartalomra koncentráljon (lásd Időbélyegek figyelmen kívül hagyása).

Gyakran ismételt kérdések

Q: Hogyan kezelem a millió fájlt tartalmazó könyvtárakat?
A: Kombináld a kötegelt feldolgozást, növeld a JVM heap-et (-Xmx), és futtasd az alkönyvtár-összehasonlításokat párhuzamosan. A Kötegelt feldolgozási stratégia és a Párhuzamos feldolgozás szakaszok kész mintákat biztosítanak.

Q: Össze tudok hasonlítani különböző szervereken lévő könyvtárakat?
A: Igen, de a hálózati késleltetés uralhatja a futási időt. A legjobb teljesítmény érdekében másold a távoli könyvtárat helyi gépre az összehasonlítás előtt, vagy csatlakoztasd a távoli megosztást megfelelő I/O sávszélességgel.

Q: Milyen fájlformátumokat támogat a GroupDocs.Comparison?
A: A GroupDocs.Comparison széles körű formátumot támogat, beleértve a DOC/DOCX, PDF, PPT/PPTX, XLS/XLSX, TXT, HTML és általános képformátumokat. Tekintsd meg a hivatalos dokumentációt a legfrissebb listáért.

Q: Hogyan integrálhatom ezt az összehasonlítást egy CI/CD pipeline-ba?
A: Csomagold be az összehasonlítási logikát egy Maven/Gradle pluginba vagy önálló JAR-ba, majd hívd meg build lépésként Jenkins, GitHub Actions, Azure Pipelines stb. használatával. Használd a Naplózás és felügyelet példát, hogy az eredményeket build artefaktumként jelenítsd meg.

Q: Lehet testreszabni a HTML jelentés kinézetét?
A: A beépített HTML sablon rögzített, de a generált fájlt (pl. egyedi CSS vagy JavaScript beillesztésével) utólag módosíthatod, hogy illeszkedjen a márkádhoz.

Következtetés

Most már egy teljes eszközkészlettel rendelkezel a robusztus könyvtár-összehasonlítás megvalósításához Java-ban a groupdocs comparison java használatával. Az alap beállítástól a gyártási szintű teljesítményhangolásig láttad, hogyan:

Telepítsd és licenceld a GroupDocs.Comparison-t
Végezz egyszerű könyvtár-összehasonlítást
Testreszabhatod a kimenetet, szűrheted a fájlokat, és kezelheted a nagy adathalmazokat
Optimalizálhatod a memóriahasználatot és párhuzamosan futtathatod az összehasonlításokat
Alkalmazhatod a technikát valós helyzetekben a DevOps, pénzügy, adatátvitel és tartalomkezelés területén
Naplózást, újrapróbálkozási logikát és külső konfigurációt adhatsz hozzá a karbantarthatóságért

A siker kulcsa, hogy egyszerűen kezdj, validáld az eredményeket, majd csak azokra a optimalizációkra építs, amelyekre valóban szükséged van. Miután elsajátítottad az alapokat, beágyazhatod ezt a képességet automatizált build pipeline-okba, megfelelőségi műszerfalakba, vagy akár egy webes felhasználói felületbe a nem technikai felhasználók számára.

Következő lépések

Próbáld ki a mintakódot egy kis tesztkönyvtáron a kimenet ellenőrzéséhez
Méretezz fel egy nagyobb könyvtárra, és kísérletezz a kötegelt/párhuzamos feldolgozással
Integráld az összehasonlítási lépést a CI/CD munkafolyamatodba, és generálj automatizált jelentéseket minden kiadásra

Segítségre van szükség? A GroupDocs közösség aktív és reagál. Nézd meg a dokumentációjukat, fórumokat, vagy fordulj a támogatáshoz konkrét API kérdések esetén.

Utolsó frissítés: 2025-12-20
Tesztelve: GroupDocs.Comparison 25.2 (Java)
Szerző: GroupDocs

FilesExpand file tree

_index.md

Latest commit

History