เปรียบเทียบเอกสารใน Java – คู่มือเต็มของ GroupDocs API

บทนำ

เคยเจอว่าตัวเองต้องเปรียบเทียบเอกสารสองไฟล์แบบทำมือทีละบรรทัด แล้วพลาดความแตกต่างที่สำคัญหรือไม่? คุณไม่ได้เป็นคนเดียว compare documents in java เป็นความท้าทายที่พบบ่อย โดยเฉพาะเมื่อคุณต้องคงเมตาดาต้า, จัดการไฟล์ที่มีการป้องกันด้วยรหัสผ่าน, หรือเปรียบเทียบไฟล์หลายไฟล์พร้อมกัน.

นี่คือเรื่อง: นักพัฒนาส่วนใหญ่ประสบปัญหาเพราะพวกเขาหรือสร้างอะไรจากศูนย์ (ซึ่งใช้เวลานาน) หรือใช้เครื่องมือ diff พื้นฐานที่ละเลยการจัดรูปแบบ, เมตาดาต้า, และการตั้งค่าความปลอดภัย. นั่นคือจุดที่ GroupDocs.Comparison for Java เข้ามาช่วย.

ในบทแนะนำที่ครอบคลุมนี้ คุณจะได้ค้นพบวิธีการทำให้การเปรียบเทียบเอกสารในแอปพลิเคชัน Java ของคุณมีความแข็งแรง เราจะครอบคลุมทุกอย่างตั้งแต่การตั้งค่าเบื้องต้นจนถึงการจัดการเมตาดาต้าขั้นสูง พร้อมตัวอย่างจากโลกจริงที่คุณสามารถนำไปใช้ในขั้นตอนการผลิตได้จริง เมื่อจบคุณจะรู้วิธี:

ตั้งค่า GroupDocs.Comparison ในโปรเจกต์ Java ของคุณ (ง่ายกว่าที่คิด)
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, และอื่น ๆ
จัดการเมตาดาต้า – เลือกใช้เมตาดาต้าจากต้นฉบับ, เป้าหมาย, หรือไม่มีเมตาดาต้าในผลลัพธ์
รองรับรหัสผ่าน – เปิดไฟล์ที่ป้องกันโดยไม่ต้องถอดรหัสด้วยตนเอง
ประสิทธิภาพที่ขยายได้ – ประมวลผลเป็นชุด, การทำงานแบบ async, และการออกแบบที่ประหยัดหน่วยความจำ

ข้อกำหนดเบื้องต้น

สภาพแวดล้อม Java: JDK 8+ (แนะนำ JDK 11+), IDE ที่คุณชอบ, Maven (หรือ Gradle)
ไลบรารี GroupDocs.Comparison: เวอร์ชัน 25.2 หรือใหม่กว่า (ควรใช้เวอร์ชันล่าสุดเสมอ)
ไลเซนส์: ทดลองฟรี, ไลเซนส์ชั่วคราว 30‑วัน, หรือไลเซนส์เชิงพาณิชย์

การตั้งค่า GroupDocs.Comparison ในโปรเจกต์ของคุณ

การกำหนดค่า Maven

เริ่มต้นด้วยการเพิ่มรีโพสิตอรีของ GroupDocs และ dependency ลงใน pom.xml ของคุณ นี่คือจุดที่หลายบทเรียนทำให้ซับซ้อนเกินความจำเป็น แต่จริง ๆ แล้วค่อนข้างง่าย:

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

เคล็ดลับ: ตรวจสอบหมายเลขเวอร์ชันล่าสุดเสมอบน หน้า releases ของ GroupDocs เวอร์ชันใหม่มักมาพร้อมการปรับปรุงประสิทธิภาพและแก้บั๊กที่ช่วยลดปัญหาได้

การจัดการไลเซนส์ของคุณ

นี่คือสิ่งที่นักพัฒนาส่วนใหญ่ไม่รู้: คุณสามารถเริ่มทดสอบ GroupDocs.Comparison ได้ทันทีด้วยการทดลองฟรี ไม่ต้องใช้บัตรเครดิต ไม่ต้องมีเงื่อนไขใด ๆ

ตัวเลือกของคุณ:

ทดลองฟรี – เหมาะสำหรับการทดสอบและโปรเจกต์ขนาดเล็ก เพียงดาวน์โหลดและเริ่มเขียนโค้ด!
ไลเซนส์ชั่วคราว – ต้องการเวลามากกว่านี้เพื่อประเมิน? รับไลเซนส์ชั่วคราว 30‑วัน ที่นี่
ไลเซนส์เชิงพาณิชย์ – พร้อมสำหรับการผลิต? ดูราคา ที่นี่

การทดลองฟรีให้คุณเข้าถึงทุกฟีเจอร์ แต่จะใส่ลายน้ำบนไฟล์ผลลัพธ์ สำหรับการพัฒนาและทดสอบโดยทั่วไปถือว่าเพียงพอ

