groupdocs összehasonlítás java – Java Word dokumentum összehasonlítás

Eltöltöttél már órákat kézzel két Word dokumentum összehasonlításával, hogy megtaláltad a legapróbb változást? Biztosan nem vagy egyedül. Legyen szó szerződésváltozatok kezeléséről, tartalomfrissítések nyomon követéséről vagy együttműködő szerkesztési munkafolyamatok kezeléséről, a dokumentumok kézi összehasonlítása időigényes és hibás hajlamos.

A groupdocs összehasonlítása java segítségével ez a fáradságos folyamat másodpercek alatt automatizálható. A könyvtár pontosan meghatározza a különbségeket, kiemeli a beszúrásokat, törléseket és formázási változásokat, és egy professzionális jelentést generál, amelyet megoszthatsz az érintettekkel.

az átfogó útmutatóban pontosan megtudod, hogyan valósítható meg a dokumentum-összehasonlítás a Java alkalmazásaidban – az alapbeállítástól a fejlett forgatókönyvekig –, hogy a kézi ellenőrzéseket megbízhatóan, ismételhető automatizációra cseréld.

Gyors válaszok

  • **Melyik könyvtár kezeli a Word diff-et Java-ban?**groupdocs összehasonlító java
  • **Összehasonlíthatom a DOCX-fájlokat?**Igen, használja a “Java docx-fájlok összehasonlítása” funkciót
  • Szükség van licencre a termeléshez? Teljes GroupDocs.Comparison licenc szükséges
  • **Milyen gyors az összehasonlítás?**A tipikus kis dokumentumok kevesebb mint 1 másodperc alatt elkészülnek; nagy dokumentumokhoz néhány másodpercre lehet szükség
  • Kompatibilis a Maven és a Gradle programokkal? Természetesen mindkét összeállítási eszköz támogatott

Mi az a groupdocs összehasonlító java?

groupdocs összehasonlítása java egy Java SDK, amely két vagy több dokumentumot elemez, szöveges és strukturális változásokat észlel, és egy kiemelt eredménydokumentumot hoz létre. Word, PDF, Excel, PowerPoint és számos egyéb formátummal működik, egyértelműen vizuális diffet biztosítva, amelyet a nem-technikai ellenőrzők is megértenek.

Miért érdemes a groupdocs összehasonlító javát használni?

  • Sebesség: Automatizálja a perceket vagy órákat manuálisan.
  • Pontosság: Még a legkisebb karakterváltozást is érzékeli.
  • Skálázhatóság: Több tucat dokumentum kötegelt feldolgozását kezeli.
  • Rugalmasság: DOCX, PDF és több mint 50 egyéb formátummal működik.

Előfeltételek és amire szüksége lesz

Mielőtt belevágnánk a megvalósításba, győződjünk meg róla, hogy a fejlesztői környezet készen áll. Ne aggódj – a beállítás egyszerű, és minden lépésen végigvezetlek.

Alapvető követelmények:

  • Java Development Kit (JDK): 8-as vagy újabb verzió (JDK11+ ajánlott a jobb teljesítmény érdekében)
  • Maven vagy Gradle: Függőségkezeléshez (a példáinkban Mavent fogunk használni)
  • Alapvető Java ismeretek: Osztályok, objektumok és fájlkezelés ismerete
  • GroupDocs.Comparison Library: 25.2-es verzió (legújabb stabil kiadás)

Ajánlott beállítás:

  • IDE, mint például IntelliJ IDEA vagy Eclipse a jobb fejlesztési élmény érdekében
  • Legalább 2 GB RAM rendelkezésre áll nagyobb dokumentumok feldolgozásához
  • Minta Word dokumentumok teszteléshez (megmutatjuk, hogyan hozhat létre tesztfájlokat)

Gyors környezetellenőrzés:

Futtassa a java -version parancsot a terminálban. Ha 8-as vagy újabb verziót lát, akkor indulhat is!

Most, hogy az alapokkal tisztában vagyunk, integráljuk a GroupDocs.Comparisont a projektbe.

A GroupDocs.Comparison beállítása Java számára

A GroupDocs.Comparison beillesztése a projektedbe egyszerűbb, mint gondolnád. A könyvtár Maven‑en érhető el, ami azt jelenti, hogy nincs szükség kézi JAR‑letöltésre vagy classpath‑bonyodalomra.

Maven Integration Made Simple

Adja hozzá ezt a konfigurációt a “pom.xml” fájlhoz:

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

Miért működik ez a konfiguráció:

  • A tárhely URL-címe közvetlenül a GroupDocs hivatalos Maven tárhelyére mutat.
  • A 25.2-es verzió a legújabb stabil kiadás, amely tartalmazza az összes szükséges hibajavítást.
  • A függőség automatikusan behívja az összes szükséges alfüggőséget.

