jak wyświetlić formaty – Kompletny przewodnik wykrywania

Czy kiedykolwiek próbowałeś przetworzyć dokument w Javie i napotkałeś problem, ponieważ twoja biblioteka nie obsługuje tego konkretnego formatu? Nie jesteś sam. Zgodność formatów plików to jeden z tych gotcha momentów, które mogą zniweczyć projekt szybciej niż zdążysz powiedzieć UnsupportedFileException.

Znajomość how to list formats jest niezbędna do budowania solidnych systemów przetwarzania dokumentów. Niezależnie od tego, czy tworzysz platformę zarządzania dokumentami, usługę konwersji plików, czy po prostu potrzebujesz validate document upload java, programowe wykrywanie formatów chroni cię przed niespodziewanymi problemami w czasie działania i niezadowolonymi użytkownikami.

W tym przewodniku dowiesz się, jak check file format java, pobrać typy plików java i zintegrować te kontrole w rzeczywistych aplikacjach Java przy użyciu GroupDocs.Comparison.

Szybkie odpowiedzi

  • What is the primary method to list formats? FileType.getSupportedFileTypes() zwraca każdy format, który może obsłużyć bieżąca wersja biblioteki.
  • Do I need a license to use the API? Tak — darmowa wersja próbna lub tymczasowa licencja jest wymagana do rozwoju, a licencja komercyjna do produkcji.
  • Can I cache the format list? Absolutnie — buforowanie zmniejsza jednorazowy narzut ładowania metadanych formatu.
  • Is format detection thread‑safe? Tak, API GroupDocs jest wątkowo‑bezpieczne; wystarczy zapewnić, że własne buforowanie obsługuje współbieżność.
  • Will the list change with library updates? Nowe wydania często dodają formaty; ponownie buforuj po aktualizacjach, aby być na bieżąco.

Dlaczego wykrywanie formatu pliku ma znaczenie w aplikacjach Java?

Wczesne wykrywanie obsługiwanych formatów zapobiega awariom w czasie działania, redukuje marnowanie cykli CPU i pozwala dawać użytkownikom natychmiastową informację zwrotną o tym, jakie pliki mogą przesłać. Sprawdzając kompatybilność przed jakimkolwiek intensywnym przetwarzaniem, utrzymujesz usługę responsywną i czyste logi błędów.

Typowe scenariusze, w których wykrywanie formatu ratuje sytuację:

  • Upload validation – odrzucaj nieobsługiwane pliki na krawędzi.
  • Batch processing – pomijaj pliki, które spowodowałyby błąd, utrzymując wsad przy życiu.
  • API integration – zwracaj jasne komunikaty o błędach zamiast ogólnych 500.
  • Resource planning – oszacuj CPU i pamięć na podstawie znanych cech formatu.
  • User experience – wyświetl zwięzłą listę obsługiwanych rozszerzeń w selektorach plików.

Wpływ na biznes

Inteligentne wykrywanie formatu to nie tylko techniczna ozdoba — ma bezpośredni wpływ na Twój wynik finansowy:

  • Reduced support tickets: Użytkownicy wiedzą z góry, co działa.
  • Better resource utilization: Przetwarzaj tylko kompatybilne pliki, zwalniając CPU dla innych zadań.
  • Improved satisfaction: Jasna informacja zwrotna eliminuje frustrację.
  • Faster development cycles: Wczesna walidacja łapie błędy przed QA.

Wymagania wstępne i konfiguracja

Czego będziesz potrzebować

Środowisko programistyczne

  • Java Development Kit (JDK) 8 lub wyższy
  • Maven lub Gradle do zarządzania zależnościami
  • Twoje ulubione IDE (IntelliJ IDEA, Eclipse, VS Code)

Wymagania wiedzy

  • Podstawowa składnia Java i koncepcje OOP
  • Znajomość struktury projektów Maven/Gradle
  • Zrozumienie obsługi wyjątków w Javie

Zależności biblioteczne

  • GroupDocs.Comparison for Java (pokażemy, jak go dodać)

Nie martw się, jeśli nigdy wcześniej nie używałeś GroupDocs — przeprowadzimy Cię przez każdy krok.

Konfiguracja GroupDocs.Comparison dla Java

Dlaczego GroupDocs.Comparison?