การทำงานเปรียบเทียบเอกสาร: คู่มือครบถ้วน

นี่คือส่วนสำคัญ! เราจะสร้างโซลูชันการเปรียบเทียบเอกสารแบบเต็มขั้นตอน อย่ากังวล – เราจะอธิบายไม่เพียง “วิธีทำ” แต่ยังรวมถึง “ทำไม” ของแต่ละขั้นตอน

ทำความเข้าใจแหล่งเมตาดาต้า (สำคัญมาก!)

ก่อนเริ่มเขียนโค้ด เรามาพูดถึงสิ่งที่ทำให้นักพัฒนาหลายคนสับสน: แหล่งเมตาดาต้า เมื่อคุณ compare documents in java คุณต้องตัดสินใจว่าจะใช้เมตาดาต้าของเอกสารใด (ผู้เขียน, วันที่สร้าง, คุณสมบัติที่กำหนดเอง ฯลฯ) เพื่อคงไว้ในผลลัพธ์

GroupDocs.Comparison มีสามตัวเลือก:

SOURCE – ใช้เมตาดาต้าจากเอกสารต้นฉบับ
TARGET – ใช้เมตาดาต้าจากเอกสารเป้าหมาย
NONE – ลบเมตาดาต้าทั้งหมดออกจากผลลัพธ์

สำหรับแอปธุรกิจส่วนใหญ่ คุณมักจะเลือก SOURCE เพื่อรักษาความสอดคล้อง

ขั้นตอนการทำงานแบบเป็นขั้นตอน

เราจะสร้างยูทิลิตี้ที่สามารถนำกลับมาใช้ใหม่ได้ในทุกโปรเจกต์

ขั้นตอนที่ 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
}

ทำไมต้องใช้ try‑with‑resources? คลาส Comparer implements AutoCloseable ซึ่งหมายความว่าจะทำความสะอาดทรัพยากรอย่างถูกต้องเมื่อเสร็จสิ้น ป้องกันการรั่วของหน่วยความจำ – สำคัญมากเมื่อประมวลผลเอกสารจำนวนมาก

ขั้นตอนที่ 3: เพิ่มเอกสารเป้าหมายสำหรับการเปรียบเทียบ

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

สิ่งที่น่าสนใจ: คุณสามารถเพิ่มเอกสารเป้าหมายหลายไฟล์และเปรียบเทียบทั้งหมดกับต้นฉบับในหนึ่งการดำเนินการ เพียงเรียก 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());

กำลังทำอะไรอยู่? เราบอก GroupDocs ให้:

เปรียบเทียบเอกสารที่เพิ่มทั้งหมดกับต้นฉบับ
บันทึกผลลัพธ์ไปยังเส้นทางที่กำหนด
ใช้เมตาดาต้า 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);
        }
    }
}

ปัญหาที่พบบ่อยและวิธีหลีกเลี่ยง

หลังจากช่วยนักพัฒนาหลายร้อยคนทำการเปรียบเทียบเอกสาร ฉันพบปัญหาเดิม ๆ ซ้ำ ๆ นี่คือปัญหาใหญ่ (และวิธีแก้)

ปัญหาเส้นทางไฟล์

ปัญหา: FileNotFoundException แม้ไฟล์จะมีอยู่จริง
วิธีแก้: ใช้เส้นทางแบบ absolute เสมอ หรือแก้ไขการ resolve เส้นทาง relative อย่างถูกต้อง

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

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

ปัญหาการจัดการหน่วยความจำ

ปัญหา: Out of memory เมื่อเปรียบเทียบเอกสารขนาดใหญ่
วิธีแก้: เพิ่มขนาด heap ของ JVM และใช้การจัดการทรัพยากรที่เหมาะสม

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

การจัดการเมตาดาต้าไม่ถูกต้อง

ปัญหา: สูญเสียเมตาดาต้าที่สำคัญระหว่างการเปรียบเทียบ
วิธีแก้: ตั้งค่า Metadata อย่างชัดเจน – อย่าพึ่งพาค่าตั้งต้น

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

ปัญหาไลเซนส์

ปัญหา: ลายน้ำปรากฏในสภาพการผลิต
วิธีแก้: ตรวจสอบว่าไลเซนส์โหลดอย่างถูกต้องก่อนสร้างอินสแตนซ์ Comparer

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

แนวทางปฏิบัติที่ดีที่สุดสำหรับการใช้งานใน Production

จากประสบการณ์จริง นี่คือแนวทางที่ทำให้โค้ดจากระดับสมัครเล่นกลายเป็นโซลูชันพร้อมใช้งานจริง

การจัดการข้อผิดพลาดที่มีประโยชน์

อย่าแค่จับ Exception – ให้จัดการอย่างมีความหมาย:

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