Gradle felhasználók

Ha a Gradle-t részesíti előnyben, itt van az egyenértékű konfiguráció:

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

Licencopciók (Fontos éles használatra)

A GroupDocs.Comparison rugalmas licencopciókat kínál:

  • Ingyenes próbaverzió: Tökéletes kiértékeléshez – teljes funkcionalitást tartalmaz kisebb korlátozásokkal
  • Ideiglenes licenc: Ideális hosszabb tesztelési időszakokhoz vagy koncepcióbizonyítás fejlesztéséhez
  • Teljes licenc: Éles alkalmazásokhoz szükséges – eltávolítja az összes korlátozást

Profi tipp: Kezdje az ingyenes próbaverzióval, hogy megismerkedjen az API-val. A funkcionalitás megegyezik a teljes verzióval, így a fejlesztői munkája nem vész kárba.

Miután a függőségek megoldódtak és a projekt sikeresen felépített, készen áll a dokumentum-összehasonlító funkció megvalósítására.

Lépésről lépésre útmutató a megvalósításhoz

Most jön az izgalmas rész – a dokumentumok tényleges összehasonlítása! Részletes magyarázatokkal végigvezetem minden lépésen, így nemcsak a „hogyan”, hanem a „miért” mögött álló döntéseket is megérti.

1. lépés: A Comparer objektum inicializálása

Minden dokumentum-összehasonlítás egy Comparer objektum létrehozásával kezdődik. Gondolj erre úgy, mint a munkaterület beállítására, mielőtt elkezdenéd a tényleges összehasonlítást.

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

Mi történik itt:

  • Egy „try-with-resources” blokkot használunk a megfelelő erőforrás-tisztítás biztosítására.
  • A forrásdokumentum szolgál „alapvonalként” – minden módosítást ehhez mérünk.
  • Cserélje ki a „YOUR_DOCUMENT_DIRECTORY” részt a dokumentumok tényleges elérési útjával.

Gyakori hiba: Győződjön meg arról, hogy a fájlelérési utak helyesek! Használjon abszolút elérési utakat, ha nem biztos benne, vagy ellenőrizze, hogy a relatív elérési utak helyesek-e az alkalmazás munkakönyvtárából.

2. lépés: Céldokumentumok hozzáadása összehasonlításhoz

Ezután megadjuk, hogy mely dokumentumo(ka)t szeretnénk összehasonlítani a forrásdokumentummal. Itt kezdődik a varázslat!

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

Miért fontos ez a lépés:

  • A céldokumentum tartalmazza az azonosítani kívánt módosításokat.
  • Szükség esetén több céldokumentumot is hozzáadhat (nagyszerű több verzió összehasonlításához).
  • A könyvtár elemzi a forrás- és az összes céldokumentum közötti különbségeket.

Haladó használat: Több dokumentummal kell összehasonlítania? Nem probléma:

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

3. lépés: Összehasonlítás végrehajtása és eredmények generálása

Itt történik a nehéz munka. A könyvtár mindkét dokumentumot elemzi, és átfogó összehasonlító jelentést készít.

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

Amit kapsz:

  • Egy új Word-dokumentum, amely kiemeli az összes különbséget

  • A törölt szöveg egyértelműen megjelölve (általában áthúzással)

  • A hozzáadott szöveg kiemelve (általában más színnel)

  • A módosított részek egyértelműen megjelölve

A létrehozott összehasonlító dokumentum nem csupán egy egyszerű különbség – ez egy professzionális minőségű jelentés, amelyet megoszthat az érdekelt felekkel, belefoglalhat a dokumentációba, vagy felhasználhat auditálási célokra.

Teljes működő példa

Íme a teljes implementáció, amelyet másolhat és futtathat:

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();
        }
    }
}

Gyakori problémák elhárítása

Probléma: FileNotFoundException Megoldás: Ellenőrizze a fájlútvonalakat, és győződjön meg arról, hogy a dokumentumok léteznek. Az összehasonlítás előtt használja a File.exists() függvényt.

Probléma: OutOfMemoryError nagy dokumentumoknál Megoldás: Növelje a JVM heap méretét -Xmx2g vagy magasabb paraméterrel a futtatási konfigurációban.

Probléma: Váratlan összehasonlítási eredmények Megoldás: Győződjön meg arról, hogy mindkét dokumentum érvényes Word-fájl, és nem sérült. Először próbálja meg megnyitni őket Microsoft Wordben.

Most, hogy az alapvető összehasonlítás működik, vizsgáljuk meg, hogy ez a funkció hol igazán kiemelkedik a valós alkalmazásokban.