GroupDocs.Comparison obsługuje ponad 70 formatów wejściowych i wyjściowych, od klasycznych plików Office po rysunki CAD i archiwa e‑mail. Oferuje jednorodne, spójne API, więc nie musisz żonglować wieloma bibliotekami.

Instalacja Maven

Dodaj to repozytorium i zależność do swojego 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>

Konfiguracja Gradle

Dla użytkowników Gradle, dodaj to do swojego build.gradle:

repositories {
    maven {
        url 'https://releases.groupdocs.com/comparison/java/'
    }
}

dependencies {
    implementation 'com.groupdocs:groupdocs-comparison:25.2'
}

Opcje konfiguracji licencji

Do rozwoju

  • Free Trial – idealny do oceny, nie wymaga karty kredytowej.
  • Temporary License – pełny zestaw funkcji na fazę rozwoju.

Do produkcji

  • Commercial License – obowiązkowa przy każdej produkcyjnej instalacji.

Pro tip: Zacznij od wersji próbnej, zweryfikuj, że wszystkie potrzebne formaty są wymienione, a następnie przejdź na tymczasową licencję, gdy kończysz kodowanie.

Jak wyświetlić formaty

Wywołaj FileType.getSupportedFileTypes() raz przy uruchomieniu, buforuj zwróconą kolekcję i użyj HashSet<String> do wyszukiwań O(1) przy walidacji przychodzących plików. Polegając na tym API unikasz twardo zakodowanych list i zapewniasz kompatybilność z przyszłymi aktualizacjami biblioteki. To jednowierszowe wywołanie daje pełną, wersję‑dokładną listę każdego formatu, który GroupDocs.Comparison może obsłużyć.

Główna implementacja

Klasa FileType jest reprezentacją pojedynczego formatu pliku w GroupDocs.Comparison, zawierającą rozszerzenie, typ MIME i flagi możliwości.

import com.groupdocs.comparison.result.FileType;

// Retrieve the iterable collection of supported file types
Iterable<FileType> fileTypes = FileType.getSupportedFileTypes();

// Iterate over each file type in the collection
for (FileType fileType : fileTypes) {
    // Print out the file type to demonstrate retrieval
    System.out.println(fileType);
}

// Indicate successful retrieval of supported file types
System.out.println("\nSupported file types retrieved successfully.");

Zrozumienie kodu

Co się tutaj dzieje

  1. FileType.getSupportedFileTypes() zwraca Iterable<FileType> zawierające każdy format, który biblioteka zna.
  2. Każdy obiekt FileType udostępnia właściwości takie jak getExtension(), getMimeType() i isSupportedForComparison().
  3. Pętla po prostu wypisuje rozszerzenie każdego formatu i krótką opis.

Kluczowe korzyści tego podejścia

  • Runtime discovery – Brak twardo zakodowanych list do utrzymania.
  • Version compatibility – Lista zawsze odzwierciedla dokładne możliwości używanego JAR.
  • Dynamic validation – Buduj logikę walidacji bezpośrednio z wyjścia API.

Rozszerzona implementacja z filtrowaniem

W produkcji często będziesz musiał filtrować formaty (np. tylko te obsługiwane do porównania lub tylko dokumenty biurowe). Poniższy wzorzec pokazuje, jak zbudować przefiltrowany Set<String>, którego możesz używać w całej bazie kodu.

import com.groupdocs.comparison.result.FileType;
import java.util.*;

public class FormatDetector {
    
    public static Map<String, List<String>> categorizeFormats() {
        Map<String, List<String>> categories = new HashMap<>();
        categories.put("Documents", new ArrayList<>());
        categories.put("Spreadsheets", new ArrayList<>());
        categories.put("Presentations", new ArrayList<>());
        categories.put("Images", new ArrayList<>());
        categories.put("Other", new ArrayList<>());
        
        Iterable<FileType> fileTypes = FileType.getSupportedFileTypes();
        
        for (FileType fileType : fileTypes) {
            String extension = fileType.getExtension().toLowerCase();
            String category = determineCategory(extension);
            categories.get(category).add(extension);
        }
        
        return categories;
    }
    