การเพิ่มประสิทธิภาพ

สำหรับสถานการณ์ที่ต้องประมวลผลปริมาณมาก ให้พิจารณาการปรับแต่งต่อไปนี้:

Reuse อินสแตนซ์ Comparer เมื่อเป็นไปได้ (ต้องระวังเรื่อง thread‑safety)
ประมวลผลเป็นชุด เพื่อหลีกเลี่ยงการใช้ทรัพยากรเกินขนาด
ใช้การประมวลผลแบบ asynchronous สำหรับเอกสารขนาดใหญ่
มอนิเตอร์การใช้หน่วยความจำ และปรับตั้งค่า JVM ตามความจำเป็น

พิจารณาด้านความปลอดภัย

เมื่อจัดการเอกสารที่เป็นความลับ:

ตรวจสอบประเภทไฟล์ ก่อนประมวลผล
กำหนดการควบคุมการเข้าถึง อย่างเหมาะสม
ลบไฟล์ชั่วคราว ทันทีหลังใช้งาน
พิจารณาการเข้ารหัส ผลลัพธ์การเปรียบเทียบ

การใช้งานจริงและกรณีศึกษา

มาดูว่าผู้พัฒนาจริง ๆ ใช้ 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)

แพลตฟอร์ม 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”

สาเหตุที่พบบ่อยที่สุด:

รูปแบบไฟล์ที่ไม่รองรับ
เอกสารต้นฉบับเสียหาย
หน่วยความจำไม่พอ
ปัญหาการอนุญาตไฟล์

ขั้นตอนการดีบัก:

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

ปัญหาประสิทธิภาพ

หากการเปรียบเทียบใช้เวลานานเกินไป:

ตรวจสอบขนาดเอกสาร – ไฟล์ที่ใหญ่กว่า 100 MB อาจต้องการการจัดการพิเศษ
มอนิเตอร์การใช้หน่วยความจำ – เพิ่ม heap หากจำเป็น
ตรวจสอบประสิทธิภาพ I/O – ที่เก็บข้อมูลช้าอาจเป็นคอขวด
พิจารณารูปแบบไฟล์ – บางรูปแบบซับซ้อนต่อการประมวลผลมากกว่า

การรั่วของหน่วยความจำ

สัญญาณว่ามีการรั่ว:

ประสิทธิภาพของแอปลดลงตามเวลา
OutOfMemoryError หลังประมวลผลหลายไฟล์
การทำ GC สูงเกินไป

วิธีแก้: ใช้ 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
}

การผสานรวมกับ Spring Boot

สำหรับนักพัฒนาที่สร้าง microservices ให้ห่อหุ้มตรรกะการเปรียบเทียบไว้ใน 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);
        }
    }
}

คำถามที่พบบ่อย

ถาม: ฉันสามารถเปรียบเทียบมากกว่าสองเอกสารพร้อมกันได้หรือไม่?
ตอบ: แน่นอน! เพิ่มเอกสารเป้าหมายหลายไฟล์ด้วย comparer.add() ก่อนรันการเปรียบเทียบ

ถาม: GroupDocs.Comparison รองรับรูปแบบไฟล์อะไรบ้าง?
ตอบ: รองรับ DOCX, PDF, XLSX, PPTX, TXT และอื่น ๆ อีกหลายรูปแบบ ดูรายการเต็มในเอกสารอย่างเป็นทางการ

ถาม: ฉันจะจัดการกับเอกสารที่ป้องกันด้วยรหัสผ่านอย่างไร?
ตอบ: ใช้คลาส LoadOptions เพื่อส่งรหัสผ่านเมื่อสร้างอินสแตนซ์ Comparer (ดูตัวอย่างด้านบน)

ถาม: GroupDocs.Comparison ปลอดภัยต่อการทำงานหลายเธรดหรือไม่?
ตอบ: อินสแตนซ์ Comparer เดียวไม่ปลอดภัยต่อหลายเธรด แต่คุณสามารถสร้างหลายอินสแตนซ์และใช้พร้อมกันได้

ถาม: ฉันจะปรับปรุงประสิทธิภาพสำหรับเอกสารขนาดใหญ่ได้อย่างไร?
ตอบ: เพิ่ม heap ของ JVM (-Xmx), ประมวลผลไฟล์แบบ asynchronous, ทำเป็นชุด, และ reuse อินสแตนซ์ Comparer เมื่อเหมาะสม

แหล่งข้อมูลเพิ่มเติม

GroupDocs.Comparison Documentation – เอกสาร API อย่างละเอียดและตัวอย่าง
GroupDocs Community Forum – รับความช่วยเหลือจากนักพัฒนาคนอื่น

อัปเดตล่าสุด: 2025-12-21
ทดสอบกับ: GroupDocs.Comparison 25.2
ผู้เขียน: GroupDocs

FilesExpand file tree

_index.md

Latest commit

History