Valós alkalmazások és használati esetek

A dokumentum-összehasonlítás nem csak egy jó, ha van – sok üzleti helyzetben gyökeres változást hoz. Hadd mutassak be néhány gyakorlati alkalmazást, ahol ez a funkció órákig tartó manuális munkát takaríthat meg.

1. Szerződéskezelés és jogi felülvizsgálat

A kihívás: Az ügyvédi irodáknak és a vállalkozásoknak nyomon kell követniük a szerződésmódosítások változásait, biztosítva, hogy semmi fontos ne maradjon ki vagy ne módosuljon véletlenül.

A GroupDocs hogyan segít:

  • Automatikusan kiemeli az összes változást a szerződésváltozatok között
  • Professzionális jelentéseket készít az ügyfelek felülvizsgálatára
  • A jogi felülvizsgálati idő 70–80%-kal csökken
  • Az emberi hibák kiküszöbölése a változtatások észlelésekor

Megvalósítási tipp: Hozzon létre egy kötegelt feldolgozási rendszert, amely automatikusan összehasonlítja a több szerződésváltozatot, amikor új tervezetek kerülnek feltöltésre.

2. Tartalomkezelés és közzétételi munkafolyamatok

A forgatókönyv: A kiadói csapatoknak a közzététel előtt át kell tekinteniük a tartalomfrissítéseket, biztosítva a minőséget és az egységességet.

Előnyök:

  • Egyszerűsíti a szerkesztői ellenőrzési folyamatokat
  • Követi a közreműködők változásait az együttműködésen alapuló projektekben
  • Fenntartja a tartalomminőségi szabványokat
  • Automatizálja a publikálás előtti ellenőrzéseket

3. Verziókövetés nem műszaki csapatok számára

A probléma: Nem mindenki használja a Git-et, vagy érti a műszaki verziókövetést, de továbbra is nyomon kell követniük a dokumentumok változásait.

Megoldás:

  • Vizuális, könnyen érthető változáskövetés biztosítása
  • Lehetővé teszi a nem műszaki érdekelt felek számára a módosítások áttekintését
  • Auditnaplók létrehozása a megfelelőségi követelményekhez
  • Egyszerűsíti a jóváhagyási munkafolyamatokat

4. Minőségbiztosítás a dokumentációban

Használati eset: Műszaki írócsapatok, akik felhasználói kézikönyveket, API-dokumentációkat vagy megfelelőségi dokumentumokat tartanak karban.

Szolgáltatott érték:

  • Pontosság biztosítása a dokumentációfrissítések során
  • A műszaki terminológia egységességének fenntartása
  • Felgyorsítja az áttekintési ciklusokat
  • Csökkenti a dokumentációs hibákat

Integrációs lehetőségek

Fontolja meg a dokumentum-összehasonlítás integrálását a következőkkel:

  • Dokumentumkezelő rendszerek: Verziók automatikus összehasonlítása új fájlok feltöltésekor
  • Munkafolyamat-automatizálás: Összehasonlító jelentések indítása a jóváhagyási folyamatok részeként
  • Értesítési rendszerek: Értesítse az érdekelt feleket jelentős változások észlelésekor
  • Megfelelőség-felügyelet: Változások nyomon követése a szabályozási jelentésekhez

A programozott dokumentum-összehasonlítás sokoldalúsága számtalan lehetőséget nyit meg az üzleti folyamatok javítására.

Teljesítményoptimalizálás és bevált gyakorlatok

Amikor termelési környezetben végez dokumentum-összehasonlítást, a teljesítmény kulcsfontosságúvá válik. Íme néhány bevált stratégia, amelyek biztosítják a zökkenőmentes megvalósítást, még nagy terhelés alatt is.

Memóriakezelés nagy dokumentumokhoz

Kihívás: A nagyméretű Word-dokumentumok (50+ oldal) jelentős memóriát fogyaszthatnak az összehasonlítás során.

Megoldások:

  • JVM finomhangolás: Foglaljon le elegendő heap memóriát -Xmx4g vagy újabb kapcsolóval.
  • Adagfeldolgozás: Nagyon nagy dokumentumok esetén érdemes részekre bontani őket.
  • Szemétgyűjtés: Használjon G1 szemétgyűjtőt a jobb memóriakezelés érdekében.

Kódpélda a memória-tudatos összehasonlításhoz:

// 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();
}

Kötegelt feldolgozási stratégiák

Több dokumentumpár összehasonlításakor:

Szekvenciális feldolgozás (Egyszerű, de lassabb):

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

Párhuzamos feldolgozás (Gyorsabb, de memóriaigényes):

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);
    }
});

Teljesítményfigyelési tippek