    private static String determineCategory(String extension) {
        if (extension.matches("\\.(doc|docx|pdf|txt|rtf)")) {
            return "Documents";
        } else if (extension.matches("\\.(xls|xlsx|csv)")) {
            return "Spreadsheets";
        } else if (extension.matches("\\.(ppt|pptx)")) {
            return "Presentations";
        } else if (extension.matches("\\.(jpg|jpeg|png|gif|bmp)")) {
            return "Images";
        }
        return "Other";
    }
}

Typowe problemy z konfiguracją i rozwiązania

Problem 1: Problemy z rozwiązywaniem zależności

Symptom: Maven/Gradle nie może znaleźć repozytorium GroupDocs lub artefaktów.
Solution

  • Sprawdź, czy sieć zezwala na wychodzące połączenia HTTPS do repo.groupdocs.com.
  • Podwójnie sprawdź pisownię URL repozytorium.
  • W środowiskach korporacyjnych dodaj repozytorium do wewnętrznego lustra Nexus lub Artifactory.

Quick fix

<!-- Add to Maven settings.xml if repository access is restricted -->
<mirrors>
    <mirror>
        <id>central-proxy</id>
        <mirrorOf>*</mirrorOf>
        <url>http://your-corporate-nexus/repository/maven-public/</url>
    </mirror>
</mirrors>

Problem 2: Błędy walidacji licencji

Symptom: Aplikacja działa, ale zapisuje ostrzeżenia licencyjne lub ogranicza funkcjonalność.
Solution

  • Umieść plik .lic na classpath (np. src/main/resources).
  • Potwierdź, że licencja nie wygasła i pasuje do wersji produktu.
  • Jeśli używasz wersji próbnej, pamiętaj, że wygasa po 30 dniach.

Code example for license loading

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

Problem 3: ClassNotFoundException w czasie działania

Symptom: Kod się kompiluje, ale nie działa w czasie działania z błędami brakujących klas.
Common causes

  • Konfliktujące zależności tranzytywne (np. inna biblioteka pobierająca starszą wersję commons-logging).
  • Używanie wersji JDK starszej niż minimalny wymóg biblioteki.

Debugging steps

  1. Uruchom mvn dependency:tree (lub gradle dependencies), aby wykryć konflikty.
  2. Upewnij się, że używasz JDK 8 lub wyższego.
  3. Wyklucz problematyczną zależność tranzytywną, jeśli to konieczne.

Problem 4: Problemy z wydajnością przy dużych listach formatów

Symptom: Pierwsze wywołanie getSupportedFileTypes() trwa zauważalnie dłużej niż kolejne wywołania.
Solution: Buforuj wynik w wątkowo‑bezpiecznym singletonie (np. używając EnumMap lub ConcurrentHashMap). Lista nie zmienia się w czasie życia JVM, więc jednorazowe załadowanie eliminuje powtarzający się narzut refleksji.

public class FormatCache {
    private static volatile List<FileType> cachedFormats;
    
    public static List<FileType> getSupportedFormats() {
        if (cachedFormats == null) {
            synchronized (FormatCache.class) {
                if (cachedFormats == null) {
                    cachedFormats = new ArrayList<>();
                    FileType.getSupportedFileTypes().forEach(cachedFormats::add);
                }
            }
        }
        return cachedFormats;
    }
}

Wzorce integracji dla rzeczywistych aplikacji

Wzorzec 1: Walidacja przed przesłaniem

Idealne dla aplikacji webowych, które muszą check file format java zanim plik dotrze do serwera.

public class FileUploadValidator {
    
    private static final Set<String> SUPPORTED_EXTENSIONS = 
        getSupportedExtensions();
    
    public boolean isSupported(String filename) {
        String extension = getExtension(filename).toLowerCase();
        return SUPPORTED_EXTENSIONS.contains(extension);
    }
    
    private static Set<String> getSupportedExtensions() {
        Set<String> extensions = new HashSet<>();
        FileType.getSupportedFileTypes().forEach(
            type -> extensions.add(type.getExtension().toLowerCase())
        );
        return extensions;
    }
    
    private String getExtension(String filename) {
        int lastDot = filename.lastIndexOf('.');
        return lastDot > 0 ? filename.substring(lastDot) : "";
    }
}

Wzorzec 2: Przetwarzanie wsadowe z filtrowaniem formatów

Kiedy potrzebujesz batch process file formats, ten wzorzec elegancko pomija nieobsługiwane pliki i zapisuje je w logach do późniejszej analizy.

public class BatchProcessor {
    
    public ProcessingResult processBatch(List<File> files) {
        Map<String, List<File>> categorized = categorizeFiles(files);
        
        ProcessingResult result = new ProcessingResult();
        result.setProcessedFiles(processSupported(categorized.get("supported")));
        result.setSkippedFiles(categorized.get("unsupported"));
        
        return result;
    }
    
    private Map<String, List<File>> categorizeFiles(List<File> files) {
        Set<String> supportedExts = getSupportedExtensions();
        
        return files.stream().collect(
            Collectors.groupingBy(file -> 
                supportedExts.contains(getExtension(file.getName())) 
                    ? "supported" : "unsupported"
            )
        );
    }
}

Wzorzec 3: Informacje o formacie w API REST

Udostępnij endpoint list supported file types, aby aplikacje klienckie mogły dynamicznie wyświetlać dozwolone rozszerzenia.

@RestController
@RequestMapping("/api/formats")
public class FormatController {
    
    @GetMapping("/supported")
    public ResponseEntity<List<FormatInfo>> getSupportedFormats() {
        List<FormatInfo> formats = new ArrayList<>();
        
        FileType.getSupportedFileTypes().forEach(type -> {
            formats.add(new FormatInfo(
                type.getExtension(),
                type.getFileFormat(),
                determineDescription(type)
            ));
        });
        
        return ResponseEntity.ok(formats);
    }
    
    @GetMapping("/check/{extension}")
    public ResponseEntity<SupportInfo> checkFormat(@PathVariable String extension) {
        boolean supported = isFormatSupported(extension);
        return ResponseEntity.ok(new SupportInfo(extension, supported));
    }
}

Najlepsze praktyki dla środowiska produkcyjnego

Zarządzanie pamięcią

Cache wisely: Przechowuj listę obsługiwanych formatów w polu static final lub dedykowanym dostawcy pamięci podręcznej (np. Caffeine). Metadane zajmują tylko kilka kilobajtów, ale powtarzająca się refleksja może się sumować.

// Good: Initialize once, use many times
private static final List<FileType> SUPPORTED_FORMATS = 
    StreamSupport.stream(FileType.getSupportedFileTypes().spliterator(), false)
                 .collect(Collectors.toList());

// Avoid: Calling getSupportedFileTypes() repeatedly

Obsługa błędów

Graceful degradation: Jeśli wykrywanie formatu nie powiedzie się (np. z powodu uszkodzonego JAR), przejdź do twardo zakodowanej minimalnej listy i zapisz ostrzeżenie w logu. Nigdy nie pozwól, aby wyjątek dotarł do interfejsu użytkownika.

public boolean isFormatSupported(String filename) {
    try {
        String extension = getExtension(filename);
        return SUPPORTED_FORMATS.stream()
            .anyMatch(type -> type.getExtension().equalsIgnoreCase(extension));
    } catch (Exception e) {
        // Log the error but don't fail the operation
        logger.warn("Format check failed for: " + filename, e);
        return false; // Conservative approach
    }
}

Optymalizacja wydajności

Lazy initialization: Opóźnij ładowanie listy formatów do pierwszego żądania, które faktycznie jej potrzebuje. To zmniejsza czas uruchamiania mikro‑serwisów, które mogą nigdy nie obsługiwać dokumentów.

public class LazyFormatChecker {
    private volatile boolean initialized = false;
    private Set<String> supportedExtensions;
    
    public boolean isSupported(String extension) {
        ensureInitialized();
        return supportedExtensions.contains(extension.toLowerCase());
    }
    
    private void ensureInitialized() {
        if (!initialized) {
            synchronized (this) {
                if (!initialized) {
                    loadSupportedExtensions();
                    initialized = true;
                }
            }
        }
    }
}

Zarządzanie konfiguracją

Externalize format restrictions: Trzymaj plik application.yml lub properties, który wymienia dozwolone rozszerzenia dla jednostek biznesowych. To umożliwia zmianę polityki bez ponownego wdrażania kodu.

# application.yml
document-processing:
  allowed-formats:
    - pdf
    - docx
    - xlsx
  max-file-size: 10MB
  validation-mode: strict