Kulcsfontosságú mérőszámok a nyomon követéshez:

  • Összehasonlítási idő dokumentumméret szerint
  • Memóriahasználati minták
  • Siker/sikertelenség aránya
  • Várakozási sor feldolgozási ideje (aszinkron feldolgozás használata esetén)

Megvalósítási példa:

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");
}

Könyvtárfrissítések és karbantartás

Maradjon naprakész: A GroupDocs rendszeresen ad ki frissítéseket teljesítménybeli fejlesztésekkel és hibajavításokkal. Frissítse a függőségét legalább negyedévente:

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

Ezen gyakorlatok betartása biztosítja, hogy a dokumentum-összehasonlító rendszer a használat skálázódása mellett is gyors és megbízható maradjon.

Speciális konfiguráció és testreszabás

Míg az alapvető összehasonlítási funkciók azonnal nagyszerűen működnek, a GroupDocs.Comparison hatékony testreszabási lehetőségeket kínál, amelyek lehetővé teszik a viselkedés testreszabását az Ön egyedi igényeihez.

Összehasonlítási beállítások testreszabása

Miért érdemes testreszabni? A különböző felhasználási esetek eltérő megközelítéseket igényelnek. A jogi dokumentumok nagyobb érzékenységet igényelnek, mint az alkalmi tartalom-áttekintések.

Példa – Nagy érzékenységű összehasonlítás:

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);
}

Kimeneti formázási beállítások

Szabályozza, hogyan jelenjenek meg a különbségek az eredménydokumentumban:

  • Színsémák: Kiemelő színek testreszabása
  • Változásjelzők: Válassza ki, hogyan jelenjenek meg a beszúrások és törlések
  • Összefoglaló jelentések: Tartalmazza a változások statisztikai összefoglalását

Hibakezelési bevált gyakorlatok

Hatékony hibakezelési példa:

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);
        }
    }
}

Ez a megközelítés biztosítja, hogy az alkalmazás szabályosan kezelje a hibákat, és értelmes visszajelzést adjon a felhasználóknak.

Gyakran Ismételt Kérdések

Összehasonlíthatok kettőnél több dokumentumot egyszerre?

Természetesen! A GroupDocs.Comparison több céldokumentumot támogat egyetlen forrásból. Egyszerűen hívja meg a comparer.add() függvényt többször:

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");
}

Ez különösen hasznos több dokumentumverzió közötti változások követéséhez vagy a különböző csapattagok hozzájárulásainak összehasonlításához.

Milyen fájlformátumokat támogat a GroupDocs.Comparison a Word dokumentumokon túl?

A GroupDocs.Comparison több mint 50 fájlformátummal működik, beleértve:

  • Dokumentumok: DOCX, DOC, PDF, RTF, TXT
  • Táblázatok: XLSX, XLS, CSV
  • Prezentációk: PPTX, PPT
  • Képek: PNG, JPEG, BMP, TIFF
  • Web: HTML, MHT
  • E-mail: EML, MSG

Az API minden formátumban konzisztens marad, így a készségek könnyen átvihetők.

Hogyan kezeljem a jelszóval védett dokumentumokat?

A GroupDocs.Comparison jelszóval védett dokumentumokkal is tud dolgozni a jelszó inicializálás során történő megadásával:

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");
}

Milyen hatással van a teljesítményre nagy dokumentumok esetén?

A teljesítmény a dokumentum méretétől és összetettségétől függően változik:

  • Kis dokumentumok (<10 oldal): Másodpercnél rövidebb idő összehasonlításban
  • Közepes dokumentumok (10-50 oldal): Általában 2-10 másodperc
  • Nagy dokumentumok (50+ oldal): 30+ másodpercet és további memóriát igényelhetnek

Optimalizálási tippek:

  • Foglaljon le elegendő JVM heap memóriát (4 GB+ nagy dokumentumokhoz)
  • Használjon SSD tárolót a gyorsabb I/O érdekében
  • Fontolja meg a dokumentumok szegmentálását nagyon nagy fájlok esetén

Integrálhatom ezt Spring Boot vagy más Java keretrendszerekkel?

Határozottan! A GroupDocs.Comparison zökkenőmentesen integrálható bármilyen Java keretrendszerrel. Íme egy példa a Spring Boot szolgáltatásra:

@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);
        }
    }
}

Hogyan szabhatom testre az összehasonlítási eredmények megjelenését?

A GroupDocs széleskörű stílusbeállításokat kínál:

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

Ez lehetővé teszi, hogy megfeleljen szervezete dokumentumszabványainak, vagy tematikus összehasonlító jelentéseket készítsen.

További források

Utolsó frissítés: 2026-02-16 Tesztelve: GroupDocs.Comparison 25.2 for Java Szerző: GroupDocs