Zaawansowane przypadki użycia i aplikacje

Zarządzanie dokumentami w przedsiębiorstwie

Duże organizacje często potrzebują list dozwolonych formatów specyficznych dla działów. Łącząc metadane FileType z kontrolą dostępu opartą na rolach, możesz egzekwować szczegółowe zasady, takie jak „Dział prawny może przesyłać PDF i DOCX, a dział marketingu także PPTX”.

Integracja z chmurą

Podczas synchronizacji plików z usług takich jak AWS S3, Azure Blob czy Google Drive, filtruj nieobsługiwane formaty przed ich pobraniem. To oszczędza pasmo i zmniejsza koszty przechowywania.

Zautomatyzowane systemy przepływu pracy

Automatyzacja procesów biznesowych może kierować dokumenty w zależności od formatu. Na przykład, przepływ recenzji umów może akceptować tylko DOCX, podczas gdy pipeline przetwarzania faktur może przyjmować PDF, XLSX i CSV.

Rozważania dotyczące wydajności i optymalizacja

Optymalizacja zużycia pamięci

Ładowanie wszystkich metadanych formatów do pamięci jest tanie (≈ 5 KB). Jednakże, jeśli uruchamiasz dziesiątki mikro‑serwisów w ograniczonym kontenerze, możesz:

  1. Lazy load tylko w razie potrzeby.
  2. Selective cache – zachowuj tylko formaty, które rzeczywiście obsługujesz (np. dokumenty biurowe).
  3. Używaj pamięci podręcznej WeakReference, aby JVM mógł odzyskać pamięć pod obciążeniem.

Wskazówki dotyczące wydajności CPU

  • Użyj HashSet<String> zbudowanego z buforowanych rozszerzeń do wyszukiwań w czasie stałym.
  • Wstępnie kompiluj wyrażenia regularne używane do walidacji nazw plików.
  • W przypadku masowych zadań wsadowych przetwarzaj pliki w równoległych strumieniach (parallelStream()), respektując limity I/O.
// Efficient format validation
private static final Set<String> SUPPORTED_EXTENSIONS = 
    Collections.unmodifiableSet(loadSupportedExtensions());

public boolean isSupported(String extension) {
    return SUPPORTED_EXTENSIONS.contains(extension.toLowerCase());
}

Rozważania skalowania

  • Application startup: Zainicjalizuj listę formatów w metodzie @PostConstruct beana Spring.
  • Distributed caches: W środowisku klastrowym udostępnij buforowaną listę przez Redis lub Hazelcast, aby uniknąć ładowania jej przez każdy węzeł osobno.
  • Connection pooling: Jeśli wywołujesz zewnętrzne usługi w celu dodatkowej walidacji, użyj puli (np. HikariCP), aby utrzymać niskie opóźnienia.

Rozwiązywanie typowych problemów w czasie działania

Problem: Niespójne wyniki wykrywania formatu

Symptoms: Ten sam rozszerzenie pliku czasami jest zgłaszane jako nieobsługiwane.
Root causes

  • Różne wersje biblioteki na różnych węzłach.
  • Ograniczenia licencyjne wyłączające niektóre formaty premium.
  • Duplikaty JAR powodujące zamieszanie w classloaderze.

Debugging approach

  1. Zaloguj wersję GroupDocs.Comparison przy starcie (VersionInfo.getVersion()).
  2. Sprawdź, czy plik licencji jest identyczny na wszystkich serwerach.
  3. Uruchom java -verbose:class, aby upewnić się, że załadowana jest tylko jedna kopia biblioteki.

Problem: Spadek wydajności w czasie

Symptoms: Wykrywanie formatu staje się wolniejsze po kilku godzinach działania.
Common causes

  • Wycieki pamięci w niestandardowych buforach, które ciągle rosną.
  • Nieograniczona ArrayList używana do przechowywania tymczasowych obiektów FileType.
  • Nadmierne przerwy GC spowodowane dużym obciążeniem sterty.

Solutions

  • Wdroż politykę usuwania (np. LRU) dla wszelkich niestandardowych buforów.
  • Monitoruj zużycie sterty za pomocą JVisualVM lub podobnych narzędzi.
  • Profiluj przy użyciu Java Flight Recorder, aby zlokalizować gorące miejsca.

Problem: Wykrywanie formatu milczy

Symptoms: Nie zostaje rzucony żaden wyjątek, ale niektóre formaty nigdy nie pojawiają się na liście.
Investigation steps

  1. Włącz logowanie debug dla com.groupdocs (log4j.logger.com.groupdocs=DEBUG).
  2. Potwierdź, że inicjalizacja biblioteki powiodła się (License.isValid()).
  3. Sprawdź, czy brakujące formaty są częścią dodatku premium, który wymaga wyższej licencji.

Wnioski i kolejne kroki

Zrozumienie how to list formats to nie tylko pojedyncze wywołanie API — to podstawa odpornego, przyjaznego dla użytkownika potoku dokumentów. Integrując wykrywanie w czasie działania, buforowanie i solidną obsługę błędów, wyeliminujesz całą klasę błędów i zapewnisz płynniejsze doświadczenia swoim klientom.

Takeaway checklist

  • Użyj FileType.getSupportedFileTypes() raz, buforuj wynik i odpytywaj go przy pomocy HashSet.
  • Waliduj przesyłane pliki przed intensywnym przetwarzaniem, aby oszczędzić CPU i poprawić UX.
  • Utrzymuj licencję aktualną; nowe wydania wprowadzają dodatkowe formaty.
  • Zewnętrznie przechowuj listy dozwolonych formatów, aby zasady biznesowe mogły ewoluować bez zmian w kodzie.

Next actions

  1. Dodaj podstawowy fragment wykrywania do istniejącej usługi przesyłania.
  2. Zaimplementuj singletonowy cache (np. używając Spring @Cacheable).
  3. Wybierz jeden ze wzorców integracji (przed‑przesłaniem, wsad, lub REST), który pasuje do Twojej architektury.
  4. Uruchom benchmarki wydajności na reprezentatywnym zestawie danych, aby potwierdzić prędkość wyszukiwania O(1).

Gotowy na więcej? Poznaj zaawansowane funkcje GroupDocs.Comparison, takie jak porównanie side‑by‑side, ekstrakcja metadanych i masowe zadania porównawcze, aby zbudować naprawdę przedsiębiorstwowy przepływ dokumentów.

Najczęściej zadawane pytania

Q: Co się stanie, jeśli spróbuję przetworzyć nieobsługiwany format pliku?
A: GroupDocs.Comparison rzuca UnsupportedFileFormatException. Pre‑walidacja przy użyciu getSupportedFileTypes() pozwala przechwycić problem przed rozpoczęciem kosztownego przetwarzania.

Q: Czy lista obsługiwanych formatów zmienia się między wersjami biblioteki?
A: Tak. Każde nowe wydanie dodaje wsparcie dla dodatkowych formatów — często 3‑5 nowych na wersję minor. Zawsze ponownie buforuj po aktualizacji.

Q: Czy mogę rozszerzyć bibliotekę o dodatkowe formaty?
A: Lista obsługiwanych formatów jest stała dla każdej wersji. Dla niszowych formatów połącz GroupDocs.Comparison ze specjalistycznym parserem zewnętrznym lub skontaktuj się z GroupDocs w celu uzyskania dodatku na zamówienie.

Q: Ile pamięci zużywa wykrywanie formatu?
A: Metadane zajmują około 5 KB. Rzeczywisty wpływ na pamięć zależy od sposobu przechowywania i udostępniania buforowanej kolekcji; prosty HashSet<String> dodaje znikomy narzut.

Q: Czy wykrywanie formatu jest wątkowo‑bezpieczne?
A: Tak, FileType.getSupportedFileTypes() jest wątkowo‑bezpieczne. Upewnij się, że własny cache (np. statyczny ConcurrentHashMap) również obsługuje równoczesne odczyty/zapisy.

Q: Jaki jest wpływ na wydajność sprawdzania wsparcia formatu?
A: Pierwsze wywołanie generuje jednorazowy koszt ~10‑15 ms na typowym serwerze. Kolejne wyszukiwania są O(1) i trwają poniżej 0,1 ms.

Ostatnia aktualizacja: 2026-07-20
Testowano z: GroupDocs.Comparison 25.2 for Java
Autor: GroupDocs

Dodatkowe zasoby

Powiązane samouczki