diff --git a/content/arabic/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/arabic/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..4abe42ac --- /dev/null +++ b/content/arabic/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,187 @@ +--- +date: '2026-02-06' +description: تعلم كيفية إضافة المستندات إلى الفهرس وتمكين البحث الحساس لحالة الأحرف + في Java باستخدام GroupDocs.Search، مما يعزز دقة تطبيقك. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'إضافة مستندات إلى الفهرس: بحث جافا حساس لحالة الأحرف باستخدام GroupDocs' +type: docs +url: /ar/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# إضافة المستندات إلى الفهرس: إتقان عمليات البحث الحساسة لحالة الأحرف في Java باستخدام GroupDocs + +استخراج المعلومة الصحيحة من مجموعة ضخمة من المستندات هو مطلب أساسي للتطبيقات الحديثة. في هذا الدليل، ستتعلم **كيفية إضافة المستندات إلى الفهرس** وإجراء **عمليات بحث حساسة لحالة الأحرف** باستخدام GroupDocs.Search للغة Java. سواءً كنت تبني مستودع مستندات قانونية، أو كتالوجًا للتجارة الإلكترونية، أو نظام إدارة محتوى، فإن نتائج البحث الدقيقة تحافظ على سعادة المستخدمين ومصداقية بياناتك. + +## إجابات سريعة +- **ما هي الخطوة الأساسية لبدء البحث؟** إضافة المستندات إلى فهرس باستخدام `index.add(...)`. +- **كيف يمكن تمكين البحث الحسّاس لحالة الأحرف؟** ضبط `options.setUseCaseSensitiveSearch(true)`. +- **هل يمكنني البحث عبر عدة دلائل؟** نعم – استدعِ `index.add()` لكل مجلد تريد تضمينه. +- **أي طريقة تسمح لي بالبحث باستخدام الكائنات؟** استخدم `SearchQuery.createWordQuery(...)`. +- **هل أحتاج إلى ترخيص للاختبار؟** ترخيص مؤقت متاح لأغراض التجربة. + +## ماذا يعني “إضافة المستندات إلى الفهرس”؟ +إضافة المستندات إلى الفهرس تعني تغذية ملفات المصدر (PDFs، مستندات Word، نصوص عادية، إلخ) إلى GroupDocs.Search حتى يتمكن من بناء بنية بيانات قابلة للبحث. بمجرد فهرستها، يمكن للمحرك تنفيذ استعلامات سريعة، بما في ذلك تلك الحساسة لحالة الأحرف. + +## لماذا تمكين البحث الحسّاس لحالة الأحرف في Java؟ +- **مطابقة المصطلحات بدقة** – التمييز بين “Apple” (الشركة) و “apple” (الفاكهة). +- **الامتثال التنظيمي** – بعض الصناعات تتطلب مطابقة العبارة بدقة. +- **تحسين الصلة** – يتوقع المستخدمون غالبًا نتائج حساسة لحالة الأحرف في السياقات التقنية أو القانونية. + +## المتطلبات المسبقة +- JDK (يوصى بـ Java 17 أو أحدث) +- Maven لإدارة التبعيات +- بيئة تطوير متكاملة مثل IntelliJ IDEA أو Eclipse +- إلمام أساسي ببرمجة Java + +## إعداد GroupDocs.Search للغة Java +أولاً، أضف مستودع GroupDocs والاعتماد إلى ملف `pom.xml` الخاص بك: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +بدلاً من ذلك، يمكنك تنزيل أحدث نسخة مباشرةً من [إصدارات GroupDocs.Search للغة Java](https://releases.groupdocs.com/search/java/). + +### الترخيص +للبدء بتجربة مجانية، زر موقع GroupDocs للحصول على ترخيص مؤقت. سيمكنك ذلك من اختبار جميع الميزات دون أي قيود. + +## كيفية إضافة المستندات إلى الفهرس – بحث نصي + +### الخطوة 1: إنشاء فهرس وإضافة مستنداتك +أنشئ مجلدًا سيتم تخزين ملفات الفهرس فيه، ثم أضف دليل المصدر الذي يحتوي على المستندات التي تريد البحث فيها. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **نصيحة احترافية:** يمكنك استدعاء `index.add()` عدة مرات **للبحث عبر دلائل متعددة** في فهرس واحد. + +### الخطوة 2: تمكين البحث الحسّاس لحالة الأحرف +قم بتكوين خيارات البحث لتراعي حالة الأحرف. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### الخطوة 3: تنفيذ استعلام نصي حساس لحالة الأحرف +شغّل استعلامًا يميز بين “Advantages” و “advantages”. + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +تطبع الحلقة المسار الكامل لكل مستند يحتوي على المصطلح المطابق لحالة الأحرف بالضبط. + +## كيفية إضافة المستندات إلى الفهرس – بحث كائنات + +توفر استعلامات الكائنات مرونة أكبر، خاصةً عندما تحتاج إلى دمج معايير متعددة. + +### الخطوة 1: تهيئة فهرس ثانٍ (اختياري) +إذا رغبت في إبقاء عمليات البحث القائمة على الكائنات منفصلة، أنشئ مجلد فهرس آخر. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### الخطوة 2: إعادة استخدام خيار الحساسية لحالة الأحرف +نفس كائن `SearchOptions` يعمل مع استعلامات الكائنات. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### الخطوة 3: بناء وتشغيل استعلام كائن +أنشئ كائن استعلام كلمة ومرره إلى محرك البحث. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +استخدام `createWordQuery` يتيح لك لاحقًا دمجه مع استعلامات العبارة أو الأحرف البديلة أو الاستعلامات البوليانية لم scenari​و أكثر تعقيدًا. + +## تطبيقات عملية +- **إدارة المستندات القانونية:** استرجاع القوانين الخاصة بالقضايا حيث تكون حالة الأحرف مهمة. +- **منصات التجارة الإلكترونية:** التمييز بين رموز المنتجات مثل “PRO‑X” مقابل “pro‑x”. +- **أنظمة إدارة المحتوى (CMS):** ضمان قدرة المؤلفين على العثور على العناوين أو الوسوم الدقيقة. + +## اعتبارات الأداء +- **الحفاظ على تحديث الفهرس** – أعد الفهرسة عندما تُضاف ملفات جديدة أو تُغيّر الملفات الحالية. +- **مراقبة استهلاك الذاكرة** – تستفيد المجموعات الكبيرة من الفهرسة المتزايدة وتحديد حجم heap المناسب لـ JVM. +- **الاستفادة من جامع القمامة في Java** – حرّر كائنات `Index` عندما لا تعد بحاجة إليها. + +## المشكلات الشائعة والحلول +| المشكلة | الحل | +|-------|----------| +| يظهر أن `useCaseSensitiveSearch` غير فعال | تأكد من أنك تستخدم أحدث نسخة من GroupDocs.Search وأن الفهرس أُعيد بناؤه بعد تغيير الخيار. | +| لا تُرجع أي نتائج لمصطلح معروف | تأكد من أن حالة المصطلح مطابقة تمامًا وأن المستند أُضيف بنجاح إلى الفهرس. | +| البحث في العديد من المجلدات يبطئ الأداء | أضف كل مجلد على حدة باستخدام `index.add()` وفكّر في تقسيم الفهرس إلى شظايا للبيانات الضخمة جدًا. | + +## الأسئلة المتكررة + +**س:** كيف أتعامل مع مجموعات بيانات كبيرة باستخدام GroupDocs.Search؟ +**ج:** استخدم تقسيم الفهرس، ضبط إعدادات ذاكرة JVM، وقم بضغط الفهرس دوريًا للحفاظ على الأداء المثالي. + +**س:** هل يمكنني البحث عبر عدة دلائل في آن واحد؟ +**ج:** نعم – استدعِ `index.add()` لكل دليل تريد تضمينه، ثم نفّذ استعلامًا واحدًا ضد الفهرس المدمج. + +**س:** ما هي الأخطاء الشائعة عند إعداد البحث الحسّاس لحالة الأحرف؟ +**ج:** نسيان إعادة بناء الفهرس بعد تمكين `useCaseSensitiveSearch`، أو استخدام حالة غير صحيحة في سلسلة الاستعلام. + +**س:** كيف يمكنني استكشاف أخطاء البحث؟ +**ج:** راجع ملفات السجل التي يولدها GroupDocs.Search للحصول على تتبع الأخطاء، وتأكد من حل جميع تبعيات Maven بشكل صحيح. + +**س:** هل GroupDocs.Search مناسب للتطبيقات الفورية (real‑time)؟ +**ج:** مع استراتيجيات الفهرسة المناسبة (تحديثات متزايدة وتخزين مؤقت في الذاكرة)، يمكنه تقديم نتائج بحث شبه فورية. + +## موارد +- **الوثائق:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **مرجع API:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **التنزيل:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **مستودع GitHub:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **منتدى الدعم:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **ترخيص مؤقت:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**آخر تحديث:** 2026-02-06 +**تم الاختبار مع:** GroupDocs.Search 25.4 +**المؤلف:** GroupDocs + +--- \ No newline at end of file diff --git a/content/arabic/java/searching/master-document-search-groupdocs-java/_index.md b/content/arabic/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..9fb57a6f --- /dev/null +++ b/content/arabic/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,182 @@ +--- +date: '2026-02-06' +description: تعلم كيفية فهرسة المستندات وإضافة المستندات إلى الفهرس باستخدام GroupDocs.Search + للغة Java. أنشئ تطبيقات بحث قوية باستخدام استعلامات النص والكائن. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: كيفية فهرسة المستندات باستخدام GroupDocs.Search للغة Java +type: docs +url: /ar/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# كيفية فهرسة المستندات باستخدام GroupDocs.Search للغة Java + +في عالم اليوم القائم على البيانات، **كيفية فهرسة المستندات** بفعالية هي مهارة حاسمة لأي مطور Java يتعامل مع مجموعات كبيرة من الملفات. سواء كنت تتعامل مع العقود القانونية، البيانات المالية، أو التقارير الداخلية، فإن القدرة على العثور بسرعة على المعلومات الصحيحة يمكن أن توفر ساعات من العمل اليدوي. في هذا الدرس ستتعلم **كيفية فهرسة المستندات** باستخدام مكتبة GroupDocs.Search، ثم إجراء استعلامات نصية واستعلامات كائنية على الفهرس المُنشأ. لنبدأ! + +## إجابات سريعة +- **ما هي الخطوة الأولى لفهرسة المستندات؟** تهيئة كائن `Index` يشير إلى المجلد الذي سيُخزن فيه الفهرس. +- **أي طريقة تضيف المستندات إلى الفهرس؟** استخدم `index.add("PATH_TO_DOCUMENTS")`. +- **هل يمكنني البحث عن نطاقات رقمية؟** نعم، باستخدام استعلام نصي مثل `"400 ~~ 4000"` أو استعلام كائن عبر `SearchQuery.createNumericRangeQuery`. +- **هل أحتاج إلى ترخيص؟** يتوفر نسخة تجريبية مجانية؛ الترخيص التجاري يفتح جميع الميزات. +- **ما نسخة Java المطلوبة؟** JDK 8 أو أعلى. + +## ما هو “كيفية فهرسة المستندات” باستخدام GroupDocs.Search؟ +فهرسة المستندات تعني مسح محتوى الملفات في مجلد وتخزين الرموز القابلة للبحث في مجلد فهرس مخصص. هذه الخطوة المسبقة تمكن من عمليات بحث سريعة للغاية لاحقًا، لأن المكتبة تبحث في الفهرس المُعد بدلاً من الملفات الأصلية في كل مرة. + +## لماذا تستخدم GroupDocs.Search للغة Java؟ +- **الأداء:** يتم تنفيذ عمليات البحث في مللي ثانية حتى مع آلاف الملفات. +- **دعم الصيغ:** يتعامل مع PDFs، Word، Excel، PowerPoint، والعديد غيرها. +- **المرونة:** يدعم استعلامات النص العادي، النطاقات الرقمية، واستعلامات الكائن المعقدة. +- **القابلية للتوسع:** يمكن تحديث الفهرس بسهولة بإضافة مستندات جديدة دون الحاجة لإعادة بناءه من الصفر. + +## المتطلبات المسبقة +- Maven مثبت لإدارة الاعتمادات. +- بيئة تطوير متكاملة مثل IntelliJ IDEA أو Eclipse. +- معرفة أساسية بـ Java (مفاهيم OOP، معالجة الاستثناءات). + +## إعداد GroupDocs.Search للغة Java +### إعداد Maven +أضف المستودع والاعتماد إلى ملف `pom.xml` الخاص بك: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### التحميل المباشر +يمكنك أيضًا تنزيل أحدث JAR من [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +#### خطوات الحصول على الترخيص +1. **نسخة تجريبية مجانية** – استكشاف المكتبة دون تكلفة. +2. **ترخيص مؤقت** – طلب مفتاح قصير الأجل لتقييم ممتد. +3. **شراء** – الحصول على ترخيص كامل للاستخدام في الإنتاج. + +## التهيئة والإعداد الأساسي +لـ **إضافة المستندات إلى الفهرس**، عليك أولاً إنشاء كائن `Index` يشير إلى المجلد الذي ستُخزن فيه ملفات الفهرس: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +هذا السطر ينشئ (أو يفتح) فهرسًا جاهزًا لاستقبال المستندات. + +## دليل التنفيذ +### إنشاء وفهرسة المستندات +#### كيفية إضافة المستندات إلى الفهرس +طريقة `add` تقوم بمسح مجلد وتخزين بيانات قابلة للبحث لكل ملف. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **المعلمات:** سلسلة المسار تشير إلى المجلد الذي يحتوي على الملفات التي تريد فهرستها. +- **الغرض:** بعد هذه الخطوة، يحتوي الفهرس على رموز من جميع أنواع المستندات المدعومة، مما يتيح عمليات بحث سريعة. + +### بحث استعلام نصي +#### كيفية إجراء بحث نطاق رقمي نصي +يمكنك البحث باستخدام سلسلة بسيطة تحدد النطاق. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **المعلمات:** سلسلة الاستعلام `"400 ~~ 4000"` تخبر المحرك بالعثور على الأرقام بين 400 و 4000. +- **قيمة الإرجاع:** `SearchResult` يحتوي على قائمة المستندات المطابقة والتظليلات. + +### بحث استعلام كائن +#### كيفية استخدام استعلام كائن للنطاقات الرقمية +استعلامات الكائن تعطيك تحكمًا برمجيًا في معايير البحث. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **المعلمات:** `createNumericRangeQuery` تستقبل الأعداد الصحيحة للبداية والنهاية. +- **الغرض:** هذه الطريقة مثالية عندما تحتاج إلى دمج شروط متعددة أو بناء استعلامات بشكل ديناميكي. + +## تطبيقات عملية +إليك بعض السيناريوهات الواقعية حيث تصبح **كيفية فهرسة المستندات** عامل تغيير رئيسي: + +1. **إدارة المستندات القانونية** – العثور على البنود، أرقام القضايا، أو التواريخ عبر آلاف العقود. +2. **التقارير المالية** – استخراج المعاملات التي تقع ضمن نطاق مالي محدد. +3. **تتبع المخزون** – العثور على العناصر عبر أرقام السيريال، رموز الدفعات، أو نطاقات SKU. + +دمج GroupDocs.Search مع قواعد البيانات، التخزين السحابي، أو قوائم الرسائل يمكن أن يضيف أتمتة إضافية لتدفقات عمل المستندات. + +## اعتبارات الأداء +- **تحديثات الفهرس المنتظمة:** أعد تشغيل `index.add` للملفات الجديدة للحفاظ على حداثة الفهرس. +- **إدارة الموارد:** راقب استخدام الذاكرة heap؛ الفهارس الكبيرة تستفيد من إعدادات جمع القمامة JVM المُضبوطة. +- **تحسين الاستعلام:** استخدم استعلامات الكائن للمرشحات المعقدة لتقليل الفحص غير الضروري. + +## المشكلات الشائعة والحلول +| المشكلة | سبب حدوثها | الحل | +|-------|----------------|-----| +| **البحث لا يُرجع أي نتائج** | الفهرس غير مُنشأ أو مسار المجلد غير صحيح | تحقق من تنفيذ `index.add` على الدليل الصحيح وأن مجلد الفهرس قابل للكتابة. | +| **خطأ OutOfMemoryError أثناء الفهرسة** | ملفات كبيرة جدًا أو ذاكرة heap غير كافية | زيادة قيمة JVM `-Xmx` أو فهرسة الملفات على دفعات أصغر. | +| **صيغة ملف غير مدعومة** | نوع الملف غير معترف به من قبل GroupDocs.Search | تأكد من أن امتداد الملف موجود ضمن القائمة المدعومة (PDF, DOCX, XLSX, إلخ). | + +## الأسئلة المتكررة +**س: كيف أقوم بتحديث فهرس موجود بإضافة مستندات جديدة؟** +ج: استدعِ `index.add("NEW_DOCUMENT_PATH")` مرة أخرى؛ المكتبة تدمج الإدخالات الجديدة دون إعادة إنشاء الفهرس بالكامل. + +**س: هل يمكن لـ GroupDocs.Search التعامل مع صيغ ملفات مختلفة؟** +ج: نعم، يدعم PDFs، Word، Excel، PowerPoint، النص العادي، والعديد من الصيغ الشائعة الأخرى. + +**س: ما هي متطلبات النظام لاستخدام GroupDocs.Search؟** +ج: بيئة تشغيل Java 8+، ذاكرة RAM كافية (على الأقل 2 GB للمجموعات المتوسطة)، وإمكانية القراءة/الكتابة إلى مجلد الفهرس. + +**س: كيف يمكنني استكشاف مشكلات أداء البحث؟** +ج: تأكد من أن الفهرس محدث، قم بملفّ استعلاماتك، وراجع إعدادات ذاكرة JVM. تقليل عدد الحقول المفهرسة يمكن أيضًا تحسين السرعة. + +**س: هل هناك طريقة للبحث باستخدام المرادفات أو المطابقة الضبابية؟** +ج: نعم، يوفر GroupDocs.Search قواميس المرادفات وخيارات البحث الضبابي التي يمكن تفعيلها عبر فئة `SearchOptions`. + +## الخلاصة +أصبحت الآن تمتلك فهماً قوياً لـ **كيفية فهرسة المستندات** باستخدام GroupDocs.Search للغة Java، وكيفية **إضافة المستندات إلى الفهرس**، وكيفية تشغيل استعلامات نصية واستعلامات كائنية. من خلال دمج هذه التقنيات، ستوفر تطبيقات Java الخاصة بك تجارب بحث سريعة ودقيقة عبر أي مستودع مستندات. + +هل أنت مستعد للخطوة التالية؟ استكشف البحث المتعدد الأوجه، معالجة المرادفات، أو دمج الفهرس مع واجهة REST API لتوفير إمكانيات البحث للخدمات الأخرى. + +--- + +**آخر تحديث:** 2026-02-06 +**تم الاختبار مع:** GroupDocs.Search 25.4 للغة Java +**المؤلف:** GroupDocs \ No newline at end of file diff --git a/content/chinese/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/chinese/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..36240633 --- /dev/null +++ b/content/chinese/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,184 @@ +--- +date: '2026-02-06' +description: 了解如何在 Java 中使用 GroupDocs.Search 将文档添加到索引并启用区分大小写的搜索，从而提升应用程序的准确性。 +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 将文档添加到索引：使用 GroupDocs 的区分大小写 Java 搜索 +type: docs +url: /zh/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# 将文档添加到索引：在 Java 中使用 GroupDocs 实现区分大小写的搜索 + +从海量文档集合中检索到正确的信息是现代应用的核心需求。在本指南中，您将学习 **如何将文档添加到索引** 并使用 GroupDocs.Search for Java 执行 **区分大小写的搜索**。无论您是在构建法律文档库、电子商务目录，还是内容管理系统，精准的搜索结果都能让用户满意并提升数据可信度。 + +## 快速答案 +- **开始搜索的首要步骤是什么？** 使用 `index.add(...)` 将文档添加到索引。 +- **如何启用区分大小写的搜索？** 设置 `options.setUseCaseSensitiveSearch(true)`。 +- **可以跨多个目录搜索吗？** 可以——对每个想要包含的文件夹调用 `index.add()`。 +- **哪个方法可以使用对象进行搜索？** 使用 `SearchQuery.createWordQuery(...)`。 +- **测试时需要许可证吗？** 可获取临时许可证用于试用。 + +## “将文档添加到索引” 是什么意思？ +将文档添加到索引是指将源文件（PDF、Word 文档、纯文本等）导入 GroupDocs.Search，以便它构建可搜索的数据结构。完成索引后，搜索引擎即可快速执行查询，包括区分大小写的查询。 + +## 为什么在 Java 中启用区分大小写的搜索？ +- **精确词语匹配** – 区分 “Apple”（公司） 与 “apple”（水果）。 +- **合规要求** – 某些行业需要精确短语匹配。 +- **提升相关性** – 在技术或法律场景下，用户常常期望区分大小写的结果。 + +## 前置条件 +- JDK（推荐 Java 17 或更高） +- 用于依赖管理的 Maven +- IntelliJ IDEA 或 Eclipse 等 IDE +- 基本的 Java 编程经验 + +## 为 Java 设置 GroupDocs.Search +首先，在 `pom.xml` 中添加 GroupDocs 仓库和依赖： + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +或者，您也可以直接从 [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) 下载最新版本。 + +### 许可证 +要开始试用，请前往 GroupDocs 获取临时许可证。这样即可在不受限制的情况下测试所有功能。 + +## 如何将文档添加到索引 – 文本查询搜索 + +### 步骤 1：创建索引并添加文档 +创建一个用于存放索引文件的文件夹，然后添加包含待搜索文档的源目录。 + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **专业提示：** 您可以多次调用 `index.add()`，在单个索引中 **跨多个目录搜索**。 + +### 步骤 2：启用区分大小写的搜索 +配置搜索选项以遵循字母大小写。 + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### 步骤 3：执行区分大小写的文本查询 +运行一个能够区分 “Advantages” 与 “advantages” 的查询。 + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +循环会打印出每个包含完全匹配大小写词语的文档的完整路径。 + +## 如何将文档添加到索引 – 对象查询搜索 + +对象查询提供了更大的灵活性，尤其在需要组合多个条件时。 + +### 步骤 1：初始化第二个索引（可选） +如果希望将基于对象的搜索单独管理，可创建另一个索引文件夹。 + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### 步骤 2：复用区分大小写的选项 +相同的 `SearchOptions` 实例同样适用于对象查询。 + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### 步骤 3：构建并运行对象查询 +创建一个词查询对象并将其传递给搜索引擎。 + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +使用 `createWordQuery` 可在后续将其与短语、通配符或布尔查询组合，实现更复杂的场景。 + +## 实际应用场景 +- **法律文档管理：** 检索大小写敏感的法规条文。 +- **电子商务平台：** 区分 “PRO‑X” 与 “pro‑x” 等 SKU。 +- **内容管理系统（CMS）：** 确保作者能够精确找到标题或标签。 + +## 性能注意事项 +- **保持索引最新** – 在新增或修改文件后重新索引。 +- **监控内存使用** – 大规模语料库受益于增量索引和适当的 JVM 堆大小。 +- **利用 Java 垃圾回收** – 在不再需要时释放 `Index` 对象。 + +## 常见问题与解决方案 +| 问题 | 解决方案 | +|-------|----------| +| `useCaseSensitiveSearch` 似乎被忽略 | 确认使用的是最新的 GroupDocs.Search 版本，并在更改选项后重新构建索引。 | +| 已知词语没有返回结果 | 确认查询词的大小写完全匹配，并且文档已成功添加到索引。 | +| 搜索大量文件夹导致变慢 | 使用 `index.add()` 分别添加每个文件夹，必要时将索引拆分为多个分片以处理超大数据集。 | + +## 常见问答 + +**问：** 如何使用 GroupDocs.Search 处理大规模数据集？ +**答：** 采用索引分区、调优 JVM 内存设置，并定期压缩索引，以保持最佳性能。 + +**问：** 能否同时跨多个目录搜索？ +**答：** 可以——对每个目录调用 `index.add()`，随后对合并后的索引执行单一查询。 + +**问：** 设置区分大小写搜索时常见的坑有哪些？ +**答：** 启用 `useCaseSensitiveSearch` 后忘记重新构建索引，或在查询字符串中使用了错误的大小写。 + +**问：** 如何排查搜索错误？ +**答：** 检查 GroupDocs.Search 生成的日志文件中的堆栈跟踪，并确认所有 Maven 依赖已正确解析。 + +**问：** GroupDocs.Search 适合实时应用吗？ +**答：** 通过适当的索引策略（增量更新和内存缓存），它能够提供近实时的搜索结果。 + +## 资源 +- **文档：** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **API 参考：** [Java API Reference](https://reference.groupdocs.com/search/java) +- **下载：** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **GitHub 仓库：** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **支持论坛：** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **临时许可证：** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**最后更新：** 2026-02-06 +**测试环境：** GroupDocs.Search 25.4 +**作者：** GroupDocs \ No newline at end of file diff --git a/content/chinese/java/searching/master-document-search-groupdocs-java/_index.md b/content/chinese/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..62806f18 --- /dev/null +++ b/content/chinese/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,181 @@ +--- +date: '2026-02-06' +description: 学习如何使用 GroupDocs.Search for Java 对文档进行索引并将文档添加到索引中。构建具有文本和对象查询功能的强大搜索应用程序。 +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: 如何使用 GroupDocs.Search for Java 索引文档 +type: docs +url: /zh/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# 如何使用 GroupDocs.Search for Java 索引文档 + +在当今数据驱动的世界中，**如何索引文档** 是任何处理大量文件的 Java 开发者的关键技能。无论您在处理法律合同、财务报表还是内部报告，能够快速定位所需信息都能节省数小时的人工工作。在本教程中，您将学习使用 GroupDocs.Search 库 **如何索引文档**，并对创建的索引执行基于文本和基于对象的查询。让我们开始吧！ + +## 快速答案 +- **索引文档的第一步是什么？** 初始化一个指向存放索引的文件夹的 `Index` 对象。 +- **哪个方法向索引添加文档？** 使用 `index.add("PATH_TO_DOCUMENTS")`。 +- **我可以搜索数值范围吗？** 可以，使用类似 `"400 ~~ 4000"` 的文本查询或通过 `SearchQuery.createNumericRangeQuery` 的对象查询。 +- **我需要许可证吗？** 有免费试用版；商业许可证可解锁全部功能。 +- **需要哪个 Java 版本？** JDK 8 或更高。 + +## 什么是使用 GroupDocs.Search 进行文档索引？ +文档索引是指扫描文件夹中文件的内容，并将可搜索的标记存储在专用的索引文件夹中。此预处理步骤使后续的查找速度极快，因为库搜索的是已准备好的索引，而不是每次都读取原始文件。 + +## 为什么使用 GroupDocs.Search for Java？ +- **性能：** 即使在成千上万的文件上，搜索也能在毫秒级完成。 +- **格式支持：** 处理 PDF、Word、Excel、PowerPoint 等多种格式。 +- **灵活性：** 支持纯文本查询、数值范围以及复杂的对象查询。 +- **可扩展性：** 通过添加新文档即可轻松更新索引，无需从头重建。 + +## 前置条件 +- 已安装 Maven 用于依赖管理。 +- 使用 IntelliJ IDEA 或 Eclipse 等 IDE。 +- 基础 Java 知识（面向对象概念、异常处理）。 + +## 设置 GroupDocs.Search for Java +### Maven 设置 +在您的 `pom.xml` 中添加仓库和依赖： + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### 直接下载 +您也可以从 [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) 下载最新的 JAR。 + +#### 获取许可证的步骤 +1. **免费试用** – 免费探索该库。 +2. **临时许可证** – 请求短期密钥以进行更长时间的评估。 +3. **购买** – 获取用于生产的完整许可证。 + +## 基本初始化和设置 +要 **向索引添加文档**，首先创建一个指向存放索引文件的文件夹的 `Index` 对象： + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +此行创建（或打开）一个准备接收文档的索引。 + +## 实施指南 +### 创建和索引文档 +#### 如何向索引添加文档 +`add` 方法扫描文件夹并为每个文件存储可搜索的数据。 + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **参数：** 路径字符串指向包含您想要索引的文件的文件夹。 +- **目的：** 此步骤完成后，索引包含所有受支持文档类型的标记，从而实现快速搜索。 + +### 文本查询搜索 +#### 如何执行基于文本的数值范围搜索 +您可以使用定义范围的简单字符串进行搜索。 + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **参数：** 查询字符串 `"400 ~~ 4000"` 告诉引擎查找介于 400 到 4000 之间的数字。 +- **返回值：** `SearchResult` 包含匹配文档的列表及高亮信息。 + +### 对象查询搜索 +#### 如何使用对象查询进行数值范围搜索 +基于对象的查询为您提供对搜索条件的编程控制。 + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **参数：** `createNumericRangeQuery` 接收起始和结束整数。 +- **目的：** 当您需要组合多个条件或动态构建查询时，此方法非常适用。 + +## 实际应用 +以下是一些实际场景，在这些场景中 **如何索引文档** 能带来颠覆性改变： + +1. **法律文档管理** – 在成千上万的合同中定位条款、案件编号或日期。 +2. **财务报告** – 提取落在特定金额范围内的交易。 +3. **库存跟踪** – 通过序列号、批次码或 SKU 范围查找项目。 + +将 GroupDocs.Search 与数据库、云存储或消息队列集成，可进一步自动化文档工作流。 + +## 性能考虑 +- **定期更新索引：** 对新文件重新运行 `index.add` 以保持索引最新。 +- **资源管理：** 监控堆使用情况；大型索引受益于调优的 JVM 垃圾回收设置。 +- **查询优化：** 对复杂过滤使用对象查询，以减少不必要的扫描。 + +## 常见问题及解决方案 +| 问题 | 原因 | 解决方案 | +|-------|----------------|-----| +| **搜索未返回结果** | 索引未构建或文件夹路径不正确 | 确认已在正确的目录上执行 `index.add`，且索引文件夹可写。 | +| **索引期间出现 OutOfMemoryError** | 文件过大或堆内存不足 | 增加 JVM `-Xmx` 参数值或将文件分批索引。 | +| **不受支持的文件格式** | 文件类型未被 GroupDocs.Search 识别 | 确保文件扩展名在支持列表中（PDF、DOCX、XLSX 等）。 | + +## 常见问答 +**问：如何使用新文档更新已有索引？** +答：再次调用 `index.add("NEW_DOCUMENT_PATH")`；库会合并新条目，而无需重新创建整个索引。 + +**问：GroupDocs.Search 能处理不同的文件格式吗？** +答：可以，它支持 PDF、Word、Excel、PowerPoint、纯文本以及许多其他常见格式。 + +**问：使用 GroupDocs.Search 的系统要求是什么？** +答：Java 8+ 运行时，足够的内存（中等规模集合至少 2 GB），以及对索引文件夹的读写权限。 + +**问：如何排查搜索性能问题？** +答：确保索引是最新的，对查询进行分析，并检查 JVM 内存设置。减少索引的字段数量也能提升速度。 + +**问：是否可以使用同义词或模糊匹配进行搜索？** +答：可以，GroupDocs.Search 提供同义词词典和模糊搜索选项，可通过 `SearchOptions` 类启用。 + +## 结论 +您现在已经对使用 GroupDocs.Search for Java **如何索引文档**、如何 **向索引添加文档** 以及如何运行基于文本和基于对象的查询有了扎实的了解。通过整合这些技术，您的 Java 应用程序将在任何文档库中提供快速、准确的搜索体验。 + +准备好下一步了吗？探索分面搜索、同义词处理，或将索引与 REST API 集成，以向其他服务提供搜索功能。 + +--- + +**最后更新：** 2026-02-06 +**测试环境：** GroupDocs.Search 25.4 for Java +**作者：** GroupDocs \ No newline at end of file diff --git a/content/czech/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/czech/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..50303831 --- /dev/null +++ b/content/czech/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,189 @@ +--- +date: '2026-02-06' +description: Naučte se, jak přidávat dokumenty do indexu a povolit rozlišování velkých + a malých písmen při vyhledávání v Javě s GroupDocs.Search, čímž zvýšíte přesnost + své aplikace. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'Přidat dokumenty do indexu: rozlišující velká a malá písmena při vyhledávání + v Javě s GroupDocs' +type: docs +url: /cs/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# Přidání dokumentů do indexu: Ovládání vyhledávání rozlišujícího velikost písmen v Javě s GroupDocs + +Získání správného kusu informace z obrovské kolekce dokumentů je základní požadavek moderních aplikací. V tomto průvodci se naučíte **jak přidat dokumenty do indexu** a provádět **vyhledávání rozlišující velikost písmen** pomocí GroupDocs.Search pro Javu. Ať už budujete úložiště právních dokumentů, katalog e‑commerce nebo systém pro správu obsahu, přesné výsledky vyhledávání udržují uživatele spokojené a vaše data důvěryhodná. + +## Rychlé odpovědi +- **Jaký je hlavní krok pro zahájení vyhledávání?** Přidejte dokumenty do indexu pomocí `index.add(...)`. +- **Jak povolit vyhledávání rozlišující velikost písmen?** Nastavte `options.setUseCaseSensitiveSearch(true)`. +- **Mohu vyhledávat napříč více adresáři?** Ano – zavolejte `index.add()` pro každý složku, kterou chcete zahrnout. +- **Která metoda mi umožní vyhledávat pomocí objektů?** Použijte `SearchQuery.createWordQuery(...)`. +- **Potřebuji licenci pro testování?** Dočasná licence je k dispozici pro zkušební účely. + +## Co znamená „přidat dokumenty do indexu“? +Přidání dokumentů do indexu znamená vložit vaše zdrojové soubory (PDF, Word, prostý text atd.) do GroupDocs.Search, aby mohl vytvořit prohledávatelnou datovou strukturu. Po indexaci může engine provádět rychlé dotazy, včetně těch rozlišujících velikost písmen. + +## Proč povolit vyhledávání rozlišující velikost písmen v Javě? +- **Přesná shoda termínu** – rozlište „Apple“ (společnost) od „apple“ (ovoce). +- **Regulační shoda** – některá odvětví vyžadují přesnou shodu frází. +- **Zlepšená relevance** – uživatelé často očekávají výsledky specifické pro velikost písmen v technických nebo právních kontextech. + +## Předpoklady +- JDK (doporučeno Java 17 nebo novější) +- Maven pro správu závislostí +- IDE jako IntelliJ IDEA nebo Eclipse +- Základní znalost programování v Javě + +## Nastavení GroupDocs.Search pro Javu +Nejprve přidejte repozitář GroupDocs a závislost do vašeho `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Alternativně můžete stáhnout nejnovější verzi přímo z [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Licencování +Pro zahájení zkušebního období navštivte GroupDocs a získejte dočasnou licenci. To vám umožní otestovat všechny funkce bez jakýchkoli omezení. + +## Jak přidat dokumenty do indexu – Vyhledávání textových dotazů + +### Krok 1: Vytvořte index a přidejte své dokumenty +Vytvořte složku, kde budou uloženy soubory indexu, a poté přidejte zdrojový adresář, který obsahuje dokumenty, jež chcete prohledávat. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **Tip:** Můžete volat `index.add()` vícekrát, abyste **vyhledávali napříč více adresáři** v jediném indexu. + +### Krok 2: Povolit vyhledávání rozlišující velikost písmen +Nastavte možnosti vyhledávání tak, aby respektovaly velikost písmen. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Krok 3: Proveďte vyhledávání rozlišující velikost písmen v textovém dotazu +Spusťte dotaz, který rozliší „Advantages“ od „advantages“. + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Smyčka vypíše úplnou cestu každého dokumentu, který obsahuje přesně shodný termín s požadovanou velikostí písmen. + +## Jak přidat dokumenty do indexu – Vyhledávání objektových dotazů + +Objektové dotazy vám poskytují větší flexibilitu, zejména když potřebujete kombinovat více kritérií. + +### Krok 1: Inicializujte druhý index (volitelné) +Pokud chcete objektové vyhledávání oddělit, vytvořte další složku pro index. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Krok 2: Znovu použijte možnost rozlišující velikost písmen +Stejná instance `SearchOptions` funguje i pro objektové dotazy. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Krok 3: Sestavte a spusťte objektový dotaz +Vytvořte objekt dotazu na slovo a předávejte jej vyhledávacímu enginu. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Použití `createWordQuery` vám později umožní kombinovat jej s frázovými, zástupnými nebo Boolean dotazy pro složitější scénáře. + +## Praktické aplikace +- **Správa právních dokumentů:** Vyhledávejte konkrétní zákony, kde záleží na kapitalizaci. +- **Platformy e‑commerce:** Rozlišujte SKU produktů jako „PRO‑X“ vs. „pro‑x“. +- **Systémy pro správu obsahu (CMS):** Zajistěte, aby autoři našli přesné nadpisy nebo štítky. + +## Úvahy o výkonu +- **Udržujte index aktuální** – reindexujte, když jsou přidány nové soubory nebo se existující změní. +- **Sledujte využití paměti** – velké korpusy těží z inkrementálního indexování a správného nastavení velikosti haldy JVM. +- **Využijte garbage collector Javy** – uvolněte objekty `Index`, když již nejsou potřeba. + +## Časté problémy a řešení +| Problém | Řešení | +|-------|----------| +| `useCaseSensitiveSearch` se zdá být ignorováno | Ověřte, že používáte nejnovější verzi GroupDocs.Search a že byl index znovu vytvořen po změně této volby. | +| Žádné výsledky pro známý termín | Ujistěte se, že velikost písmen termínu přesně odpovídá a že dokument byl úspěšně přidán do indexu. | +| Vyhledávání v mnoha složkách zpomaluje | Přidejte každou složku samostatně pomocí `index.add()` a zvažte rozdělení indexu na shardy pro velmi velké datové sady. | + +## Často kladené otázky + +**Q:** Jak zacházet s velkými datovými sadami pomocí GroupDocs.Search? +**A:** Využijte rozdělení indexu, optimalizujte nastavení paměti JVM a pravidelně kompaktně index, aby byl výkon optimální. + +**Q:** Můžu vyhledávat napříč více adresáři současně? +**A:** Ano – zavolejte `index.add()` pro každý adresář, který chcete zahrnout, a poté spusťte jediný dotaz proti sloučenému indexu. + +**Q:** Jaké jsou běžné úskalí při nastavování vyhledávání rozlišujícího velikost písmen? +**A:** Zapomenutí znovu vytvořit index po povolení `useCaseSensitiveSearch` nebo použití nesprávné velikosti písmen v řetězci dotazu. + +**Q:** Jak mohu řešit chyby vyhledávání? +**A:** Zkontrolujte logovací soubory generované GroupDocs.Search pro stack trace a potvrďte, že všechny Maven závislosti jsou správně vyřešeny. + +**Q:** Je GroupDocs.Search vhodný pro aplikace v reálném čase? +**A:** S vhodnými strategiemi indexování (inkrementální aktualizace a in‑memory cache) může poskytovat téměř real‑time výsledky vyhledávání. + +## Zdroje +- **Dokumentace:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **API Reference:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **Stáhnout:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **GitHub Repository:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Support Forum:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Dočasná licence:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Poslední aktualizace:** 2026-02-06 +**Testováno s:** GroupDocs.Search 25.4 +**Autor:** GroupDocs + +--- \ No newline at end of file diff --git a/content/czech/java/searching/master-document-search-groupdocs-java/_index.md b/content/czech/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..7007794a --- /dev/null +++ b/content/czech/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,183 @@ +--- +date: '2026-02-06' +description: Naučte se, jak indexovat dokumenty a přidávat dokumenty do indexu pomocí + GroupDocs.Search pro Javu. Vytvářejte výkonné vyhledávací aplikace s textovými a + objektovými dotazy. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Jak indexovat dokumenty pomocí GroupDocs.Search pro Javu +type: docs +url: /cs/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# Jak indexovat dokumenty pomocí GroupDocs.Search pro Java + +V dnešním datově řízeném světě je **jak indexovat dokumenty** efektivně klíčová dovednost pro každého Java vývojáře pracujícího s velkými kolekcemi souborů. Ať už zpracováváte právní smlouvy, finanční výkazy nebo interní zprávy, schopnost rychle najít správnou informaci může ušetřit hodiny ruční práce. V tomto tutoriálu se naučíte **jak indexovat dokumenty** pomocí knihovny GroupDocs.Search a poté provádět jak textové, tak objektové dotazy na vytvořeném indexu. Pojďme na to! + +## Rychlé odpovědi +- **Jaký je první krok k indexaci dokumentů?** Inicializujte objekt `Index`, který ukazuje na složku, kde bude index uložen. +- **Která metoda přidává dokumenty do indexu?** Použijte `index.add("PATH_TO_DOCUMENTS")`. +- **Mohu vyhledávat číselné rozsahy?** Ano, pomocí textového dotazu jako `"400 ~~ 4000"` nebo objektového dotazu přes `SearchQuery.createNumericRangeQuery`. +- **Potřebuji licenci?** K dispozici je bezplatná zkušební verze; komerční licence odemyká všechny funkce. +- **Jaká verze Javy je vyžadována?** JDK 8 nebo vyšší. + +## Co je „jak indexovat dokumenty“ s GroupDocs.Search? +Indexování dokumentů znamená prohledání obsahu souborů ve složce a uložení vyhledávatelných tokenů do vyhrazené složky indexu. Tento předzpracovatelský krok umožňuje bleskově rychlé vyhledávání později, protože knihovna prohledává připravený index místo surových souborů při každém dotazu. + +## Proč používat GroupDocs.Search pro Java? +- **Výkon:** Vyhledávání probíhá během milisekund i u tisíců souborů. +- **Podpora formátů:** Zpracovává PDF, Word, Excel, PowerPoint a mnoho dalších. +- **Flexibilita:** Podporuje dotazy v prostém textu, číselné rozsahy i složité objektové dotazy. +- **Škálovatelnost:** Index lze snadno aktualizovat přidáním nových dokumentů bez nutnosti kompletního přestavování. + +## Předpoklady +- Maven nainstalovaný pro správu závislostí. +- IDE, například IntelliJ IDEA nebo Eclipse. +- Základní znalost Javy (OOP koncepty, zpracování výjimek). + +## Nastavení GroupDocs.Search pro Java +### Maven nastavení +Přidejte repozitář a závislost do souboru `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Přímé stažení +Nejnovější JAR můžete také stáhnout z [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +#### Kroky pro získání licence +1. **Free Trial** – prozkoumejte knihovnu bez nákladů. +2. **Temporary License** – požádejte o krátkodobý klíč pro rozšířené hodnocení. +3. **Purchase** – získejte plnou licenci pro produkční použití. + +## Základní inicializace a nastavení +Pro **přidání dokumentů do indexu** nejprve vytvoříte objekt `Index`, který ukazuje na složku, kde budou uloženy soubory indexu: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +Tento řádek vytvoří (nebo otevře) index připravený přijímat dokumenty. + +## Průvodce implementací +### Vytváření a indexování dokumentů +#### Jak přidat dokumenty do indexu +Metoda `add` prohledá složku a **uloží vyhledávatelná data** pro každý soubor. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Parametry:** Řetězec cesty ukazuje na složku obsahující soubory, které chcete indexovat. +- **Účel:** Po tomto kroku index obsahuje tokeny ze všech podporovaných typů dokumentů, což umožňuje rychlé vyhledávání. + +### Vyhledávání textovým dotazem +#### Jak provést textový vyhledávací dotaz s číselným rozsahem +Můžete vyhledávat pomocí jednoduchého řetězce, který definuje rozsah. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Parametry:** Řetězec dotazu `"400 ~~ 4000"` říká enginu, aby našel čísla mezi 400 a 4000. +- **Návratová hodnota:** `SearchResult` obsahuje seznam odpovídajících dokumentů a zvýraznění. + +### Vyhledávání objektovým dotazem +#### Jak použít objektový dotaz pro číselné rozsahy +Objektové dotazy vám dávají programovou kontrolu nad kritérii vyhledávání. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Parametry:** `createNumericRangeQuery` přijímá počáteční a koncové celé číslo. +- **Účel:** Tato metoda je ideální, když potřebujete kombinovat více podmínek nebo dynamicky stavět dotazy. + +## Praktické aplikace +Zde jsou některé reálné scénáře, kde **jak indexovat dokumenty** představuje zásadní výhodu: + +1. **Správa právních dokumentů** – najděte klauzule, čísla případů nebo data napříč tisíci smluv. +2. **Finanční výkaznictví** – vyberte transakce spadající do konkrétního finančního rozsahu. +3. **Sledování zásob** – najděte položky podle sériových čísel, šarží nebo SKU rozsahů. + +Integrace GroupDocs.Search s databázemi, cloudovým úložištěm nebo frontami zpráv může dále automatizovat workflow dokumentů. + +## Úvahy o výkonu +- **Pravidelné aktualizace indexu:** Opakujte `index.add` pro nové soubory, aby byl index aktuální. +- **Správa zdrojů:** Sledujte využití haldy; velké indexy těží z optimalizovaných nastavení garbage‑collection JVM. +- **Optimalizace dotazů:** Pro složité filtry používejte objektové dotazy, abyste snížili zbytečné prohledávání. + +## Časté problémy a řešení +| Problém | Proč se vyskytuje | Řešení | +|-------|----------------|-----| +| **Vyhledávání nevrací žádné výsledky** | Index není vytvořen nebo je cesta ke složce nesprávná | Ověřte, že `index.add` byl spuštěn na správném adresáři a že složka indexu je zapisovatelná. | +| **OutOfMemoryError během indexování** | Velmi velké soubory nebo nedostatečná velikost haldy | Zvyšte hodnotu JVM `-Xmx` nebo indexujte soubory v menších dávkách. | +| **Nesprávný formát souboru** | Typ souboru není rozpoznán GroupDocs.Search | Ujistěte se, že přípona souboru patří mezi podporované (PDF, DOCX, XLSX, atd.). | + +## Často kladené otázky +**Q: Jak aktualizuji existující index novými dokumenty?** +A: Znovu zavolejte `index.add("NEW_DOCUMENT_PATH")`; knihovna sloučí nové položky bez nutnosti přestavovat celý index. + +**Q: Dokáže GroupDocs.Search pracovat s různými formáty souborů?** +A: Ano, podporuje PDF, Word, Excel, PowerPoint, prostý text a mnoho dalších běžných formátů. + +**Q: Jaké jsou systémové požadavky pro používání GroupDocs.Search?** +A: Java 8+ runtime, dostatek RAM (alespoň 2 GB pro středně velké kolekce) a čtení/zápis do složky indexu. + +**Q: Jak mohu řešit problémy s výkonem vyhledávání?** +A: Ujistěte se, že je index aktuální, profilujte své dotazy a zkontrolujte nastavení paměti JVM. Snížení počtu indexovaných polí může také zrychlit vyhledávání. + +**Q: Existuje možnost vyhledávat se synonymy nebo fuzzy matchingem?** +A: Ano, GroupDocs.Search poskytuje slovníky synonym a možnosti fuzzy vyhledávání, které lze aktivovat pomocí třídy `SearchOptions`. + +## Závěr +Nyní máte solidní pochopení **jak indexovat dokumenty** pomocí GroupDocs.Search pro Java, jak **přidat dokumenty do indexu** a jak spouštět jak textové, tak objektové dotazy. Integrací těchto technik vaše Java aplikace nabídnou rychlé a přesné vyhledávací zážitky napříč jakýmkoli úložištěm dokumentů. + +Jste připraveni na další krok? Prozkoumejte faceted search, práci se synonymy nebo integraci indexu s REST API pro zpřístupnění vyhledávacích možností dalším službám. + +--- + +**Poslední aktualizace:** 2026-02-06 +**Testováno s:** GroupDocs.Search 25.4 pro Java +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/dutch/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/dutch/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..3d3bd034 --- /dev/null +++ b/content/dutch/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,188 @@ +--- +date: '2026-02-06' +description: Leer hoe u documenten aan de index kunt toevoegen en hoofdlettergevoelige + zoekopdrachten in Java met GroupDocs.Search kunt inschakelen, waardoor de nauwkeurigheid + van uw applicatie wordt verhoogd. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'Documenten toevoegen aan index: hoofdlettergevoelige Java-zoekopdracht met + GroupDocs' +type: docs +url: /nl/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# Documenten toevoegen aan index: Case‑gevoelige zoekopdrachten in Java beheersen met GroupDocs + +Het ophalen van het juiste stukje informatie uit een enorme verzameling documenten is een kernvereiste voor moderne applicaties. In deze gids leer je **hoe je documenten toevoegt aan een index** en **case‑gevoelige zoekopdrachten** uitvoert met GroupDocs.Search voor Java. Of je nu een juridisch documentarchief, een e‑commerce catalogus of een content‑managementsysteem bouwt, nauwkeurige zoekresultaten houden gebruikers tevreden en je data betrouwbaar. + +## Snelle antwoorden +- **Wat is de eerste stap om te beginnen met zoeken?** Voeg documenten toe aan een index met `index.add(...)`. +- **Hoe schakel je case‑gevoelige zoekopdrachten in?** Stel `options.setUseCaseSensitiveSearch(true)` in. +- **Kan ik zoeken over meerdere mappen?** Ja – roep `index.add()` aan voor elke map die je wilt opnemen. +- **Welke methode laat me zoeken met objecten?** Gebruik `SearchQuery.createWordQuery(...)`. +- **Heb ik een licentie nodig voor testen?** Een tijdelijke licentie is beschikbaar voor proefdoeleinden. + +## Wat betekent “documenten toevoegen aan index”? +Documenten toevoegen aan een index betekent dat je je bronbestanden (PDF's, Word‑documenten, platte tekst, enz.) in GroupDocs.Search laadt zodat het een doorzoekbare datastructuur kan opbouwen. Eenmaal geïndexeerd kan de engine snelle queries uitvoeren, inclusief case‑gevoelige. + +## Waarom case‑gevoelige zoekopdrachten inschakelen in Java? +- **Exacte termovereenkomst** – onderscheid “Apple” (het bedrijf) van “apple” (de vrucht). +- **Regelgeving naleving** – sommige sectoren vereisen exacte frase‑overeenstemming. +- **Verbeterde relevantie** – gebruikers verwachten vaak case‑specifieke resultaten in technische of juridische contexten. + +## Vereisten +- JDK (Java 17 of later aanbevolen) +- Maven voor afhankelijkheidsbeheer +- Een IDE zoals IntelliJ IDEA of Eclipse +- Basiskennis van Java‑programmeren + +## GroupDocs.Search voor Java instellen +Voeg eerst de GroupDocs‑repository en afhankelijkheid toe aan je `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Alternatief kun je de nieuwste versie direct downloaden van [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Licenties +Om te beginnen met een proefversie, ga naar GroupDocs om een tijdelijke licentie aan te schaffen. Hiermee kun je alle functies testen zonder beperkingen. + +## Hoe documenten toevoegen aan index – Tekst‑query zoeken + +### Stap 1: Maak een index aan en voeg je documenten toe +Maak een map aan waar de indexbestanden worden opgeslagen, en voeg vervolgens de bronmap toe die de documenten bevat die je wilt doorzoeken. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **Pro tip:** Je kunt `index.add()` meerdere keren aanroepen om **over meerdere mappen te zoeken** in één enkele index. + +### Stap 2: Schakel case‑gevoelige zoekopdrachten in +Configureer de zoekopties zodat ze hoofdlettergebruik respecteren. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Stap 3: Voer een case‑gevoelige tekst‑query uit +Voer een query uit die “Advantages” onderscheidt van “advantages”. + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +De lus print het volledige pad van elk document dat de exact case‑overeenkomende term bevat. + +## Hoe documenten toevoegen aan index – Object‑query zoeken + +Object‑queries geven je meer flexibiliteit, vooral wanneer je meerdere criteria moet combineren. + +### Stap 1: Initialiseert een tweede index (optioneel) +Als je object‑gebaseerde zoekopdrachten gescheiden wilt houden, maak dan een andere indexmap aan. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Stap 2: Hergebruik de case‑gevoelige optie +Dezelfde `SearchOptions`‑instantie werkt voor object‑queries. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Stap 3: Bouw en voer een object‑query uit +Maak een woord‑query‑object aan en geef het door aan de zoekengine. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Het gebruik van `createWordQuery` stelt je later in staat het te combineren met phrase-, wildcard- of Boolean‑queries voor complexere scenario's. + +## Praktische toepassingen +- **Juridisch documentbeheer:** Haal case‑specifieke wetgevingen op waar hoofdlettergebruik van belang is. +- **E‑commerce platforms:** Onderscheid product‑SKU's zoals “PRO‑X” versus “pro‑x”. +- **Content Management Systems (CMS):** Zorg ervoor dat auteurs exacte koppen of tags vinden. + +## Prestatie‑overwegingen +- **Houd de index up‑to‑date** – re‑indexeer wanneer nieuwe bestanden worden toegevoegd of bestaande wijzigen. +- **Monitor geheugenverbruik** – grote corpora profiteren van incrementeel indexeren en juiste JVM‑heap‑grootte. +- **Maak gebruik van Java’s garbage collector** – geef `Index`‑objecten vrij wanneer ze niet meer nodig zijn. + +## Veelvoorkomende problemen en oplossingen + +| Probleem | Oplossing | +|----------|-----------| +| `useCaseSensitiveSearch` lijkt genegeerd te worden | Controleer of je de nieuwste GroupDocs.Search‑versie gebruikt en of de index opnieuw is opgebouwd na het wijzigen van de optie. | +| Geen resultaten teruggekregen voor een bekende term | Zorg ervoor dat de hoofdlettergebruik van de term exact overeenkomt en dat het document succesvol aan de index is toegevoegd. | +| Zoeken in veel mappen vertraagt | Voeg elke map afzonderlijk toe met `index.add()` en overweeg de index op te splitsen in shards voor zeer grote datasets. | + +## Veelgestelde vragen + +**Q:** Hoe ga ik om met grote datasets met GroupDocs.Search? +**A:** Maak gebruik van index‑partitionering, stel JVM‑geheugeninstellingen af en compactteer periodiek de index om de prestaties optimaal te houden. + +**Q:** Kan ik gelijktijdig zoeken over meerdere mappen? +**A:** Ja – roep `index.add()` aan voor elke map die je wilt opnemen, en voer vervolgens één enkele query uit tegen de gecombineerde index. + +**Q:** Wat zijn veelvoorkomende valkuilen bij het instellen van case‑gevoelige zoekopdrachten? +**A:** Het vergeten opnieuw opbouwen van de index na het inschakelen van `useCaseSensitiveSearch`, of het gebruiken van de verkeerde hoofdlettercase in de query‑string. + +**Q:** Hoe kan ik zoekfouten oplossen? +**A:** Controleer de logbestanden die door GroupDocs.Search worden gegenereerd op stacktraces, en bevestig dat alle Maven‑afhankelijkheden correct zijn opgelost. + +**Q:** Is GroupDocs.Search geschikt voor realtime‑applicaties? +**A:** Met de juiste indexeringsstrategieën (incrementele updates en in‑memory caching) kan het bijna realtime zoekresultaten leveren. + +## Bronnen +- **Documentatie:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **API‑referentie:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **Download:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **GitHub‑repository:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Supportforum:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Tijdelijke licentie:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Laatst bijgewerkt:** 2026-02-06 +**Getest met:** GroupDocs.Search 25.4 +**Auteur:** GroupDocs \ No newline at end of file diff --git a/content/dutch/java/searching/master-document-search-groupdocs-java/_index.md b/content/dutch/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..fa3fff37 --- /dev/null +++ b/content/dutch/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,182 @@ +--- +date: '2026-02-06' +description: Leer hoe u documenten indexeert en documenten aan de index toevoegt met + GroupDocs.Search voor Java. Bouw krachtige zoekapplicaties met tekst‑ en objectquery’s. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Hoe documenten indexeren met GroupDocs.Search voor Java +type: docs +url: /nl/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# Hoe documenten indexeren met GroupDocs.Search voor Java + +In de hedendaagse data‑gedreven wereld is **hoe documenten te indexeren** efficiënt een cruciale vaardigheid voor elke Java‑ontwikkelaar die met grote collecties bestanden werkt. Of je nu juridische contracten, financiële overzichten of interne rapporten verwerkt, het kunnen snel vinden van de juiste informatie kan uren handmatig werk besparen. In deze tutorial leer je **hoe documenten te indexeren** met behulp van de GroupDocs.Search‑bibliotheek, en vervolgens zowel tekst‑gebaseerde als object‑gebaseerde queries op de aangemaakte index uit te voeren. Laten we beginnen! + +## Snelle antwoorden +- **Wat is de eerste stap om documenten te indexeren?** Initialiseer een `Index`‑object dat naar een map wijst waar de index wordt opgeslagen. +- **Welke methode voegt documenten toe aan een index?** Gebruik `index.add("PATH_TO_DOCUMENTS")`. +- **Kan ik numerieke bereiken zoeken?** Ja, met een tekstquery zoals `"400 ~~ 4000"` of een objectquery via `SearchQuery.createNumericRangeQuery`. +- **Heb ik een licentie nodig?** Een gratis proefversie is beschikbaar; een commerciële licentie ontgrendelt alle functies. +- **Welke Java‑versie is vereist?** JDK 8 of hoger. + +## Wat is “hoe documenten te indexeren” met GroupDocs.Search? +Documenten indexeren betekent het scannen van de inhoud van bestanden in een map en het opslaan van doorzoekbare tokens in een speciale indexmap. Deze pre‑processing stap maakt razendsnelle zoekopdrachten later mogelijk, omdat de bibliotheek de voorbereide index doorzoekt in plaats van elke keer de ruwe bestanden. + +## Waarom GroupDocs.Search voor Java gebruiken? +- **Prestaties:** Zoekopdrachten worden uitgevoerd in milliseconden, zelfs bij duizenden bestanden. +- **Formaatondersteuning:** Verwerkt PDF's, Word, Excel, PowerPoint en nog veel meer. +- **Flexibiliteit:** Ondersteunt plain‑text queries, numerieke bereiken en complexe objectqueries. +- **Schaalbaarheid:** Werk de index eenvoudig bij door nieuwe documenten toe te voegen zonder de index opnieuw te bouwen. + +## Vereisten +- Maven geïnstalleerd voor dependency‑beheer. +- Een IDE zoals IntelliJ IDEA of Eclipse. +- Basiskennis van Java (OOP‑concepten, exception handling). + +## GroupDocs.Search voor Java instellen +### Maven‑configuratie +Voeg de repository en afhankelijkheid toe aan je `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Directe download +Je kunt ook de nieuwste JAR downloaden van [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +#### Stappen voor het verkrijgen van een licentie +1. **Gratis proefversie** – verken de bibliotheek zonder kosten. +2. **Tijdelijke licentie** – vraag een kort‑lopende sleutel aan voor uitgebreide evaluatie. +3. **Aankoop** – verkrijg een volledige licentie voor productiegebruik. + +## Basisinitialisatie en configuratie +Om **documenten toe te voegen aan de index**, maak je eerst een `Index`‑object aan dat naar de map wijst waar de indexbestanden worden opgeslagen: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +Deze regel maakt (of opent) een index die klaar is om documenten te ontvangen. + +## Implementatie‑gids +### Documenten maken en indexeren +#### Hoe documenten toe te voegen aan de index +De `add`‑methode scant een map en slaat doorzoekbare gegevens op voor elk bestand. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Parameters:** De pad‑string wijst naar de map die de bestanden bevat die je wilt indexeren. +- **Doel:** Na deze stap bevat de index tokens van alle ondersteunde documenttypes, waardoor snelle zoekopdrachten mogelijk zijn. + +### Tekst‑query zoeken +#### Hoe een tekst‑gebaseerde numerieke bereikzoekopdracht uit te voeren +Je kunt zoeken met een eenvoudige tekenreeks die een bereik definieert. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Parameters:** De query‑string `"400 ~~ 4000"` vertelt de engine om nummers tussen 400 en 4000 te vinden. +- **Returnwaarde:** `SearchResult` bevat de lijst met overeenkomende documenten en markeringen. + +### Object‑query zoeken +#### Hoe een object‑query te gebruiken voor numerieke bereiken +Object‑gebaseerde queries geven je programmatische controle over zoekcriteria. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Parameters:** `createNumericRangeQuery` ontvangt de start‑ en eind‑integers. +- **Doel:** Deze methode is ideaal wanneer je meerdere voorwaarden wilt combineren of queries dynamisch wilt opbouwen. + +## Praktische toepassingen +Hier zijn enkele praktijkvoorbeelden waarbij **hoe documenten te indexeren** een doorslaggevende factor wordt: + +1. **Beheer van juridische documenten** – vind clausules, zaaknummers of data in duizenden contracten. +2. **Financiële rapportage** – haal transacties op die binnen een specifiek geldbedrag vallen. +3. **Voorraadbeheer** – vind items op serienummers, batchcodes of SKU‑bereiken. + +Het integreren van GroupDocs.Search met databases, cloudopslag of berichtqueues kan documentworkflows verder automatiseren. + +## Prestatie‑overwegingen +- **Regelmatige indexupdates:** Voer `index.add` opnieuw uit voor nieuwe bestanden om de index actueel te houden. +- **Resource‑beheer:** Houd het heap‑gebruik in de gaten; grote indexen profiteren van geoptimaliseerde JVM‑garbage‑collection‑instellingen. +- **Query‑optimalisatie:** Gebruik objectqueries voor complexe filters om onnodig scannen te verminderen. + +## Veelvoorkomende problemen en oplossingen +| Probleem | Waarom het gebeurt | Oplossing | +|----------|--------------------|-----------| +| **Search returns no results** | Index niet gebouwd of mappad onjuist | Controleer of `index.add` is uitgevoerd op de juiste directory en of de indexmap schrijfbaar is. | +| **OutOfMemoryError during indexing** | Zeer grote bestanden of onvoldoende heap | Verhoog de JVM `-Xmx`‑waarde of indexeer bestanden in kleinere batches. | +| **Unsupported file format** | Bestandstype niet herkend door GroupDocs.Search | Zorg ervoor dat de bestandsextensie voorkomt in de ondersteunde lijst (PDF, DOCX, XLSX, etc.). | + +## Veelgestelde vragen +**V: Hoe werk ik een bestaande index bij met nieuwe documenten?** +A: Roep `index.add("NEW_DOCUMENT_PATH")` opnieuw aan; de bibliotheek voegt nieuwe items samen zonder de hele index opnieuw te maken. + +**V: Kan GroupDocs.Search verschillende bestandsformaten aan?** +A: Ja, het ondersteunt PDF's, Word, Excel, PowerPoint, platte tekst en vele andere gangbare formaten. + +**V: Wat zijn de systeemvereisten voor het gebruik van GroupDocs.Search?** +A: Java 8+ runtime, voldoende RAM (minimaal 2 GB voor middelgrote collecties) en lees‑/schrijftoegang tot de indexmap. + +**V: Hoe kan ik zoek‑prestatieproblemen oplossen?** +A: Zorg ervoor dat de index up‑to‑date is, profileer je queries en controleer de JVM‑geheugeninstellingen. Het verminderen van het aantal geïndexeerde velden kan de snelheid ook verbeteren. + +**V: Is er een manier om te zoeken met synoniemen of fuzzy matching?** +A: Ja, GroupDocs.Search biedt synoniemdictionaries en fuzzy‑zoekopties die via de `SearchOptions`‑klasse kunnen worden ingeschakeld. + +## Conclusie +Je hebt nu een solide begrip van **hoe documenten te indexeren** met GroupDocs.Search voor Java, hoe **documenten toe te voegen aan de index**, en hoe zowel tekst‑gebaseerde als object‑gebaseerde queries uit te voeren. Door deze technieken te integreren, zullen je Java‑applicaties snelle, nauwkeurige zoekervaringen bieden over elke documentrepository. + +Klaar voor de volgende stap? Verken gefacetteerd zoeken, synoniem‑verwerking, of integreer de index met een REST‑API om zoekfunctionaliteit beschikbaar te maken voor andere services. + +--- + +**Laatst bijgewerkt:** 2026-02-06 +**Getest met:** GroupDocs.Search 25.4 for Java +**Auteur:** GroupDocs \ No newline at end of file diff --git a/content/english/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/english/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md index 74405321..e7dee580 100644 --- a/content/english/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md +++ b/content/english/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -1,7 +1,7 @@ --- -title: "Master Case-Sensitive Searches in Java Using GroupDocs: A Comprehensive Guide" -description: "Learn to implement precise case-sensitive text and object query searches in Java with GroupDocs.Search. Enhance your application's search functionality for better data accuracy." -date: "2025-05-20" +title: "Add documents to index: case‑sensitive Java search with GroupDocs" +description: "Learn how to add documents to index and enable case sensitive search in Java with GroupDocs.Search, boosting accuracy of your application." +date: "2026-02-06" weight: 1 url: "/java/searching/master-case-sensitive-searches-java-groupdocs/" keywords: @@ -11,26 +11,34 @@ keywords: - object query search in Java type: docs --- -# Mastering Case Sensitive Text and Object Query Searches in Java with GroupDocs -In today’s digital age, retrieving precise information from vast amounts of text is not just a convenience—it's an imperative. Whether you're developing sophisticated document management systems or crafting intricate search functionalities for business applications, the ability to perform case-sensitive searches can significantly enhance data accuracy and user satisfaction. This tutorial will guide you through implementing case-sensitive text and object query searches using GroupDocs.Search Java, ensuring your projects meet the highest standards of precision. +# Add documents to index: Mastering Case‑Sensitive Searches in Java with GroupDocs -## What You'll Learn -- **Perform Case-Sensitive Text Queries**: Understand how to configure and execute precise text searches. -- **Implement Object Query Searches**: Learn how to use advanced search objects for more dynamic querying. -- **Optimize Your Search Setup**: Gain insights into performance tuning and resource management. +Retrieving the right piece of information from a massive collection of documents is a core requirement for modern applications. In this guide, you’ll learn **how to add documents to index** and perform **case‑sensitive searches** using GroupDocs.Search for Java. Whether you’re building a legal‑document repository, an e‑commerce catalog, or a content‑management system, precise search results keep users happy and your data trustworthy. -Before diving in, ensure you meet all the necessary prerequisites. +## Quick Answers +- **What is the primary step to start searching?** Add documents to an index with `index.add(...)`. +- **How to enable case sensitive search?** Set `options.setUseCaseSensitiveSearch(true)`. +- **Can I search across multiple directories?** Yes – call `index.add()` for each folder you want to include. +- **Which method lets me search with objects?** Use `SearchQuery.createWordQuery(...)`. +- **Do I need a license for testing?** A temporary license is available for trial purposes. -### Prerequisites -To follow this tutorial effectively, you'll need: -- Java Development Kit (JDK) installed on your system. -- An Integrated Development Environment (IDE), such as IntelliJ IDEA or Eclipse. -- Familiarity with basic Java programming concepts. -- Maven for managing dependencies. +## What does “add documents to index” mean? +Adding documents to an index means feeding your source files (PDFs, Word docs, plain text, etc.) into GroupDocs.Search so it can build a searchable data structure. Once indexed, the engine can execute fast queries, including case‑sensitive ones. + +## Why enable case‑sensitive search in Java? +- **Exact term matching** – differentiate “Apple” (the company) from “apple” (the fruit). +- **Regulatory compliance** – some industries require exact phrase matching. +- **Improved relevance** – users often expect case‑specific results in technical or legal contexts. + +## Prerequisites +- JDK (Java 17 or later recommended) +- Maven for dependency management +- An IDE such as IntelliJ IDEA or Eclipse +- Basic familiarity with Java programming ## Setting Up GroupDocs.Search for Java -Firstly, let’s set up GroupDocs.Search for Java using Maven. Add the following to your `pom.xml` file: +First, add the GroupDocs repository and dependency to your `pom.xml`: ```xml @@ -55,14 +63,10 @@ Alternatively, you can download the latest version directly from [GroupDocs.Sear ### Licensing To get started with a trial, visit GroupDocs to acquire a temporary license. This will allow you to test all features without any limitations. -## Implementation Guide -Now, let’s break down the implementation into two key features: text query search and object query search. - -### Case Sensitive Text Query Search -**Overview**: This feature allows for precise searching by considering case sensitivity, crucial in distinguishing between terms like "Advantages" and "advantages." +## How to add documents to index – Text Query Search -#### Step 1: Create an Index -Create a directory for your index data: +### Step 1: Create an Index and add your documents +Create a folder where the index files will be stored, then add the source directory that contains the documents you want to search. ```java String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; @@ -70,20 +74,18 @@ Index index = new Index(indexFolder); index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index ``` -This step initializes an `Index` object, storing indexed data in a specified directory. +> **Pro tip:** You can call `index.add()` multiple times to **search across multiple directories** in a single index. -#### Step 2: Configure Search Options -Enable case-sensitive search: +### Step 2: Enable case‑sensitive search +Configure the search options to respect letter casing. ```java SearchOptions options = new SearchOptions(); options.setUseCaseSensitiveSearch(true); ``` -By setting `useCaseSensitiveSearch` to true, you ensure that the search respects letter casing. - -#### Step 3: Execute the Search -Perform a case-sensitive text query: +### Step 3: Execute a case‑sensitive text query +Run a query that differentiates “Advantages” from “advantages”. ```java String query = "Advantages"; @@ -95,13 +97,14 @@ for (FoundDocument doc : result.getDocuments()) { } ``` -This code snippet searches for the term "Advantages" while respecting case sensitivity. +The loop prints the full path of each document that contains the exact case‑matched term. + +## How to add documents to index – Object Query Search -### Case Sensitive Object Query Search -**Overview**: This approach leverages object queries to perform more dynamic and flexible searches, maintaining case sensitivity. +Object queries give you more flexibility, especially when you need to combine multiple criteria. -#### Step 1: Initialize Index -Create another index directory: +### Step 1: Initialize a second index (optional) +If you prefer to keep object‑based searches separate, create another index folder. ```java String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; @@ -109,18 +112,16 @@ Index index = new Index(indexFolder); index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index ``` -This setup is similar to the text query but for object-based searches. - -#### Step 2: Set Up Search Options -Enable case sensitivity: +### Step 2: Re‑use the case‑sensitive option +The same `SearchOptions` instance works for object queries. ```java SearchOptions options = new SearchOptions(); options.setUseCaseSensitiveSearch(true); ``` -#### Step 3: Perform Object Query Search -Create and execute an object query: +### Step 3: Build and run an object query +Create a word query object and pass it to the search engine. ```java SearchQuery query = SearchQuery.createWordQuery("Advantages"); @@ -132,50 +133,54 @@ for (FoundDocument doc : result.getDocuments()) { } ``` -Here, `createWordQuery` constructs a search query object, providing more flexibility in search configurations. +Using `createWordQuery` lets you later combine it with phrase, wildcard, or Boolean queries for more complex scenarios. ## Practical Applications -- **Legal Document Management**: Enhance retrieval of case-specific legal documents. -- **E-commerce Platforms**: Improve product searches by distinguishing between similar-sounding product names. -- **Content Management Systems (CMS)**: Refine content discovery with precise keyword matching. - -Integration with databases and other document management systems is straightforward, allowing for seamless data access and manipulation. +- **Legal Document Management:** Retrieve case‑specific statutes where capitalization matters. +- **E‑commerce Platforms:** Distinguish product SKUs like “PRO‑X” vs. “pro‑x”. +- **Content Management Systems (CMS):** Ensure authors find exact headings or tags. ## Performance Considerations -To optimize your search performance: -- Regularly update indexes to reflect changes in the dataset. -- Monitor memory usage, especially when dealing with large datasets. -- Utilize Java’s garbage collection effectively by managing object lifecycles. - -Adhering to these best practices ensures efficient resource utilization and faster query responses. +- **Keep the index up‑to‑date** – re‑index when new files are added or existing ones change. +- **Monitor memory usage** – large corpora benefit from incremental indexing and proper JVM heap sizing. +- **Leverage Java’s garbage collector** – release `Index` objects when they’re no longer needed. -## Conclusion -You now have a comprehensive understanding of implementing case-sensitive text and object query searches using GroupDocs.Search for Java. With this knowledge, you can enhance your applications' search functionalities, ensuring they meet the precise needs of users. +## Common Issues and Solutions +| Issue | Solution | +|-------|----------| +| `useCaseSensitiveSearch` appears ignored | Verify you are using the latest GroupDocs.Search version and that the index was rebuilt after changing the option. | +| No results returned for a known term | Ensure the term’s case matches exactly and that the document was successfully added to the index. | +| Searching many folders slows down | Add each folder individually with `index.add()` and consider splitting the index into shards for very large datasets. | -Next steps include exploring more advanced features of GroupDocs.Search or integrating it with other tools in your tech stack. +## Frequently Asked Questions -## FAQ Section -**Q1: How do I handle large datasets with GroupDocs.Search?** -A1: Utilize index partitioning and optimize memory settings for better performance. +**Q:** How do I handle large datasets with GroupDocs.Search? +**A:** Utilize index partitioning, tune JVM memory settings, and periodically compact the index to keep performance optimal. -**Q2: Can I search across multiple directories simultaneously?** -A2: Yes, you can add multiple directories to the index during initialization. +**Q:** Can I search across multiple directories simultaneously? +**A:** Yes – call `index.add()` for each directory you want to include, then run a single query against the combined index. -**Q3: What are some common issues when setting up case-sensitive searches?** -A3: Ensure that `useCaseSensitiveSearch` is correctly set and verify your environment configurations. +**Q:** What are common pitfalls when setting up case‑sensitive searches? +**A:** Forgetting to rebuild the index after enabling `useCaseSensitiveSearch`, or using the wrong case in the query string. -**Q4: How do I troubleshoot search errors?** -A4: Check log files for detailed error messages and ensure all dependencies are correctly configured. +**Q:** How can I troubleshoot search errors? +**A:** Check the log files generated by GroupDocs.Search for stack traces, and confirm that all Maven dependencies are correctly resolved. -**Q5: Is GroupDocs.Search suitable for real-time applications?** -A5: With proper indexing strategies, it can be optimized for near real-time search capabilities. +**Q:** Is GroupDocs.Search suitable for real‑time applications? +**A:** With proper indexing strategies (incremental updates and in‑memory caching), it can deliver near‑real‑time search results. ## Resources -- **Documentation**: [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) -- **API Reference**: [Java API Reference](https://reference.groupdocs.com/search/java) -- **Download**: [Latest Releases](https://releases.groupdocs.com/search/java/) -- **GitHub Repository**: [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- **Support Forum**: [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) -- **Temporary License**: [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) - -Dive into the world of precise search functionalities with GroupDocs.Search for Java, and revolutionize how your applications handle data retrieval. Happy coding! +- **Documentation:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **API Reference:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **Download:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **GitHub Repository:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Support Forum:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Temporary License:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Last Updated:** 2026-02-06 +**Tested With:** GroupDocs.Search 25.4 +**Author:** GroupDocs + +--- \ No newline at end of file diff --git a/content/english/java/searching/master-document-search-groupdocs-java/_index.md b/content/english/java/searching/master-document-search-groupdocs-java/_index.md index ac0db21a..ab0b185b 100644 --- a/content/english/java/searching/master-document-search-groupdocs-java/_index.md +++ b/content/english/java/searching/master-document-search-groupdocs-java/_index.md @@ -1,7 +1,7 @@ --- -title: "Master Document Search with GroupDocs.Search Java: A Comprehensive Guide for Efficient File Indexing and Searching" -description: "Learn how to use GroupDocs.Search for Java to create powerful search applications. Master text-based and object query searches in your Java projects." -date: "2025-05-20" +title: "How to Index Documents with GroupDocs.Search for Java" +description: "Learn how to index documents and add documents to index using GroupDocs.Search for Java. Build powerful search apps with text and object queries." +date: "2026-02-06" weight: 1 url: "/java/searching/master-document-search-groupdocs-java/" keywords: @@ -10,30 +10,36 @@ keywords: - Java document search type: docs --- -# Create a Powerful Search Application with GroupDocs.Search for Java -## Introduction +# How to Index Documents with GroupDocs.Search for Java -In today's data-driven world, the ability to quickly locate specific information within vast collections of documents is invaluable. Whether you're managing legal documents, financial records, or internal reports, efficient document searching can save time and enhance productivity. This tutorial will guide you through using **GroupDocs.Search for Java** to create an index from a specified folder and perform both text-based and object query searches on the indexed data. By mastering this feature-rich library, you'll unlock powerful search capabilities within your Java applications. +In today's data‑driven world, **how to index documents** efficiently is a critical skill for any Java developer dealing with large collections of files. Whether you're handling legal contracts, financial statements, or internal reports, being able to quickly locate the right information can save hours of manual work. In this tutorial you’ll learn **how to index documents** using the GroupDocs.Search library, then perform both text‑based and object‑based queries on the created index. Let’s get started! -### What You’ll Learn -- How to set up and use GroupDocs.Search in a Java project. -- Creating and indexing documents using the library. -- Performing text query searches for specific numeric ranges. -- Executing object-based searches with ease. -By the end of this tutorial, you'll have a comprehensive understanding of how to integrate powerful search functionalities into your Java applications. Let’s dive into setting up your environment first! +## Quick Answers +- **What is the first step to index documents?** Initialize a `Index` object pointing to a folder where the index will be stored. +- **Which method adds documents to an index?** Use `index.add("PATH_TO_DOCUMENTS")`. +- **Can I search numeric ranges?** Yes, with a text query like `"400 ~~ 4000"` or an object query via `SearchQuery.createNumericRangeQuery`. +- **Do I need a license?** A free trial is available; a commercial license unlocks full features. +- **Which Java version is required?** JDK 8 or higher. + +## What is “how to index documents” with GroupDocs.Search? +Indexing documents means scanning the content of files in a folder and storing searchable tokens in a dedicated index folder. This pre‑processing step enables lightning‑fast look‑ups later, because the library searches the prepared index rather than the raw files each time. + +## Why use GroupDocs.Search for Java? +- **Performance:** Searches run in milliseconds even on thousands of files. +- **Format support:** Handles PDFs, Word, Excel, PowerPoint, and many more. +- **Flexibility:** Supports plain‑text queries, numeric ranges, and complex object queries. +- **Scalability:** Easily update the index by adding new documents without rebuilding from scratch. ## Prerequisites -Before we begin implementing GroupDocs.Search for Java, ensure you meet the following prerequisites: -- **Required Libraries & Dependencies**: You will need Maven installed on your system for dependency management. -- **Environment Setup**: A basic understanding of Java and familiarity with an IDE like IntelliJ IDEA or Eclipse is recommended. -- **Knowledge Prerequisites**: Basic knowledge of object-oriented programming in Java. +- Maven installed for dependency management. +- An IDE such as IntelliJ IDEA or Eclipse. +- Basic Java knowledge (OOP concepts, exception handling). ## Setting Up GroupDocs.Search for Java -To get started, you'll need to integrate the GroupDocs.Search library into your project. Here's how: - ### Maven Setup -Add the following repository and dependency configurations to your `pom.xml` file: +Add the repository and dependency to your `pom.xml`: + ```xml @@ -51,34 +57,32 @@ Add the following repository and dependency configurations to your `pom.xml` fil ``` + ### Direct Download -Alternatively, you can download the latest version from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). +You can also download the latest JAR from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). #### License Acquisition Steps -1. **Free Trial**: Start by downloading a free trial to explore the library's capabilities. -2. **Temporary License**: Apply for a temporary license if you need extended access for evaluation purposes. -3. **Purchase**: For commercial use, consider purchasing a license to unlock full features and support. +1. **Free Trial** – explore the library without cost. +2. **Temporary License** – request a short‑term key for extended evaluation. +3. **Purchase** – obtain a full license for production use. + +## Basic Initialization and Setup +To **add documents to index**, you first create an `Index` object that points to the folder where the index files will be stored: -### Basic Initialization and Setup -To initialize GroupDocs.Search in your Java application, follow these steps: ```java import com.groupdocs.search.Index; // Initialize the index by specifying a directory path Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); ``` -This code snippet sets up an index in a specified folder to store and manage your documents efficiently. -## Implementation Guide -Now, let's implement the key features of GroupDocs.Search for Java. We'll break it down into logical sections for clarity. +This line creates (or opens) an index ready to receive documents. +## Implementation Guide ### Creating and Indexing Documents -#### Overview -Creating an index is crucial as it allows efficient search operations on large datasets stored in folders. +#### How to add documents to index +The `add` method scans a folder and stores searchable data for each file. -#### Steps to Create and Index Documents -1. **Initialize the Index**: Define a directory where your indexed data will reside. -2. **Add Documents**: Specify the folder containing documents to be indexed. ```java import com.groupdocs.search.Index; @@ -88,16 +92,14 @@ Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searchi // Add documents from a directory for indexing index.add("YOUR_DOCUMENT_DIRECTORY"); ``` -- **Parameters**: The `add` method takes a string parameter representing the folder containing your documents. -- **Purpose**: This setup allows you to manage and search through documents stored in various folders effectively. + +- **Parameters:** The path string points to the folder containing the files you want to index. +- **Purpose:** After this step, the index contains tokens from all supported document types, enabling rapid searches. ### Text Query Search -#### Overview -Performing text-based searches enables quick retrieval of information based on specific criteria, such as numeric ranges. +#### How to perform a text‑based numeric range search +You can search using a simple string that defines a range. -#### Steps for Text-Based Searching -1. **Define the Query**: Specify the range or keywords to be searched. -2. **Execute the Search**: Use the `search` method to find matching documents. ```java import com.groupdocs.search.*; import com.groupdocs.search.results.*; @@ -108,16 +110,14 @@ String query1 = "400 ~~ 4000"; // Execute text-based search on indexed data SearchResult result1 = index.search(query1); ``` -- **Parameters**: The `search` method requires a string representing the query. -- **Return Value**: Returns a `SearchResult` object containing documents matching the query. + +- **Parameters:** The query string `"400 ~~ 4000"` tells the engine to find numbers between 400 and 4000. +- **Return Value:** `SearchResult` holds the list of matching documents and highlights. ### Object Query Search -#### Overview -Using an object-based approach provides more flexibility and precision for complex queries. +#### How to use an object query for numeric ranges +Object‑based queries give you programmatic control over search criteria. -#### Steps to Perform Object-Based Searches -1. **Create a Numeric Range Query Object**: Define search parameters using objects. -2. **Execute the Query**: Use the `search` method with the created query object. ```java import com.groupdocs.search.*; import com.groupdocs.search.results.*; @@ -128,37 +128,54 @@ SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); // Perform search using the query object SearchResult result2 = index.search(query2); ``` -- **Parameters**: The `createNumericRangeQuery` method requires two integers representing the start and end of the numeric range. -- **Purpose**: This approach allows for more complex queries to be constructed programmatically. + +- **Parameters:** `createNumericRangeQuery` receives the start and end integers. +- **Purpose:** This method is ideal when you need to combine multiple conditions or build queries dynamically. ## Practical Applications -Here are some real-world use cases where GroupDocs.Search can be particularly useful: -1. **Legal Document Management**: Quickly find specific clauses or references in large volumes of legal documents. -2. **Financial Reporting**: Search financial records for transactions within a particular range. -3. **Inventory Tracking**: Locate items based on serial numbers or batch codes. +Here are some real‑world scenarios where **how to index documents** becomes a game‑changer: + +1. **Legal Document Management** – locate clauses, case numbers, or dates across thousands of contracts. +2. **Financial Reporting** – pull transactions that fall within a specific monetary range. +3. **Inventory Tracking** – find items by serial numbers, batch codes, or SKU ranges. -Integrating GroupDocs.Search with other systems, like databases or cloud storage solutions, can further enhance its capabilities and streamline workflows. +Integrating GroupDocs.Search with databases, cloud storage, or messaging queues can further automate document workflows. ## Performance Considerations -To ensure optimal performance when using GroupDocs.Search in Java: -- **Optimize Indexing**: Regularly update your index to reflect changes in the document repository. -- **Manage Resources**: Monitor memory usage and optimize query execution paths for faster results. -- **Java Memory Management**: Follow best practices like garbage collection tuning and memory-efficient data structures. +- **Regular Index Updates:** Re‑run `index.add` for new files to keep the index fresh. +- **Resource Management:** Monitor heap usage; large indexes benefit from tuned JVM garbage‑collection settings. +- **Query Optimization:** Use object queries for complex filters to reduce unnecessary scanning. -## Conclusion -In this tutorial, we explored how to implement GroupDocs.Search for Java to create indexes and perform powerful search queries. With these skills, you can significantly enhance the search capabilities of your Java applications, making document retrieval faster and more efficient. +## Common Issues and Solutions +| Issue | Why It Happens | Fix | +|-------|----------------|-----| +| **Search returns no results** | Index not built or folder path incorrect | Verify `index.add` executed on the correct directory and that the index folder is writable. | +| **OutOfMemoryError during indexing** | Very large files or insufficient heap | Increase JVM `-Xmx` value or index files in smaller batches. | +| **Unsupported file format** | File type not recognized by GroupDocs.Search | Ensure the file extension is among the supported list (PDF, DOCX, XLSX, etc.). | + +## Frequently Asked Questions +**Q: How do I update an existing index with new documents?** +A: Call `index.add("NEW_DOCUMENT_PATH")` again; the library merges new entries without recreating the whole index. + +**Q: Can GroupDocs.Search handle different file formats?** +A: Yes, it supports PDFs, Word, Excel, PowerPoint, plain text, and many other common formats. -Consider exploring additional features offered by GroupDocs.Search, such as faceted searches or synonym handling, to further refine your application's search functionality. +**Q: What are the system requirements for using GroupDocs.Search?** +A: Java 8+ runtime, sufficient RAM (at least 2 GB for moderate collections), and read/write access to the index folder. -## FAQ Section -**Q1: How do I update an existing index with new documents?** -- Use the `index.add` method with the path of new documents to include them in the existing index. +**Q: How can I troubleshoot search performance issues?** +A: Ensure the index is up‑to‑date, profile your queries, and review JVM memory settings. Reducing the number of fields indexed can also improve speed. -**Q2: Can GroupDocs.Search handle different file formats?** -- Yes, it supports a wide range of document types including PDFs, Word files, and Excel spreadsheets. +**Q: Is there a way to search with synonyms or fuzzy matching?** +A: Yes, GroupDocs.Search provides synonym dictionaries and fuzzy search options that can be enabled via the `SearchOptions` class. -**Q3: What are the system requirements for using GroupDocs.Search?** -- A Java Development Kit (JDK) version 8 or higher is required along with sufficient memory to handle indexing operations. +## Conclusion +You now have a solid understanding of **how to index documents** using GroupDocs.Search for Java, how to **add documents to index**, and how to run both text‑based and object‑based queries. By integrating these techniques, your Java applications will deliver fast, accurate search experiences across any document repository. + +Ready for the next step? Explore faceted search, synonym handling, or integrate the index with a REST API to expose search capabilities to other services. + +--- -**Q4: How can I troubleshoot search performance issues?** -- Ensure your index is updated and consider optimizing query parameters. Review resource usage logs for potential bottlenecks. +**Last Updated:** 2026-02-06 +**Tested With:** GroupDocs.Search 25.4 for Java +**Author:** GroupDocs \ No newline at end of file diff --git a/content/french/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/french/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..95eb126f --- /dev/null +++ b/content/french/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,189 @@ +--- +date: '2026-02-06' +description: Apprenez à ajouter des documents à l'index et à activer la recherche + sensible à la casse en Java avec GroupDocs.Search, améliorant la précision de votre + application. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'Ajouter des documents à l''index : recherche Java sensible à la casse avec + GroupDocs' +type: docs +url: /fr/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# Ajouter des documents à l'index : Maîtriser les recherches sensibles à la casse en Java avec GroupDocs + +Récupérer la bonne information au sein d’une collection massive de documents est une exigence fondamentale pour les applications modernes. Dans ce guide, vous apprendrez **comment ajouter des documents à l'index** et effectuer des **recherches sensibles à la casse** en utilisant GroupDocs.Search pour Java. Que vous construisiez un dépôt de documents juridiques, un catalogue e‑commerce ou un système de gestion de contenu, des résultats de recherche précis maintiennent les utilisateurs satisfaits et vos données fiables. + +## Réponses rapides +- **Quelle est l’étape principale pour commencer à rechercher ?** Ajouter des documents à un index avec `index.add(...)`. +- **Comment activer la recherche sensible à la casse ?** Définir `options.setUseCaseSensitiveSearch(true)`. +- **Puis‑je rechercher dans plusieurs répertoires ?** Oui – appelez `index.add()` pour chaque dossier que vous souhaitez inclure. +- **Quelle méthode permet de rechercher avec des objets ?** Utilisez `SearchQuery.createWordQuery(...)`. +- **Ai‑je besoin d’une licence pour les tests ?** Une licence temporaire est disponible à des fins d’essai. + +## Que signifie « ajouter des documents à l'index » ? +Ajouter des documents à un index consiste à alimenter vos fichiers sources (PDF, documents Word, texte brut, etc.) dans GroupDocs.Search afin qu’il puisse construire une structure de données interrogeable. Une fois indexés, le moteur peut exécuter des requêtes rapides, y compris celles sensibles à la casse. + +## Pourquoi activer la recherche sensible à la casse en Java ? +- **Correspondance exacte des termes** – différencier « Apple » (l’entreprise) de « apple » (le fruit). +- **Conformité réglementaire** – certaines industries exigent une correspondance exacte des phrases. +- **Pertinence améliorée** – les utilisateurs s’attendent souvent à des résultats spécifiques à la casse dans des contextes techniques ou juridiques. + +## Prérequis +- JDK (Java 17 ou version ultérieure recommandée) +- Maven pour la gestion des dépendances +- Un IDE tel qu’IntelliJ IDEA ou Eclipse +- Familiarité de base avec la programmation Java + +## Configuration de GroupDocs.Search pour Java +Tout d’abord, ajoutez le dépôt GroupDocs et la dépendance à votre `pom.xml` : + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Vous pouvez également télécharger la dernière version directement depuis [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Licence +Pour commencer avec un essai, rendez‑vous sur le site GroupDocs afin d’obtenir une licence temporaire. Cela vous permettra de tester toutes les fonctionnalités sans aucune limitation. + +## Comment ajouter des documents à l'index – Recherche par requête texte + +### Étape 1 : Créer un index et ajouter vos documents +Créez un dossier où les fichiers d’index seront stockés, puis ajoutez le répertoire source contenant les documents que vous souhaitez rechercher. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **Astuce :** Vous pouvez appeler `index.add()` plusieurs fois pour **rechercher dans plusieurs répertoires** au sein d’un même index. + +### Étape 2 : Activer la recherche sensible à la casse +Configurez les options de recherche pour respecter la casse des lettres. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Étape 3 : Exécuter une requête texte sensible à la casse +Lancez une requête qui différencie « Advantages » de « advantages ». + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +La boucle affiche le chemin complet de chaque document contenant le terme exactement correspondant à la casse. + +## Comment ajouter des documents à l'index – Recherche par requête d’objet + +Les requêtes d’objet offrent plus de flexibilité, notamment lorsque vous devez combiner plusieurs critères. + +### Étape 1 : Initialiser un second index (facultatif) +Si vous préférez garder les recherches basées sur les objets séparées, créez un autre dossier d’index. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Étape 2 : Réutiliser l’option sensible à la casse +La même instance de `SearchOptions` fonctionne pour les requêtes d’objet. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Étape 3 : Construire et exécuter une requête d’objet +Créez un objet de requête de mot et transmettez‑le au moteur de recherche. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Utiliser `createWordQuery` vous permet ensuite de le combiner avec des requêtes de phrase, de caractère générique ou booléennes pour des scénarios plus complexes. + +## Applications pratiques +- **Gestion de documents juridiques :** Récupérer des statuts spécifiques où la capitalisation compte. +- **Plateformes e‑commerce :** Distinguer des SKU produits comme « PRO‑X » vs. « pro‑x ». +- **Systèmes de gestion de contenu (CMS) :** Garantir que les auteurs trouvent les titres ou tags exacts. + +## Considérations de performance +- **Maintenir l’index à jour** – ré‑indexer lorsque de nouveaux fichiers sont ajoutés ou que les existants changent. +- **Surveiller l’utilisation de la mémoire** – les grands corpus bénéficient d’un indexage incrémental et d’une taille de heap JVM appropriée. +- **Exploiter le ramasse‑miettes Java** – libérer les objets `Index` lorsqu’ils ne sont plus nécessaires. + +## Problèmes courants et solutions +| Problème | Solution | +|----------|----------| +| `useCaseSensitiveSearch` semble ignoré | Vérifiez que vous utilisez la dernière version de GroupDocs.Search et que l’index a été reconstruit après modification de l’option. | +| Aucun résultat retourné pour un terme connu | Assurez‑vous que la casse du terme correspond exactement et que le document a bien été ajouté à l’index. | +| La recherche dans de nombreux dossiers ralentit | Ajoutez chaque dossier individuellement avec `index.add()` et envisagez de diviser l’index en fragments pour des ensembles de données très volumineux. | + +## Questions fréquemment posées + +**Q :** Comment gérer de grands ensembles de données avec GroupDocs.Search ? +**R :** Utilisez le partitionnement d’index, ajustez les paramètres de mémoire JVM et compactez périodiquement l’index pour maintenir des performances optimales. + +**Q :** Puis‑je rechercher simultanément dans plusieurs répertoires ? +**R :** Oui – appelez `index.add()` pour chaque répertoire que vous souhaitez inclure, puis exécutez une seule requête sur l’index combiné. + +**Q :** Quels sont les pièges courants lors de la configuration des recherches sensibles à la casse ? +**R :** Oublier de reconstruire l’index après avoir activé `useCaseSensitiveSearch`, ou utiliser une casse incorrecte dans la chaîne de requête. + +**Q :** Comment dépanner les erreurs de recherche ? +**R :** Consultez les fichiers journaux générés par GroupDocs.Search pour les traces de pile, et confirmez que toutes les dépendances Maven sont correctement résolues. + +**Q :** GroupDocs.Search est‑il adapté aux applications en temps réel ? +**R :** Avec des stratégies d’indexation appropriées (mises à jour incrémentales et mise en cache en mémoire), il peut fournir des résultats de recherche quasi temps réel. + +## Ressources +- **Documentation :** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **Référence API :** [Java API Reference](https://reference.groupdocs.com/search/java) +- **Téléchargement :** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **Dépôt GitHub :** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Forum d’assistance :** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Licence temporaire :** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Dernière mise à jour :** 2026-02-06 +**Testé avec :** GroupDocs.Search 25.4 +**Auteur :** GroupDocs + +--- \ No newline at end of file diff --git a/content/french/java/searching/master-document-search-groupdocs-java/_index.md b/content/french/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..90a1cefa --- /dev/null +++ b/content/french/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,183 @@ +--- +date: '2026-02-06' +description: Apprenez à indexer des documents et à ajouter des documents à l’index + en utilisant GroupDocs.Search pour Java. Créez des applications de recherche puissantes + avec des requêtes textuelles et d’objets. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Comment indexer des documents avec GroupDocs.Search pour Java +type: docs +url: /fr/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# Comment indexer des documents avec GroupDocs.Search pour Java + +Dans le monde actuel axé sur les données, **comment indexer des documents** efficacement est une compétence cruciale pour tout développeur Java travaillant avec de grandes collections de fichiers. Que vous manipuliez des contrats juridiques, des états financiers ou des rapports internes, pouvoir localiser rapidement l'information pertinente peut faire gagner des heures de travail manuel. Dans ce tutoriel, vous apprendrez **comment indexer des documents** en utilisant la bibliothèque GroupDocs.Search, puis effectuerez des requêtes à la fois basées sur du texte et sur des objets sur l'index créé. Commençons ! + +## Réponses rapides +- **Quelle est la première étape pour indexer des documents ?** Initialize a `Index` object pointing to a folder where the index will be stored. +- **Quelle méthode ajoute des documents à un index ?** Use `index.add("PATH_TO_DOCUMENTS")`. +- **Puis-je rechercher des plages numériques ?** Yes, with a text query like `"400 ~~ 4000"` or an object query via `SearchQuery.createNumericRangeQuery`. +- **Ai-je besoin d'une licence ?** A free trial is available; a commercial license unlocks full features. +- **Quelle version de Java est requise ?** JDK 8 or higher. + +## Qu’est‑ce que “comment indexer des documents” avec GroupDocs.Search ? +L'indexation des documents consiste à analyser le contenu des fichiers d'un dossier et à stocker des jetons recherchables dans un dossier d'index dédié. Cette étape de pré‑traitement permet des recherches ultra‑rapides par la suite, car la bibliothèque interroge l'index préparé plutôt que les fichiers bruts à chaque fois. + +## Pourquoi utiliser GroupDocs.Search pour Java ? +- **Performance :** Searches run in milliseconds even on thousands of files. +- **Prise en charge des formats :** Handles PDFs, Word, Excel, PowerPoint, and many more. +- **Flexibilité :** Supports plain‑text queries, numeric ranges, and complex object queries. +- **Évolutivité :** Easily update the index by adding new documents without rebuilding from scratch. + +## Prérequis +- Maven installé pour la gestion des dépendances. +- Un IDE tel qu'IntelliJ IDEA ou Eclipse. +- Connaissances de base en Java (concepts OOP, gestion des exceptions). + +## Configuration de GroupDocs.Search pour Java +### Configuration Maven +Add the repository and dependency to your `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Téléchargement direct +Vous pouvez également télécharger le JAR le plus récent depuis [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +#### Étapes d'obtention de licence +1. **Essai gratuit** – explorez la bibliothèque sans frais. +2. **Licence temporaire** – demandez une clé à court terme pour une évaluation prolongée. +3. **Achat** – obtenez une licence complète pour une utilisation en production. + +## Initialisation et configuration de base +Pour **ajouter des documents à l'index**, vous créez d'abord un objet `Index` qui pointe vers le dossier où les fichiers d'index seront stockés : + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +Cette ligne crée (ou ouvre) un index prêt à recevoir des documents. + +## Guide d'implémentation +### Création et indexation de documents +#### Comment ajouter des documents à l'index +La méthode `add` analyse un dossier et stocke les données recherchables pour chaque fichier. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Paramètres :** Le texte du chemin pointe vers le dossier contenant les fichiers que vous souhaitez indexer. +- **Objectif :** Après cette étape, l'index contient des jetons de tous les types de documents pris en charge, permettant des recherches rapides. + +### Recherche par requête texte +#### Comment effectuer une recherche de plage numérique basée sur du texte +Vous pouvez rechercher en utilisant une chaîne simple qui définit une plage. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Paramètres :** La chaîne de requête "400 ~~ 4000" indique au moteur de trouver les nombres compris entre 400 et 4000. +- **Valeur de retour :** `SearchResult` contient la liste des documents correspondants et les surlignages. + +### Recherche par requête d'objet +#### Comment utiliser une requête d'objet pour des plages numériques +Les requêtes basées sur des objets vous donnent un contrôle programmatique sur les critères de recherche. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Paramètres :** `createNumericRangeQuery` reçoit les entiers de début et de fin. +- **Objectif :** Cette méthode est idéale lorsque vous devez combiner plusieurs conditions ou construire des requêtes dynamiquement. + +## Applications pratiques +Voici quelques scénarios réels où **comment indexer des documents** devient un facteur décisif : + +1. **Gestion de documents juridiques** – localisez les clauses, numéros de dossier ou dates à travers des milliers de contrats. +2. **Reporting financier** – extrayez les transactions qui se situent dans une plage monétaire spécifique. +3. **Suivi d'inventaire** – trouvez les articles par numéros de série, codes de lot ou plages de SKU. + +Intégrer GroupDocs.Search avec des bases de données, du stockage cloud ou des files d'attente de messagerie peut automatiser davantage les flux de travail des documents. + +## Considérations de performance +- **Mises à jour régulières de l'index :** Relancez `index.add` pour les nouveaux fichiers afin de garder l'index à jour. +- **Gestion des ressources :** Surveillez l'utilisation du tas ; les grands index bénéficient de réglages optimisés du ramassage de déchets JVM. +- **Optimisation des requêtes :** Utilisez des requêtes d'objet pour les filtres complexes afin de réduire les analyses inutiles. + +## Problèmes courants et solutions +| Problème | Pourquoi cela se produit | Solution | +|----------|--------------------------|----------| +| **Recherche ne renvoie aucun résultat** | Index non construit ou chemin du dossier incorrect | Vérifiez que `index.add` a été exécuté sur le bon répertoire et que le dossier d'index est accessible en écriture. | +| **OutOfMemoryError lors de l'indexation** | Fichiers très volumineux ou mémoire tampon insuffisante | Augmentez la valeur JVM `-Xmx` ou indexez les fichiers par lots plus petits. | +| **Format de fichier non pris en charge** | Type de fichier non reconnu par GroupDocs.Search | Assurez-vous que l'extension du fichier figure parmi la liste prise en charge (PDF, DOCX, XLSX, etc.). | + +## Questions fréquemment posées +**Q: Comment mettre à jour un index existant avec de nouveaux documents ?** +A: Appelez à nouveau `index.add("NEW_DOCUMENT_PATH")` ; la bibliothèque fusionne les nouvelles entrées sans recréer l'intégralité de l'index. + +**Q: GroupDocs.Search peut‑il gérer différents formats de fichiers ?** +A: Oui, il prend en charge les PDF, Word, Excel, PowerPoint, le texte brut et de nombreux autres formats courants. + +**Q: Quelles sont les exigences système pour utiliser GroupDocs.Search ?** +A: Runtime Java 8+, RAM suffisante (au moins 2 Go pour des collections modérées) et accès en lecture/écriture au dossier d'index. + +**Q: Comment dépanner les problèmes de performance de recherche ?** +A: Assurez‑vous que l'index est à jour, profilez vos requêtes et examinez les paramètres de mémoire JVM. Réduire le nombre de champs indexés peut également améliorer la vitesse. + +**Q: Existe‑t‑il un moyen de rechercher avec des synonymes ou une correspondance floue ?** +A: Oui, GroupDocs.Search propose des dictionnaires de synonymes et des options de recherche floue qui peuvent être activées via la classe `SearchOptions`. + +## Conclusion +Vous avez maintenant une compréhension solide de **comment indexer des documents** avec GroupDocs.Search pour Java, de **comment ajouter des documents à l'index**, et de comment exécuter des requêtes à la fois basées sur du texte et sur des objets. En intégrant ces techniques, vos applications Java offriront des expériences de recherche rapides et précises sur n'importe quel référentiel de documents. + +Prêt pour l'étape suivante ? Explorez la recherche à facettes, la gestion des synonymes, ou intégrez l'index à une API REST pour exposer les capacités de recherche à d'autres services. + +--- + +**Dernière mise à jour :** 2026-02-06 +**Testé avec :** GroupDocs.Search 25.4 for Java +**Auteur :** GroupDocs \ No newline at end of file diff --git a/content/german/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/german/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..e0040844 --- /dev/null +++ b/content/german/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,186 @@ +--- +date: '2026-02-06' +description: Erfahren Sie, wie Sie Dokumente zum Index hinzufügen und die Groß‑/Kleinschreibungssuche + in Java mit GroupDocs.Search aktivieren, um die Genauigkeit Ihrer Anwendung zu erhöhen. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'Dokumente zum Index hinzufügen: Java‑Suche mit Groß‑ und Kleinschreibung mit + GroupDocs' +type: docs +url: /de/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# Dokumente zum Index hinzufügen: Fall‑sensitive Suche in Java mit GroupDocs meistern + +Das Abrufen der richtigen Information aus einer riesigen Dokumentensammlung ist eine Kernanforderung moderner Anwendungen. In diesem Leitfaden lernen Sie **wie man Dokumente zum Index hinzufügt** und **fall‑sensitive Suchen** mit GroupDocs.Search für Java durchführt. Egal, ob Sie ein Rechtsdokument‑Repository, einen E‑Commerce‑Katalog oder ein Content‑Management‑System aufbauen – präzise Suchergebnisse halten Nutzer zufrieden und Ihre Daten vertrauenswürdig. + +## Schnellantworten +- **Was ist der erste Schritt, um mit der Suche zu beginnen?** Dokumente mit `index.add(...)` zu einem Index hinzufügen. +- **Wie aktiviert man die fall‑sensitive Suche?** `options.setUseCaseSensitiveSearch(true)` setzen. +- **Kann ich über mehrere Verzeichnisse hinweg suchen?** Ja – `index.add()` für jedes einzuschließende Verzeichnis aufrufen. +- **Welche Methode ermöglicht die Suche mit Objekten?** `SearchQuery.createWordQuery(...)` verwenden. +- **Benötige ich eine Lizenz für Tests?** Eine temporäre Lizenz ist für Testzwecke verfügbar. + +## Was bedeutet „Dokumente zum Index hinzufügen“? +Dokumente zum Index hinzuzufügen bedeutet, Ihre Quelldateien (PDFs, Word‑Dokumente, Klartext usw.) in GroupDocs.Search zu speisen, damit daraus eine durchsuchbare Datenstruktur aufgebaut wird. Sobald sie indiziert sind, kann die Engine schnelle Abfragen ausführen, einschließlich fall‑sensitiver Suchvorgänge. + +## Warum fall‑sensitive Suche in Java aktivieren? +- **Exakte Begriff‑Übereinstimmung** – unterscheidet „Apple“ (das Unternehmen) von „apple“ (die Frucht). +- **Regulatorische Konformität** – einige Branchen verlangen exakte Phrasen‑Übereinstimmung. +- **Verbesserte Relevanz** – Nutzer erwarten häufig fall‑spezifische Ergebnisse in technischen oder juristischen Kontexten. + +## Voraussetzungen +- JDK (empfohlen: Java 17 oder neuer) +- Maven für das Abhängigkeits‑Management +- Eine IDE wie IntelliJ IDEA oder Eclipse +- Grundlegende Kenntnisse in der Java‑Programmierung + +## GroupDocs.Search für Java einrichten +Fügen Sie zunächst das GroupDocs‑Repository und die Abhängigkeit zu Ihrer `pom.xml` hinzu: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Alternativ können Sie die neueste Version direkt von [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) herunterladen. + +### Lizenzierung +Um mit einer Testversion zu starten, besuchen Sie GroupDocs und holen Sie sich eine temporäre Lizenz. Diese ermöglicht das Testen aller Funktionen ohne Einschränkungen. + +## Wie man Dokumente zum Index hinzufügt – Text‑Abfrage‑Suche + +### Schritt 1: Einen Index erstellen und Ihre Dokumente hinzufügen +Erzeugen Sie einen Ordner, in dem die Indexdateien gespeichert werden, und fügen Sie anschließend das Quellverzeichnis hinzu, das die zu durchsuchenden Dokumente enthält. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **Pro‑Tipp:** Sie können `index.add()` mehrfach aufrufen, um **über mehrere Verzeichnisse hinweg** in einem einzigen Index zu suchen. + +### Schritt 2: Fall‑sensitive Suche aktivieren +Konfigurieren Sie die Suchoptionen so, dass die Groß‑/Kleinschreibung berücksichtigt wird. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Schritt 3: Eine fall‑sensitive Text‑Abfrage ausführen +Führen Sie eine Abfrage aus, die „Advantages“ von „advantages“ unterscheidet. + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Die Schleife gibt den vollständigen Pfad jedes Dokuments aus, das den exakt groß‑/kleingeschriebenen Begriff enthält. + +## Wie man Dokumente zum Index hinzufügt – Objekt‑Abfrage‑Suche + +Objekt‑Abfragen bieten mehr Flexibilität, insbesondere wenn mehrere Kriterien kombiniert werden sollen. + +### Schritt 1: Einen zweiten Index initialisieren (optional) +Falls Sie objektbasierte Suchen getrennt halten möchten, erstellen Sie einen weiteren Index‑Ordner. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Schritt 2: Die fall‑sensitive Option erneut verwenden +Die gleiche `SearchOptions`‑Instanz funktioniert auch für Objekt‑Abfragen. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Schritt 3: Eine Objekt‑Abfrage erstellen und ausführen +Erzeugen Sie ein Word‑Query‑Objekt und übergeben Sie es an die Such‑Engine. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Die Verwendung von `createWordQuery` ermöglicht später die Kombination mit Phrase‑, Wildcard‑ oder Booleschen Abfragen für komplexere Szenarien. + +## Praktische Anwendungsfälle +- **Rechtsdokumenten‑Management:** Abrufen von fall‑spezifischen Gesetzen, bei denen die Großschreibung entscheidend ist. +- **E‑Commerce‑Plattformen:** Unterscheiden von Produkt‑SKUs wie „PRO‑X“ vs. „pro‑x“. +- **Content‑Management‑Systeme (CMS):** Sicherstellen, dass Autoren exakte Überschriften oder Tags finden. + +## Leistungs‑Überlegungen +- **Index aktuell halten** – neu hinzugefügte oder geänderte Dateien erneut indizieren. +- **Speichernutzung überwachen** – große Korpora profitieren von inkrementellem Indexieren und richtiger JVM‑Heap‑Größe. +- **Java‑Garbage‑Collector nutzen** – `Index`‑Objekte freigeben, sobald sie nicht mehr benötigt werden. + +## Häufige Probleme und Lösungen +| Problem | Lösung | +|-------|----------| +| `useCaseSensitiveSearch` scheint ignoriert zu werden | Stellen Sie sicher, dass Sie die neueste Version von GroupDocs.Search verwenden und dass der Index nach Änderung der Option neu aufgebaut wurde. | +| Keine Ergebnisse für einen bekannten Begriff | Prüfen Sie, ob die Groß‑/Kleinschreibung exakt übereinstimmt und das Dokument erfolgreich zum Index hinzugefügt wurde. | +| Suche in vielen Ordnern verlangsamt sich | Jeder Ordner einzeln mit `index.add()` hinzufügen und bei sehr großen Datenmengen das Index‑Sharding in Betracht ziehen. | + +## Häufig gestellte Fragen + +**F:** Wie gehe ich mit großen Datensätzen in GroupDocs.Search um? +**A:** Nutzen Sie Index‑Partitionierung, passen Sie die JVM‑Speichereinstellungen an und führen Sie regelmäßig eine Index‑Komprimierung durch, um die Leistung zu optimieren. + +**F:** Kann ich gleichzeitig über mehrere Verzeichnisse suchen? +**A:** Ja – `index.add()` für jedes gewünschte Verzeichnis aufrufen und anschließend eine einzelne Abfrage gegen den kombinierten Index ausführen. + +**F:** Welche typischen Stolperfallen gibt es bei fall‑sensitiven Suchen? +**A:** Das Vergessen, den Index nach dem Aktivieren von `useCaseSensitiveSearch` neu zu bauen, oder die falsche Groß‑/Kleinschreibung im Abfrage‑String. + +**F:** Wie kann ich Such‑Fehler diagnostizieren? +**A:** Prüfen Sie die von GroupDocs.Search erzeugten Log‑Dateien auf Stack‑Traces und stellen Sie sicher, dass alle Maven‑Abhängigkeiten korrekt aufgelöst wurden. + +**F:** Eignet sich GroupDocs.Search für Echtzeit‑Anwendungen? +**A:** Mit geeigneten Indexierungs‑Strategien (inkrementelle Updates und In‑Memory‑Caching) kann es nahezu Echtzeit‑Suchergebnisse liefern. + +## Ressourcen +- **Dokumentation:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **API‑Referenz:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **Download:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **GitHub‑Repository:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Support‑Forum:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Temporäre Lizenz:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Zuletzt aktualisiert:** 2026-02-06 +**Getestet mit:** GroupDocs.Search 25.4 +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/german/java/searching/master-document-search-groupdocs-java/_index.md b/content/german/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..7f27daae --- /dev/null +++ b/content/german/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,183 @@ +--- +date: '2026-02-06' +description: Erfahren Sie, wie Sie Dokumente indexieren und Dokumente dem Index hinzufügen, + indem Sie GroupDocs.Search für Java verwenden. Erstellen Sie leistungsstarke Suchanwendungen + mit Text‑ und Objektabfragen. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Wie man Dokumente mit GroupDocs.Search für Java indiziert +type: docs +url: /de/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# Wie man Dokumente mit GroupDocs.Search für Java indiziert + +In der heutigen datengetriebenen Welt ist **wie man Dokumente indiziert** effizient eine entscheidende Fähigkeit für jeden Java‑Entwickler, der mit großen Dateisammlungen arbeitet. Egal, ob Sie rechtliche Verträge, Finanzberichte oder interne Berichte bearbeiten, die Fähigkeit, schnell die richtigen Informationen zu finden, kann Stunden manueller Arbeit einsparen. In diesem Tutorial lernen Sie **wie man Dokumente indiziert** mit der GroupDocs.Search‑Bibliothek und führen anschließend sowohl textbasierte als auch objektbasierte Abfragen auf dem erstellten Index aus. Lassen Sie uns beginnen! + +## Schnelle Antworten +- **Was ist der erste Schritt, um Dokumente zu indizieren?** Initialisieren Sie ein `Index`‑Objekt, das auf einen Ordner zeigt, in dem der Index gespeichert wird. +- **Welche Methode fügt Dokumente zu einem Index hinzu?** Verwenden Sie `index.add("PATH_TO_DOCUMENTS")`. +- **Kann ich nach numerischen Bereichen suchen?** Ja, mit einer Textabfrage wie `"400 ~~ 4000"` oder einer Objektabfrage über `SearchQuery.createNumericRangeQuery`. +- **Brauche ich eine Lizenz?** Eine kostenlose Testversion ist verfügbar; eine kommerzielle Lizenz schaltet alle Funktionen frei. +- **Welche Java‑Version wird benötigt?** JDK 8 oder höher. + +## Was bedeutet “wie man Dokumente indiziert” mit GroupDocs.Search? +Das Indizieren von Dokumenten bedeutet, den Inhalt von Dateien in einem Ordner zu scannen und durchsuchbare Token in einem dedizierten Index‑Ordner zu speichern. Dieser Vorverarbeitungsschritt ermöglicht blitzschnelle Abfragen später, da die Bibliothek den vorbereiteten Index anstatt der Rohdateien jedes Mal durchsucht. + +## Warum GroupDocs.Search für Java verwenden? +- **Performance:** Suchen laufen in Millisekunden selbst bei tausenden von Dateien. +- **Formatunterstützung:** Verarbeitet PDFs, Word, Excel, PowerPoint und viele weitere. +- **Flexibilität:** Unterstützt reine Textabfragen, numerische Bereiche und komplexe Objektabfragen. +- **Skalierbarkeit:** Der Index kann leicht aktualisiert werden, indem neue Dokumente hinzugefügt werden, ohne ihn von Grund auf neu zu erstellen. + +## Voraussetzungen +- Maven installiert für die Verwaltung von Abhängigkeiten. +- Eine IDE wie IntelliJ IDEA oder Eclipse. +- Grundlegende Java‑Kenntnisse (OOP‑Konzepte, Ausnahmebehandlung). + +## Einrichtung von GroupDocs.Search für Java +### Maven‑Einrichtung +Fügen Sie das Repository und die Abhängigkeit zu Ihrer `pom.xml` hinzu: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Direkter Download +Sie können das neueste JAR auch von [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) herunterladen. + +#### Schritte zum Erwerb einer Lizenz +1. **Kostenlose Testversion** – Erkunden Sie die Bibliothek kostenlos. +2. **Temporäre Lizenz** – Fordern Sie einen kurzfristigen Schlüssel für erweiterte Evaluierung an. +3. **Kauf** – Erwerben Sie eine Voll‑Lizenz für den Produktionseinsatz. + +## Grundlegende Initialisierung und Einrichtung +Um **Dokumente zum Index hinzuzufügen**, erstellen Sie zunächst ein `Index`‑Objekt, das auf den Ordner zeigt, in dem die Indexdateien gespeichert werden: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +Diese Zeile erstellt (oder öffnet) einen Index, der bereit ist, Dokumente zu empfangen. + +## Implementierungs‑Leitfaden +### Erstellen und Indizieren von Dokumenten +#### Wie man Dokumente zum Index hinzufügt +Die Methode `add` scannt einen Ordner und speichert durchsuchbare Daten für jede Datei. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Parameter:** Der Pfad‑String verweist auf den Ordner, der die Dateien enthält, die Sie indizieren möchten. +- **Zweck:** Nach diesem Schritt enthält der Index Token aller unterstützten Dokumenttypen, was schnelle Suchen ermöglicht. + +### Textabfrage‑Suche +#### Wie man eine textbasierte numerische Bereichssuche durchführt +Sie können mit einem einfachen String, der einen Bereich definiert, suchen. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Parameter:** Der Abfrage‑String `"400 ~~ 4000"` weist die Engine an, Zahlen zwischen 400 und 4000 zu finden. +- **Rückgabewert:** `SearchResult` enthält die Liste der passenden Dokumente und Hervorhebungen. + +### Objekt‑Abfrage‑Suche +#### Wie man eine Objekt‑Abfrage für numerische Bereiche verwendet +Objektbasierte Abfragen geben Ihnen programmatische Kontrolle über die Suchkriterien. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Parameter:** `createNumericRangeQuery` erhält die Start‑ und End‑Ganzzahlen. +- **Zweck:** Diese Methode ist ideal, wenn Sie mehrere Bedingungen kombinieren oder Abfragen dynamisch erstellen müssen. + +## Praktische Anwendungen +Hier sind einige reale Szenarien, in denen **wie man Dokumente indiziert** ein Wendepunkt ist: + +1. **Verwaltung juristischer Dokumente** – Finden Sie Klauseln, Aktenzeichen oder Daten in tausenden von Verträgen. +2. **Finanzberichterstattung** – Extrahieren Sie Transaktionen, die in einen bestimmten Geldbetrag‑Bereich fallen. +3. **Bestandsverfolgung** – Finden Sie Artikel nach Seriennummern, Chargencodes oder SKU‑Bereichen. + +Die Integration von GroupDocs.Search mit Datenbanken, Cloud‑Speicher oder Messaging‑Queues kann Dokumenten‑Workflows weiter automatisieren. + +## Leistungs‑Überlegungen +- **Regelmäßige Index‑Updates:** Führen Sie `index.add` erneut für neue Dateien aus, um den Index aktuell zu halten. +- **Ressourcen‑Management:** Überwachen Sie die Heap‑Nutzung; große Indizes profitieren von abgestimmten JVM‑Garbage‑Collection‑Einstellungen. +- **Abfrage‑Optimierung:** Verwenden Sie Objekt‑Abfragen für komplexe Filter, um unnötiges Scannen zu reduzieren. + +## Häufige Probleme und Lösungen +| Problem | Warum es passiert | Lösung | +|-------|----------------|-----| +| **Suche liefert keine Ergebnisse** | Index nicht erstellt oder Ordnerpfad ist falsch | Stellen Sie sicher, dass `index.add` im richtigen Verzeichnis ausgeführt wurde und dass der Index‑Ordner beschreibbar ist. | +| **OutOfMemoryError während des Indexierens** | Sehr große Dateien oder unzureichender Heap | Erhöhen Sie den JVM‑`-Xmx`‑Wert oder indexieren Sie Dateien in kleineren Stapeln. | +| **Nicht unterstütztes Dateiformat** | Dateityp wird von GroupDocs.Search nicht erkannt | Stellen Sie sicher, dass die Dateierweiterung in der unterstützten Liste (PDF, DOCX, XLSX usw.) enthalten ist. | + +## Häufig gestellte Fragen +**Q: Wie aktualisiere ich einen bestehenden Index mit neuen Dokumenten?** +A: Rufen Sie `index.add("NEW_DOCUMENT_PATH")` erneut auf; die Bibliothek fügt neue Einträge zusammen, ohne den gesamten Index neu zu erstellen. + +**Q: Kann GroupDocs.Search verschiedene Dateiformate verarbeiten?** +A: Ja, es unterstützt PDFs, Word, Excel, PowerPoint, Klartext und viele andere gängige Formate. + +**Q: Was sind die Systemanforderungen für die Verwendung von GroupDocs.Search?** +A: Java 8+ Laufzeit, ausreichender RAM (mindestens 2 GB für moderate Sammlungen) und Lese‑/Schreibzugriff auf den Index‑Ordner. + +**Q: Wie kann ich Leistungsprobleme bei der Suche beheben?** +A: Stellen Sie sicher, dass der Index aktuell ist, profilieren Sie Ihre Abfragen und überprüfen Sie die JVM‑Speichereinstellungen. Das Reduzieren der indizierten Felder kann ebenfalls die Geschwindigkeit erhöhen. + +**Q: Gibt es eine Möglichkeit, mit Synonymen oder unscharfer Suche zu suchen?** +A: Ja, GroupDocs.Search bietet Synonym‑Wörterbücher und unscharfe Suchoptionen, die über die Klasse `SearchOptions` aktiviert werden können. + +## Fazit +Sie haben nun ein fundiertes Verständnis davon, **wie man Dokumente indiziert** mit GroupDocs.Search für Java, wie man **Dokumente zum Index hinzufügt** und wie man sowohl textbasierte als auch objektbasierte Abfragen ausführt. Durch die Integration dieser Techniken bieten Ihre Java‑Anwendungen schnelle, präzise Sucherlebnisse über jedes Dokumenten‑Repository. + +Sind Sie bereit für den nächsten Schritt? Erkunden Sie facettierte Suche, Synonym‑Verarbeitung oder integrieren Sie den Index in eine REST‑API, um Suchfunktionen anderen Diensten zur Verfügung zu stellen. + +--- + +**Zuletzt aktualisiert:** 2026-02-06 +**Getestet mit:** GroupDocs.Search 25.4 für Java +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/greek/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/greek/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..2c590ee7 --- /dev/null +++ b/content/greek/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,189 @@ +--- +date: '2026-02-06' +description: Μάθετε πώς να προσθέτετε έγγραφα στο ευρετήριο και να ενεργοποιήσετε + την αναζήτηση με διάκριση πεζών‑κεφαλαίων σε Java με το GroupDocs.Search, βελτιώνοντας + την ακρίβεια της εφαρμογής σας. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'Προσθήκη εγγράφων στο ευρετήριο: αναζήτηση Java με διάκριση πεζών‑κεφαλαίων + με το GroupDocs' +type: docs +url: /el/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# Προσθήκη εγγράφων στο ευρετήριο: Κατάκτηση αναζητήσεων με διάκριση πεζών‑κεφαλαίων σε Java με το GroupDocs + +Η ανάκτηση του σωστού κομματιού πληροφορίας από μια τεράστια συλλογή εγγράφων αποτελεί βασική απαίτηση για τις σύγχρονες εφαρμογές. Σε αυτόν τον οδηγό, θα μάθετε **πώς να προσθέτετε έγγραφα στο ευρετήριο** και να εκτελείτε **αναζητήσεις με διάκριση πεζών‑κεφαλαίων** χρησιμοποιώντας το GroupDocs.Search για Java. Είτε δημιουργείτε μια αποθήκη νομικών εγγράφων, έναν κατάλογο e‑commerce, είτε ένα σύστημα διαχείρισης περιεχομένου, τα ακριβή αποτελέσματα αναζήτησης κρατούν τους χρήστες ευχαριστημένους και τα δεδομένα σας αξιόπιστα. + +## Γρήγορες Απαντήσεις +- **Ποιο είναι το βασικό βήμα για να ξεκινήσετε την αναζήτηση;** Προσθέστε έγγραφα σε ένα ευρετήριο με `index.add(...)`. +- **Πώς ενεργοποιείται η αναζήτηση με διάκριση πεζών‑κεφαλαίων;** Ορίστε `options.setUseCaseSensitiveSearch(true)`. +- **Μπορώ να αναζητήσω σε πολλαπλούς φακέλους;** Ναι – καλέστε `index.add()` για κάθε φάκελο που θέλετε να συμπεριλάβετε. +- **Ποια μέθοδος επιτρέπει την αναζήτηση με αντικείμενα;** Χρησιμοποιήστε `SearchQuery.createWordQuery(...)`. +- **Χρειάζομαι άδεια για δοκιμές;** Διατίθεται προσωρινή άδεια για δοκιμαστικούς σκοπούς. + +## Τι σημαίνει «προσθήκη εγγράφων στο ευρετήριο»; +Η προσθήκη εγγράφων σε ένα ευρετήριο σημαίνει την τροφοδοσία των αρχικών αρχείων σας (PDF, Word, απλό κείμενο κ.λπ.) στο GroupDocs.Search ώστε να δημιουργήσει μια δομή δεδομένων αναζητήσιμη. Μόλις γίνει η ευρετηρίαση, η μηχανή μπορεί να εκτελεί γρήγορα ερωτήματα, συμπεριλαμβανομένων και των ερωτημάτων με διάκριση πεζών‑κεφαλαίων. + +## Γιατί να ενεργοποιήσετε την αναζήτηση με διάκριση πεζών‑κεφαλαίων σε Java; +- **Ακριβής αντιστοίχηση όρων** – διαχωρίστε το “Apple” (η εταιρεία) από το “apple” (το φρούτο). +- **Κανονιστική συμμόρφωση** – ορισμένες βιομηχανίες απαιτούν ακριβή αντιστοίχηση φράσεων. +- **Βελτιωμένη συνάφεια** – οι χρήστες συχνά αναμένουν αποτελέσματα με συγκεκριμένη κεφαλοποίηση σε τεχνικά ή νομικά πλαίσια. + +## Προαπαιτούμενα +- JDK (συνιστάται Java 17 ή νεότερη) +- Maven για διαχείριση εξαρτήσεων +- Ένα IDE όπως IntelliJ IDEA ή Eclipse +- Βασική εξοικείωση με τον προγραμματισμό σε Java + +## Ρύθμιση του GroupDocs.Search για Java +Πρώτα, προσθέστε το αποθετήριο και την εξάρτηση του GroupDocs στο `pom.xml` σας: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Εναλλακτικά, μπορείτε να κατεβάσετε την πιο πρόσφατη έκδοση απευθείας από [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Άδεια +Για να ξεκινήσετε με μια δοκιμαστική έκδοση, επισκεφθείτε το GroupDocs για να αποκτήσετε μια προσωρινή άδεια. Αυτό θα σας επιτρέψει να δοκιμάσετε όλες τις λειτουργίες χωρίς περιορισμούς. + +## Πώς να προσθέσετε έγγραφα στο ευρετήριο – Αναζήτηση κειμένου + +### Βήμα 1: Δημιουργία ευρετηρίου και προσθήκη εγγράφων +Δημιουργήστε έναν φάκελο όπου θα αποθηκευτούν τα αρχεία του ευρετηρίου, στη συνέχεια προσθέστε τον φάκελο πηγής που περιέχει τα έγγραφα που θέλετε να αναζητήσετε. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **Συμβουλή:** Μπορείτε να καλέσετε `index.add()` πολλές φορές για **αναζήτηση σε πολλαπλούς φακέλους** μέσα σε ένα ενιαίο ευρετήριο. + +### Βήμα 2: Ενεργοποίηση αναζήτησης με διάκριση πεζών‑κεφαλαίων +Ρυθμίστε τις επιλογές αναζήτησης ώστε να λαμβάνουν υπόψη τη διαφορά μεταξύ πεζών και κεφαλαίων. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Βήμα 3: Εκτέλεση ερωτήματος κειμένου με διάκριση πεζών‑κεφαλαίων +Τρέξτε ένα ερώτημα που διακρίνει το “Advantages” από το “advantages”. + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Ο βρόχος εκτυπώνει τη πλήρη διαδρομή κάθε εγγράφου που περιέχει τον ακριβή όρο με τη σωστή κεφαλοποίηση. + +## Πώς να προσθέσετε έγγραφα στο ευρετήριο – Αναζήτηση αντικειμένων + +Οι ερωτήσεις αντικειμένων προσφέρουν μεγαλύτερη ευελιξία, ειδικά όταν χρειάζεται να συνδυάσετε πολλαπλά κριτήρια. + +### Βήμα 1: Αρχικοποίηση δεύτερου ευρετηρίου (προαιρετικό) +Αν προτιμάτε να διατηρείτε τις αναζητήσεις με αντικείμενα ξεχωριστά, δημιουργήστε έναν άλλο φάκελο ευρετηρίου. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Βήμα 2: Επανάχρηση της επιλογής διάκρισης πεζών‑κεφαλαίων +Η ίδια παρουσία `SearchOptions` λειτουργεί και για ερωτήσεις αντικειμένων. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Βήμα 3: Δημιουργία και εκτέλεση ερώτησης αντικειμένου +Δημιουργήστε ένα αντικείμενο ερώτησης λέξης και περάστε το στη μηχανή αναζήτησης. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Η χρήση του `createWordQuery` σας επιτρέπει αργότερα να το συνδυάσετε με φράσεις, μπαλαντέρ ή Boolean ερωτήματα για πιο σύνθετα σενάρια. + +## Πρακτικές Εφαρμογές +- **Διαχείριση νομικών εγγράφων:** Ανάκτηση ειδικών άρθρων όπου η κεφαλοποίηση έχει σημασία. +- **Πλατφόρμες e‑commerce:** Διάκριση SKU προϊόντων όπως “PRO‑X” έναντι “pro‑x”. +- **Συστήματα διαχείρισης περιεχομένου (CMS):** Διασφάλιση ότι οι συγγραφείς βρίσκουν ακριβείς τίτλους ή ετικέτες. + +## Σκέψεις για την Απόδοση +- **Διατηρήστε το ευρετήριο ενημερωμένο** – επαναευρετηριάστε όταν προστεθούν νέα αρχεία ή αλλάξουν υπάρχοντα. +- **Παρακολουθήστε τη χρήση μνήμης** – μεγάλα σύνολα ωφελούνται από την επαναληπτική ευρετηρίαση και τη σωστή ρύθμιση του heap της JVM. +- **Εκμεταλλευτείτε τον garbage collector της Java** – απελευθερώστε αντικείμενα `Index` όταν δεν χρειάζονται πια. + +## Συχνά Προβλήματα και Λύσεις +| Πρόβλημα | Λύση | +|-------|----------| +| `useCaseSensitiveSearch` φαίνεται να αγνοείται | Βεβαιωθείτε ότι χρησιμοποιείτε την πιο πρόσφατη έκδοση του GroupDocs.Search και ότι το ευρετήριο ξαναδημιουργήθηκε μετά την αλλαγή της επιλογής. | +| Δεν επιστρέχονται αποτελέσματα για γνωστό όρο | Ελέγξτε ότι η κεφαλοποίηση του όρου ταιριάζει ακριβώς και ότι το έγγραφο προστέθηκε επιτυχώς στο ευρετήριο. | +| Η αναζήτηση σε πολλούς φακέλους επιβραδύνει | Προσθέστε κάθε φάκελο ξεχωριστά με `index.add()` και εξετάστε το ενδεχόμενο διαίρεσης του ευρετηρίου σε shards για πολύ μεγάλα σύνολα δεδομένων. | + +## Συχνές Ερωτήσεις + +**Ε:** Πώς διαχειρίζομαι μεγάλα σύνολα δεδομένων με το GroupDocs.Search; +**Α:** Χρησιμοποιήστε κατατμήσεις ευρετηρίου, ρυθμίστε τις παραμέτρους μνήμης της JVM και περιοδικά συμπιέστε το ευρετήριο για βέλτιστη απόδοση. + +**Ε:** Μπορώ να αναζητήσω σε πολλαπλούς φακέλους ταυτόχρονα; +**Α:** Ναι – καλέστε `index.add()` για κάθε φάκελο που θέλετε να συμπεριλάβετε, στη συνέχεια εκτελέστε ένα ενιαίο ερώτημα στο συνδυασμένο ευρετήριο. + +**Ε:** Ποια είναι τα κοινά λάθη κατά τη ρύθμιση αναζητήσεων με διάκριση πεζών‑κεφαλαίων; +**Α:** Η παράλειψη επαναδημιουργίας του ευρετηρίου μετά την ενεργοποίηση του `useCaseSensitiveSearch`, ή η χρήση λανθασμένης κεφαλοποίησης στη συμβολοσειρά ερωτήματος. + +**Ε:** Πώς μπορώ να εντοπίσω σφάλματα αναζήτησης; +**Α:** Ελέγξτε τα αρχεία καταγραφής που δημιουργεί το GroupDocs.Search για stack traces και βεβαιωθείτε ότι όλες οι εξαρτήσεις Maven έχουν επιλυθεί σωστά. + +**Ε:** Είναι το GroupDocs.Search κατάλληλο για εφαρμογές σε πραγματικό χρόνο; +**Α:** Με τις κατάλληλες στρατηγικές ευρετηρίασης (αυξομολόγητες ενημερώσεις και caching στη μνήμη), μπορεί να παρέχει σχεδόν άμεσες απαντήσεις αναζήτησης. + +## Πόροι +- **Τεκμηρίωση:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **Αναφορά API:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **Λήψη:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **Αποθετήριο GitHub:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Φόρουμ Υποστήριξης:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Προσωρινή Άδεια:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Τελευταία ενημέρωση:** 2026-02-06 +**Δοκιμασμένο με:** GroupDocs.Search 25.4 +**Συγγραφέας:** GroupDocs + +--- \ No newline at end of file diff --git a/content/greek/java/searching/master-document-search-groupdocs-java/_index.md b/content/greek/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..e3c0bab9 --- /dev/null +++ b/content/greek/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,183 @@ +--- +date: '2026-02-06' +description: Μάθετε πώς να δημιουργείτε ευρετήριο εγγράφων και να προσθέτετε έγγραφα + στο ευρετήριο χρησιμοποιώντας το GroupDocs.Search για Java. Δημιουργήστε ισχυρές + εφαρμογές αναζήτησης με ερωτήματα κειμένου και αντικειμένων. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Πώς να δημιουργήσετε ευρετήριο εγγράφων με το GroupDocs.Search για Java +type: docs +url: /el/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# Πώς να Καταχωρίσετε Έγγραφα με το GroupDocs.Search για Java + +Στον σημερινό κόσμο που βασίζεται στα δεδομένα, **πώς να καταχωρίσετε έγγραφα** αποδοτικά είναι μια κρίσιμη δεξιότητα για κάθε προγραμματιστή Java που εργάζεται με μεγάλες συλλογές αρχείων. Είτε διαχειρίζεστε νομικές συμβάσεις, οικονομικές καταστάσεις ή εσωτερικές αναφορές, η δυνατότητα γρήγορης εντοπισμού των σωστών πληροφοριών μπορεί να εξοικονομήσει ώρες χειροκίνητης εργασίας. Σε αυτό το σεμινάριο θα μάθετε **πώς να καταχωρίσετε έγγραφα** χρησιμοποιώντας τη βιβλιοθήκη GroupDocs.Search, και στη συνέχεια να εκτελέσετε ερωτήματα κειμένου και αντικειμένου στο δημιουργημένο ευρετήριο. Ας ξεκινήσουμε! + +## Γρήγορες Απαντήσεις +- **Ποιο είναι το πρώτο βήμα για την καταχώριση εγγράφων;** Αρχικοποιήστε ένα αντικείμενο `Index` που δείχνει σε έναν φάκελο όπου θα αποθηκευτεί το ευρετήριο. +- **Ποια μέθοδος προσθέτει έγγραφα σε ένα ευρετήριο;** Χρησιμοποιήστε `index.add("PATH_TO_DOCUMENTS")`. +- **Μπορώ να αναζητήσω αριθμητικές περιοχές;** Ναι, με ένα ερώτημα κειμένου όπως `"400 ~~ 4000"` ή ένα ερώτημα αντικειμένου μέσω `SearchQuery.createNumericRangeQuery`. +- **Χρειάζομαι άδεια;** Διατίθεται δωρεάν δοκιμή· μια εμπορική άδεια ξεκλειδώνει όλες τις λειτουργίες. +- **Ποια έκδοση της Java απαιτείται;** JDK 8 ή νεότερη. + +## Τι είναι η “πώς να καταχωρίσετε έγγραφα” με το GroupDocs.Search; +Η καταχώριση εγγράφων σημαίνει σάρωση του περιεχομένου των αρχείων σε έναν φάκελο και αποθήκευση των αναζητήσιμων tokens σε έναν αφιερωμένο φάκελο ευρετηρίου. Αυτό το βήμα προεπεξεργασίας επιτρέπει εξαιρετικά γρήγορες αναζητήσεις αργότερα, επειδή η βιβλιοθήκη ψάχνει στο προετοιμασμένο ευρετήριο αντί για τα ακατέργαστα αρχεία κάθε φορά. + +## Γιατί να χρησιμοποιήσετε το GroupDocs.Search για Java; +- **Απόδοση:** Οι αναζητήσεις εκτελούνται σε χιλιοστά του δευτερολέπτου ακόμη και σε χιλιάδες αρχεία. +- **Υποστήριξη μορφών:** Διαχειρίζεται PDF, Word, Excel, PowerPoint και πολλά άλλα. +- **Ευελιξία:** Υποστηρίζει ερωτήματα απλού κειμένου, αριθμητικές περιοχές και σύνθετα ερωτήματα αντικειμένου. +- **Κλιμακωσιμότητα:** Ενημερώνει εύκολα το ευρετήριο προσθέτοντας νέα έγγραφα χωρίς να χρειάζεται επανδημιουργία από την αρχή. + +## Προαπαιτούμενα +- Maven εγκατεστημένο για διαχείριση εξαρτήσεων. +- Ένα IDE όπως IntelliJ IDEA ή Eclipse. +- Βασικές γνώσεις Java (αρχές OOP, διαχείριση εξαιρέσεων). + +## Ρύθμιση του GroupDocs.Search για Java +### Ρύθμιση Maven +Προσθέστε το αποθετήριο και την εξάρτηση στο `pom.xml` σας: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Άμεση Λήψη +Μπορείτε επίσης να κατεβάσετε το τελευταίο JAR από [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +#### Βήματα Απόκτησης Άδειας +1. **Δωρεάν Δοκιμή** – εξερευνήστε τη βιβλιοθήκη χωρίς κόστος. +2. **Προσωρινή Άδεια** – ζητήστε ένα βραχυπρόθεσμο κλειδί για εκτεταμένη αξιολόγηση. +3. **Αγορά** – αποκτήστε πλήρη άδεια για χρήση σε παραγωγή. + +## Βασική Αρχικοποίηση και Ρύθμιση +Για **προσθήκη εγγράφων στο ευρετήριο**, πρώτα δημιουργείτε ένα αντικείμενο `Index` που δείχνει στον φάκελο όπου θα αποθηκευτούν τα αρχεία του ευρετηρίου: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +Αυτή η γραμμή δημιουργεί (ή ανοίγει) ένα ευρετήριο έτοιμο να λάβει έγγραφα. + +## Οδηγός Υλοποίησης +### Δημιουργία και Καταχώριση Εγγράφων +#### Πώς να προσθέσετε έγγραφα στο ευρετήριο +Η μέθοδος `add` σαρώνει έναν φάκελο και αποθηκεύει αναζητήσιμα δεδομένα για κάθε αρχείο. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Παράμετροι:** Η συμβολοσειρά διαδρομής δείχνει στον φάκελο που περιέχει τα αρχεία που θέλετε να καταχωρίσετε. +- **Σκοπός:** Μετά από αυτό το βήμα, το ευρετήριο περιέχει tokens από όλους τους υποστηριζόμενους τύπους εγγράφων, επιτρέποντας γρήγορες αναζητήσεις. + +### Αναζήτηση με Ερώτημα Κειμένου +#### Πώς να εκτελέσετε αναζήτηση αριθμητικής περιοχής με κείμενο +Μπορείτε να αναζητήσετε χρησιμοποιώντας μια απλή συμβολοσειρά που ορίζει μια περιοχή. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Παράμετροι:** Η συμβολοσειρά ερωτήματος `"400 ~~ 4000"` λέει στη μηχανή να βρει αριθμούς μεταξύ 400 και 4000. +- **Τιμή Επιστροφής:** Το `SearchResult` περιέχει τη λίστα των ταιριαστών εγγράφων και τις επισήμανση. + +### Αναζήτηση με Ερώτημα Αντικειμένου +#### Πώς να χρησιμοποιήσετε ερώτημα αντικειμένου για αριθμητικές περιοχές +Τα ερωτήματα βασισμένα σε αντικείμενα σας δίνουν προγραμματιστικό έλεγχο πάνω στα κριτήρια αναζήτησης. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Παράμετροι:** Η `createNumericRangeQuery` λαμβάνει τους αρχικούς και τελικούς ακέραιους. +- **Σκοπός:** Αυτή η μέθοδος είναι ιδανική όταν χρειάζεται να συνδυάσετε πολλαπλές συνθήκες ή να δημιουργήσετε ερωτήματα δυναμικά. + +## Πρακτικές Εφαρμογές +Ακολουθούν μερικά σενάρια πραγματικού κόσμου όπου η **καταχώριση εγγράφων** γίνεται καθοριστική: + +1. **Διαχείριση Νομικών Εγγράφων** – εντοπίστε ρήτρες, αριθμούς υποθέσεων ή ημερομηνίες σε χιλιάδες συμβάσεις. +2. **Οικονομική Αναφορά** – εξάγετε συναλλαγές που εμπίπτουν σε συγκεκριμένο χρηματικό εύρος. +3. **Παρακολούθηση Αποθεμάτων** – βρείτε αντικείμενα με σειριακούς αριθμούς, κωδικούς παρτίδας ή εύρη SKU. + +Η ενσωμάτωση του GroupDocs.Search με βάσεις δεδομένων, αποθήκευση στο cloud ή ουρές μηνυμάτων μπορεί να αυτοματοποιήσει περαιτέρω τις ροές εργασίας εγγράφων. + +## Σκέψεις για την Απόδοση +- **Κανονικές Ενημερώσεις Ευρετηρίου:** Εκτελέστε ξανά `index.add` για νέα αρχεία ώστε να διατηρείται το ευρετήριο ενημερωμένο. +- **Διαχείριση Πόρων:** Παρακολουθήστε τη χρήση του heap· μεγάλα ευρετήρια ωφελούνται από ρυθμισμένες ρυθμίσεις συλλογής απορριμμάτων της JVM. +- **Βελτιστοποίηση Ερωτημάτων:** Χρησιμοποιήστε ερωτήματα αντικειμένου για σύνθετα φίλτρα ώστε να μειώσετε την περιττή σάρωση. + +## Συχνά Προβλήματα και Λύσεις +| Πρόβλημα | Γιατί Συμβαίνει | Διόρθωση | +|-------|----------------|-----| +| **Η αναζήτηση δεν επιστρέφει αποτελέσματα** | Το ευρετήριο δεν έχει δημιουργηθεί ή η διαδρομή φακέλου είναι λανθασμένη | Επαληθεύστε ότι το `index.add` εκτελέστηκε στον σωστό κατάλογο και ότι ο φάκελος του ευρετηρίου είναι εγγράψιμος. | +| **OutOfMemoryError κατά την καταχώριση** | Πολύ μεγάλα αρχεία ή ανεπαρκής μνήμη heap | Αυξήστε την τιμή `-Xmx` της JVM ή καταχωρίστε τα αρχεία σε μικρότερες παρτίδες. | +| **Μη υποστηριζόμενη μορφή αρχείου** | Ο τύπος αρχείου δεν αναγνωρίζεται από το GroupDocs.Search | Βεβαιωθείτε ότι η επέκταση του αρχείου βρίσκεται στη λίστα υποστηριζόμενων (PDF, DOCX, XLSX, κλπ.). | + +## Συχνές Ερωτήσεις +**Ε: Πώς ενημερώνω ένα υπάρχον ευρετήριο με νέα έγγραφα;** +Α: Καλέστε ξανά `index.add("NEW_DOCUMENT_PATH")`; η βιβλιοθήκη συγχωνεύει τις νέες καταχωρήσεις χωρίς να δημιουργεί ξανά ολόκληρο το ευρετήριο. + +**Ε: Μπορεί το GroupDocs.Search να διαχειριστεί διαφορετικές μορφές αρχείων;** +Α: Ναι, υποστηρίζει PDF, Word, Excel, PowerPoint, απλό κείμενο και πολλές άλλες κοινές μορφές. + +**Ε: Ποιες είναι οι απαιτήσεις συστήματος για τη χρήση του GroupDocs.Search;** +Α: Εκτέλεση Java 8+, επαρκής μνήμη RAM (τουλάχιστον 2 GB για μέτριες συλλογές) και πρόσβαση ανάγνωσης/εγγραφής στον φάκελο του ευρετηρίου. + +**Ε: Πώς μπορώ να αντιμετωπίσω προβλήματα απόδοσης αναζήτησης;** +Α: Βεβαιωθείτε ότι το ευρετήριο είναι ενημερωμένο, προφίλτε τα ερωτήματά σας και ελέγξτε τις ρυθμίσεις μνήμης της JVM. Η μείωση του αριθμού των πεδίων που ευρετηριάζονται μπορεί επίσης να βελτιώσει την ταχύτητα. + +**Ε: Υπάρχει τρόπος να αναζητήσω με συνώνυμα ή ασαφή αντιστοίχιση;** +Α: Ναι, το GroupDocs.Search παρέχει λεξικά συνωνύμων και επιλογές ασαφούς αναζήτησης που μπορούν να ενεργοποιηθούν μέσω της κλάσης `SearchOptions`. + +## Συμπέρασμα +Τώρα έχετε μια ισχυρή κατανόηση της **καταχώρισης εγγράφων** χρησιμοποιώντας το GroupDocs.Search για Java, του πώς να **προσθέσετε έγγραφα στο ευρετήριο**, και του πώς να εκτελείτε τόσο ερωτήματα κειμένου όσο και ερωτήματα αντικειμένου. Ενσωματώνοντας αυτές τις τεχνικές, οι εφαρμογές Java σας θα παρέχουν γρήγορες, ακριβείς εμπειρίες αναζήτησης σε οποιοδήποτε αποθετήριο εγγράφων. + +Έτοιμοι για το επόμενο βήμα; Εξερευνήστε την πολυδιάστατη αναζήτηση, τη διαχείριση συνωνύμων ή ενσωματώστε το ευρετήριο με ένα REST API για να εκθέσετε τις δυνατότητες αναζήτησης σε άλλες υπηρεσίες. + +--- + +**Τελευταία Ενημέρωση:** 2026-02-06 +**Δοκιμάστηκε Με:** GroupDocs.Search 25.4 for Java +**Συγγραφέας:** GroupDocs \ No newline at end of file diff --git a/content/hindi/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/hindi/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..3f1930af --- /dev/null +++ b/content/hindi/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,187 @@ +--- +date: '2026-02-06' +description: GroupDocs.Search के साथ जावा में दस्तावेज़ों को इंडेक्स में जोड़ना और + केस‑सेंसिटिव खोज को सक्षम करना सीखें, जिससे आपके एप्लिकेशन की सटीकता बढ़ेगी। +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'इंडेक्स में दस्तावेज़ जोड़ें: केस‑सेंसिटिव जावा खोज GroupDocs के साथ' +type: docs +url: /hi/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# इंडेक्स में दस्तावेज़ जोड़ें: जावा में केस‑सेंसिटिव सर्च को मास्टर करना GroupDocs + +एक बड़े दस्तावेज़ संग्रह से सही जानकारी प्राप्त करना आधुनिक अनुप्रयोगों की मुख्य आवश्यकता है। इस गाइड में, आप सीखेंगे **इंडेक्स में दस्तावेज़ कैसे जोड़ें** और GroupDocs.Search for Java का उपयोग करके **केस‑सेंसिटिव सर्च** कैसे करें। चाहे आप एक कानूनी‑दस्तावेज़ रिपॉजिटरी, ई‑कॉमर्स कैटलॉग, या कंटेंट‑मैनेजमेंट सिस्टम बना रहे हों, सटीक खोज परिणाम उपयोगकर्ताओं को खुश रखते हैं और आपके डेटा को विश्वसनीय बनाते हैं। + +## त्वरित उत्तर +- **खोज शुरू करने के लिए प्राथमिक कदम क्या है?** `index.add(...)` के साथ इंडेक्स में दस्तावेज़ जोड़ें। +- **केस‑सेंसिटिव सर्च कैसे सक्षम करें?** `options.setUseCaseSensitiveSearch(true)` सेट करें। +- **क्या मैं कई डायरेक्टरीज़ में खोज कर सकता हूँ?** हाँ – प्रत्येक फ़ोल्डर को शामिल करने के लिए `index.add()` कॉल करें। +- **कौन सा मेथड मुझे ऑब्जेक्ट्स के साथ खोजने देता है?** `SearchQuery.createWordQuery(...)` का उपयोग करें। +- **परीक्षण के लिए मुझे लाइसेंस चाहिए?** परीक्षण उद्देश्यों के लिए एक अस्थायी लाइसेंस उपलब्ध है। + +## “इंडेक्स में दस्तावेज़ जोड़ना” का क्या अर्थ है? +इंडेक्स में दस्तावेज़ जोड़ना का मतलब है कि आपके स्रोत फ़ाइलों (PDFs, Word दस्तावेज़, प्लेन टेक्स्ट, आदि) को GroupDocs.Search में फीड करना ताकि वह एक सर्चेबल डेटा स्ट्रक्चर बना सके। एक बार इंडेक्स हो जाने पर, इंजन तेज़ क्वेरीज़ चला सकता है, जिसमें केस‑सेंसिटिव खोज भी शामिल है। + +## जावा में केस‑सेंसिटिव सर्च को सक्षम क्यों करें? +- **सटीक शब्द मिलान** – “Apple” (कंपनी) को “apple” (फल) से अलग करें। +- **नियामक अनुपालन** – कुछ उद्योगों को सटीक वाक्यांश मिलान की आवश्यकता होती है। +- **बेहतर प्रासंगिकता** – उपयोगकर्ता अक्सर तकनीकी या कानूनी संदर्भों में केस‑विशिष्ट परिणामों की अपेक्षा करते हैं। + +## पूर्वापेक्षाएँ +- JDK (Java 17 या बाद का अनुशंसित) +- डिपेंडेंसी प्रबंधन के लिए Maven +- IntelliJ IDEA या Eclipse जैसे IDE +- जावा प्रोग्रामिंग की बुनियादी परिचितता + +## जावा के लिए GroupDocs.Search सेटअप करना +पहले, अपने `pom.xml` में GroupDocs रिपॉजिटरी और डिपेंडेंसी जोड़ें: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +वैकल्पिक रूप से, आप नवीनतम संस्करण सीधे [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) से डाउनलोड कर सकते हैं। + +### लाइसेंसिंग +ट्रायल शुरू करने के लिए, अस्थायी लाइसेंस प्राप्त करने हेतु GroupDocs पर जाएँ। यह आपको सभी फीचर्स को बिना किसी सीमा के परीक्षण करने की अनुमति देगा। + +## इंडेक्स में दस्तावेज़ जोड़ें – टेक्स्ट क्वेरी सर्च + +### चरण 1: एक इंडेक्स बनाएं और अपने दस्तावेज़ जोड़ें +एक फ़ोल्डर बनाएं जहाँ इंडेक्स फ़ाइलें संग्रहीत होंगी, फिर उस स्रोत डायरेक्टरी को जोड़ें जिसमें वे दस्तावेज़ हों जिन्हें आप खोजना चाहते हैं। + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **प्रो टिप:** आप एक ही इंडेक्स में **कई डायरेक्टरीज़ में खोज** करने के लिए `index.add()` को कई बार कॉल कर सकते हैं। + +### चरण 2: केस‑सेंसिटिव सर्च सक्षम करें +सर्च विकल्पों को सेट करें ताकि वह अक्षर केस का सम्मान करे। + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### चरण 3: केस‑सेंसिटिव टेक्स्ट क्वेरी चलाएँ +ऐसी क्वेरी चलाएँ जो “Advantages” को “advantages” से अलग करे। + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +लूप प्रत्येक दस्तावेज़ का पूरा पाथ प्रिंट करता है जिसमें सटीक केस‑मैच्ड टर्म मौजूद है। + +## इंडेक्स में दस्तावेज़ जोड़ें – ऑब्जेक्ट क्वेरी सर्च + +ऑब्जेक्ट क्वेरीज़ अधिक लचीलापन देती हैं, विशेषकर जब आपको कई मानदंडों को मिलाना हो। + +### चरण 1: दूसरा इंडेक्स इनिशियलाइज़ करें (वैकल्पिक) +यदि आप ऑब्जेक्ट‑आधारित खोजों को अलग रखना चाहते हैं, तो एक और इंडेक्स फ़ोल्डर बनाएं। + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### चरण 2: केस‑सेंसिटिव विकल्प को पुनः उपयोग करें +एक ही `SearchOptions` इंस्टेंस ऑब्जेक्ट क्वेरीज़ के लिए काम करता है। + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### चरण 3: ऑब्जेक्ट क्वेरी बनाएं और चलाएँ +एक शब्द क्वेरी ऑब्जेक्ट बनाएं और उसे सर्च इंजन को पास करें। + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +`createWordQuery` का उपयोग करने से आप बाद में इसे फ़्रेज़, वाइल्डकार्ड, या बूलियन क्वेरीज़ के साथ मिलाकर अधिक जटिल परिदृश्यों के लिए उपयोग कर सकते हैं। + +## व्यावहारिक अनुप्रयोग +- **लीगल डॉक्यूमेंट मैनेजमेंट:** ऐसे केस‑स्पेसिफिक स्टैच्यूट्स प्राप्त करें जहाँ कैपिटलाइज़ेशन महत्वपूर्ण हो। +- **ई‑कॉमर्स प्लेटफ़ॉर्म:** “PRO‑X” और “pro‑x” जैसे प्रोडक्ट SKU को अलग करें। +- **कंटेंट मैनेजमेंट सिस्टम (CMS):** सुनिश्चित करें कि लेखकों को सटीक हेडिंग्स या टैग्स मिलें। + +## प्रदर्शन संबंधी विचार +- **इंडेक्स को अद्यतित रखें** – नई फ़ाइलें जोड़ने या मौजूदा फ़ाइलों में बदलाव होने पर पुनः‑इंडेक्स करें। +- **मेमोरी उपयोग की निगरानी करें** – बड़े कॉर्पोरा को इन्क्रीमेंटल इंडेक्सिंग और उचित JVM हीप साइजिंग से लाभ मिलता है। +- **जावा के गार्बेज कलेक्टर का उपयोग करें** – जब `Index` ऑब्जेक्ट्स की आवश्यकता न रहे तो उन्हें रिलीज़ करें। + +## सामान्य समस्याएँ और समाधान +| समस्या | समाधान | +|-------|----------| +| `useCaseSensitiveSearch` अनदेखा हो रहा है | सुनिश्चित करें कि आप नवीनतम GroupDocs.Search संस्करण का उपयोग कर रहे हैं और विकल्प बदलने के बाद इंडेक्स को पुनः बनाय गया है। | +| ज्ञात शब्द के लिए कोई परिणाम नहीं मिला | सुनिश्चित करें कि शब्द का केस बिल्कुल मेल खाता है और दस्तावेज़ सफलतापूर्वक इंडेक्स में जोड़ा गया है। | +| कई फ़ोल्डर खोजने से गति धीमी हो जाती है | `index.add()` से प्रत्येक फ़ोल्डर को अलग‑अलग जोड़ें और बहुत बड़े डेटासेट के लिए इंडेक्स को शार्ड्स में विभाजित करने पर विचार करें। | + +## अक्सर पूछे जाने वाले प्रश्न + +**प्रश्न:** मैं GroupDocs.Search के साथ बड़े डेटासेट को कैसे संभालूँ? +**उत्तर:** इंडेक्स पार्टिशनिंग का उपयोग करें, JVM मेमोरी सेटिंग्स को ट्यून करें, और प्रदर्शन को अनुकूल रखने के लिए समय‑समय पर इंडेक्स को कम्पैक्ट करें। + +**प्रश्न:** क्या मैं एक साथ कई डायरेक्टरीज़ में खोज सकता हूँ? +**उत्तर:** हाँ – प्रत्येक डायरेक्टरी को शामिल करने के लिए `index.add()` कॉल करें, फिर संयुक्त इंडेक्स पर एक ही क्वेरी चलाएँ। + +**प्रश्न:** केस‑सेंसिटिव सर्च सेटअप करते समय आम pitfalls क्या हैं? +**उत्तर:** `useCaseSensitiveSearch` सक्षम करने के बाद इंडेक्स को पुनः बनाना भूल जाना, या क्वेरी स्ट्रिंग में गलत केस का उपयोग करना। + +**प्रश्न:** मैं सर्च एरर्स को कैसे ट्रबलशूट करूँ? +**उत्तर:** GroupDocs.Search द्वारा उत्पन्न लॉग फ़ाइलों में स्टैक ट्रेस देखें, और सुनिश्चित करें कि सभी Maven डिपेंडेंसी सही ढंग से रिजॉल्व्ड हैं। + +**प्रश्न:** क्या GroupDocs.Search रीयल‑टाइम एप्लिकेशन्स के लिए उपयुक्त है? +**उत्तर:** उचित इंडेक्सिंग रणनीतियों (इन्क्रीमेंटल अपडेट्स और इन‑मेरी कैशिंग) के साथ, यह निकट‑रीयल‑टाइम सर्च परिणाम प्रदान कर सकता है। + +## संसाधन +- **डॉक्यूमेंटेशन:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **API रेफ़रेंस:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **डाउनलोड:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **GitHub रिपॉजिटरी:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **सपोर्ट फ़ोरम:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **अस्थायी लाइसेंस:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**अंतिम अपडेट:** 2026-02-06 +**परीक्षण किया गया:** GroupDocs.Search 25.4 +**लेखक:** GroupDocs + +--- \ No newline at end of file diff --git a/content/hindi/java/searching/master-document-search-groupdocs-java/_index.md b/content/hindi/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..a4cf0924 --- /dev/null +++ b/content/hindi/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,183 @@ +--- +date: '2026-02-06' +description: GroupDocs.Search for Java का उपयोग करके दस्तावेज़ों को इंडेक्स करना और + इंडेक्स में दस्तावेज़ जोड़ना सीखें। टेक्स्ट और ऑब्जेक्ट क्वेरीज़ के साथ शक्तिशाली + सर्च एप्लिकेशन बनाएं। +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: GroupDocs.Search for Java के साथ दस्तावेज़ों को कैसे इंडेक्स करें +type: docs +url: /hi/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# GroupDocs.Search for Java के साथ दस्तावेज़ों को इंडेक्स करने का तरीका + +आज के डेटा‑चालित विश्व में, **दस्तावेज़ों को इंडेक्स करने** की कुशलता किसी भी जावा डेवलपर के लिए एक महत्वपूर्ण कौशल है जो बड़ी फ़ाइल संग्रहों से निपटता है। चाहे आप कानूनी अनुबंध, वित्तीय विवरण, या आंतरिक रिपोर्टों को संभाल रहे हों, सही जानकारी को जल्दी से ढूँढ़ना कई घंटे के मैन्युअल काम को बचा सकता है। इस ट्यूटोरियल में आप GroupDocs.Search लाइब्रेरी का उपयोग करके **दस्तावेज़ों को इंडेक्स करना** सीखेंगे, और फिर बनाए गए इंडेक्स पर टेक्स्ट‑आधारित तथा ऑब्जेक्ट‑आधारित दोनों प्रकार की क्वेरीज़ चलाएंगे। चलिए शुरू करते हैं! + +## त्वरित उत्तर +- **दस्तावेज़ों को इंडेक्स करने का पहला कदम क्या है?** एक `Index` ऑब्जेक्ट को इनिशियलाइज़ करें जो उस फ़ोल्डर की ओर इशारा करता हो जहाँ इंडेक्स संग्रहीत किया जाएगा। +- **कौन सी मेथड दस्तावेज़ों को इंडेक्स में जोड़ती है?** `index.add("PATH_TO_DOCUMENTS")` का उपयोग करें। +- **क्या मैं संख्यात्मक रेंज खोज सकता हूँ?** हाँ, `"400 ~~ 4000"` जैसी टेक्स्ट क्वेरी या `SearchQuery.createNumericRangeQuery` के माध्यम से ऑब्जेक्ट क्वेरी का उपयोग करके। +- **क्या मुझे लाइसेंस की आवश्यकता है?** एक फ्री ट्रायल उपलब्ध है; एक कमर्शियल लाइसेंस पूरी सुविधाएँ अनलॉक करता है। +- **कौन सा जावा संस्करण आवश्यक है?** JDK 8 या उससे ऊपर। + +## GroupDocs.Search के साथ “दस्तावेज़ों को इंडेक्स करने” का क्या अर्थ है? +दस्तावेज़ों को इंडेक्स करना मतलब फ़ोल्डर में फ़ाइलों की सामग्री को स्कैन करना और खोज योग्य टोकन को एक समर्पित इंडेक्स फ़ोल्डर में संग्रहीत करना है। यह प्री‑प्रोसेसिंग चरण बाद में तेज़ लुक‑अप को सक्षम करता है, क्योंकि लाइब्रेरी हर बार कच्ची फ़ाइलों के बजाय तैयार किए गए इंडेक्स को खोजती है। + +## जावा के लिए GroupDocs.Search क्यों उपयोग करें? +- **प्रदर्शन:** हजारों फ़ाइलों पर भी सर्च मिलिसेकंड में चलती है। +- **फ़ॉर्मेट समर्थन:** PDFs, Word, Excel, PowerPoint, और कई अन्य फ़ॉर्मेट को संभालता है। +- **लचीलापन:** प्लेन‑टेक्स्ट क्वेरीज़, संख्यात्मक रेंज, और जटिल ऑब्जेक्ट क्वेरीज़ को सपोर्ट करता है। +- **स्केलेबिलिटी:** नई दस्तावेज़ जोड़कर इंडेक्स को आसानी से अपडेट किया जा सकता है बिना फिर से बिल्ड किए। + +## पूर्वापेक्षाएँ +- डिपेंडेंसी मैनेजमेंट के लिए Maven स्थापित हो। +- IntelliJ IDEA या Eclipse जैसे IDE। +- बेसिक जावा ज्ञान (OOP कॉन्सेप्ट्स, एक्सेप्शन हैंडलिंग)। + +## जावा के लिए GroupDocs.Search सेट अप करना +### Maven सेटअप +अपने `pom.xml` में रिपॉज़िटरी और डिपेंडेंसी जोड़ें: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### डायरेक्ट डाउनलोड +आप नवीनतम JAR को [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) से भी डाउनलोड कर सकते हैं। + +#### लाइसेंस प्राप्त करने के चरण +1. **फ्री ट्रायल** – लाइब्रेरी को बिना लागत के एक्सप्लोर करें। +2. **टेम्पररी लाइसेंस** – विस्तारित मूल्यांकन के लिए शॉर्ट‑टर्म की का अनुरोध करें। +3. **पर्चेज** – प्रोडक्शन उपयोग के लिए पूर्ण लाइसेंस प्राप्त करें। + +## बेसिक इनिशियलाइज़ेशन और सेटअप +**इंडेक्स में दस्तावेज़ जोड़ने** के लिए, आप पहले एक `Index` ऑब्जेक्ट बनाते हैं जो उस फ़ोल्डर की ओर इशारा करता है जहाँ इंडेक्स फ़ाइलें संग्रहीत होंगी: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +यह लाइन एक इंडेक्स बनाती (या खोलती) है जो दस्तावेज़ों को प्राप्त करने के लिए तैयार है। + +## इम्प्लीमेंटेशन गाइड +### दस्तावेज़ बनाना और इंडेक्स करना +#### इंडेक्स में दस्तावेज़ कैसे जोड़ें +`add` मेथड एक फ़ोल्डर को स्कैन करता है और प्रत्येक फ़ाइल के लिए खोज योग्य डेटा संग्रहीत करता है। + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **पैरामीटर्स:** पाथ स्ट्रिंग उस फ़ोल्डर की ओर इशारा करता है जिसमें वे फ़ाइलें हैं जिन्हें आप इंडेक्स करना चाहते हैं। +- **उद्देश्य:** इस चरण के बाद, इंडेक्स सभी सपोर्टेड डॉक्यूमेंट टाइप्स के टोकन रखता है, जिससे तेज़ सर्च संभव होती है। + +### टेक्स्ट क्वेरी सर्च +#### टेक्स्ट‑आधारित संख्यात्मक रेंज सर्च कैसे करें +आप एक साधारण स्ट्रिंग का उपयोग करके रेंज को परिभाषित कर सर्च कर सकते हैं। + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **पैरामीटर्स:** क्वेरी स्ट्रिंग `"400 ~~ 4000"` इंजन को 400 और 4000 के बीच की संख्याएँ खोजने को बताती है। +- **रिटर्न वैल्यू:** `SearchResult` मिलते-जुलते दस्तावेज़ों की सूची और हाइलाइट्स रखता है। + +### ऑब्जेक्ट क्वेरी सर्च +#### संख्यात्मक रेंज के लिए ऑब्जेक्ट क्वेरी कैसे उपयोग करें +ऑब्जेक्ट‑आधारित क्वेरीज़ आपको सर्च मानदंडों पर प्रोग्रामेटिक कंट्रोल देती हैं। + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **पैरामीटर्स:** `createNumericRangeQuery` शुरू और अंत के इंटीजर लेता है। +- **उद्देश्य:** यह मेथड तब आदर्श है जब आपको कई शर्तें जोड़नी हों या क्वेरीज़ को डायनामिकली बनाना हो। + +## व्यावहारिक अनुप्रयोग +यहाँ कुछ वास्तविक‑दुनिया के परिदृश्य हैं जहाँ **दस्तावेज़ों को इंडेक्स करना** एक गेम‑चेंजर बन जाता है: + +1. **लीगल डॉक्यूमेंट मैनेजमेंट** – हजारों कॉन्ट्रैक्ट्स में क्लॉज़, केस नंबर, या डेट्स को ढूँढ़ें। +2. **फ़ाइनेंशियल रिपोर्टिंग** – विशिष्ट मौद्रिक रेंज में आने वाले ट्रांज़ैक्शन को निकालें। +3. **इन्वेंटरी ट्रैकिंग** – सीरियल नंबर, बैच कोड, या SKU रेंज द्वारा आइटम खोजें। + +GroupDocs.Search को डेटाबेस, क्लाउड स्टोरेज, या मैसेजिंग क्यूज़ के साथ इंटीग्रेट करने से दस्तावेज़ वर्कफ़्लो और भी ऑटोमेट हो सकते हैं। + +## प्रदर्शन संबंधी विचार +- **नियमित इंडेक्स अपडेट:** नई फ़ाइलों के लिए `index.add` फिर से चलाएँ ताकि इंडेक्स ताज़ा रहे। +- **रिसोर्स मैनेजमेंट:** हीप उपयोग को मॉनिटर करें; बड़े इंडेक्स ट्यून किए गए JVM गैर्बेज‑कलेक्शन सेटिंग्स से लाभान्वित होते हैं। +- **क्वेरी ऑप्टिमाइज़ेशन:** अनावश्यक स्कैनिंग कम करने के लिए जटिल फ़िल्टर के लिए ऑब्जेक्ट क्वेरीज़ का उपयोग करें। + +## सामान्य समस्याएँ और समाधान +| समस्या | क्यों होता है | समाधान | +|-------|----------------|-----| +| **सर्च कोई परिणाम नहीं देता** | इंडेक्स नहीं बना या फ़ोल्डर पाथ गलत | सुनिश्चित करें कि `index.add` सही डायरेक्टरी पर चलाया गया है और इंडेक्स फ़ोल्डर लिखने योग्य है। | +| **इंडेक्सिंग के दौरान OutOfMemoryError** | बहुत बड़ी फ़ाइलें या अपर्याप्त हीप | JVM `-Xmx` वैल्यू बढ़ाएँ या फ़ाइलों को छोटे बैच में इंडेक्स करें। | +| **असमर्थित फ़ाइल फ़ॉर्मेट** | फ़ाइल टाइप GroupDocs.Search द्वारा पहचाना नहीं गया | सुनिश्चित करें कि फ़ाइल एक्सटेंशन समर्थित सूची (PDF, DOCX, XLSX, आदि) में है। | + +## अक्सर पूछे जाने वाले प्रश्न +**Q: मौजूदा इंडेक्स को नए दस्तावेज़ों से कैसे अपडेट करूँ?** +A: फिर से `index.add("NEW_DOCUMENT_PATH")` कॉल करें; लाइब्रेरी नई एंट्रीज़ को पूरे इंडेक्स को फिर से बनाये बिना मर्ज कर देती है। + +**Q: क्या GroupDocs.Search विभिन्न फ़ाइल फ़ॉर्मेट को संभाल सकता है?** +A: हाँ, यह PDFs, Word, Excel, PowerPoint, प्लेन टेक्स्ट, और कई अन्य सामान्य फ़ॉर्मेट को सपोर्ट करता है। + +**Q: GroupDocs.Search उपयोग करने के लिए सिस्टम आवश्यकताएँ क्या हैं?** +A: Java 8+ रनटाइम, पर्याप्त RAM (मध्यम संग्रहों के लिए कम से कम 2 GB), और इंडेक्स फ़ोल्डर तक पढ़ने/लिखने की पहुँच। + +**Q: सर्च प्रदर्शन समस्याओं का समाधान कैसे करूँ?** +A: सुनिश्चित करें कि इंडेक्स अद्यतित है, अपनी क्वेरीज़ को प्रोफ़ाइल करें, और JVM मेमोरी सेटिंग्स की समीक्षा करें। इंडेक्स किए गए फ़ील्ड्स की संख्या कम करने से भी गति बढ़ सकती है। + +**Q: क्या सर्च में साइनोनिम्स या फज़ी मैचिंग का उपयोग किया जा सकता है?** +A: हाँ, GroupDocs.Search साइनोनिम डिक्शनरी और फज़ी सर्च विकल्प प्रदान करता है जिन्हें `SearchOptions` क्लास के माध्यम से सक्षम किया जा सकता है। + +## निष्कर्ष +अब आपके पास GroupDocs.Search for Java का उपयोग करके **दस्तावेज़ों को इंडेक्स करने** की ठोस समझ है, आप **इंडेक्स में दस्तावेज़ जोड़ना** और टेक्स्ट‑आधारित तथा ऑब्जेक्ट‑आधारित दोनों प्रकार की क्वेरीज़ चलाना जानते हैं। इन तकनीकों को इंटीग्रेट करके, आपके जावा एप्लिकेशन किसी भी दस्तावेज़ रिपॉज़िटरी में तेज़, सटीक सर्च अनुभव प्रदान करेंगे। + +अगले चरण के लिए तैयार हैं? फ़ैसिटेड सर्च, साइनोनिम हैंडलिंग को एक्सप्लोर करें, या इंडेक्स को REST API के साथ इंटीग्रेट करके सर्च क्षमताओं को अन्य सर्विसेज़ को एक्सपोज़ करें। + +--- + +**अंतिम अपडेट:** 2026-02-06 +**परीक्षित संस्करण:** GroupDocs.Search 25.4 for Java +**लेखक:** GroupDocs \ No newline at end of file diff --git a/content/hongkong/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/hongkong/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..98a9804b --- /dev/null +++ b/content/hongkong/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,185 @@ +--- +date: '2026-02-06' +description: 學習如何在 Java 中使用 GroupDocs.Search 將文件加入索引並啟用大小寫區分搜尋，提升應用程式的準確性。 +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 將文件新增至索引：使用 GroupDocs 的區分大小寫 Java 搜尋 +type: docs +url: /zh-hant/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# 新增文件至索引：精通 Java 中的大小寫敏感搜尋（使用 GroupDocs） + +從龐大的文件集合中檢索正確資訊是現代應用程式的核心需求。在本指南中，您將學習 **如何將文件新增至索引** 以及使用 GroupDocs.Search for Java 執行 **大小寫敏感搜尋**。無論您是構建法律文件庫、電子商務目錄，或是內容管理系統，精確的搜尋結果都能讓使用者滿意，並確保資料的可信度。 + +## 快速解答 +- **開始搜尋的首要步驟是什麼？** 使用 `index.add(...)` 將文件新增至索引。 +- **如何啟用大小寫敏感搜尋？** 設定 `options.setUseCaseSensitiveSearch(true)`。 +- **我可以跨多個目錄搜尋嗎？** 可以 — 為每個想要納入的資料夾呼叫 `index.add()`。 +- **哪個方法允許使用物件進行搜尋？** 使用 `SearchQuery.createWordQuery(...)`。 +- **測試是否需要授權？** 可取得臨時授權供試用使用。 + +## 「將文件新增至索引」是什麼意思？ +將文件新增至索引是指將您的來源檔案（PDF、Word 文件、純文字等）輸入至 GroupDocs.Search，讓其建立可搜尋的資料結構。完成索引後，搜尋引擎即可執行快速查詢，包括大小寫敏感的查詢。 + +## 為什麼在 Java 中啟用大小寫敏感搜尋？ +- **精確詞彙匹配** — 區分「Apple」（公司）與「apple」（水果）。 +- **符合法規要求** — 某些產業需要精確片語匹配。 +- **提升相關性** — 使用者在技術或法律情境中常期待大小寫特定的結果。 + +## 前置條件 +- JDK（建議使用 Java 17 或更新版本） +- Maven（用於相依管理） +- IDE，例如 IntelliJ IDEA 或 Eclipse +- 具備基本的 Java 程式設計知識 + +## 設定 GroupDocs.Search for Java +First, add the GroupDocs repository and dependency to your `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +或者，您也可以直接從 [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) 下載最新版本。 + +### 授權 +若要開始試用，請前往 GroupDocs 取得臨時授權。這樣即可在無限制的情況下測試所有功能。 + +## 如何將文件新增至索引 — 文字查詢搜尋 + +### 步驟 1：建立索引並新增文件 +建立一個用於存放索引檔案的資料夾，然後加入包含欲搜尋文件的來源目錄。 + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **專業提示：** 您可以多次呼叫 `index.add()`，以在單一索引中 **跨多個目錄搜尋**。 + +### 步驟 2：啟用大小寫敏感搜尋 +設定搜尋選項以遵守字母大小寫。 + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### 步驟 3：執行大小寫敏感的文字查詢 +執行一個能區分「Advantages」與「advantages」的查詢。 + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +此迴圈會印出每個包含完全相符大小寫詞彙的文件完整路徑。 + +## 如何將文件新增至索引 — 物件查詢搜尋 + +物件查詢提供更大的彈性，特別是當您需要結合多個條件時。 + +### 步驟 1：初始化第二個索引（可選） +如果您希望將基於物件的搜尋分開管理，請建立另一個索引資料夾。 + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### 步驟 2：重複使用大小寫敏感選項 +相同的 `SearchOptions` 實例同樣適用於物件查詢。 + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### 步驟 3：建立並執行物件查詢 +建立一個字詞查詢物件，並將其傳遞給搜尋引擎。 + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +使用 `createWordQuery` 可讓您稍後將其與片語、萬用字元或布林查詢結合，以應對更複雜的情境。 + +## 實務應用 +- **法律文件管理：** 取得在大小寫重要的特定案例法條。 +- **電子商務平台：** 區分如「PRO‑X」與「pro‑x」的商品 SKU。 +- **內容管理系統（CMS）：** 確保作者能找到精確的標題或標籤。 + +## 效能考量 +- **保持索引即時更新** — 當新增檔案或現有檔案變更時重新索引。 +- **監控記憶體使用** — 大型語料庫受惠於增量索引與適當的 JVM 堆積大小設定。 +- **善用 Java 的垃圾回收機制** — 當 `Index` 物件不再需要時釋放它們。 + +## 常見問題與解決方案 + +| 問題 | 解決方案 | +|-------|----------| +| `useCaseSensitiveSearch` 似乎被忽略 | 請確認您使用的是最新的 GroupDocs.Search 版本，且在變更選項後已重新建立索引。 | +| 已知詞彙未返回結果 | 確保詞彙的大小寫完全匹配，且文件已成功加入索引。 | +| 搜尋大量資料夾導致速度變慢 | 使用 `index.add()` 個別加入每個資料夾，並考慮將索引拆分為多個分片以應對極大型資料集。 | + +## 常見問答 + +**Q:** 我該如何使用 GroupDocs.Search 處理大型資料集？ +**A:** 使用索引分割、調整 JVM 記憶體設定，並定期壓縮索引以維持最佳效能。 + +**Q:** 我能同時跨多個目錄搜尋嗎？ +**A:** 可以 — 為每個想要納入的目錄呼叫 `index.add()`，然後對合併後的索引執行單一查詢。 + +**Q:** 設定大小寫敏感搜尋時常見的陷阱是什麼？ +**A:** 啟用 `useCaseSensitiveSearch` 後忘記重新建立索引，或在查詢字串中使用錯誤的大小寫。 + +**Q:** 我該如何排除搜尋錯誤？ +**A:** 檢查 GroupDocs.Search 產生的日誌檔以取得堆疊追蹤，並確認所有 Maven 相依項目已正確解析。 + +**Q:** GroupDocs.Search 適用於即時應用程式嗎？ +**A:** 只要採取適當的索引策略（增量更新與記憶體快取），即可提供近即時的搜尋結果。 + +## 資源 +- **文件說明：** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **API 參考：** [Java API Reference](https://reference.groupdocs.com/search/java) +- **下載：** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **GitHub 程式庫：** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **支援論壇：** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **臨時授權：** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**最後更新：** 2026-02-06 +**測試版本：** GroupDocs.Search 25.4 +**作者：** GroupDocs \ No newline at end of file diff --git a/content/hongkong/java/searching/master-document-search-groupdocs-java/_index.md b/content/hongkong/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..f9cb52fe --- /dev/null +++ b/content/hongkong/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,181 @@ +--- +date: '2026-02-06' +description: 學習如何使用 GroupDocs.Search for Java 為文件建立索引並將文件加入索引。利用文字與物件查詢打造功能強大的搜尋應用程式。 +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: 如何使用 GroupDocs.Search for Java 為文件建立索引 +type: docs +url: /zh-hant/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# 如何使用 GroupDocs.Search for Java 建立文件索引 + +在當今資料驅動的世界裡，**如何有效地建立文件索引** 是任何處理大量檔案的 Java 開發者必備的關鍵技能。無論是處理法律合約、財務報表或內部報告，能夠快速定位正確資訊都能節省大量手動工作時間。在本教學中，你將學會使用 GroupDocs.Search 函式庫**建立文件索引**，並在建立好的索引上執行文字查詢與物件查詢。讓我們開始吧！ + +## 快速答案 +- **建立文件索引的第一步是什麼？** 初始化一個指向索引儲存資料夾的 `Index` 物件。 +- **哪個方法可將文件加入索引？** 使用 `index.add("PATH_TO_DOCUMENTS")`。 +- **我可以搜尋數值範圍嗎？** 可以，使用類似 `"400 ~~ 4000"` 的文字查詢，或透過 `SearchQuery.createNumericRangeQuery` 的物件查詢。 +- **我需要授權嗎？** 提供免費試用版；商業授權可解鎖全部功能。 +- **需要哪個 Java 版本？** JDK 8 或以上。 + +## 什麼是使用 GroupDocs.Search 進行「如何建立文件索引」？ +建立文件索引是指掃描資料夾內檔案的內容，並將可搜尋的詞彙儲存在專屬的索引資料夾中。這個前置處理步驟讓之後的查詢能夠閃電般快速，因為函式庫會搜尋已準備好的索引，而不是每次都直接讀取原始檔案。 + +## 為什麼要使用 GroupDocs.Search for Java？ +- **效能：** 即使在上千個檔案上，搜尋也能在毫秒內完成。 +- **格式支援：** 支援 PDF、Word、Excel、PowerPoint 等多種檔案。 +- **彈性：** 支援純文字查詢、數值範圍以及複雜的物件查詢。 +- **可擴充性：** 可透過新增文件直接更新索引，無需重新建構。 + +## 前置條件 +- 已安裝 Maven 以管理相依性。 +- 使用 IntelliJ IDEA 或 Eclipse 等 IDE。 +- 基本的 Java 知識（物件導向概念、例外處理）。 + +## 設定 GroupDocs.Search for Java +### Maven 設定 +將儲存庫與相依性加入 `pom.xml`： + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### 直接下載 +你也可以從 [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) 下載最新的 JAR。 + +#### 取得授權的步驟 +1. **免費試用** – 無償體驗此函式庫。 +2. **臨時授權** – 申請短期金鑰以延長評估時間。 +3. **購買** – 取得正式授權以供正式環境使用。 + +## 基本初始化與設定 +要 **將文件加入索引**，首先建立一個指向索引檔案儲存資料夾的 `Index` 物件： + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +此行程式碼會建立（或開啟）一個可接收文件的索引。 + +## 實作指南 +### 建立與索引文件 +#### 如何將文件加入索引 +`add` 方法會掃描資料夾，並為每個檔案儲存可搜尋的資料。 + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **參數：** 路徑字串指向欲索引檔案所在的資料夾。 +- **目的：** 完成此步驟後，索引將包含所有支援文件類型的詞彙，從而實現快速搜尋。 + +### 文字查詢搜尋 +#### 如何執行文字型數值範圍搜尋 +你可以使用定義範圍的簡單字串進行搜尋。 + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **參數：** 查詢字串 `"400 ~~ 4000"` 告訴引擎搜尋介於 400 至 4000 之間的數字。 +- **返回值：** `SearchResult` 包含符合條件的文件清單與高亮顯示。 + +### 物件查詢搜尋 +#### 如何使用物件查詢進行數值範圍搜尋 +物件型查詢讓你能以程式方式控制搜尋條件。 + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **參數：** `createNumericRangeQuery` 接收起始與結束的整數。 +- **目的：** 當需要結合多個條件或動態建構查詢時，此方法非常適合。 + +## 實務應用 +以下是一些 **如何建立文件索引** 能夠改變遊戲規則的真實情境： + +1. **法律文件管理** – 在成千上萬的合約中快速定位條款、案號或日期。 +2. **財務報表** – 抽取落在特定金額範圍內的交易。 +3. **庫存追蹤** – 依序號、批號或 SKU 範圍搜尋項目。 + +將 GroupDocs.Search 與資料庫、雲端儲存或訊息佇列整合，可進一步自動化文件工作流程。 + +## 效能考量 +- **定期更新索引：** 針對新檔案重新執行 `index.add`，保持索引最新。 +- **資源管理：** 監控堆積記憶體使用情況；大型索引可透過調整 JVM 垃圾回收設定獲得效能提升。 +- **查詢最佳化：** 針對複雜篩選使用物件查詢，以減少不必要的掃描。 + +## 常見問題與解決方案 +| 問題 | 發生原因 | 解決方式 | +|------|----------|----------| +| **搜尋無結果** | 索引未建立或資料夾路徑不正確 | 確認已在正確目錄執行 `index.add`，且索引資料夾具備寫入權限。 | +| **索引期間發生 OutOfMemoryError** | 檔案過大或堆積記憶體不足 | 提升 JVM `-Xmx` 設定或將檔案分批索引。 | +| **不支援的檔案格式** | 檔案類型未被 GroupDocs.Search 識別 | 確保檔案副檔名屬於支援清單（PDF、DOCX、XLSX 等）。 | + +## 常見問答 +**Q: 如何使用新文件更新現有索引？** +A: 再次呼叫 `index.add("NEW_DOCUMENT_PATH")`；函式庫會合併新條目，無需重新建立整個索引。 + +**Q: GroupDocs.Search 能處理不同的檔案格式嗎？** +A: 能，支援 PDF、Word、Excel、PowerPoint、純文字以及其他多種常見格式。 + +**Q: 使用 GroupDocs.Search 的系統需求是什麼？** +A: Java 8+ 執行環境、足夠的記憶體（中等規模集合至少 2 GB），以及對索引資料夾的讀寫權限。 + +**Q: 如何排除搜尋效能問題？** +A: 確保索引為最新、分析查詢效能，並檢查 JVM 記憶體設定。減少索引欄位數量亦可提升速度。 + +**Q: 是否可以使用同義詞或模糊匹配搜尋？** +A: 可以，GroupDocs.Search 提供同義詞字典與模糊搜尋選項，可透過 `SearchOptions` 類別啟用。 + +## 結論 +你現在已掌握 **如何使用 GroupDocs.Search for Java 建立文件索引**、**將文件加入索引**，以及執行文字與物件查詢的技巧。將這些方法整合到你的 Java 應用程式中，即可在任何文件庫提供快速、精確的搜尋體驗。 + +準備好進一步探索了嗎？試試分面搜尋、同義詞處理，或將索引整合至 REST API，將搜尋功能提供給其他服務使用。 + +--- + +**最後更新：** 2026-02-06 +**測試環境：** GroupDocs.Search 25.4 for Java +**作者：** GroupDocs \ No newline at end of file diff --git a/content/hungarian/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/hungarian/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..c1e60de7 --- /dev/null +++ b/content/hungarian/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,187 @@ +--- +date: '2026-02-06' +description: Tanulja meg, hogyan adhat dokumentumokat az indexhez, és hogyan engedélyezhet + esetérzékeny keresést Java-ban a GroupDocs.Search segítségével, ezáltal növelve + alkalmazása pontosságát. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'Dokumentumok hozzáadása az indexhez: kis‑ és nagybetűkre érzékeny Java‑keresés + a GroupDocs‑szal' +type: docs +url: /hu/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# Add documents to index: Mastering Case‑Sensitive Searches in Java with GroupDocs + +A megfelelő információ megtalálása egy hatalmas dokumentumgyűjteményben alapvető követelmény a modern alkalmazások számára. Ebben az útmutatóban megtanulja, **hogyan adjon dokumentumokat az indexhez** és végezzen **kis‑ és nagybetűérzékeny kereséseket** a GroupDocs.Search for Java segítségével. Legyen szó jogi dokumentumtár, e‑kereskedelmi katalógus vagy tartalomkezelő rendszer építéséről, a pontos keresési eredmények boldoggá teszik a felhasználókat és megbízhatóvá teszik az adatokat. + +## Quick Answers +- **Mi a legfontosabb lépés a keresés megkezdéséhez?** Dokumentumok hozzáadása egy indexhez a `index.add(...)` segítségével. +- **Hogyan engedélyezhető a kis‑ és nagybetűérzékeny keresés?** Állítsa be a `options.setUseCaseSensitiveSearch(true)` értéket. +- **Kereshetek több könyvtárban egyszerre?** Igen – hívja meg az `index.add()`‑t minden egyes mappához, amelyet fel szeretne venni. +- **Melyik metódus teszi lehetővé a keresést objektumokkal?** Használja a `SearchQuery.createWordQuery(...)`‑t. +- **Szükség van licencre a teszteléshez?** Ideiglenes licenc áll rendelkezésre próbaverzióhoz. + +## What does “add documents to index” mean? +A dokumentumok indexhez adása azt jelenti, hogy a forrásfájlokat (PDF‑ek, Word‑dokumentumok, egyszerű szöveg stb.) betáplálja a GroupDocs.Search‑be, hogy az felépíthesse a kereshető adatstruktúrát. Az indexelés után a motor gyors lekérdezéseket tud végrehajtani, beleértve a kis‑ és nagybetűérzékeny kereséseket is. + +## Why enable case‑sensitive search in Java? +- **Pontos kifejezésillesztés** – megkülönbözteti a „Apple” (a cég) és az „apple” (a gyümölcs) kifejezéseket. +- **Szabályozási megfelelés** – egyes iparágak pontos kifejezésillesztést követelnek meg. +- **Javított relevancia** – a felhasználók gyakran kis‑ és nagybetűspecifikus eredményeket várnak technikai vagy jogi környezetben. + +## Prerequisites +- JDK (ajánlott a Java 17 vagy újabb) +- Maven a függőségkezeléshez +- IDE, például IntelliJ IDEA vagy Eclipse +- Alapvető Java programozási ismeretek + +## Setting Up GroupDocs.Search for Java +Először adja hozzá a GroupDocs tárolót és a függőséget a `pom.xml`‑hez: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Alternatívaként letöltheti a legújabb verziót közvetlenül a [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) oldalról. + +### Licensing +A próbaverzióhoz látogasson el a GroupDocs oldalára, és szerezzen be egy ideiglenes licencet. Ez lehetővé teszi, hogy minden funkciót korlátozás nélkül teszteljen. + +## How to add documents to index – Text Query Search + +### Step 1: Create an Index and add your documents +Hozzon létre egy mappát, ahol az indexfájlok tárolódnak, majd adja meg a forráskönyvtárat, amely a keresni kívánt dokumentumokat tartalmazza. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **Pro tip:** Többször is meghívhatja az `index.add()`‑t, hogy **több könyvtárban is keresést végezzen** egyetlen indexben. + +### Step 2: Enable case‑sensitive search +Állítsa be a keresési opciókat úgy, hogy figyelembe vegyék a betűk nagyságát. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Step 3: Execute a case‑sensitive text query +Futtasson egy lekérdezést, amely megkülönbözteti a „Advantages” és a „advantages” kifejezéseket. + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +A ciklus kiírja minden olyan dokumentum teljes elérési útját, amely a pontos, betűérzékeny kifejezést tartalmazza. + +## How to add documents to index – Object Query Search + +Az objektumalapú lekérdezések nagyobb rugalmasságot biztosítanak, különösen, ha több kritériumot kell kombinálni. + +### Step 1: Initialize a second index (optional) +Ha külön szeretné tartani az objektumalapú kereséseket, hozzon létre egy másik indexmappát. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Step 2: Re‑use the case‑sensitive option +Ugyanaz a `SearchOptions` példány használható objektumlekérdezésekhez is. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Step 3: Build and run an object query +Hozzon létre egy szólekérdezés‑objektumot, és adja át a keresőmotornak. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +A `createWordQuery` használatával később kombinálhatja azt kifejezés‑, helyettesítő‑ vagy logikai lekérdezésekkel összetettebb forgatókönyvekhez. + +## Practical Applications +- **Jogi dokumentumkezelés:** Olyan eset‑specifikus törvények visszakeresése, ahol a nagybetűk számítanak. +- **E‑commerce platformok:** Termékkódok megkülönböztetése, például „PRO‑X” vs. „pro‑x”. +- **Tartalomkezelő rendszerek (CMS):** Biztosítja, hogy a szerzők pontos címeket vagy címkéket találjanak. + +## Performance Considerations +- **Az index naprakészen tartása** – új fájlok hozzáadásakor vagy meglévők módosításakor újra kell indexelni. +- **Memóriahasználat figyelése** – nagy korpuszok esetén előnyös az inkrementális indexelés és a megfelelő JVM heap méret beállítása. +- **A Java szemétgyűjtőjének kihasználása** – szabadítsa fel az `Index` objektumokat, ha már nincs rájuk szükség. + +## Common Issues and Solutions +| Issue | Solution | +|-------|----------| +| `useCaseSensitiveSearch` figyelmen kívül marad | Ellenőrizze, hogy a legújabb GroupDocs.Search verziót használja, és hogy az opció módosítása után újraépítette-e az indexet. | +| Nem érkezik eredmény egy ismert kifejezésre | Győződjön meg róla, hogy a kifejezés pontosan megegyezik a betűmérettel, és hogy a dokumentum sikeresen hozzá lett adva az indexhez. | +| Sok mappa keresése lelassul | Adja hozzá egyesével minden mappát az `index.add()`‑vel, és fontolja meg az index szétbontását shard‑okra nagyon nagy adathalmazok esetén. | + +## Frequently Asked Questions + +**Q:** Hogyan kezeljem a nagy adatállományokat a GroupDocs.Search‑szal? +**A:** Használjon indexpartícionálást, finomhangolja a JVM memória beállításait, és időnként tömörítse az indexet a teljesítmény optimalizálása érdekében. + +**Q:** Kereshetek egyszerre több könyvtárban? +**A:** Igen – hívja meg az `index.add()`‑t minden egyes könyvtárhoz, majd egyetlen lekérdezést futtasson a kombinált indexen. + +**Q:** Mik a gyakori buktatók a kis‑ és nagybetűérzékeny keresések beállításakor? +**A:** Az `useCaseSensitiveSearch` engedélyezése után elfelejtik újraépíteni az indexet, vagy a lekérdezésben rossz betűméretet használnak. + +**Q:** Hogyan tudom hibakeresni a keresési hibákat? +**A:** Ellenőrizze a GroupDocs.Search által generált naplófájlokat a stack trace‑ekért, és győződjön meg róla, hogy minden Maven függőség helyesen fel van oldva. + +**Q:** Alkalmas a GroupDocs.Search valós‑idő alkalmazásokhoz? +**A:** Megfelelő indexelési stratégiákkal (inkrementális frissítések és memóriában tárolt gyorsítótár) közel valós‑idő keresési eredményeket tud biztosítani. + +## Resources +- **Documentation:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **API Reference:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **Download:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **GitHub Repository:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Support Forum:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Temporary License:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Last Updated:** 2026-02-06 +**Tested With:** GroupDocs.Search 25.4 +**Author:** GroupDocs \ No newline at end of file diff --git a/content/hungarian/java/searching/master-document-search-groupdocs-java/_index.md b/content/hungarian/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..99914871 --- /dev/null +++ b/content/hungarian/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,183 @@ +--- +date: '2026-02-06' +description: Ismerje meg, hogyan indexelhet dokumentumokat, és adhat hozzá dokumentumokat + az indexhez a GroupDocs.Search for Java használatával. Készítsen erőteljes keresőalkalmazásokat + szöveg- és objektumlekérdezésekkel. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Hogyan indexeljük a dokumentumokat a GroupDocs.Search for Java segítségével +type: docs +url: /hu/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# Dokumentumok indexelése a GroupDocs.Search for Java segítségével + +A mai adat‑központú világban a **dokumentumok hatékony indexelése** kritikus készség minden olyan Java fejlesztő számára, aki nagy fájlkészletekkel dolgozik. Akár jogi szerződéseket, pénzügyi kimutatásokat vagy belső jelentéseket kezel, a megfelelő információ gyors megtalálása órákat takaríthat meg a manuális munkában. Ebben az útmutatóban megtanulja, **hogyan indexeljen dokumentumokat** a GroupDocs.Search könyvtár segítségével, majd szöveges és objektumalapú lekérdezéseket hajtson végre a létrehozott indexen. Kezdjünk is! + +## Gyors válaszok +- **Mi az első lépés a dokumentumok indexeléséhez?** Hozzon létre egy `Index` objektumot, amely egy olyan mappára mutat, ahol az index tárolva lesz. +- **Melyik metódus ad dokumentumokat az indexhez?** Használja a `index.add("PATH_TO_DOCUMENTS")`-t. +- **Kereshetek numerikus tartományokat?** Igen, egy szöveges lekérdezéssel, például `"400 ~~ 4000"` vagy egy objektum lekérdezéssel a `SearchQuery.createNumericRangeQuery` segítségével. +- **Szükségem van licencre?** Elérhető egy ingyenes próba, a kereskedelmi licenc pedig a teljes funkciókat feloldja. +- **Melyik Java verzió szükséges?** JDK 8 vagy újabb. + +## Mi az a dokumentumok indexelése a GroupDocs.Search segítségével? +A dokumentumok indexelése azt jelenti, hogy egy mappában lévő fájlok tartalmát beolvassuk, és kereshető tokeneket tárolunk egy dedikált index mappában. Ez az előfeldolgozási lépés villámgyors kereséseket tesz lehetővé később, mivel a könyvtár a kész indexet keresgéli a nyers fájlok helyett. + +## Miért használjuk a GroupDocs.Search for Java‑t? +- **Teljesítmény:** A keresések ezrek fájlja esetén is ezredmásodperc alatt lefutnak. +- **Formátumtámogatás:** Kezeli a PDF‑eket, Word‑et, Excel‑t, PowerPoint‑ot és még sok mást. +- **Rugalmasság:** Támogatja az egyszerű szöveges lekérdezéseket, numerikus tartományokat és összetett objektum lekérdezéseket. +- **Skálázhatóság:** Az index könnyen frissíthető új dokumentumok hozzáadásával anélkül, hogy újra kellene építeni. + +## Előkövetelmények +- Maven telepítve a függőségkezeléshez. +- Egy IDE, például IntelliJ IDEA vagy Eclipse. +- Alap Java ismeretek (OOP koncepciók, kivételkezelés). + +## A GroupDocs.Search for Java beállítása +### Maven beállítás +Adja hozzá a repót és a függőséget a `pom.xml`-hez: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Közvetlen letöltés +A legújabb JAR‑t letöltheti a [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) oldalról is. + +#### Licenc megszerzésének lépései +1. **Ingyenes próba** – a könyvtár költség nélkül történő felfedezése. +2. **Ideiglenes licenc** – kérjen rövid távú kulcsot a kiterjesztett értékeléshez. +3. **Vásárlás** – szerezzen teljes licencet a termelési használathoz. + +## Alap inicializálás és beállítás +A **dokumentumok indexhez adásához** először egy `Index` objektumot hoz létre, amely arra a mappára mutat, ahol az index fájlok tárolva lesznek: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +Ez a sor létrehozza (vagy megnyitja) az indexet, amely készen áll a dokumentumok fogadására. + +## Implementációs útmutató +### Dokumentumok létrehozása és indexelése +#### Hogyan adjunk dokumentumokat az indexhez +Az `add` metódus beolvassa egy mappa tartalmát, és kereshető adatokat tárol minden egyes fájlhoz. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Paraméterek:** Az útvonal karakterlánc arra a mappára mutat, amely a indexelni kívánt fájlokat tartalmazza. +- **Cél:** Ez után az index tartalmazza az összes támogatott dokumentumtípus tokenjeit, lehetővé téve a gyors kereséseket. + +### Szöveges lekérdezés keresés +#### Hogyan hajtsunk végre szöveges numerikus tartomány keresést +Kereshet egy egyszerű karakterlánc segítségével, amely meghatároz egy tartományt. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Paraméterek:** A `"400 ~~ 4000"` lekérdezési karakterlánc azt mondja a motornak, hogy találja meg a 400 és 4000 közötti számokat. +- **Visszatérési érték:** A `SearchResult` tartalmazza a megfelelő dokumentumok listáját és a kiemeléseket. + +### Objektum lekérdezés keresés +#### Hogyan használjunk objektum lekérdezést numerikus tartományokhoz +Az objektumalapú lekérdezések programozott vezérlést biztosítanak a keresési feltételek felett. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Paraméterek:** A `createNumericRangeQuery` megkapja a kezdő és befejező egész számokat. +- **Cél:** Ez a metódus ideális, ha több feltételt kell kombinálni vagy dinamikusan kell lekérdezéseket építeni. + +## Gyakorlati alkalmazások +Íme néhány valós példája annak, amikor a **dokumentumok indexelése** forradalmi hatású: + +1. **Jogi dokumentumkezelés** – klauzulák, ügyszámok vagy dátumok keresése több ezer szerződésben. +2. **Pénzügyi jelentés** – olyan tranzakciók lekérdezése, amelyek egy adott pénzügyi tartományba esnek. +3. **Készletkövetés** – tételek keresése sorozatszám, tétel kód vagy SKU tartomány alapján. + +A GroupDocs.Search adatbázisokkal, felhőtárolóval vagy üzenetsorokkal való integrálása tovább automatizálhatja a dokumentum munkafolyamatokat. + +## Teljesítmény szempontok +- **Rendszeres index frissítések:** Futtassa újra az `index.add`-t új fájlokhoz, hogy az index naprakész maradjon. +- **Erőforrás-kezelés:** Figyelje a heap használatát; nagy indexek esetén előnyös a JVM szemétgyűjtés beállításainak finomhangolása. +- **Lekérdezés optimalizálás:** Használjon objektum lekérdezéseket összetett szűrőkhez, hogy csökkentse a felesleges beolvasást. + +## Gyakori problémák és megoldások +| Probléma | Miért fordul elő | Megoldás | +|----------|------------------|----------| +| **A keresés nem ad eredményt** | Az index nincs felépítve vagy a mappa útvonala helytelen | Ellenőrizze, hogy az `index.add` a megfelelő könyvtárban lett végrehajtva, és hogy az index mappa írható. | +| **OutOfMemoryError indexelés közben** | Nagyon nagy fájlok vagy nem elegendő heap | Növelje a JVM `-Xmx` értékét, vagy kisebb adagokban indexelje a fájlokat. | +| **Nem támogatott fájlformátum** | A fájltípus nem ismerhető fel a GroupDocs.Search által | Győződjön meg róla, hogy a fájl kiterjesztése a támogatott listán szerepel (PDF, DOCX, XLSX, stb.). | + +## Gyakran feltett kérdések +**Q: Hogyan frissíthetem a meglévő indexet új dokumentumokkal?** +A: Hívja újra az `index.add("NEW_DOCUMENT_PATH")`-t; a könyvtár az új bejegyzéseket egyesíti anélkül, hogy újraépítené az egész indexet. + +**Q: Kezelheti a GroupDocs.Search a különböző fájlformátumokat?** +A: Igen, támogatja a PDF‑eket, Word‑et, Excel‑t, PowerPoint‑ot, egyszerű szöveget és számos más gyakori formátumot. + +**Q: Mik a rendszerkövetelmények a GroupDocs.Search használatához?** +A: Java 8+ futtatókörnyezet, elegendő RAM (legalább 2 GB közepes méretű gyűjteményekhez), és olvasási/írási hozzáférés az index mappához. + +**Q: Hogyan háríthatom el a keresési teljesítményproblémákat?** +A: Győződjön meg róla, hogy az index naprakész, profilozza a lekérdezéseket, és ellenőrizze a JVM memória beállításait. A indexelt mezők számának csökkentése is javíthatja a sebességet. + +**Q: Van lehetőség szinonimákkal vagy fuzzy kereséssel keresni?** +A: Igen, a GroupDocs.Search szinonima szótárakat és fuzzy keresési opciókat kínál, amelyeket a `SearchOptions` osztályon keresztül lehet engedélyezni. + +## Következtetés +Most már alapos ismeretekkel rendelkezik a **dokumentumok indexeléséről** a GroupDocs.Search for Java használatával, arról, hogyan **adjunk dokumentumokat az indexhez**, és hogyan hajtsunk végre szöveges és objektumalapú lekérdezéseket egyaránt. E technikák integrálásával Java alkalmazásai gyors és pontos keresési élményt nyújtanak bármilyen dokumentumtárban. + +Készen áll a következő lépésre? Fedezze fel a facettált keresést, a szinonima kezelést, vagy integrálja az indexet egy REST API‑val, hogy a keresési funkciókat más szolgáltatások számára is elérhetővé tegye. + +--- + +**Utoljára frissítve:** 2026-02-06 +**Tesztelve a következővel:** GroupDocs.Search 25.4 for Java +**Szerző:** GroupDocs \ No newline at end of file diff --git a/content/indonesian/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/indonesian/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..debda6cb --- /dev/null +++ b/content/indonesian/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,187 @@ +--- +date: '2026-02-06' +description: Pelajari cara menambahkan dokumen ke indeks dan mengaktifkan pencarian + sensitif huruf besar/kecil di Java dengan GroupDocs.Search, meningkatkan akurasi + aplikasi Anda. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'Tambahkan dokumen ke indeks: pencarian Java yang sensitif huruf besar/kecil + dengan GroupDocs' +type: docs +url: /id/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# Tambahkan dokumen ke indeks: Menguasai Pencarian Sensitif Huruf di Java dengan GroupDocs + +Mengambil potongan informasi yang tepat dari kumpulan dokumen yang sangat besar adalah kebutuhan inti bagi aplikasi modern. Dalam panduan ini, Anda akan belajar **cara menambahkan dokumen ke indeks** dan melakukan **pencarian sensitif huruf** menggunakan GroupDocs.Search untuk Java. Baik Anda membangun repositori dokumen hukum, katalog e‑commerce, atau sistem manajemen konten, hasil pencarian yang tepat membuat pengguna senang dan data Anda dapat dipercaya. + +## Jawaban Cepat +- **Apa langkah utama untuk memulai pencarian?** Tambahkan dokumen ke indeks dengan `index.add(...)`. +- **Bagaimana mengaktifkan pencarian sensitif huruf?** Setel `options.setUseCaseSensitiveSearch(true)`. +- **Bisakah saya mencari di beberapa direktori?** Ya – panggil `index.add()` untuk setiap folder yang ingin Anda sertakan. +- **Metode apa yang memungkinkan saya mencari dengan objek?** Gunakan `SearchQuery.createWordQuery(...)`. +- **Apakah saya memerlukan lisensi untuk pengujian?** Lisensi sementara tersedia untuk tujuan percobaan. + +## Apa arti “menambahkan dokumen ke indeks”? +Menambahkan dokumen ke indeks berarti memasukkan file sumber Anda (PDF, dokumen Word, teks biasa, dll.) ke dalam GroupDocs.Search sehingga dapat membangun struktur data yang dapat dicari. Setelah diindeks, mesin dapat mengeksekusi kueri cepat, termasuk yang sensitif huruf. + +## Mengapa mengaktifkan pencarian sensitif huruf di Java? +- **Pencocokan istilah yang tepat** – membedakan “Apple” (perusahaan) dari “apple” (buah). +- **Kepatuhan regulasi** – beberapa industri memerlukan pencocokan frasa yang tepat. +- **Relevansi yang lebih baik** – pengguna sering mengharapkan hasil yang spesifik huruf dalam konteks teknis atau hukum. + +## Prasyarat +- JDK (Java 17 atau lebih baru disarankan) +- Maven untuk manajemen dependensi +- IDE seperti IntelliJ IDEA atau Eclipse +- Familiaritas dasar dengan pemrograman Java + +## Menyiapkan GroupDocs.Search untuk Java +Pertama, tambahkan repositori GroupDocs dan dependensinya ke `pom.xml` Anda: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Atau, Anda dapat mengunduh versi terbaru langsung dari [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Lisensi +Untuk memulai dengan percobaan, kunjungi GroupDocs untuk memperoleh lisensi sementara. Ini akan memungkinkan Anda menguji semua fitur tanpa batasan. + +## Cara menambahkan dokumen ke indeks – Pencarian Kuery Teks + +### Langkah 1: Buat Indeks dan tambahkan dokumen Anda +Buat folder tempat file indeks akan disimpan, lalu tambahkan direktori sumber yang berisi dokumen yang ingin Anda cari. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **Tips profesional:** Anda dapat memanggil `index.add()` beberapa kali untuk **mencari di banyak direktori** dalam satu indeks. + +### Langkah 2: Aktifkan pencarian sensitif huruf +Konfigurasikan opsi pencarian agar memperhatikan kapitalisasi huruf. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Langkah 3: Jalankan kueri teks sensitif huruf +Jalankan kueri yang membedakan “Advantages” dari “advantages”. + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Loop tersebut mencetak jalur lengkap setiap dokumen yang berisi istilah dengan kecocokan huruf yang tepat. + +## Cara menambahkan dokumen ke indeks – Pencarian Kuery Objek + +Kuery objek memberi Anda fleksibilitas lebih, terutama ketika Anda perlu menggabungkan beberapa kriteria. + +### Langkah 1: Inisialisasi indeks kedua (opsional) +Jika Anda lebih suka memisahkan pencarian berbasis objek, buat folder indeks lain. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Langkah 2: Gunakan kembali opsi sensitif huruf +Instansi `SearchOptions` yang sama dapat dipakai untuk kueri objek. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Langkah 3: Bangun dan jalankan kueri objek +Buat objek kueri kata dan berikan ke mesin pencari. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Menggunakan `createWordQuery` memungkinkan Anda menggabungkannya nanti dengan kueri frasa, wildcard, atau Boolean untuk skenario yang lebih kompleks. + +## Aplikasi Praktis +- **Manajemen Dokumen Hukum:** Mengambil undang‑undang spesifik kasus di mana kapitalisasi penting. +- **Platform E‑commerce:** Membedakan SKU produk seperti “PRO‑X” vs. “pro‑x”. +- **Sistem Manajemen Konten (CMS):** Memastikan penulis menemukan judul atau tag yang tepat. + +## Pertimbangan Kinerja +- **Jaga indeks tetap terbaru** – lakukan re‑indeks ketika file baru ditambahkan atau yang lama diubah. +- **Pantau penggunaan memori** – korpus besar mendapat manfaat dari indeks inkremental dan penyesuaian ukuran heap JVM yang tepat. +- **Manfaatkan garbage collector Java** – lepaskan objek `Index` ketika tidak lagi diperlukan. + +## Masalah Umum dan Solusinya +| Masalah | Solusi | +|-------|----------| +| `useCaseSensitiveSearch` tampak diabaikan | Pastikan Anda menggunakan versi GroupDocs.Search terbaru dan indeks dibangun ulang setelah mengubah opsi. | +| Tidak ada hasil untuk istilah yang diketahui | Pastikan kapitalisasi istilah cocok persis dan dokumen berhasil ditambahkan ke indeks. | +| Pencarian di banyak folder menjadi lambat | Tambahkan setiap folder secara terpisah dengan `index.add()` dan pertimbangkan membagi indeks menjadi shard untuk dataset sangat besar. | + +## Pertanyaan yang Sering Diajukan + +**T:** Bagaimana cara menangani dataset besar dengan GroupDocs.Search? +**J:** Manfaatkan partisi indeks, sesuaikan pengaturan memori JVM, dan secara periodik kompak indeks untuk menjaga kinerja optimal. + +**T:** Bisakah saya mencari di beberapa direktori secara bersamaan? +**J:** Ya – panggil `index.add()` untuk setiap direktori yang ingin Anda sertakan, lalu jalankan satu kueri terhadap indeks gabungan. + +**T:** Apa jebakan umum saat menyiapkan pencarian sensitif huruf? +**J:** Lupa membangun ulang indeks setelah mengaktifkan `useCaseSensitiveSearch`, atau menggunakan kapitalisasi yang salah pada string kueri. + +**T:** Bagaimana cara memecahkan masalah kesalahan pencarian? +**J:** Periksa file log yang dihasilkan oleh GroupDocs.Search untuk jejak stack, dan pastikan semua dependensi Maven terresolusi dengan benar. + +**T:** Apakah GroupDocs.Search cocok untuk aplikasi waktu‑nyata? +**J:** Dengan strategi indeks yang tepat (pembaruan inkremental dan caching dalam memori), ia dapat memberikan hasil pencarian hampir secara waktu‑nyata. + +## Sumber Daya +- **Dokumentasi:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **Referensi API:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **Unduhan:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **Repositori GitHub:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Forum Dukungan:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Lisensi Sementara:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Terakhir Diperbarui:** 2026-02-06 +**Diuji Dengan:** GroupDocs.Search 25.4 +**Penulis:** GroupDocs \ No newline at end of file diff --git a/content/indonesian/java/searching/master-document-search-groupdocs-java/_index.md b/content/indonesian/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..ba6fb78a --- /dev/null +++ b/content/indonesian/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,183 @@ +--- +date: '2026-02-06' +description: Pelajari cara mengindeks dokumen dan menambahkan dokumen ke indeks menggunakan + GroupDocs.Search untuk Java. Bangun aplikasi pencarian yang kuat dengan kueri teks + dan objek. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Cara Mengindeks Dokumen dengan GroupDocs.Search untuk Java +type: docs +url: /id/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# Cara Mengindeks Dokumen dengan GroupDocs.Search untuk Java + +Dalam dunia yang didorong oleh data saat ini, **cara mengindeks dokumen** secara efisien adalah keterampilan penting bagi setiap pengembang Java yang menangani koleksi file besar. Baik Anda menangani kontrak hukum, laporan keuangan, atau laporan internal, kemampuan untuk dengan cepat menemukan informasi yang tepat dapat menghemat berjam‑jam kerja manual. Dalam tutorial ini Anda akan belajar **cara mengindeks dokumen** menggunakan pustaka GroupDocs.Search, kemudian melakukan kueri berbasis teks maupun berbasis objek pada indeks yang dibuat. Mari kita mulai! + +## Jawaban Cepat +- **Apa langkah pertama untuk mengindeks dokumen?** Inisialisasi objek `Index` yang menunjuk ke folder tempat indeks akan disimpan. +- **Metode mana yang menambahkan dokumen ke indeks?** Gunakan `index.add("PATH_TO_DOCUMENTS")`. +- **Bisakah saya mencari rentang numerik?** Ya, dengan kueri teks seperti `"400 ~~ 4000"` atau kueri objek melalui `SearchQuery.createNumericRangeQuery`. +- **Apakah saya memerlukan lisensi?** Versi percobaan gratis tersedia; lisensi komersial membuka semua fitur. +- **Versi Java apa yang diperlukan?** JDK 8 atau yang lebih tinggi. + +## Apa itu “cara mengindeks dokumen” dengan GroupDocs.Search? +Mengindeks dokumen berarti memindai konten file dalam sebuah folder dan menyimpan token yang dapat dicari di folder indeks khusus. Langkah pra‑pemrosesan ini memungkinkan pencarian yang sangat cepat kemudian, karena pustaka mencari di indeks yang telah dipersiapkan bukan pada file mentah setiap kali. + +## Mengapa menggunakan GroupDocs.Search untuk Java? +- **Kinerja:** Pencarian berjalan dalam milidetik bahkan pada ribuan file. +- **Dukungan format:** Menangani PDF, Word, Excel, PowerPoint, dan banyak lagi. +- **Fleksibilitas:** Mendukung kueri teks biasa, rentang numerik, dan kueri objek kompleks. +- **Skalabilitas:** Mudah memperbarui indeks dengan menambahkan dokumen baru tanpa harus membangun ulang dari awal. + +## Prasyarat +- Maven terpasang untuk manajemen dependensi. +- IDE seperti IntelliJ IDEA atau Eclipse. +- Pengetahuan dasar Java (konsep OOP, penanganan pengecualian). + +## Menyiapkan GroupDocs.Search untuk Java +### Pengaturan Maven +Tambahkan repositori dan dependensi ke `pom.xml` Anda: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Unduhan Langsung +Anda juga dapat mengunduh JAR terbaru dari [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +#### Langkah-langkah Akuisisi Lisensi +1. **Free Trial** – jelajahi pustaka tanpa biaya. +2. **Temporary License** – minta kunci jangka pendek untuk evaluasi yang lebih lama. +3. **Purchase** – dapatkan lisensi penuh untuk penggunaan produksi. + +## Inisialisasi dan Pengaturan Dasar +Untuk **menambahkan dokumen ke indeks**, pertama Anda membuat objek `Index` yang menunjuk ke folder tempat file indeks akan disimpan: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +Baris ini membuat (atau membuka) sebuah indeks yang siap menerima dokumen. + +## Panduan Implementasi +### Membuat dan Mengindeks Dokumen +#### Cara menambahkan dokumen ke indeks +Metode `add` memindai sebuah folder dan menyimpan data yang dapat dicari untuk setiap file. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Parameter:** String path menunjuk ke folder yang berisi file yang ingin Anda indeks. +- **Tujuan:** Setelah langkah ini, indeks berisi token dari semua tipe dokumen yang didukung, memungkinkan pencarian cepat. + +### Pencarian Kueri Teks +#### Cara melakukan pencarian rentang numerik berbasis teks +Anda dapat mencari menggunakan string sederhana yang mendefinisikan rentang. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Parameter:** String kueri `"400 ~~ 4000"` memberi tahu mesin untuk menemukan angka antara 400 dan 4000. +- **Nilai Kembali:** `SearchResult` menyimpan daftar dokumen yang cocok dan sorotan. + +### Pencarian Kueri Objek +#### Cara menggunakan kueri objek untuk rentang numerik +Kueri berbasis objek memberi Anda kontrol programatik atas kriteria pencarian. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Parameter:** `createNumericRangeQuery` menerima integer awal dan akhir. +- **Tujuan:** Metode ini ideal ketika Anda perlu menggabungkan beberapa kondisi atau membangun kueri secara dinamis. + +## Aplikasi Praktis +Berikut beberapa skenario dunia nyata di mana **cara mengindeks dokumen** menjadi pengubah permainan: + +1. **Manajemen Dokumen Hukum** – temukan klausul, nomor kasus, atau tanggal di antara ribuan kontrak. +2. **Pelaporan Keuangan** – tarik transaksi yang berada dalam rentang uang tertentu. +3. **Pelacakan Inventaris** – temukan item berdasarkan nomor seri, kode batch, atau rentang SKU. + +Mengintegrasikan GroupDocs.Search dengan basis data, penyimpanan cloud, atau antrian pesan dapat lebih mengotomatisasi alur kerja dokumen. + +## Pertimbangan Kinerja +- **Pembaruan Indeks Reguler:** Jalankan kembali `index.add` untuk file baru agar indeks tetap segar. +- **Manajemen Sumber Daya:** Pantau penggunaan heap; indeks besar mendapat manfaat dari pengaturan garbage‑collection JVM yang disesuaikan. +- **Optimasi Kueri:** Gunakan kueri objek untuk filter kompleks guna mengurangi pemindaian yang tidak perlu. + +## Masalah Umum dan Solusinya +| Issue | Why It Happens | Fix | +|-------|----------------|-----| +| **Pencarian tidak menghasilkan hasil** | Indeks belum dibangun atau jalur folder tidak tepat | Verifikasi `index.add` dijalankan pada direktori yang benar dan bahwa folder indeks dapat ditulisi. | +| **OutOfMemoryError selama pengindeksan** | File sangat besar atau heap tidak cukup | Tingkatkan nilai JVM `-Xmx` atau indeks file dalam batch yang lebih kecil. | +| **Format file tidak didukung** | Tipe file tidak dikenali oleh GroupDocs.Search | Pastikan ekstensi file termasuk dalam daftar yang didukung (PDF, DOCX, XLSX, dll.). | + +## Pertanyaan yang Sering Diajukan +**Q: Bagaimana cara memperbarui indeks yang ada dengan dokumen baru?** +A: Panggil `index.add("NEW_DOCUMENT_PATH")` lagi; pustaka menggabungkan entri baru tanpa membuat ulang seluruh indeks. + +**Q: Apakah GroupDocs.Search dapat menangani berbagai format file?** +A: Ya, ia mendukung PDF, Word, Excel, PowerPoint, teks biasa, dan banyak format umum lainnya. + +**Q: Apa persyaratan sistem untuk menggunakan GroupDocs.Search?** +A: Runtime Java 8+, RAM yang cukup (minimal 2 GB untuk koleksi sedang), serta akses baca/tulis ke folder indeks. + +**Q: Bagaimana cara mengatasi masalah performa pencarian?** +A: Pastikan indeks terbaru, profilkan kueri Anda, dan tinjau pengaturan memori JVM. Mengurangi jumlah bidang yang diindeks juga dapat meningkatkan kecepatan. + +**Q: Apakah ada cara untuk mencari dengan sinonim atau pencocokan fuzzy?** +A: Ya, GroupDocs.Search menyediakan kamus sinonim dan opsi pencarian fuzzy yang dapat diaktifkan melalui kelas `SearchOptions`. + +## Kesimpulan +Anda kini memiliki pemahaman yang kuat tentang **cara mengindeks dokumen** menggunakan GroupDocs.Search untuk Java, cara **menambahkan dokumen ke indeks**, dan cara menjalankan kueri berbasis teks maupun berbasis objek. Dengan mengintegrasikan teknik ini, aplikasi Java Anda akan memberikan pengalaman pencarian yang cepat dan akurat di seluruh repositori dokumen apa pun. + +Siap untuk langkah selanjutnya? Jelajahi pencarian berfaset, penanganan sinonim, atau integrasikan indeks dengan REST API untuk menampilkan kemampuan pencarian ke layanan lain. + +--- + +**Terakhir Diperbarui:** 2026-02-06 +**Diuji Dengan:** GroupDocs.Search 25.4 for Java +**Penulis:** GroupDocs \ No newline at end of file diff --git a/content/italian/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/italian/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..6a588730 --- /dev/null +++ b/content/italian/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,189 @@ +--- +date: '2026-02-06' +description: Scopri come aggiungere documenti all'indice e abilitare la ricerca sensibile + al maiuscolo/minuscolo in Java con GroupDocs.Search, migliorando l'accuratezza della + tua applicazione. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'Aggiungi documenti all''indice: ricerca Java sensibile a maiuscole/minuscole + con GroupDocs' +type: docs +url: /it/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# Aggiungere documenti all'indice: Padroneggiare le ricerche Case‑Sensitive in Java con GroupDocs + +Recuperare la giusta informazione da una collezione enorme di documenti è un requisito fondamentale per le applicazioni moderne. In questa guida, imparerai **come aggiungere documenti all'indice** e eseguire **ricerche case‑sensitive** usando GroupDocs.Search per Java. Che tu stia costruendo un repository di documenti legali, un catalogo e‑commerce o un sistema di gestione dei contenuti, risultati di ricerca precisi mantengono gli utenti soddisfatti e i tuoi dati affidabili. + +## Risposte rapide +- **Qual è il passo principale per iniziare a cercare?** Aggiungi documenti a un indice con `index.add(...)`. +- **Come abilitare la ricerca case sensitive?** Imposta `options.setUseCaseSensitiveSearch(true)`. +- **Posso cercare in più directory?** Sì – chiama `index.add()` per ogni cartella che desideri includere. +- **Quale metodo consente di cercare con oggetti?** Usa `SearchQuery.createWordQuery(...)`. +- **È necessaria una licenza per i test?** È disponibile una licenza temporanea per scopi di prova. + +## Cosa significa “add documents to index”? +Aggiungere documenti a un indice significa fornire i tuoi file sorgente (PDF, documenti Word, testo semplice, ecc.) a GroupDocs.Search affinché possa costruire una struttura dati ricercabile. Una volta indicizzati, il motore può eseguire query rapide, incluse quelle case‑sensitive. + +## Perché abilitare la ricerca case‑sensitive in Java? +- **Corrispondenza esatta del termine** – differenzia “Apple” (l'azienda) da “apple” (il frutto). +- **Conformità normativa** – alcune industrie richiedono una corrispondenza esatta delle frasi. +- **Rilevanza migliorata** – gli utenti spesso si aspettano risultati case‑specifici in contesti tecnici o legali. + +## Prerequisiti +- JDK (Java 17 o successivo consigliato) +- Maven per la gestione delle dipendenze +- Un IDE come IntelliJ IDEA o Eclipse +- Familiarità di base con la programmazione Java + +## Configurare GroupDocs.Search per Java +Per prima cosa, aggiungi il repository GroupDocs e la dipendenza al tuo `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +In alternativa, puoi scaricare l'ultima versione direttamente da [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Licenza +Per iniziare con una versione di prova, visita GroupDocs per ottenere una licenza temporanea. Questo ti permetterà di testare tutte le funzionalità senza alcuna limitazione. + +## Come aggiungere documenti all'indice – Ricerca con query di testo + +### Passo 1: Creare un indice e aggiungere i tuoi documenti +Crea una cartella dove saranno memorizzati i file dell'indice, quindi aggiungi la directory sorgente che contiene i documenti che desideri cercare. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **Consiglio professionale:** Puoi chiamare `index.add()` più volte per **cercare in più directory** in un unico indice. + +### Passo 2: Abilitare la ricerca case‑sensitive +Configura le opzioni di ricerca per rispettare la distinzione tra maiuscole e minuscole. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Passo 3: Eseguire una query di testo case‑sensitive +Esegui una query che differenzia “Advantages” da “advantages”. + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Il ciclo stampa il percorso completo di ogni documento che contiene il termine con corrispondenza esatta di maiuscole/minuscole. + +## Come aggiungere documenti all'indice – Ricerca con query di oggetto + +Le query di oggetto ti offrono maggiore flessibilità, soprattutto quando devi combinare più criteri. + +### Passo 1: Inizializzare un secondo indice (opzionale) +Se preferisci tenere separate le ricerche basate su oggetti, crea un'altra cartella per l'indice. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Passo 2: Riutilizzare l'opzione case‑sensitive +La stessa istanza di `SearchOptions` funziona per le query di oggetto. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Passo 3: Costruire ed eseguire una query di oggetto +Crea un oggetto query di parola e passalo al motore di ricerca. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Usare `createWordQuery` ti consente di combinarlo in seguito con query di frase, wildcard o Boolean per scenari più complessi. + +## Applicazioni pratiche +- **Gestione documenti legali:** Recupera normative specifiche del caso dove la capitalizzazione è importante. +- **Piattaforme e‑commerce:** Distinguere SKU di prodotto come “PRO‑X” vs. “pro‑x”. +- **Sistemi di gestione dei contenuti (CMS):** Garantire che gli autori trovino intestazioni o tag esatti. + +## Considerazioni sulle prestazioni +- **Mantenere l'indice aggiornato** – re‑indicizzare quando vengono aggiunti nuovi file o quelli esistenti cambiano. +- **Monitorare l'uso della memoria** – grandi corpora beneficiano dell'indicizzazione incrementale e di una corretta dimensione dell'heap JVM. +- **Sfruttare il garbage collector di Java** – rilascia gli oggetti `Index` quando non sono più necessari. + +## Problemi comuni e soluzioni +| Problema | Soluzione | +|----------|-----------| +| `useCaseSensitiveSearch` appears ignored | Verifica di utilizzare l'ultima versione di GroupDocs.Search e che l'indice sia stato ricostruito dopo aver modificato l'opzione. | +| No results returned for a known term | Assicurati che la capitalizzazione del termine corrisponda esattamente e che il documento sia stato aggiunto correttamente all'indice. | +| Searching many folders slows down | Aggiungi ogni cartella singolarmente con `index.add()` e considera di suddividere l'indice in shard per dataset molto grandi. | + +## Domande frequenti + +**D:** Come gestisco grandi dataset con GroupDocs.Search? +**R:** Utilizza il partizionamento dell'indice, ottimizza le impostazioni di memoria della JVM e compatta periodicamente l'indice per mantenere le prestazioni ottimali. + +**D:** Posso cercare simultaneamente in più directory? +**R:** Sì – chiama `index.add()` per ogni directory che desideri includere, quindi esegui una singola query sull'indice combinato. + +**D:** Quali sono gli errori comuni nella configurazione delle ricerche case‑sensitive? +**R:** Dimenticare di ricostruire l'indice dopo aver abilitato `useCaseSensitiveSearch`, o usare la capitalizzazione errata nella stringa di query. + +**D:** Come posso risolvere gli errori di ricerca? +**R:** Controlla i file di log generati da GroupDocs.Search per le tracce di stack e conferma che tutte le dipendenze Maven siano risolte correttamente. + +**D:** GroupDocs.Search è adatto per applicazioni in tempo reale? +**R:** Con strategie di indicizzazione adeguate (aggiornamenti incrementali e caching in‑memory), può fornire risultati di ricerca quasi in tempo reale. + +## Risorse +- **Documentazione:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **Riferimento API:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **Download:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **Repository GitHub:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Forum di supporto:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Licenza temporanea:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Ultimo aggiornamento:** 2026-02-06 +**Testato con:** GroupDocs.Search 25.4 +**Autore:** GroupDocs + +--- \ No newline at end of file diff --git a/content/italian/java/searching/master-document-search-groupdocs-java/_index.md b/content/italian/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..687f0750 --- /dev/null +++ b/content/italian/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,183 @@ +--- +date: '2026-02-06' +description: Scopri come indicizzare documenti e aggiungere documenti all'indice usando + GroupDocs.Search per Java. Crea potenti applicazioni di ricerca con query di testo + e di oggetti. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Come indicizzare documenti con GroupDocs.Search per Java +type: docs +url: /it/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# Come indicizzare documenti con GroupDocs.Search per Java + +Nel mondo odierno guidato dai dati, **come indicizzare documenti** in modo efficiente è una competenza fondamentale per qualsiasi sviluppatore Java che gestisce grandi collezioni di file. Che tu stia gestendo contratti legali, bilanci finanziari o report interni, la capacità di individuare rapidamente le informazioni giuste può far risparmiare ore di lavoro manuale. In questo tutorial imparerai **come indicizzare documenti** usando la libreria GroupDocs.Search, per poi eseguire query sia basate su testo sia basate su oggetti sull'indice creato. Iniziamo! + +## Risposte rapide +- **Qual è il primo passo per indicizzare documenti?** Inizializza un oggetto `Index` che punta a una cartella dove verrà memorizzato l'indice. +- **Quale metodo aggiunge documenti a un indice?** Usa `index.add("PATH_TO_DOCUMENTS")`. +- **Posso cercare intervalli numerici?** Sì, con una query di testo come `"400 ~~ 4000"` o una query oggetto tramite `SearchQuery.createNumericRangeQuery`. +- **Ho bisogno di una licenza?** È disponibile una prova gratuita; una licenza commerciale sblocca tutte le funzionalità. +- **Quale versione di Java è richiesta?** JDK 8 o superiore. + +## Cos'è “come indicizzare documenti” con GroupDocs.Search? +Indicizzare documenti significa scansionare il contenuto dei file in una cartella e memorizzare token ricercabili in una cartella indice dedicata. Questa fase di pre‑elaborazione consente ricerche fulminee in seguito, poiché la libreria ricerca l'indice preparato anziché i file grezzi ogni volta. + +## Perché usare GroupDocs.Search per Java? +- **Performance:** Le ricerche vengono eseguite in millisecondi anche su migliaia di file. +- **Supporto dei formati:** Gestisce PDF, Word, Excel, PowerPoint e molti altri. +- **Flessibilità:** Supporta query di testo semplice, intervalli numerici e query oggetto complesse. +- **Scalabilità:** Aggiorna facilmente l'indice aggiungendo nuovi documenti senza ricostruirlo da zero. + +## Prerequisiti +- Maven installato per la gestione delle dipendenze. +- Un IDE come IntelliJ IDEA o Eclipse. +- Conoscenze di base di Java (concetti OOP, gestione delle eccezioni). + +## Configurazione di GroupDocs.Search per Java +### Configurazione Maven +Aggiungi il repository e la dipendenza al tuo `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Download diretto +Puoi anche scaricare l'ultima JAR da [rilasci di GroupDocs.Search per Java](https://releases.groupdocs.com/search/java/). + +#### Passaggi per l'acquisizione della licenza +1. **Prova gratuita** – esplora la libreria senza costi. +2. **Licenza temporanea** – richiedi una chiave a breve termine per una valutazione estesa. +3. **Acquisto** – ottieni una licenza completa per l'uso in produzione. + +## Inizializzazione e configurazione di base +Per **aggiungere documenti all'indice**, devi prima creare un oggetto `Index` che punti alla cartella dove verranno memorizzati i file dell'indice: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +Questa riga crea (o apre) un indice pronto a ricevere documenti. + +## Guida all'implementazione +### Creazione e indicizzazione di documenti +#### Come aggiungere documenti all'indice +Il metodo `add` scansiona una cartella e memorizza i dati ricercabili per ogni file. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Parametri:** La stringa del percorso punta alla cartella contenente i file che desideri indicizzare. +- **Scopo:** Dopo questo passaggio, l'indice contiene token da tutti i tipi di documento supportati, consentendo ricerche rapide. + +### Ricerca con query di testo +#### Come eseguire una ricerca di intervallo numerico basata su testo +Puoi cercare usando una semplice stringa che definisce un intervallo. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Parametri:** La stringa di query `"400 ~~ 4000"` indica al motore di trovare numeri tra 400 e 4000. +- **Valore di ritorno:** `SearchResult` contiene l'elenco dei documenti corrispondenti e gli evidenziamenti. + +### Ricerca con query oggetto +#### Come utilizzare una query oggetto per intervalli numerici +Le query basate su oggetti ti danno il controllo programmatico sui criteri di ricerca. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Parametri:** `createNumericRangeQuery` riceve gli interi di inizio e fine. +- **Scopo:** Questo metodo è ideale quando è necessario combinare più condizioni o costruire query in modo dinamico. + +## Applicazioni pratiche +Ecco alcuni scenari reali in cui **come indicizzare documenti** diventa un elemento decisivo: + +1. **Gestione dei documenti legali** – individua clausole, numeri di caso o date tra migliaia di contratti. +2. **Reporting finanziario** – estrai transazioni che rientrano in un intervallo monetario specifico. +3. **Tracciamento dell'inventario** – trova articoli per numeri di serie, codici di lotto o intervalli SKU. + +Integrare GroupDocs.Search con database, storage cloud o code di messaggistica può automatizzare ulteriormente i flussi di lavoro dei documenti. + +## Considerazioni sulle prestazioni +- **Aggiornamenti regolari dell'indice:** Riesegui `index.add` per i nuovi file per mantenere l'indice aggiornato. +- **Gestione delle risorse:** Monitora l'utilizzo dell'heap; gli indici di grandi dimensioni beneficiano di impostazioni di garbage‑collection della JVM ottimizzate. +- **Ottimizzazione delle query:** Usa query oggetto per filtri complessi per ridurre scansioni non necessarie. + +## Problemi comuni e soluzioni +| Problema | Perché accade | Soluzione | +|----------|----------------|----------| +| **La ricerca non restituisce risultati** | Indice non costruito o percorso della cartella errato | Verifica che `index.add` sia stato eseguito sulla directory corretta e che la cartella dell'indice sia scrivibile. | +| **OutOfMemoryError durante l'indicizzazione** | File molto grandi o heap insufficiente | Aumenta il valore JVM `-Xmx` o indicizza i file in batch più piccoli. | +| **Formato file non supportato** | Tipo di file non riconosciuto da GroupDocs.Search | Assicurati che l'estensione del file sia nella lista supportata (PDF, DOCX, XLSX, ecc.). | + +## Domande frequenti +**Q: Come posso aggiornare un indice esistente con nuovi documenti?** +A: Richiama nuovamente `index.add("NEW_DOCUMENT_PATH")`; la libreria unisce le nuove voci senza ricreare l'intero indice. + +**Q: GroupDocs.Search può gestire diversi formati di file?** +A: Sì, supporta PDF, Word, Excel, PowerPoint, testo semplice e molti altri formati comuni. + +**Q: Quali sono i requisiti di sistema per usare GroupDocs.Search?** +A: Runtime Java 8+, RAM sufficiente (almeno 2 GB per collezioni moderate) e accesso in lettura/scrittura alla cartella dell'indice. + +**Q: Come posso risolvere problemi di prestazioni nella ricerca?** +A: Assicurati che l'indice sia aggiornato, profila le tue query e rivedi le impostazioni di memoria della JVM. Ridurre il numero di campi indicizzati può migliorare la velocità. + +**Q: È possibile cercare con sinonimi o corrispondenza fuzzy?** +A: Sì, GroupDocs.Search fornisce dizionari di sinonimi e opzioni di ricerca fuzzy che possono essere abilitate tramite la classe `SearchOptions`. + +## Conclusione +Ora hai una solida comprensione di **come indicizzare documenti** usando GroupDocs.Search per Java, di come **aggiungere documenti all'indice**, e di come eseguire sia query basate su testo sia query basate su oggetti. Integrando queste tecniche, le tue applicazioni Java offriranno esperienze di ricerca rapide e accurate su qualsiasi repository di documenti. + +Pronto per il passo successivo? Esplora la ricerca a faccette, la gestione dei sinonimi, o integra l'indice con un'API REST per esporre le funzionalità di ricerca ad altri servizi. + +--- + +**Ultimo aggiornamento:** 2026-02-06 +**Testato con:** GroupDocs.Search 25.4 per Java +**Autore:** GroupDocs \ No newline at end of file diff --git a/content/japanese/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/japanese/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..077a8455 --- /dev/null +++ b/content/japanese/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,184 @@ +--- +date: '2026-02-06' +description: GroupDocs.Search を使用して Java でドキュメントをインデックスに追加し、ケースセンシティブ検索を有効にする方法を学び、アプリケーションの精度を向上させましょう。 +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: インデックスにドキュメントを追加：GroupDocs を使用した大文字小文字を区別する Java 検索 +type: docs +url: /ja/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# インデックスにドキュメントを追加: GroupDocs を使用した Java の大文字小文字検索のマスター + +大量のドキュメントコレクションから目的の情報を取得することは、現代アプリケーションの重要な要件です。このガイドでは、GroupDocs.Search for Java を使用して **インデックスにドキュメントを追加** し、 **大文字小文字を区別した検索** を実行する方法を学びます。法務文書リポジトリ、eコマースカタログ、コンテンツ管理システムなど、正確な検索結果はユーザーの満足度とデータの信頼性を高めます。 + +## Quick Answers +- **検索を開始するための最初のステップは何ですか？** `index.add(...)` でインデックスにドキュメントを追加します。 +- **大文字小文字検索を有効にするには？** `options.setUseCaseSensitiveSearch(true)` を設定します。 +- **複数ディレクトリを横断して検索できますか？** はい – 追加したいフォルダーごとに `index.add()` を呼び出します。 +- **オブジェクトで検索するメソッドはどれですか？** `SearchQuery.createWordQuery(...)` を使用します。 +- **テスト用にライセンスは必要ですか？** 試用目的の一時ライセンスが利用可能です。 + +## “インデックスにドキュメントを追加” とは何ですか？ +インデックスにドキュメントを追加するとは、PDF、Word、プレーンテキストなどのソースファイルを GroupDocs.Search に取り込み、検索可能なデータ構造を構築することです。インデックス化が完了すると、エンジンは高速なクエリ（大文字小文字を区別したものも含む）を実行できます。 + +## Java で大文字小文字検索を有効にする理由 +- **正確な語句一致** – 「Apple」（企業）と「apple」（果物）を区別できます。 +- **規制遵守** – 業界によっては正確なフレーズ一致が求められます。 +- **関連性の向上** – 技術文書や法務文書など、ケースセンシティブな結果が期待されるシナリオで有用です。 + +## 前提条件 +- JDK（Java 17 以上推奨） +- 依存関係管理のための Maven +- IntelliJ IDEA または Eclipse などの IDE +- Java プログラミングの基本的な知識 + +## GroupDocs.Search for Java のセットアップ +まず、`pom.xml` に GroupDocs リポジトリと依存関係を追加します。 + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +あるいは、[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) から最新バージョンを直接ダウンロードできます。 + +### ライセンス +トライアルを開始するには、GroupDocs のサイトで一時ライセンスを取得してください。これにより、機能制限なしで全ての機能をテストできます。 + +## インデックスにドキュメントを追加 – テキストクエリ検索 + +### 手順 1: インデックスを作成し、ドキュメントを追加 +インデックスファイルを保存するフォルダーを作成し、検索対象となるドキュメントが格納されたソースディレクトリを追加します。 + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **プロのコツ:** `index.add()` を複数回呼び出すことで、**単一インデックス内で複数ディレクトリを検索** できます。 + +### 手順 2: 大文字小文字検索を有効化 +検索オプションで文字ケースを考慮するよう設定します。 + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### 手順 3: 大文字小文字を区別したテキストクエリを実行 +「Advantages」と「advantages」を区別するクエリを実行します。 + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +このループは、正確にケースが一致した語句を含む各ドキュメントのフルパスを出力します。 + +## インデックスにドキュメントを追加 – オブジェクトクエリ検索 + +オブジェクトクエリは、複数の条件を組み合わせる必要がある場合に柔軟性を提供します。 + +### 手順 1: 2 番目のインデックスを初期化（任意） +オブジェクトベースの検索を別管理したい場合は、別のインデックスフォルダーを作成します。 + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### 手順 2: 大文字小文字オプションを再利用 +同じ `SearchOptions` インスタンスをオブジェクトクエリでも使用できます。 + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### 手順 3: オブジェクトクエリを構築して実行 +ワードクエリオブジェクトを作成し、検索エンジンに渡します。 + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +`createWordQuery` を使用すると、後でフレーズ、ワイルドカード、ブールクエリと組み合わせて、より複雑なシナリオを構築できます。 + +## 実用的な活用例 +- **法務文書管理:** 大文字小文字が重要な条文や判例を正確に取得。 +- **eコマースプラットフォーム:** 「PRO‑X」 と 「pro‑x」 のような SKU を区別。 +- **コンテンツ管理システム (CMS):** 著者が正確な見出しやタグを検索できるように。 + +## パフォーマンス上の考慮点 +- **インデックスを常に最新に保つ** – 新規ファイルの追加や既存ファイルの変更時に再インデックス化します。 +- **メモリ使用量を監視** – 大規模コーパスではインクリメンタルインデックスと適切な JVM ヒープサイズが有効です。 +- **Java のガベージコレクタを活用** – `Index` オブジェクトは不要になったら解放します。 + +## よくある問題と解決策 +| Issue | Solution | +|-------|----------| +| `useCaseSensitiveSearch` が無視されているように見える | 最新の GroupDocs.Search バージョンを使用し、オプション変更後にインデックスを再構築したことを確認してください。 | +| 既知の語句で結果が返ってこない | 語句のケースが完全に一致しているか、ドキュメントがインデックスに正しく追加されたかを確認してください。 | +| 多数のフォルダーを検索すると遅くなる | 各フォルダーを個別に `index.add()` で追加し、データセットが非常に大きい場合はインデックスをシャードに分割することを検討してください。 | + +## Frequently Asked Questions + +**Q:** GroupDocs.Search で大規模データセットを扱うには？ +**A:** インデックスのパーティショニング、JVM メモリ設定の調整、定期的なインデックス圧縮を行い、パフォーマンスを最適化します。 + +**Q:** 複数ディレクトリを同時に検索できますか？ +**A:** はい – 追加したいディレクトリごとに `index.add()` を呼び出し、結合されたインデックスに対して単一クエリを実行します。 + +**Q:** 大文字小文字検索設定時の一般的な落とし穴は？ +**A:** `useCaseSensitiveSearch` を有効にした後にインデックスを再構築し忘れる、またはクエリ文字列のケースが誤っていることです。 + +**Q:** 検索エラーのトラブルシューティング方法は？ +**A:** GroupDocs.Search が生成するログファイルでスタックトレースを確認し、すべての Maven 依存関係が正しく解決されているかをチェックしてください。 + +**Q:** GroupDocs.Search はリアルタイムアプリケーションに適していますか？ +**A:** インデックス戦略（インクリメンタル更新とインメモリキャッシュ）を適切に構成すれば、ほぼリアルタイムの検索結果を提供できます。 + +## Resources +- **Documentation:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **API Reference:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **Download:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **GitHub Repository:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Support Forum:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Temporary License:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Last Updated:** 2026-02-06 +**Tested With:** GroupDocs.Search 25.4 +**Author:** GroupDocs \ No newline at end of file diff --git a/content/japanese/java/searching/master-document-search-groupdocs-java/_index.md b/content/japanese/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..6514138b --- /dev/null +++ b/content/japanese/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,181 @@ +--- +date: '2026-02-06' +description: GroupDocs.Search for Java を使用して、ドキュメントのインデックス作成方法とインデックスへのドキュメント追加方法を学びましょう。テキストクエリやオブジェクトクエリを使って、強力な検索アプリを構築できます。 +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Java 用 GroupDocs.Search でドキュメントをインデックスする方法 +type: docs +url: /ja/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# GroupDocs.Search for Java を使用したドキュメントのインデックス作成方法 + +今日のデータ駆動型の世界では、**ドキュメントのインデックス作成方法**を効率的に行うことは、大量のファイルを扱うすべての Java 開発者にとって重要なスキルです。法務契約書、財務諸表、内部レポートなどを扱う場合でも、必要な情報を迅速に見つけられることで、手作業にかかる時間を何時間も節約できます。このチュートリアルでは、GroupDocs.Search ライブラリを使用して**ドキュメントのインデックス作成方法**を学び、作成したインデックスに対してテキストベースとオブジェクトベースの両方のクエリを実行します。さあ、始めましょう！ + +## クイック回答 +- **ドキュメントをインデックスする最初のステップは何ですか？** インデックスが保存されるフォルダーを指す `Index` オブジェクトを初期化します。 +- **インデックスにドキュメントを追加するメソッドはどれですか？** `index.add("PATH_TO_DOCUMENTS")` を使用します。 +- **数値範囲を検索できますか？** はい、`"400 ~~ 4000"` のようなテキストクエリ、または `SearchQuery.createNumericRangeQuery` を使用したオブジェクトクエリで可能です。 +- **ライセンスは必要ですか？** 無料トライアルが利用可能で、商用ライセンスを取得するとすべての機能が使用可能になります。 +- **必要な Java バージョンは？** JDK 8 以上です。 + +## GroupDocs.Search で「ドキュメントのインデックス作成方法」とは何ですか？ +ドキュメントのインデックス作成とは、フォルダー内のファイル内容をスキャンし、検索可能なトークンを専用のインデックスフォルダーに保存することです。この前処理により、ライブラリは毎回生のファイルを検索するのではなく、事前に作成されたインデックスを検索するため、後の検索が瞬時に行えるようになります。 + +## なぜ Java 用 GroupDocs.Search を使用するのか？ +- **パフォーマンス:** 数千ファイルでも検索はミリ秒単位で実行されます。 +- **フォーマットサポート:** PDF、Word、Excel、PowerPoint など多数の形式に対応します。 +- **柔軟性:** プレーンテキストクエリ、数値範囲、複雑なオブジェクトクエリをサポートします。 +- **スケーラビリティ:** 新しいドキュメントを追加するだけでインデックスを簡単に更新でき、ゼロから再構築する必要がありません。 + +## 前提条件 +- 依存関係管理のために Maven がインストールされていること。 +- IntelliJ IDEA や Eclipse などの IDE。 +- 基本的な Java の知識（OOP の概念、例外処理）。 + +## Java 用 GroupDocs.Search の設定 +### Maven 設定 +`pom.xml` にリポジトリと依存関係を追加します: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### 直接ダウンロード +最新の JAR は [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) からダウンロードすることもできます。 + +#### ライセンス取得手順 +1. **無料トライアル** – コストなしでライブラリを試すことができます。 +2. **一時ライセンス** – 拡張評価のために短期間のキーをリクエストします。 +3. **購入** – 本番環境で使用するためのフルライセンスを取得します。 + +## 基本的な初期化と設定 +**インデックスにドキュメントを追加**するには、まずインデックスファイルが保存されるフォルダーを指す `Index` オブジェクトを作成します: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +この行は、ドキュメントを受け取る準備ができたインデックスを作成（または開く）します。 + +## 実装ガイド +### ドキュメントの作成とインデックス作成 +#### インデックスにドキュメントを追加する方法 +`add` メソッドはフォルダーをスキャンし、各ファイルの検索可能なデータを保存します。 + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **パラメータ:** パス文字列はインデックス対象のファイルが格納されたフォルダーを指します。 +- **目的:** このステップの後、インデックスにはすべてのサポート対象ドキュメントタイプのトークンが含まれ、迅速な検索が可能になります。 + +### テキストクエリ検索 +#### テキストベースの数値範囲検索の実行方法 +範囲を定義したシンプルな文字列で検索できます。 + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **パラメータ:** クエリ文字列 `"400 ~~ 4000"` はエンジンに 400 から 4000 の間の数値を検索させます。 +- **戻り値:** `SearchResult` は一致したドキュメントのリストとハイライト情報を保持します。 + +### オブジェクトクエリ検索 +#### 数値範囲のオブジェクトクエリの使用方法 +オブジェクトベースのクエリは、検索条件をプログラム的に制御できます。 + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **パラメータ:** `createNumericRangeQuery` は開始整数と終了整数を受け取ります。 +- **目的:** 複数条件を組み合わせたり、クエリを動的に構築したりする場合に最適です。 + +## 実用的な応用例 +以下は **ドキュメントのインデックス作成方法** が大きな効果を発揮する実際のシナリオです: + +1. **法務文書管理** – 数千件の契約書から条項、事件番号、日付などを検索します。 +2. **財務報告** – 特定の金額範囲に該当する取引を抽出します。 +3. **在庫管理** – シリアル番号、バッチコード、SKU の範囲でアイテムを検索します。 + +GroupDocs.Search をデータベース、クラウドストレージ、メッセージキューと統合することで、文書ワークフローをさらに自動化できます。 + +## パフォーマンス上の考慮点 +- **定期的なインデックス更新:** 新しいファイルに対して `index.add` を再実行し、インデックスを最新の状態に保ちます。 +- **リソース管理:** ヒープ使用量を監視します。大規模インデックスは JVM のガベージコレクション設定を調整すると効果的です。 +- **クエリ最適化:** 複雑なフィルタにはオブジェクトクエリを使用し、不要なスキャンを減らします。 + +## よくある問題と解決策 +| 問題 | 発生理由 | 解決策 | +|-------|----------------|-----| +| **検索結果が返らない** | インデックスが作成されていない、またはフォルダーパスが間違っている | 正しいディレクトリで `index.add` が実行されたこと、インデックスフォルダーが書き込み可能であることを確認してください。 | +| **インデックス作成中の OutOfMemoryError** | 非常に大きなファイル、またはヒープが不足している | JVM の `-Xmx` 値を増やすか、ファイルを小さなバッチに分けてインデックス作成してください。 | +| **サポートされていないファイル形式** | ファイル形式が GroupDocs.Search で認識されない | ファイル拡張子がサポート対象リスト（PDF、DOCX、XLSX など）に含まれていることを確認してください。 | + +## よくある質問 +**Q: 既存のインデックスに新しいドキュメントを追加更新するには？** +A: 再度 `index.add("NEW_DOCUMENT_PATH")` を呼び出します。ライブラリはインデックス全体を再作成せずに新しいエントリをマージします。 + +**Q: GroupDocs.Search はさまざまなファイル形式に対応していますか？** +A: はい、PDF、Word、Excel、PowerPoint、プレーンテキストなど、多くの一般的な形式に対応しています。 + +**Q: GroupDocs.Search を使用するためのシステム要件は何ですか？** +A: Java 8 以上のランタイム、十分な RAM（中規模コレクションで最低 2 GB 以上）、インデックスフォルダーへの読み書き権限が必要です。 + +**Q: 検索パフォーマンスの問題をトラブルシュートするには？** +A: インデックスが最新であることを確認し、クエリをプロファイルし、JVM のメモリ設定を見直してください。インデックス対象フィールド数を減らすことでも速度向上が期待できます。 + +**Q: 同義語やあいまい検索で検索する方法はありますか？** +A: はい、GroupDocs.Search は同義語辞書とあいまい検索オプションを提供しており、`SearchOptions` クラスで有効にできます。 + +## 結論 +これで、Java 用 GroupDocs.Search を使用した **ドキュメントのインデックス作成方法**、**インデックスへのドキュメント追加方法**、テキストベースとオブジェクトベースのクエリの実行方法についてしっかりと理解できました。これらの手法を統合すれば、Java アプリケーションはあらゆるドキュメントリポジトリに対して高速で正確な検索体験を提供できるようになります。 + +次のステップに進む準備はできましたか？ファセット検索や同義語処理を探求したり、インデックスを REST API と統合して他のサービスに検索機能を提供したりしてみてください。 + +--- + +**最終更新日:** 2026-02-06 +**テスト環境:** GroupDocs.Search 25.4 for Java +**作者:** GroupDocs \ No newline at end of file diff --git a/content/korean/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/korean/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..c461ffec --- /dev/null +++ b/content/korean/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,185 @@ +--- +date: '2026-02-06' +description: GroupDocs.Search를 사용하여 Java에서 문서를 인덱스에 추가하고 대소문자 구분 검색을 활성화하는 방법을 배우고, + 애플리케이션의 정확성을 높이세요. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: '문서를 인덱스에 추가: GroupDocs를 활용한 대소문자 구분 Java 검색' +type: docs +url: /ko/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# 인덱스에 문서 추가: Java와 GroupDocs를 활용한 대소문자 구분 검색 마스터하기 + +방대한 문서 컬렉션에서 올바른 정보를 찾아내는 것은 현대 애플리케이션의 핵심 요구 사항입니다. 이 가이드에서는 **인덱스에 문서를 추가하는 방법**과 GroupDocs.Search for Java를 사용한 **대소문자 구분 검색**을 수행하는 방법을 배웁니다. 법률 문서 저장소, 전자상거래 카탈로그, 콘텐츠 관리 시스템을 구축하든, 정확한 검색 결과는 사용자 만족도를 높이고 데이터의 신뢰성을 유지합니다. + +## 빠른 답변 +- **검색을 시작하기 위한 기본 단계는 무엇인가요?** `index.add(...)` 로 인덱스에 문서를 추가합니다. +- **대소문자 구분 검색을 어떻게 활성화하나요?** `options.setUseCaseSensitiveSearch(true)` 를 설정합니다. +- **여러 디렉터리를 동시에 검색할 수 있나요?** 예 – 포함하려는 각 폴더에 대해 `index.add()` 를 호출합니다. +- **객체를 사용해 검색하려면 어떤 메서드를 사용하나요?** `SearchQuery.createWordQuery(...)` 를 사용합니다. +- **테스트에 라이선스가 필요합니까?** 체험용으로 임시 라이선스를 사용할 수 있습니다. + +## “인덱스에 문서 추가”가 의미하는 바는 무엇인가요? +인덱스에 문서를 추가한다는 것은 소스 파일(PDF, Word 문서, 일반 텍스트 등)을 GroupDocs.Search에 전달하여 검색 가능한 데이터 구조를 구축한다는 의미입니다. 인덱싱이 완료되면 엔진은 대소문자 구분 검색을 포함한 빠른 쿼리를 실행할 수 있습니다. + +## Java에서 대소문자 구분 검색을 활성화하는 이유는? +- **정확한 용어 매칭** – “Apple”(회사)과 “apple”(과일)을 구분합니다. +- **규제 준수** – 일부 산업에서는 정확한 구문 매칭이 요구됩니다. +- **관련성 향상** – 기술 또는 법률 분야에서 사용자는 대소문자 구분 결과를 기대합니다. + +## 사전 요구 사항 +- JDK (Java 17 이상 권장) +- Maven (의존성 관리) +- IntelliJ IDEA 또는 Eclipse와 같은 IDE +- Java 프로그래밍에 대한 기본 지식 + +## GroupDocs.Search for Java 설정 +First, add the GroupDocs repository and dependency to your `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +또는 [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) 에서 최신 버전을 직접 다운로드할 수 있습니다. + +### 라이선스 +체험판을 시작하려면 GroupDocs 사이트에서 임시 라이선스를 획득하십시오. 이를 통해 모든 기능을 제한 없이 테스트할 수 있습니다. + +## 인덱스에 문서 추가 – 텍스트 쿼리 검색 + +### 단계 1: 인덱스 생성 및 문서 추가 +인덱스 파일이 저장될 폴더를 만든 뒤, 검색하려는 문서가 들어 있는 소스 디렉터리를 추가합니다. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **프로 팁:** `index.add()` 를 여러 번 호출하여 단일 인덱스에서 **여러 디렉터리를 검색**할 수 있습니다. + +### 단계 2: 대소문자 구분 검색 활성화 +검색 옵션을 설정하여 대소문자를 구분하도록 구성합니다. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### 단계 3: 대소문자 구분 텍스트 쿼리 실행 +“Advantages”와 “advantages”를 구분하는 쿼리를 실행합니다. + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +루프는 정확히 대소문자가 일치하는 용어를 포함한 각 문서의 전체 경로를 출력합니다. + +## 인덱스에 문서 추가 – 객체 쿼리 검색 + +객체 쿼리는 특히 여러 조건을 결합해야 할 때 더 큰 유연성을 제공합니다. + +### 단계 1: 두 번째 인덱스 초기화 (선택 사항) +객체 기반 검색을 별도로 유지하고 싶다면 다른 인덱스 폴더를 생성합니다. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### 단계 2: 대소문자 구분 옵션 재사용 +동일한 `SearchOptions` 인스턴스를 객체 쿼리에도 사용할 수 있습니다. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### 단계 3: 객체 쿼리 구축 및 실행 +워드 쿼리 객체를 생성하고 이를 검색 엔진에 전달합니다. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +`createWordQuery` 를 사용하면 이후에 구문, 와일드카드 또는 Boolean 쿼리와 결합하여 더 복잡한 시나리오를 구현할 수 있습니다. + +## 실용적인 적용 사례 +- **법률 문서 관리:** 대소문자가 중요한 사례별 조항을 검색합니다. +- **전자상거래 플랫폼:** “PRO‑X”와 “pro‑x”와 같은 제품 SKU를 구분합니다. +- **콘텐츠 관리 시스템(CMS):** 작성자가 정확한 제목이나 태그를 찾을 수 있도록 합니다. + +## 성능 고려 사항 +- **인덱스를 최신 상태로 유지** – 새 파일이 추가되거나 기존 파일이 변경될 때 재인덱싱합니다. +- **메모리 사용량 모니터링** – 대규모 코퍼스는 증분 인덱싱과 적절한 JVM 힙 크기 설정으로 이점을 얻습니다. +- **Java 가비지 컬렉터 활용** – 더 이상 필요하지 않은 `Index` 객체를 해제합니다. + +## 일반적인 문제 및 해결책 +| Issue | Solution | +|-------|----------| +| `useCaseSensitiveSearch` appears ignored | 최신 GroupDocs.Search 버전을 사용하고 옵션 변경 후 인덱스를 재구축했는지 확인하십시오. | +| No results returned for a known term | 용어의 대소문자가 정확히 일치하는지, 그리고 문서가 인덱스에 성공적으로 추가되었는지 확인하십시오. | +| Searching many folders slows down | 각 폴더를 `index.add()` 로 개별 추가하고, 매우 큰 데이터셋의 경우 인덱스를 샤드로 분할하는 것을 고려하십시오. | + +## 자주 묻는 질문 + +**Q:** GroupDocs.Search로 대용량 데이터셋을 어떻게 처리하나요? +**A:** 인덱스 파티셔닝을 활용하고 JVM 메모리 설정을 조정하며, 성능을 최적화하기 위해 주기적으로 인덱스를 압축합니다. + +**Q:** 여러 디렉터리를 동시에 검색할 수 있나요? +**A:** 예 – 포함하려는 각 디렉터리에 대해 `index.add()` 를 호출한 뒤, 결합된 인덱스에 단일 쿼리를 실행합니다. + +**Q:** 대소문자 구분 검색을 설정할 때 흔히 발생하는 실수는 무엇인가요? +**A:** `useCaseSensitiveSearch` 를 활성화한 후 인덱스를 재구축하지 않거나, 쿼리 문자열에서 잘못된 대소문자를 사용하는 경우입니다. + +**Q:** 검색 오류를 어떻게 해결하나요? +**A:** GroupDocs.Search가 생성한 로그 파일에서 스택 트레이스를 확인하고, 모든 Maven 의존성이 올바르게 해결되었는지 확인하십시오. + +**Q:** GroupDocs.Search가 실시간 애플리케이션에 적합한가요? +**A:** 적절한 인덱싱 전략(증분 업데이트 및 인메모리 캐싱)을 사용하면 거의 실시간에 가까운 검색 결과를 제공할 수 있습니다. + +## 리소스 +- **문서:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **API 레퍼런스:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **다운로드:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **GitHub 저장소:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **지원 포럼:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **임시 라이선스:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**마지막 업데이트:** 2026-02-06 +**테스트 환경:** GroupDocs.Search 25.4 +**작성자:** GroupDocs \ No newline at end of file diff --git a/content/korean/java/searching/master-document-search-groupdocs-java/_index.md b/content/korean/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..e8bffb6f --- /dev/null +++ b/content/korean/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,182 @@ +--- +date: '2026-02-06' +description: GroupDocs.Search for Java를 사용하여 문서를 인덱싱하고 인덱스에 문서를 추가하는 방법을 배우세요. 텍스트 + 및 객체 쿼리를 활용한 강력한 검색 애플리케이션을 구축하세요. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Java용 GroupDocs.Search로 문서 인덱싱하는 방법 +type: docs +url: /ko/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# GroupDocs.Search for Java로 문서 인덱싱하기 + +오늘날 데이터 중심의 세상에서 **문서를 효율적으로 인덱싱하는 방법**은 대용량 파일 컬렉션을 다루는 모든 Java 개발자에게 필수적인 기술입니다. 법률 계약서, 재무 보고서, 내부 보고서 등을 처리하든, 필요한 정보를 빠르게 찾아낼 수 있다면 수시간에 달하는 수작업을 절감할 수 있습니다. 이 튜토리얼에서는 GroupDocs.Search 라이브러리를 사용해 **문서를 인덱싱하는 방법**을 배우고, 생성된 인덱스에 대해 텍스트 기반 및 객체 기반 쿼리를 모두 수행하는 방법을 살펴봅니다. 시작해볼까요! + +## 빠른 답변 +- **문서를 인덱싱하기 위한 첫 번째 단계는?** 인덱스가 저장될 폴더를 가리키는 `Index` 객체를 초기화합니다. +- **어떤 메서드가 문서를 인덱스에 추가하나요?** `index.add("PATH_TO_DOCUMENTS")`를 사용합니다. +- **숫자 범위를 검색할 수 있나요?** 예, `"400 ~~ 4000"`와 같은 텍스트 쿼리 또는 `SearchQuery.createNumericRangeQuery`를 이용한 객체 쿼리로 가능합니다. +- **라이선스가 필요합니까?** 무료 체험판을 이용할 수 있으며, 상용 라이선스를 구매하면 전체 기능을 사용할 수 있습니다. +- **필요한 Java 버전은?** JDK 8 이상. + +## GroupDocs.Search와 함께하는 “문서 인덱싱”이란? +문서 인덱싱이란 폴더에 있는 파일들의 내용을 스캔하고, 검색 가능한 토큰을 별도의 인덱스 폴더에 저장하는 작업을 의미합니다. 이 사전 처리 단계 덕분에 라이브러리는 매번 원본 파일을 탐색하는 대신 준비된 인덱스를 빠르게 조회할 수 있어 순간적인 검색이 가능합니다. + +## 왜 Java용 GroupDocs.Search를 사용해야 할까요? +- **성능:** 수천 개 파일에서도 검색이 밀리초 단위로 완료됩니다. +- **포맷 지원:** PDF, Word, Excel, PowerPoint 등 다양한 형식을 처리합니다. +- **유연성:** 일반 텍스트 쿼리, 숫자 범위, 복합 객체 쿼리를 모두 지원합니다. +- **확장성:** 전체를 다시 구축하지 않고도 새 문서를 추가해 인덱스를 손쉽게 업데이트할 수 있습니다. + +## 사전 요구 사항 +- 의존성 관리를 위한 Maven 설치 +- IntelliJ IDEA 또는 Eclipse와 같은 IDE +- 기본 Java 지식 (OOP 개념, 예외 처리) + +## Java용 GroupDocs.Search 설정하기 +### Maven 설정 +`pom.xml`에 저장소와 의존성을 추가합니다: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### 직접 다운로드 +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/)에서 최신 JAR 파일을 다운로드할 수도 있습니다. + +#### 라이선스 획득 단계 +1. **무료 체험** – 비용 없이 라이브러리를 살펴볼 수 있습니다. +2. **임시 라이선스** – 평가 기간을 연장하기 위한 단기 키를 요청합니다. +3. **구매** – 프로덕션 사용을 위한 정식 라이선스를 획득합니다. + +## 기본 초기화 및 설정 +**문서를 인덱스에 추가**하려면 먼저 인덱스 파일이 저장될 폴더를 가리키는 `Index` 객체를 생성합니다: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +이 코드는 인덱스를 생성(또는 열기)하고 문서를 받을 준비를 합니다. + +## 구현 가이드 +### 문서 생성 및 인덱싱 +#### 인덱스에 문서를 추가하는 방법 +`add` 메서드는 폴더를 스캔하고 각 파일에 대한 검색 가능한 데이터를 저장합니다. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **매개변수:** 인덱싱하려는 파일이 들어 있는 폴더 경로 문자열 +- **목적:** 이 단계가 끝나면 인덱스에 모든 지원 문서 유형의 토큰이 저장되어 빠른 검색이 가능해집니다. + +### 텍스트 쿼리 검색 +#### 텍스트 기반 숫자 범위 검색 수행 방법 +범위를 정의한 간단한 문자열을 사용해 검색할 수 있습니다. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **매개변수:** `"400 ~~ 4000"`이라는 쿼리 문자열은 400에서 4000 사이의 숫자를 찾도록 엔진에 지시합니다. +- **반환값:** `SearchResult`는 일치하는 문서 목록과 하이라이트 정보를 담고 있습니다. + +### 객체 쿼리 검색 +#### 숫자 범위에 대한 객체 쿼리 사용 방법 +객체 기반 쿼리는 검색 조건을 프로그래밍적으로 제어할 수 있게 해줍니다. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **매개변수:** `createNumericRangeQuery`는 시작값과 종료값 정수를 받습니다. +- **목적:** 여러 조건을 결합하거나 동적으로 쿼리를 구성해야 할 때 이상적입니다. + +## 실무 적용 사례 +다음은 **문서를 인덱싱하는 방법**이 큰 변화를 가져올 수 있는 실제 시나리오입니다: + +1. **법률 문서 관리** – 수천 개 계약서에서 조항, 사건 번호, 날짜 등을 빠르게 찾아냅니다. +2. **재무 보고** – 특정 금액 범위에 해당하는 거래 내역을 추출합니다. +3. **재고 추적** – 일련 번호, 배치 코드, SKU 범위 등으로 품목을 검색합니다. + +GroupDocs.Search를 데이터베이스, 클라우드 스토리지, 메시징 큐와 연동하면 문서 워크플로를 더욱 자동화할 수 있습니다. + +## 성능 고려 사항 +- **정기적인 인덱스 업데이트:** 새 파일이 추가될 때마다 `index.add`를 다시 실행해 인덱스를 최신 상태로 유지합니다. +- **리소스 관리:** 힙 사용량을 모니터링하고, 대형 인덱스의 경우 JVM 가비지 컬렉션 설정을 최적화합니다. +- **쿼리 최적화:** 불필요한 스캔을 줄이기 위해 복잡한 필터는 객체 쿼리로 구현합니다. + +## 흔히 발생하는 문제와 해결책 +| Issue | Why It Happens | Fix | +|-------|----------------|-----| +| **Search returns no results** | 인덱스가 생성되지 않았거나 폴더 경로가 잘못됨 | `index.add`가 올바른 디렉터리에서 실행됐는지, 인덱스 폴더에 쓰기 권한이 있는지 확인합니다. | +| **OutOfMemoryError during indexing** | 파일이 너무 크거나 힙이 부족함 | JVM `-Xmx` 값을 늘리거나 파일을 작은 배치로 나누어 인덱싱합니다. | +| **Unsupported file format** | GroupDocs.Search에서 인식하지 못하는 형식 | 파일 확장자가 지원 목록(PDF, DOCX, XLSX 등)에 포함되어 있는지 확인합니다. | + +## 자주 묻는 질문 +**Q: 기존 인덱스에 새 문서를 어떻게 업데이트하나요?** +A: `index.add("NEW_DOCUMENT_PATH")`를 다시 호출하면 라이브러리가 전체 인덱스를 재생성하지 않고 새로운 항목을 병합합니다. + +**Q: GroupDocs.Search가 다양한 파일 형식을 지원하나요?** +A: 예, PDF, Word, Excel, PowerPoint, 일반 텍스트 등 여러 일반 포맷을 지원합니다. + +**Q: GroupDocs.Search 사용을 위한 시스템 요구 사항은?** +A: Java 8+ 런타임, 충분한 RAM(중간 규모 컬렉션 기준 최소 2 GB), 인덱스 폴더에 대한 읽기/쓰기 권한이 필요합니다. + +**Q: 검색 성능 문제를 어떻게 진단하나요?** +A: 인덱스가 최신인지 확인하고, 쿼리 프로파일링을 수행하며, JVM 메모리 설정을 검토합니다. 인덱싱되는 필드 수를 줄이는 것도 속도 향상에 도움이 됩니다. + +**Q: 동의어 검색이나 퍼지 매칭을 사용할 수 있나요?** +A: 예, `SearchOptions` 클래스를 통해 동의어 사전 및 퍼지 검색 옵션을 활성화할 수 있습니다. + +## 결론 +이제 **GroupDocs.Search for Java**를 활용해 **문서를 인덱싱하는 방법**, **문서를 인덱스에 추가하는 방법**, 그리고 텍스트 기반 및 객체 기반 쿼리를 실행하는 방법을 확실히 이해하셨습니다. 이러한 기술을 애플리케이션에 통합하면 어떤 문서 저장소에서도 빠르고 정확한 검색 경험을 제공할 수 있습니다. + +다음 단계가 궁금하신가요? 파싯 검색, 동의어 처리 등을 탐색하거나 인덱스를 REST API와 연동해 다른 서비스에 검색 기능을 노출해 보세요. + +--- + +**Last Updated:** 2026-02-06 +**Tested With:** GroupDocs.Search 25.4 for Java +**Author:** GroupDocs \ No newline at end of file diff --git a/content/polish/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/polish/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..dcdfe2a4 --- /dev/null +++ b/content/polish/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,187 @@ +--- +date: '2026-02-06' +description: Dowiedz się, jak dodać dokumenty do indeksu i włączyć wyszukiwanie uwzględniające + wielkość liter w Javie przy użyciu GroupDocs.Search, zwiększając dokładność swojej + aplikacji. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'Dodaj dokumenty do indeksu: wyszukiwanie w Javie rozróżniające wielkość liter + z GroupDocs' +type: docs +url: /pl/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# Dodawanie dokumentów do indeksu: Opanowanie wyszukiwań rozróżniających wielkość liter w Javie z GroupDocs + +Uzyskanie właściwej informacji z ogromnej kolekcji dokumentów jest kluczowym wymogiem współczesnych aplikacji. W tym przewodniku dowiesz się **jak dodać dokumenty do indeksu** oraz wykonać **wyszukiwania rozróżniające wielkość liter** przy użyciu GroupDocs.Search dla Javy. Niezależnie od tego, czy tworzysz repozytorium dokumentów prawnych, katalog e‑commerce, czy system zarządzania treścią, precyzyjne wyniki wyszukiwania zadowalają użytkowników i zapewniają wiarygodność danych. + +## Szybkie odpowiedzi +- **Jaki jest podstawowy krok, aby rozpocząć wyszukiwanie?** Dodaj dokumenty do indeksu za pomocą `index.add(...)`. +- **Jak włączyć wyszukiwanie rozróżniające wielkość liter?** Ustaw `options.setUseCaseSensitiveSearch(true)`. +- **Czy mogę wyszukiwać w wielu katalogach?** Tak – wywołaj `index.add()` dla każdego folderu, który chcesz uwzględnić. +- **Która metoda pozwala na wyszukiwanie przy użyciu obiektów?** Użyj `SearchQuery.createWordQuery(...)`. +- **Czy potrzebuję licencji do testów?** Dostępna jest tymczasowa licencja do celów próbnych. + +## Co oznacza „dodawanie dokumentów do indeksu”? +Dodawanie dokumentów do indeksu oznacza wprowadzenie Twoich plików źródłowych (PDF, dokumenty Word, zwykły tekst itp.) do GroupDocs.Search, aby mógł zbudować strukturę danych umożliwiającą wyszukiwanie. Po zindeksowaniu silnik może wykonywać szybkie zapytania, w tym rozróżniające wielkość liter. + +## Dlaczego włączyć wyszukiwanie rozróżniające wielkość liter w Javie? +- **Dokładne dopasowanie terminu** – rozróżnia „Apple” (firma) od „apple” (owoc). +- **Zgodność z regulacjami** – niektóre branże wymagają dokładnego dopasowania fraz. +- **Zwiększona trafność** – użytkownicy często oczekują wyników uwzględniających wielkość liter w kontekstach technicznych lub prawnych. + +## Wymagania wstępne +- JDK (zalecane Java 17 lub nowsza) +- Maven do zarządzania zależnościami +- IDE, takie jak IntelliJ IDEA lub Eclipse +- Podstawowa znajomość programowania w Javie + +## Konfiguracja GroupDocs.Search dla Javy +Najpierw dodaj repozytorium GroupDocs oraz zależność do swojego `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Alternatywnie możesz pobrać najnowszą wersję bezpośrednio z [wydania GroupDocs.Search dla Java](https://releases.groupdocs.com/search/java/). + +### Licencjonowanie +Aby rozpocząć wersję próbną, odwiedź stronę GroupDocs i zdobądź tymczasową licencję. Pozwoli to przetestować wszystkie funkcje bez żadnych ograniczeń. + +## Jak dodać dokumenty do indeksu – Wyszukiwanie zapytaniem tekstowym + +### Krok 1: Utwórz indeks i dodaj swoje dokumenty +Utwórz folder, w którym będą przechowywane pliki indeksu, a następnie dodaj katalog źródłowy zawierający dokumenty, które chcesz przeszukiwać. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **Wskazówka:** Możesz wywołać `index.add()` wielokrotnie, aby **wyszukiwać w wielu katalogach** w jednym indeksie. + +### Krok 2: Włącz wyszukiwanie rozróżniające wielkość liter +Skonfiguruj opcje wyszukiwania, aby uwzględniały wielkość liter. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Krok 3: Wykonaj zapytanie tekstowe rozróżniające wielkość liter +Uruchom zapytanie, które rozróżnia „Advantages” od „advantages”. + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Pętla wypisuje pełną ścieżkę każdego dokumentu, który zawiera dokładnie dopasowany pod względem wielkości liter termin. + +## Jak dodać dokumenty do indeksu – Wyszukiwanie zapytaniem obiektowym + +Zapytania obiektowe dają większą elastyczność, szczególnie gdy trzeba połączyć wiele kryteriów. + +### Krok 1: Zainicjuj drugi indeks (opcjonalnie) +Jeśli wolisz trzymać wyszukiwania oparte na obiektach oddzielnie, utwórz kolejny folder indeksu. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Krok 2: Ponownie użyj opcji rozróżniania wielkości liter +Ta sama instancja `SearchOptions` działa również dla zapytań obiektowych. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Krok 3: Zbuduj i uruchom zapytanie obiektowe +Utwórz obiekt zapytania słownego i przekaż go do silnika wyszukiwania. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Użycie `createWordQuery` pozwala później połączyć je z zapytaniami frazowymi, wieloznacznymi lub logicznymi w bardziej złożonych scenariuszach. + +## Praktyczne zastosowania +- **Zarządzanie dokumentami prawnymi:** Pobieraj przepisy specyficzne dla sprawy, gdzie istotna jest wielkość liter. +- **Platformy e‑commerce:** Rozróżniaj SKU produktów, np. „PRO‑X” vs. „pro‑x”. +- **Systemy zarządzania treścią (CMS):** Zapewnij autorom możliwość znajdowania dokładnych nagłówków lub tagów. + +## Uwagi dotyczące wydajności +- **Utrzymuj indeks aktualny** – przeprowadzaj ponowne indeksowanie, gdy dodane zostaną nowe pliki lub istniejące zostaną zmienione. +- **Monitoruj zużycie pamięci** – duże korpusy skorzystają z indeksowania przyrostowego i odpowiedniego przydziału pamięci JVM. +- **Wykorzystaj garbage collector Javy** – zwalniaj obiekty `Index`, gdy nie są już potrzebne. + +## Typowe problemy i rozwiązania +| Issue | Solution | +|-------|----------| +| `useCaseSensitiveSearch` appears ignored | Sprawdź, czy używasz najnowszej wersji GroupDocs.Search oraz czy indeks został przebudowany po zmianie tej opcji. | +| No results returned for a known term | Upewnij się, że wielkość liter terminu jest dokładnie dopasowana oraz że dokument został pomyślnie dodany do indeksu. | +| Searching many folders slows down | Dodawaj każdy folder osobno za pomocą `index.add()` i rozważ podzielenie indeksu na fragmenty (shards) przy bardzo dużych zbiorach danych. | + +## Najczęściej zadawane pytania + +**Q:** Jak radzić sobie z dużymi zestawami danych przy użyciu GroupDocs.Search? +**A:** Wykorzystaj partycjonowanie indeksu, dostosuj ustawienia pamięci JVM oraz okresowo kompaktuj indeks, aby utrzymać optymalną wydajność. + +**Q:** Czy mogę wyszukiwać jednocześnie w wielu katalogach? +**A:** Tak – wywołaj `index.add()` dla każdego katalogu, który chcesz uwzględnić, a następnie uruchom pojedyncze zapytanie przeciwko połączonemu indeksowi. + +**Q:** Jakie są typowe pułapki przy konfigurowaniu wyszukiwań rozróżniających wielkość liter? +**A:** Zapomnienie o przebudowaniu indeksu po włączeniu `useCaseSensitiveSearch` lub użycie niewłaściwej wielkości liter w ciągu zapytania. + +**Q:** Jak mogę rozwiązać problemy z błędami wyszukiwania? +**A:** Sprawdź pliki logów generowane przez GroupDocs.Search pod kątem śladów stosu oraz potwierdź, że wszystkie zależności Maven zostały poprawnie rozwiązane. + +**Q:** Czy GroupDocs.Search jest odpowiedni dla aplikacji czasu rzeczywistego? +**A:** Przy odpowiednich strategiach indeksowania (aktualizacje przyrostowe i buforowanie w pamięci) może dostarczać wyniki wyszukiwania zbliżone do czasu rzeczywistego. + +## Zasoby +- **Dokumentacja:** [Dokumentacja GroupDocs.Search Java](https://docs.groupdocs.com/search/java/) +- **Referencja API:** [Referencja API Java](https://reference.groupdocs.com/search/java) +- **Pobieranie:** [Najnowsze wydania](https://releases.groupdocs.com/search/java/) +- **Repozytorium GitHub:** [GroupDocs.Search dla Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Forum wsparcia:** [Bezpłatne wsparcie GroupDocs](https://forum.groupdocs.com/c/search/10) +- **Tymczasowa licencja:** [Uzyskaj tymczasową licencję](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Ostatnia aktualizacja:** 2026-02-06 +**Testowano z:** GroupDocs.Search 25.4 +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/polish/java/searching/master-document-search-groupdocs-java/_index.md b/content/polish/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..d1d5e16a --- /dev/null +++ b/content/polish/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,183 @@ +--- +date: '2026-02-06' +description: Dowiedz się, jak indeksować dokumenty i dodawać je do indeksu przy użyciu + GroupDocs.Search dla Javy. Twórz potężne aplikacje wyszukiwania z zapytaniami tekstowymi + i obiektowymi. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Jak indeksować dokumenty przy użyciu GroupDocs.Search dla Javy +type: docs +url: /pl/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# Jak indeksować dokumenty przy użyciu GroupDocs.Search dla Javy + +W dzisiejszym świecie napędzanym danymi, **jak indeksować dokumenty** efektywnie jest kluczową umiejętnością dla każdego programisty Javy pracującego z dużymi zbiorami plików. Niezależnie od tego, czy obsługujesz umowy prawne, sprawozdania finansowe, czy wewnętrzne raporty, możliwość szybkiego odnalezienia właściwych informacji może zaoszczędzić godziny ręcznej pracy. W tym samouczku nauczysz się **jak indeksować dokumenty** przy użyciu biblioteki GroupDocs.Search, a następnie wykonać zarówno zapytania tekstowe, jak i oparte na obiektach na utworzonym indeksie. Zaczynajmy! + +## Quick Answers +- **Jaki jest pierwszy krok, aby indeksować dokumenty?** Zainicjalizuj obiekt `Index`, wskazujący na folder, w którym zostanie przechowany indeks. +- **Która metoda dodaje dokumenty do indeksu?** Użyj `index.add("PATH_TO_DOCUMENTS")`. +- **Czy mogę wyszukiwać zakresy liczbowe?** Tak, za pomocą zapytania tekstowego takiego jak `"400 ~~ 4000"` lub zapytania obiektowego poprzez `SearchQuery.createNumericRangeQuery`. +- **Czy potrzebna jest licencja?** Dostępna jest darmowa wersja próbna; licencja komercyjna odblokowuje pełne funkcje. +- **Jaka wersja Javy jest wymagana?** JDK 8 lub wyższa. + +## Co oznacza „jak indeksować dokumenty” w GroupDocs.Search? +Indeksowanie dokumentów oznacza skanowanie zawartości plików w folderze i przechowywanie tokenów możliwych do przeszukania w dedykowanym folderze indeksu. Ten krok wstępnego przetwarzania umożliwia błyskawiczne wyszukiwania później, ponieważ biblioteka przeszukuje przygotowany indeks, a nie surowe pliki przy każdym zapytaniu. + +## Dlaczego warto używać GroupDocs.Search dla Javy? +- **Wydajność:** Wyszukiwania trwają milisekundy nawet przy tysiącach plików. +- **Obsługa formatów:** Obsługuje PDF‑y, Word, Excel, PowerPoint i wiele innych. +- **Elastyczność:** Obsługuje zapytania tekstowe, zakresy liczbowe i złożone zapytania obiektowe. +- **Skalowalność:** Łatwo aktualizować indeks, dodając nowe dokumenty bez konieczności przebudowy od początku. + +## Prerequisites +- Maven zainstalowany do zarządzania zależnościami. +- IDE, takie jak IntelliJ IDEA lub Eclipse. +- Podstawowa znajomość Javy (koncepcje OOP, obsługa wyjątków). + +## Setting Up GroupDocs.Search for Java +### Maven Setup +Add the repository and dependency to your `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Direct Download +Możesz również pobrać najnowszy plik JAR z [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +#### License Acquisition Steps +1. **Free Trial** – przetestuj bibliotekę bez kosztów. +2. **Temporary License** – poproś o krótkoterminowy klucz do rozszerzonej oceny. +3. **Purchase** – uzyskaj pełną licencję do użytku produkcyjnego. + +## Basic Initialization and Setup +Aby **dodać dokumenty do indeksu**, najpierw tworzysz obiekt `Index`, który wskazuje na folder, w którym będą przechowywane pliki indeksu: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +Ta linia tworzy (lub otwiera) indeks gotowy do przyjmowania dokumentów. + +## Implementation Guide +### Creating and Indexing Documents +#### How to add documents to index +Metoda `add` skanuje folder i przechowuje dane możliwe do przeszukania dla każdego pliku. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Parametry:** Ciąg ścieżki wskazuje na folder zawierający pliki, które chcesz zindeksować. +- **Cel:** Po tym kroku indeks zawiera tokeny ze wszystkich obsługiwanych typów dokumentów, umożliwiając szybkie wyszukiwania. + +### Text Query Search +#### How to perform a text‑based numeric range search +Możesz wyszukiwać używając prostego ciągu definiującego zakres. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Parametry:** Ciąg zapytania `"400 ~~ 4000"` instruuje silnik, aby znalazł liczby pomiędzy 400 a 4000. +- **Wartość zwracana:** `SearchResult` zawiera listę pasujących dokumentów i podświetlenia. + +### Object Query Search +#### How to use an object query for numeric ranges +Zapytania oparte na obiektach dają programistyczną kontrolę nad kryteriami wyszukiwania. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Parametry:** `createNumericRangeQuery` przyjmuje liczby całkowite określające początek i koniec. +- **Cel:** Ta metoda jest idealna, gdy potrzebujesz połączyć wiele warunków lub budować zapytania dynamicznie. + +## Practical Applications +Oto kilka rzeczywistych scenariuszy, w których **jak indeksować dokumenty** staje się przełomowe: + +1. **Zarządzanie dokumentami prawnymi** – znajdź klauzule, numery spraw lub daty w tysiącach umów. +2. **Raportowanie finansowe** – wyciągnij transakcje mieszczące się w określonym przedziale kwotowym. +3. **Śledzenie zapasów** – znajdź pozycje według numerów seryjnych, kodów partii lub zakresów SKU. + +Integracja GroupDocs.Search z bazami danych, przechowywaniem w chmurze lub kolejkami wiadomości może dodatkowo zautomatyzować przepływy pracy z dokumentami. + +## Performance Considerations +- **Regularne aktualizacje indeksu:** Ponownie uruchom `index.add` dla nowych plików, aby utrzymać indeks aktualny. +- **Zarządzanie zasobami:** Monitoruj zużycie pamięci heap; duże indeksy korzystają z dostosowanych ustawień garbage‑collection JVM. +- **Optymalizacja zapytań:** Używaj zapytań obiektowych dla złożonych filtrów, aby zmniejszyć niepotrzebne skanowanie. + +## Common Issues and Solutions +| Problem | Dlaczego się pojawia | Rozwiązanie | +|-------|----------------|-----| +| **Wyszukiwanie nie zwraca wyników** | Indeks nie został zbudowany lub ścieżka folderu jest nieprawidłowa | Zweryfikuj, czy `index.add` został wykonany w prawidłowym katalogu i czy folder indeksu jest zapisywalny. | +| **OutOfMemoryError podczas indeksowania** | Bardzo duże pliki lub niewystarczająca pamięć heap | Zwiększ wartość JVM `-Xmx` lub indeksuj pliki w mniejszych partiach. | +| **Nieobsługiwany format pliku** | Typ pliku nie jest rozpoznawany przez GroupDocs.Search | Upewnij się, że rozszerzenie pliku znajduje się na liście obsługiwanych (PDF, DOCX, XLSX, itp.). | + +## Frequently Asked Questions +**P: Jak zaktualizować istniejący indeks nowymi dokumentami?** +O: Wywołaj ponownie `index.add("NEW_DOCUMENT_PATH")`; biblioteka łączy nowe wpisy bez ponownego tworzenia całego indeksu. + +**P: Czy GroupDocs.Search obsługuje różne formaty plików?** +O: Tak, obsługuje PDF‑y, Word, Excel, PowerPoint, tekst zwykły i wiele innych popularnych formatów. + +**P: Jakie są wymagania systemowe dla używania GroupDocs.Search?** +O: Środowisko uruchomieniowe Java 8+, wystarczająca ilość RAM (co najmniej 2 GB dla umiarkowanych zbiorów) oraz dostęp odczytu/zapisu do folderu indeksu. + +**P: Jak mogę rozwiązać problemy z wydajnością wyszukiwania?** +O: Upewnij się, że indeks jest aktualny, profiluj zapytania i sprawdź ustawienia pamięci JVM. Zmniejszenie liczby indeksowanych pól może również przyspieszyć działanie. + +**P: Czy istnieje możliwość wyszukiwania z użyciem synonimów lub dopasowania przybliżonego?** +O: Tak, GroupDocs.Search udostępnia słowniki synonimów oraz opcje wyszukiwania przybliżonego, które można włączyć za pomocą klasy `SearchOptions`. + +## Conclusion +Masz już solidne zrozumienie **jak indeksować dokumenty** przy użyciu GroupDocs.Search dla Javy, jak **dodać dokumenty do indeksu** oraz jak uruchamiać zarówno zapytania tekstowe, jak i oparte na obiektach. Integrując te techniki, Twoje aplikacje Java zapewnią szybkie i dokładne doświadczenia wyszukiwania w dowolnym repozytorium dokumentów. + +Gotowy na kolejny krok? Zbadaj wyszukiwanie fasetowe, obsługę synonimów lub zintegrować indeks z API REST, aby udostępnić możliwości wyszukiwania innym usługom. + +--- + +**Ostatnia aktualizacja:** 2026-02-06 +**Testowano z:** GroupDocs.Search 25.4 for Java +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/portuguese/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/portuguese/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..7218ae5f --- /dev/null +++ b/content/portuguese/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,187 @@ +--- +date: '2026-02-06' +description: Aprenda como adicionar documentos ao índice e habilitar a pesquisa sensível + a maiúsculas e minúsculas em Java com o GroupDocs.Search, aumentando a precisão + da sua aplicação. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'Adicionar documentos ao índice: pesquisa Java sensível a maiúsculas e minúsculas + com GroupDocs' +type: docs +url: /pt/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# Adicionar documentos ao índice: Dominando buscas sensíveis a maiúsculas e minúsculas em Java com GroupDocs + +Recuperar a informação correta de uma enorme coleção de documentos é um requisito essencial para aplicações modernas. Neste guia, você aprenderá **como adicionar documentos ao índice** e executar **buscas sensíveis a maiúsculas e minúsculas** usando GroupDocs.Search para Java. Seja construindo um repositório de documentos legais, um catálogo de e‑commerce ou um sistema de gerenciamento de conteúdo, resultados de busca precisos mantêm os usuários satisfeitos e seus dados confiáveis. + +## Respostas rápidas +- **Qual é a etapa principal para começar a buscar?** Adicionar documentos a um índice com `index.add(...)`. +- **Como habilitar a busca sensível a maiúsculas e minúsculas?** Definir `options.setUseCaseSensitiveSearch(true)`. +- **Posso buscar em vários diretórios?** Sim – chame `index.add()` para cada pasta que desejar incluir. +- **Qual método permite buscar com objetos?** Use `SearchQuery.createWordQuery(...)`. +- **Preciso de licença para testes?** Uma licença temporária está disponível para fins de avaliação. + +## O que significa “adicionar documentos ao índice”? +Adicionar documentos ao índice significa alimentar seus arquivos de origem (PDFs, documentos Word, texto simples etc.) ao GroupDocs.Search para que ele possa construir uma estrutura de dados pesquisável. Uma vez indexado, o mecanismo pode executar consultas rápidas, inclusive sensíveis a maiúsculas e minúsculas. + +## Por que habilitar busca sensível a maiúsculas e minúsculas em Java? +- **Correspondência exata de termos** – diferenciar “Apple” (a empresa) de “apple” (a fruta). +- **Conformidade regulatória** – alguns setores exigem correspondência exata de frases. +- **Relevância aprimorada** – usuários frequentemente esperam resultados específicos de caixa em contextos técnicos ou jurídicos. + +## Pré‑requisitos +- JDK (Java 17 ou superior recomendado) +- Maven para gerenciamento de dependências +- Uma IDE como IntelliJ IDEA ou Eclipse +- Familiaridade básica com programação Java + +## Configurando GroupDocs.Search para Java +Primeiro, adicione o repositório GroupDocs e a dependência ao seu `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Alternativamente, você pode baixar a versão mais recente diretamente em [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Licenciamento +Para começar com uma avaliação, visite o GroupDocs para adquirir uma licença temporária. Isso permitirá que você teste todos os recursos sem limitações. + +## Como adicionar documentos ao índice – Busca por Consulta de Texto + +### Etapa 1: Criar um índice e adicionar seus documentos +Crie uma pasta onde os arquivos de índice serão armazenados e, em seguida, adicione o diretório de origem que contém os documentos que você deseja buscar. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **Dica profissional:** Você pode chamar `index.add()` várias vezes para **buscar em vários diretórios** em um único índice. + +### Etapa 2: Habilitar busca sensível a maiúsculas e minúsculas +Configure as opções de busca para respeitar a capitalização das letras. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Etapa 3: Executar uma consulta de texto sensível a maiúsculas e minúsculas +Execute uma consulta que diferencia “Advantages” de “advantages”. + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +O loop imprime o caminho completo de cada documento que contém o termo exatamente com a caixa correspondente. + +## Como adicionar documentos ao índice – Busca por Consulta de Objeto + +Consultas de objeto oferecem mais flexibilidade, especialmente quando você precisa combinar múltiplos critérios. + +### Etapa 1: Inicializar um segundo índice (opcional) +Se preferir manter as buscas baseadas em objeto separadas, crie outra pasta de índice. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Etapa 2: Reutilizar a opção sensível a maiúsculas e minúsculas +A mesma instância de `SearchOptions` funciona para consultas de objeto. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Etapa 3: Construir e executar uma consulta de objeto +Crie um objeto de consulta de palavra e passe‑o ao mecanismo de busca. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Usar `createWordQuery` permite que você combine posteriormente com consultas de frase, curinga ou Booleanas para cenários mais complexos. + +## Aplicações práticas +- **Gerenciamento de documentos jurídicos:** Recuperar estatutos específicos onde a capitalização importa. +- **Plataformas de e‑commerce:** Diferenciar SKUs de produtos como “PRO‑X” vs. “pro‑x”. +- **Sistemas de gerenciamento de conteúdo (CMS):** Garantir que autores encontrem exatamente títulos ou tags. + +## Considerações de desempenho +- **Mantenha o índice atualizado** – reindexe quando novos arquivos forem adicionados ou os existentes forem alterados. +- **Monitore o uso de memória** – corpora grandes se beneficiam de indexação incremental e dimensionamento adequado do heap da JVM. +- **Aproveite o coletor de lixo do Java** – libere objetos `Index` quando não forem mais necessários. + +## Problemas comuns e soluções +| Problema | Solução | +|----------|---------| +| `useCaseSensitiveSearch` parece ignorado | Verifique se está usando a versão mais recente do GroupDocs.Search e se o índice foi reconstruído após alterar a opção. | +| Nenhum resultado retornado para um termo conhecido | Certifique‑se de que o caso do termo corresponde exatamente e de que o documento foi adicionado ao índice com sucesso. | +| Busca em muitas pastas deixa o processo lento | Adicione cada pasta individualmente com `index.add()` e considere dividir o índice em shards para conjuntos de dados muito grandes. | + +## Perguntas frequentes + +**P:** Como lidar com grandes volumes de dados usando GroupDocs.Search? +**R:** Utilize particionamento de índice, ajuste as configurações de memória da JVM e compacte periodicamente o índice para manter o desempenho ideal. + +**P:** Posso buscar em vários diretórios simultaneamente? +**R:** Sim – chame `index.add()` para cada diretório que desejar incluir, depois execute uma única consulta contra o índice combinado. + +**P:** Quais são as armadilhas comuns ao configurar buscas sensíveis a maiúsculas e minúsculas? +**R:** Esquecer de reconstruir o índice após habilitar `useCaseSensitiveSearch` ou usar o caso errado na string de consulta. + +**P:** Como posso diagnosticar erros de busca? +**R:** Verifique os arquivos de log gerados pelo GroupDocs.Search para rastreamentos de pilha e confirme que todas as dependências Maven foram resolvidas corretamente. + +**P:** O GroupDocs.Search é adequado para aplicações em tempo real? +**R:** Com estratégias adequadas de indexação (atualizações incrementais e cache em memória), ele pode fornecer resultados de busca quase em tempo real. + +## Recursos +- **Documentação:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **Referência de API:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **Download:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **Repositório GitHub:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Fórum de suporte:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Licença temporária:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Última atualização:** 2026-02-06 +**Testado com:** GroupDocs.Search 25.4 +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/portuguese/java/searching/master-document-search-groupdocs-java/_index.md b/content/portuguese/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..2a123b6a --- /dev/null +++ b/content/portuguese/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,183 @@ +--- +date: '2026-02-06' +description: Aprenda como indexar documentos e adicionar documentos ao índice usando + o GroupDocs.Search para Java. Crie aplicativos de busca poderosos com consultas + de texto e de objeto. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Como indexar documentos com o GroupDocs.Search para Java +type: docs +url: /pt/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# Como Indexar Documentos com GroupDocs.Search para Java + +No mundo atual orientado por dados, **como indexar documentos** de forma eficiente é uma habilidade crítica para qualquer desenvolvedor Java que lide com grandes coleções de arquivos. Seja lidando com contratos legais, demonstrações financeiras ou relatórios internos, ser capaz de localizar rapidamente a informação correta pode economizar horas de trabalho manual. Neste tutorial você aprenderá **como indexar documentos** usando a biblioteca GroupDocs.Search e, em seguida, executar consultas baseadas em texto e em objetos no índice criado. Vamos começar! + +## Respostas Rápidas +- **Qual é o primeiro passo para indexar documentos?** Inicializar um objeto `Index` apontando para uma pasta onde o índice será armazenado. +- **Qual método adiciona documentos a um índice?** Use `index.add("PATH_TO_DOCUMENTS")`. +- **Posso pesquisar intervalos numéricos?** Sim, com uma consulta de texto como `"400 ~~ 4000"` ou uma consulta de objeto via `SearchQuery.createNumericRangeQuery`. +- **Preciso de licença?** Um teste gratuito está disponível; uma licença comercial desbloqueia todos os recursos. +- **Qual versão do Java é necessária?** JDK 8 ou superior. + +## O que é “como indexar documentos” com GroupDocs.Search? +Indexar documentos significa analisar o conteúdo dos arquivos em uma pasta e armazenar tokens pesquisáveis em uma pasta de índice dedicada. Essa etapa de pré‑processamento permite buscas ultrarrápidas posteriormente, pois a biblioteca pesquisa o índice preparado em vez dos arquivos brutos a cada vez. + +## Por que usar GroupDocs.Search para Java? +- **Desempenho:** As buscas são realizadas em milissegundos mesmo em milhares de arquivos. +- **Suporte a formatos:** Lida com PDFs, Word, Excel, PowerPoint e muitos outros. +- **Flexibilidade:** Suporta consultas de texto simples, intervalos numéricos e consultas complexas de objetos. +- **Escalabilidade:** Atualize facilmente o índice adicionando novos documentos sem reconstruir do zero. + +## Pré‑requisitos +- Maven instalado para gerenciamento de dependências. +- Uma IDE como IntelliJ IDEA ou Eclipse. +- Conhecimento básico de Java (conceitos de OOP, tratamento de exceções). + +## Configurando GroupDocs.Search para Java +### Configuração Maven +Adicione o repositório e a dependência ao seu `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Download Direto +Você também pode baixar o JAR mais recente em [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +#### Etapas para Aquisição de Licença +1. **Teste Gratuito** – explore a biblioteca sem custo. +2. **Licença Temporária** – solicite uma chave de curto prazo para avaliação estendida. +3. **Compra** – obtenha uma licença completa para uso em produção. + +## Inicialização e Configuração Básicas +Para **adicionar documentos ao índice**, primeiro crie um objeto `Index` que aponta para a pasta onde os arquivos de índice serão armazenados: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +Esta linha cria (ou abre) um índice pronto para receber documentos. + +## Guia de Implementação +### Criando e Indexando Documentos +#### Como adicionar documentos ao índice +O método `add` varre uma pasta e armazena os dados pesquisáveis de cada arquivo. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Parâmetros:** A string de caminho aponta para a pasta que contém os arquivos que você deseja indexar. +- **Objetivo:** Após esta etapa, o índice contém tokens de todos os tipos de documento suportados, permitindo buscas rápidas. + +### Busca por Consulta de Texto +#### Como executar uma busca de intervalo numérico baseada em texto +Você pode pesquisar usando uma string simples que define um intervalo. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Parâmetros:** A string de consulta `"400 ~~ 4000"` indica ao mecanismo que encontre números entre 400 e 4000. +- **Valor de Retorno:** `SearchResult` contém a lista de documentos correspondentes e os destaques. + +### Busca por Consulta de Objeto +#### Como usar uma consulta de objeto para intervalos numéricos +Consultas baseadas em objeto dão controle programático sobre os critérios de busca. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Parâmetros:** `createNumericRangeQuery` recebe os inteiros de início e fim. +- **Objetivo:** Este método é ideal quando você precisa combinar múltiplas condições ou construir consultas dinamicamente. + +## Aplicações Práticas +Aqui estão alguns cenários reais onde **como indexar documentos** se torna um diferencial: + +1. **Gerenciamento de Documentos Legais** – localize cláusulas, números de processos ou datas em milhares de contratos. +2. **Relatórios Financeiros** – extraia transações que estejam dentro de um intervalo monetário específico. +3. **Rastreamento de Inventário** – encontre itens por números de série, códigos de lote ou intervalos de SKU. + +Integrar o GroupDocs.Search com bancos de dados, armazenamento em nuvem ou filas de mensagens pode automatizar ainda mais os fluxos de trabalho de documentos. + +## Considerações de Desempenho +- **Atualizações Regulares do Índice:** Re‑execute `index.add` para novos arquivos a fim de manter o índice atualizado. +- **Gerenciamento de Recursos:** Monitore o uso de heap; índices grandes se beneficiam de configurações otimizadas de coleta de lixo da JVM. +- **Otimização de Consultas:** Use consultas de objeto para filtros complexos e reduza a varredura desnecessária. + +## Problemas Comuns e Soluções +| Problema | Por que acontece | Solução | +|----------|------------------|---------| +| **A busca não retorna resultados** | Índice não foi construído ou caminho da pasta está incorreto | Verifique se `index.add` foi executado no diretório correto e se a pasta do índice tem permissão de escrita. | +| **OutOfMemoryError durante a indexação** | Arquivos muito grandes ou heap insuficiente | Aumente o valor `-Xmx` da JVM ou indexe arquivos em lotes menores. | +| **Formato de arquivo não suportado** | Tipo de arquivo não reconhecido pelo GroupDocs.Search | Certifique‑se de que a extensão do arquivo está entre as suportadas (PDF, DOCX, XLSX, etc.). | + +## Perguntas Frequentes +**P: Como atualizo um índice existente com novos documentos?** +R: Chame `index.add("NEW_DOCUMENT_PATH")` novamente; a biblioteca mescla as novas entradas sem recriar todo o índice. + +**P: O GroupDocs.Search consegue lidar com diferentes formatos de arquivo?** +R: Sim, ele suporta PDFs, Word, Excel, PowerPoint, texto simples e muitos outros formatos comuns. + +**P: Quais são os requisitos de sistema para usar o GroupDocs.Search?** +R: Runtime Java 8+, RAM suficiente (pelo menos 2 GB para coleções moderadas) e acesso de leitura/escrita à pasta do índice. + +**P: Como posso diagnosticar problemas de desempenho na busca?** +R: Garanta que o índice esteja atualizado, profile suas consultas e revise as configurações de memória da JVM. Reduzir o número de campos indexados também pode melhorar a velocidade. + +**P: Existe forma de buscar com sinônimos ou correspondência aproximada?** +R: Sim, o GroupDocs.Search oferece dicionários de sinônimos e opções de busca fuzzy que podem ser habilitadas via a classe `SearchOptions`. + +## Conclusão +Agora você tem uma compreensão sólida de **como indexar documentos** usando o GroupDocs.Search para Java, como **adicionar documentos ao índice** e como executar consultas tanto baseadas em texto quanto em objetos. Ao integrar essas técnicas, suas aplicações Java oferecerão experiências de busca rápidas e precisas em qualquer repositório de documentos. + +Pronto para o próximo passo? Explore buscas facetadas, tratamento de sinônimos ou integre o índice a uma API REST para expor capacidades de busca a outros serviços. + +--- + +**Última atualização:** 2026-02-06 +**Testado com:** GroupDocs.Search 25.4 for Java +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/russian/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/russian/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..c1f28d17 --- /dev/null +++ b/content/russian/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,187 @@ +--- +date: '2026-02-06' +description: Узнайте, как добавить документы в индекс и включить регистрозависимый + поиск в Java с помощью GroupDocs.Search, повышая точность вашего приложения. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'Добавить документы в индекс: чувствительный к регистру поиск Java с GroupDocs' +type: docs +url: /ru/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# Добавление документов в индекс: Мастерство поиска с учётом регистра в Java с GroupDocs + +Получение нужной информации из огромной коллекции документов является основной потребностью современных приложений. В этом руководстве вы узнаете **как добавить документы в индекс** и выполнять **поиск с учётом регистра** с помощью GroupDocs.Search для Java. Независимо от того, создаёте ли вы репозиторий юридических документов, каталог электронной коммерции или систему управления контентом, точные результаты поиска делают пользователей довольными, а ваши данные надёжными. + +## Быстрые ответы +- **Какой основной шаг для начала поиска?** Добавьте документы в индекс с помощью `index.add(...)`. +- **Как включить поиск с учётом регистра?** Установите `options.setUseCaseSensitiveSearch(true)`. +- **Можно ли искать по нескольким каталогам?** Да — вызывайте `index.add()` для каждой папки, которую хотите включить. +- **Какой метод позволяет искать с объектами?** Используйте `SearchQuery.createWordQuery(...)`. +- **Нужна ли лицензия для тестирования?** Доступна временная лицензия для пробного использования. + +## Что означает «добавление документов в индекс»? +Добавление документов в индекс означает загрузку ваших исходных файлов (PDF, документы Word, обычный текст и т.д.) в GroupDocs.Search, чтобы он мог построить структуру данных, пригодную для поиска. После индексации движок может выполнять быстрые запросы, включая запросы с учётом регистра. + +## Почему включать поиск с учётом регистра в Java? +- **Точное совпадение терминов** — различать «Apple» (компания) и «apple» (фрукт). +- **Соответствие нормативным требованиям** — некоторые отрасли требуют точного совпадения фраз. +- **Повышенная релевантность** — пользователи часто ожидают результаты с учётом регистра в технических или юридических контекстах. + +## Требования +- JDK (рекомендуется Java 17 или новее) +- Maven для управления зависимостями +- IDE, например IntelliJ IDEA или Eclipse +- Базовые знания программирования на Java + +## Настройка GroupDocs.Search для Java +Сначала добавьте репозиторий GroupDocs и зависимость в ваш `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +В качестве альтернативы вы можете загрузить последнюю версию напрямую с [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Лицензирование +Чтобы начать работу с пробной версией, посетите GroupDocs и получите временную лицензию. Это позволит вам протестировать все функции без ограничений. + +## Как добавить документы в индекс — Поиск текстовым запросом + +### Шаг 1: Создайте индекс и добавьте свои документы +Создайте папку, в которой будут храниться файлы индекса, затем добавьте исходный каталог, содержащий документы, которые вы хотите искать. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **Совет:** Вы можете вызывать `index.add()` несколько раз, чтобы **искать по нескольким каталогам** в одном индексе. + +### Шаг 2: Включите поиск с учётом регистра +Настройте параметры поиска, чтобы учитывать регистр букв. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Шаг 3: Выполните текстовый запрос с учётом регистра +Выполните запрос, который различает «Advantages» и «advantages». + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Цикл выводит полный путь к каждому документу, содержащему точный термин с учётом регистра. + +## Как добавить документы в индекс — Поиск объектным запросом + +Объектные запросы предоставляют большую гибкость, особенно когда необходимо комбинировать несколько критериев. + +### Шаг 1: Инициализируйте второй индекс (по желанию) +Если вы предпочитаете держать объектные поиски отдельно, создайте другую папку для индекса. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Шаг 2: Повторно используйте параметр поиска с учётом регистра +Тот же экземпляр `SearchOptions` работает и для объектных запросов. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Шаг 3: Постройте и выполните объектный запрос +Создайте объект word query и передайте его в поисковый движок. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Использование `createWordQuery` позволяет позже комбинировать его с запросами фраз, подстановочных знаков или булевыми запросами для более сложных сценариев. + +## Практические применения +- **Управление юридическими документами:** Получайте нормативные акты, где важен регистр. +- **Платформы электронной коммерции:** Различайте артикулы продуктов, например «PRO‑X» и «pro‑x». +- **Системы управления контентом (CMS):** Обеспечьте авторам поиск точных заголовков или тегов. + +## Соображения по производительности +- **Поддерживайте индекс в актуальном состоянии** — переиндексируйте при добавлении новых файлов или изменении существующих. +- **Следите за использованием памяти** — большие корпуса выигрывают от инкрементной индексации и правильного размера кучи JVM. +- **Используйте сборщик мусора Java** — освобождайте объекты `Index`, когда они больше не нужны. + +## Распространённые проблемы и решения +| Проблема | Решение | +|----------|---------| +| `useCaseSensitiveSearch` кажется игнорируется | Убедитесь, что вы используете последнюю версию GroupDocs.Search и что индекс был перестроен после изменения параметра. | +| Не возвращаются результаты для известного термина | Убедитесь, что регистр термина точно совпадает и что документ был успешно добавлен в индекс. | +| Поиск по многим папкам замедляется | Добавляйте каждую папку отдельно с помощью `index.add()` и рассмотрите возможность разделения индекса на шарды для очень больших наборов данных. | + +## Часто задаваемые вопросы + +**В:** Как работать с большими наборами данных в GroupDocs.Search? +**О:** Используйте разбиение индекса, настройте параметры памяти JVM и периодически компактируйте индекс для поддержания оптимальной производительности. + +**В:** Можно ли искать одновременно по нескольким каталогам? +**О:** Да — вызывайте `index.add()` для каждого каталога, который хотите включить, затем выполните один запрос к объединённому индексу. + +**В:** Какие типичные подводные камни при настройке поиска с учётом регистра? +**О:** Забвение перестроить индекс после включения `useCaseSensitiveSearch` или использование неверного регистра в строке запроса. + +**В:** Как отлаживать ошибки поиска? +**О:** Проверьте файлы журналов, генерируемые GroupDocs.Search, на наличие трассировок стека и убедитесь, что все зависимости Maven корректно разрешены. + +**В:** Подходит ли GroupDocs.Search для приложений в реальном времени? +**О:** При правильных стратегиях индексации (инкрементные обновления и кэширование в памяти) он может предоставлять почти мгновенные результаты поиска. + +## Ресурсы +- **Документация:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **Справочник API:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **Скачать:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **Репозиторий GitHub:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Форум поддержки:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Временная лицензия:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Последнее обновление:** 2026-02-06 +**Тестировано с:** GroupDocs.Search 25.4 +**Автор:** GroupDocs + +--- \ No newline at end of file diff --git a/content/russian/java/searching/master-document-search-groupdocs-java/_index.md b/content/russian/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..8f33729c --- /dev/null +++ b/content/russian/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,183 @@ +--- +date: '2026-02-06' +description: Узнайте, как индексировать документы и добавлять их в индекс с помощью + GroupDocs.Search для Java. Создавайте мощные поисковые приложения с текстовыми и + объектными запросами. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Как индексировать документы с помощью GroupDocs.Search для Java +type: docs +url: /ru/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# Как индексировать документы с помощью GroupDocs.Search для Java + +В современном мире, ориентированном на данные, **как индексировать документы** эффективно — это критически важный навык для любого Java‑разработчика, работающего с большими коллекциями файлов. Независимо от того, обрабатываете ли вы юридические контракты, финансовые отчёты или внутренние доклады, возможность быстро находить нужную информацию может сэкономить часы ручной работы. В этом руководстве вы узнаете **как индексировать документы** с помощью библиотеки GroupDocs.Search, а затем выполните как текстовые, так и объектные запросы к созданному индексу. Давайте начнём! + +## Быстрые ответы +- **Какой первый шаг для индексирования документов?** Инициализировать объект `Index`, указывающий папку, где будет храниться индекс. +- **Какой метод добавляет документы в индекс?** Использовать `index.add("PATH_TO_DOCUMENTS")`. +- **Можно ли искать числовые диапазоны?** Да, с помощью текстового запроса вроде `"400 ~~ 4000"` или объектного запроса через `SearchQuery.createNumericRangeQuery`. +- **Нужна ли лицензия?** Доступна бесплатная пробная версия; коммерческая лицензия открывает полный набор функций. +- **Какая версия Java требуется?** JDK 8 или выше. + +## Что означает «как индексировать документы» с GroupDocs.Search? +Индексация документов означает сканирование содержимого файлов в папке и сохранение поисковых токенов в отдельной папке индекса. Этот предварительный шаг обеспечивает молниеносный поиск позже, поскольку библиотека ищет в подготовленном индексе, а не в исходных файлах каждый раз. + +## Почему использовать GroupDocs.Search для Java? +- **Производительность:** Поиск выполняется за миллисекунды даже на тысячах файлов. +- **Поддержка форматов:** Обрабатывает PDF, Word, Excel, PowerPoint и многие другие. +- **Гибкость:** Поддерживает запросы простого текста, числовые диапазоны и сложные объектные запросы. +- **Масштабируемость:** Легко обновлять индекс, добавляя новые документы без полного пересоздания. + +## Предварительные требования +- Maven установлен для управления зависимостями. +- IDE, например IntelliJ IDEA или Eclipse. +- Базовые знания Java (концепции ООП, обработка исключений). + +## Настройка GroupDocs.Search для Java +### Настройка Maven +Добавьте репозиторий и зависимость в ваш `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Прямое скачивание +Вы также можете скачать последнюю JAR‑файл с [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +#### Шаги получения лицензии +1. **Бесплатная пробная версия** – изучите библиотеку без затрат. +2. **Временная лицензия** – запросите краткосрочный ключ для расширенной оценки. +3. **Покупка** – получите полную лицензию для использования в продакшене. + +## Базовая инициализация и настройка +Чтобы **добавить документы в индекс**, сначала создайте объект `Index`, указывающий папку, где будут храниться файлы индекса: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +Эта строка создаёт (или открывает) индекс, готовый принимать документы. + +## Руководство по реализации +### Создание и индексация документов +#### Как добавить документы в индекс +Метод `add` сканирует папку и сохраняет поисковые данные для каждого файла. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Параметры:** Строка пути указывает на папку, содержащую файлы, которые вы хотите индексировать. +- **Назначение:** После этого шага индекс содержит токены из всех поддерживаемых типов документов, обеспечивая быстрый поиск. + +### Поиск текстовым запросом +#### Как выполнить поиск числового диапазона текстовым запросом +Вы можете искать, используя простую строку, определяющую диапазон. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Параметры:** Строка запроса `"400 ~~ 4000"` указывает движку находить числа от 400 до 4000. +- **Возвращаемое значение:** `SearchResult` содержит список подходящих документов и подсветки. + +### Поиск объектным запросом +#### Как использовать объектный запрос для числовых диапазонов +Объектные запросы предоставляют программный контроль над критериями поиска. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Параметры:** `createNumericRangeQuery` получает начальное и конечное целые числа. +- **Назначение:** Этот метод идеален, когда необходимо комбинировать несколько условий или динамически строить запросы. + +## Практические применения +Вот несколько реальных сценариев, где **как индексировать документы** становится решающим фактором: + +1. **Управление юридическими документами** – поиск пунктов, номеров дел или дат в тысячах контрактов. +2. **Финансовая отчётность** – извлечение транзакций, попадающих в определённый денежный диапазон. +3. **Отслеживание инвентаря** – поиск товаров по серийным номерам, партиям или диапазонам SKU. + +Интеграция GroupDocs.Search с базами данных, облачным хранилищем или очередями сообщений может дополнительно автоматизировать рабочие процессы с документами. + +## Соображения по производительности +- **Регулярные обновления индекса:** Повторно выполнить `index.add` для новых файлов, чтобы поддерживать актуальность индекса. +- **Управление ресурсами:** Следите за использованием кучи; большие индексы выигрывают от настроек сборки мусора JVM. +- **Оптимизация запросов:** Используйте объектные запросы для сложных фильтров, чтобы уменьшить ненужное сканирование. + +## Распространённые проблемы и решения +| Проблема | Причина | Решение | +|----------|----------|----------| +| **Search returns no results** | Индекс не построен или путь к папке неверен | Проверьте, что `index.add` выполнен в правильном каталоге и что папка индекса доступна для записи. | +| **OutOfMemoryError during indexing** | Очень большие файлы или недостаточно памяти кучи | Увеличьте значение JVM `-Xmx` или индексируйте файлы небольшими партиями. | +| **Unsupported file format** | Тип файла не распознан GroupDocs.Search | Убедитесь, что расширение файла входит в список поддерживаемых (PDF, DOCX, XLSX и т.д.). | + +## Часто задаваемые вопросы +**В: Как обновить существующий индекс новыми документами?** +**О:** Вызовите `index.add("NEW_DOCUMENT_PATH")` ещё раз; библиотека объединяет новые записи без пересоздания всего индекса. + +**В: Может ли GroupDocs.Search работать с разными форматами файлов?** +**О:** Да, поддерживает PDF, Word, Excel, PowerPoint, обычный текст и многие другие распространённые форматы. + +**В: Каковы системные требования для использования GroupDocs.Search?** +**О:** Среда выполнения Java 8+, достаточный объём ОЗУ (не менее 2 ГБ для умеренных коллекций) и доступ на чтение/запись к папке индекса. + +**В: Как решить проблемы с производительностью поиска?** +**О:** Убедитесь, что индекс актуален, профилируйте запросы и проверьте настройки памяти JVM. Сокращение количества проиндексированных полей также может повысить скорость. + +**В: Есть ли возможность искать с использованием синонимов или нечеткого поиска?** +**О:** Да, GroupDocs.Search предоставляет словари синонимов и опции нечеткого поиска, которые можно включить через класс `SearchOptions`. + +## Заключение +Теперь у вас есть прочное понимание **как индексировать документы** с помощью GroupDocs.Search для Java, как **добавлять документы в индекс** и как выполнять как текстовые, так и объектные запросы. Интегрируя эти техники, ваши Java‑приложения будут предоставлять быстрый и точный поиск в любой репозитории документов. + +Готовы к следующему шагу? Исследуйте фасетный поиск, работу с синонимами или интегрируйте индекс с REST API, чтобы предоставить возможности поиска другим сервисам. + +--- + +**Последнее обновление:** 2026-02-06 +**Тестировано с:** GroupDocs.Search 25.4 for Java +**Автор:** GroupDocs \ No newline at end of file diff --git a/content/spanish/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/spanish/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..4ef6efb7 --- /dev/null +++ b/content/spanish/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,187 @@ +--- +date: '2026-02-06' +description: Aprende cómo agregar documentos al índice y habilitar la búsqueda sensible + a mayúsculas y minúsculas en Java con GroupDocs.Search, mejorando la precisión de + tu aplicación. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'Agregar documentos al índice: búsqueda en Java sensible a mayúsculas y minúsculas + con GroupDocs' +type: docs +url: /es/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# Añadir documentos al índice: Dominando búsquedas sensibles a mayúsculas y minúsculas en Java con GroupDocs + +Recuperar la información correcta de una enorme colección de documentos es un requisito esencial para las aplicaciones modernas. En esta guía, aprenderás **cómo añadir documentos al índice** y realizar **búsquedas sensibles a mayúsculas y minúsculas** usando GroupDocs.Search para Java. Ya sea que estés construyendo un repositorio de documentos legales, un catálogo de comercio electrónico o un sistema de gestión de contenidos, los resultados de búsqueda precisos mantienen a los usuarios satisfechos y tus datos confiables. + +## Respuestas rápidas +- **¿Cuál es el paso principal para comenzar a buscar?** Añadir documentos a un índice con `index.add(...)`. +- **¿Cómo habilitar la búsqueda sensible a mayúsculas?** Establecer `options.setUseCaseSensitiveSearch(true)`. +- **¿Puedo buscar en varios directorios?** Sí – llama a `index.add()` para cada carpeta que quieras incluir. +- **¿Qué método me permite buscar con objetos?** Usa `SearchQuery.createWordQuery(...)`. +- **¿Necesito una licencia para pruebas?** Hay una licencia temporal disponible para propósitos de prueba. + +## Qué significa “añadir documentos al índice” +Añadir documentos a un índice significa alimentar tus archivos fuente (PDF, documentos Word, texto plano, etc.) a GroupDocs.Search para que pueda construir una estructura de datos indexable. Una vez indexado, el motor puede ejecutar consultas rápidas, incluidas las sensibles a mayúsculas. + +## Por qué habilitar la búsqueda sensible a mayúsculas en Java? +- **Coincidencia exacta de términos** – diferenciar “Apple” (la empresa) de “apple” (la fruta). +- **Cumplimiento normativo** – algunas industrias requieren coincidencia exacta de frases. +- **Mejora de la relevancia** – los usuarios a menudo esperan resultados específicos de mayúsculas en contextos técnicos o legales. + +## Requisitos previos +- JDK (Java 17 o posterior recomendado) +- Maven para la gestión de dependencias +- Un IDE como IntelliJ IDEA o Eclipse +- Familiaridad básica con la programación en Java + +## Configuración de GroupDocs.Search para Java +First, add the GroupDocs repository and dependency to your `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Alternativamente, puedes descargar la última versión directamente desde [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Licenciamiento +Para comenzar con una prueba, visita GroupDocs para obtener una licencia temporal. Esto te permitirá probar todas las funciones sin limitaciones. + +## Cómo añadir documentos al índice – Búsqueda por consulta de texto + +### Paso 1: Crear un índice y añadir tus documentos +Crea una carpeta donde se almacenarán los archivos del índice, luego añade el directorio fuente que contiene los documentos que deseas buscar. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **Consejo profesional:** Puedes llamar a `index.add()` varias veces para **buscar en varios directorios** en un único índice. + +### Paso 2: Habilitar la búsqueda sensible a mayúsculas +Configura las opciones de búsqueda para respetar la capitalización de las letras. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Paso 3: Ejecutar una consulta de texto sensible a mayúsculas +Ejecuta una consulta que diferencie “Advantages” de “advantages”. + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +El bucle imprime la ruta completa de cada documento que contiene el término con coincidencia exacta de mayúsculas. + +## Cómo añadir documentos al índice – Búsqueda por consulta de objeto + +Las consultas de objeto te brindan más flexibilidad, especialmente cuando necesitas combinar múltiples criterios. + +### Paso 1: Inicializar un segundo índice (opcional) +Si prefieres mantener separadas las búsquedas basadas en objetos, crea otra carpeta de índice. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Paso 2: Reutilizar la opción sensible a mayúsculas +La misma instancia de `SearchOptions` funciona para consultas de objeto. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Paso 3: Construir y ejecutar una consulta de objeto +Crea un objeto de consulta de palabra y pásalo al motor de búsqueda. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Usar `createWordQuery` te permite combinarlo posteriormente con consultas de frase, comodín o booleanas para escenarios más complejos. + +## Aplicaciones prácticas +- **Gestión de documentos legales:** Recuperar estatutos específicos de casos donde la capitalización importa. +- **Plataformas de comercio electrónico:** Distinguir SKUs de productos como “PRO‑X” vs. “pro‑x”. +- **Sistemas de gestión de contenidos (CMS):** Garantizar que los autores encuentren encabezados o etiquetas exactas. + +## Consideraciones de rendimiento +- **Mantener el índice actualizado** – volver a indexar cuando se añadan nuevos archivos o cambien los existentes. +- **Monitorear el uso de memoria** – los grandes corpus se benefician del indexado incremental y del dimensionamiento adecuado del heap de JVM. +- **Aprovechar el recolector de basura de Java** – liberar objetos `Index` cuando ya no sean necesarios. + +## Problemas comunes y soluciones +| Problema | Solución | +|----------|----------| +| `useCaseSensitiveSearch` parece ser ignorado | Verifica que estés usando la última versión de GroupDocs.Search y que el índice se haya reconstruido después de cambiar la opción. | +| No se devuelven resultados para un término conocido | Asegúrate de que la capitalización del término coincida exactamente y que el documento se haya añadido correctamente al índice. | +| Buscar en muchas carpetas ralentiza | Añade cada carpeta individualmente con `index.add()` y considera dividir el índice en fragmentos (shards) para conjuntos de datos muy grandes. | + +## Preguntas frecuentes + +**Q:** ¿Cómo manejo grandes conjuntos de datos con GroupDocs.Search? +**A:** Utiliza la partición del índice, ajusta la configuración de memoria de la JVM y compacta periódicamente el índice para mantener un rendimiento óptimo. + +**Q:** ¿Puedo buscar en varios directorios simultáneamente? +**A:** Sí – llama a `index.add()` para cada directorio que quieras incluir, luego ejecuta una única consulta contra el índice combinado. + +**Q:** ¿Cuáles son los errores comunes al configurar búsquedas sensibles a mayúsculas? +**A:** Olvidar reconstruir el índice después de habilitar `useCaseSensitiveSearch`, o usar la capitalización incorrecta en la cadena de consulta. + +**Q:** ¿Cómo puedo solucionar errores de búsqueda? +**A:** Revisa los archivos de registro generados por GroupDocs.Search en busca de trazas de pila, y confirma que todas las dependencias de Maven estén resueltas correctamente. + +**Q:** ¿Es GroupDocs.Search adecuado para aplicaciones en tiempo real? +**A:** Con estrategias de indexado adecuadas (actualizaciones incrementales y caché en memoria), puede ofrecer resultados de búsqueda casi en tiempo real. + +## Recursos +- **Documentación:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **Referencia API:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **Descarga:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **Repositorio GitHub:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Foro de soporte:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Licencia temporal:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Última actualización:** 2026-02-06 +**Probado con:** GroupDocs.Search 25.4 +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/spanish/java/searching/master-document-search-groupdocs-java/_index.md b/content/spanish/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..cd1ca18b --- /dev/null +++ b/content/spanish/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,183 @@ +--- +date: '2026-02-06' +description: Aprende cómo indexar documentos y agregar documentos al índice usando + GroupDocs.Search para Java. Crea aplicaciones de búsqueda potentes con consultas + de texto y de objetos. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Cómo indexar documentos con GroupDocs.Search para Java +type: docs +url: /es/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# Cómo indexar documentos con GroupDocs.Search para Java + +En el mundo actual impulsado por los datos, **cómo indexar documentos** de manera eficiente es una habilidad crítica para cualquier desarrollador Java que trabaje con grandes colecciones de archivos. Ya sea que estés manejando contratos legales, estados financieros o informes internos, poder localizar rápidamente la información correcta puede ahorrar horas de trabajo manual. En este tutorial aprenderás **cómo indexar documentos** usando la biblioteca GroupDocs.Search, y luego realizar consultas tanto basadas en texto como basadas en objetos sobre el índice creado. ¡Comencemos! + +## Respuestas rápidas +- **¿Cuál es el primer paso para indexar documentos?** Inicializar un objeto `Index` que apunte a una carpeta donde se almacenará el índice. +- **¿Qué método agrega documentos a un índice?** Usar `index.add("PATH_TO_DOCUMENTS")`. +- **¿Puedo buscar rangos numéricos?** Sí, con una consulta de texto como `"400 ~~ 4000"` o una consulta de objeto mediante `SearchQuery.createNumericRangeQuery`. +- **¿Necesito una licencia?** Hay una prueba gratuita disponible; una licencia comercial desbloquea todas las funciones. +- **¿Qué versión de Java se requiere?** JDK 8 o superior. + +## ¿Qué es “cómo indexar documentos” con GroupDocs.Search? +Indexar documentos significa escanear el contenido de los archivos en una carpeta y almacenar tokens buscables en una carpeta de índice dedicada. Este paso de pre‑procesamiento permite búsquedas ultrarrápidas más adelante, porque la biblioteca busca en el índice preparado en lugar de en los archivos sin procesar cada vez. + +## ¿Por qué usar GroupDocs.Search para Java? +- **Rendimiento:** Las búsquedas se ejecutan en milisegundos incluso con miles de archivos. +- **Compatibilidad de formatos:** Maneja PDFs, Word, Excel, PowerPoint y muchos más. +- **Flexibilidad:** Soporta consultas de texto plano, rangos numéricos y consultas de objetos complejas. +- **Escalabilidad:** Actualiza fácilmente el índice añadiendo nuevos documentos sin reconstruirlo desde cero. + +## Requisitos previos +- Maven instalado para la gestión de dependencias. +- Un IDE como IntelliJ IDEA o Eclipse. +- Conocimientos básicos de Java (conceptos OOP, manejo de excepciones). + +## Configuración de GroupDocs.Search para Java +### Configuración con Maven +Agrega el repositorio y la dependencia a tu `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Descarga directa +También puedes descargar el último JAR desde [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +#### Pasos para obtener la licencia +1. **Prueba gratuita** – explora la biblioteca sin costo. +2. **Licencia temporal** – solicita una clave a corto plazo para una evaluación ampliada. +3. **Compra** – obtén una licencia completa para uso en producción. + +## Inicialización y configuración básica +Para **agregar documentos al índice**, primero crea un objeto `Index` que apunte a la carpeta donde se almacenarán los archivos del índice: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +Esta línea crea (o abre) un índice listo para recibir documentos. + +## Guía de implementación +### Creación e indexación de documentos +#### Cómo agregar documentos al índice +El método `add` escanea una carpeta y **almacena datos buscables** para cada archivo. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Parámetros:** La cadena de ruta apunta a la carpeta que contiene los archivos que deseas indexar. +- **Propósito:** Después de este paso, el índice contiene tokens de todos los tipos de documentos compatibles, lo que permite búsquedas rápidas. + +### Búsqueda con consulta de texto +#### Cómo realizar una búsqueda de rango numérico basada en texto +Puedes buscar usando una cadena simple que define un rango. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Parámetros:** La cadena de consulta `"400 ~~ 4000"` indica al motor que encuentre números entre 400 y 4000. +- **Valor de retorno:** `SearchResult` contiene la lista de documentos coincidentes y los resaltados. + +### Búsqueda con consulta de objeto +#### Cómo usar una consulta de objeto para rangos numéricos +Las consultas basadas en objetos te dan control programático sobre los criterios de búsqueda. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Parámetros:** `createNumericRangeQuery` recibe los enteros de inicio y fin. +- **Propósito:** Este método es ideal cuando necesitas combinar múltiples condiciones o construir consultas de forma dinámica. + +## Aplicaciones prácticas +Aquí tienes algunos escenarios del mundo real donde **cómo indexar documentos** se convierte en un factor decisivo: + +1. **Gestión de documentos legales** – localizar cláusulas, números de caso o fechas en miles de contratos. +2. **Informes financieros** – extraer transacciones que caen dentro de un rango monetario específico. +3. **Seguimiento de inventario** – encontrar artículos por números de serie, códigos de lote o rangos de SKU. + +Integrar GroupDocs.Search con bases de datos, almacenamiento en la nube o colas de mensajería puede automatizar aún más los flujos de trabajo de documentos. + +## Consideraciones de rendimiento +- **Actualizaciones regulares del índice:** Vuelve a ejecutar `index.add` para los archivos nuevos y mantén el índice actualizado. +- **Gestión de recursos:** Monitorea el uso de heap; los índices grandes se benefician de ajustes afinados en la recolección de basura de la JVM. +- **Optimización de consultas:** Usa consultas de objeto para filtros complejos y reducir escaneos innecesarios. + +## Problemas comunes y soluciones +| Problema | Por qué ocurre | Solución | +|----------|----------------|----------| +| **La búsqueda no devuelve resultados** | El índice no está construido o la ruta de la carpeta es incorrecta | Verifica que `index.add` se haya ejecutado en el directorio correcto y que la carpeta del índice sea escribible. | +| **OutOfMemoryError durante la indexación** | Archivos muy grandes o heap insuficiente | Incrementa el valor `-Xmx` de la JVM o indexa los archivos en lotes más pequeños. | +| **Formato de archivo no compatible** | Tipo de archivo no reconocido por GroupDocs.Search | Asegúrate de que la extensión del archivo esté entre las soportadas (PDF, DOCX, XLSX, etc.). | + +## Preguntas frecuentes +**P: ¿Cómo actualizo un índice existente con documentos nuevos?** +R: Llama nuevamente a `index.add("NEW_DOCUMENT_PATH")`; la biblioteca fusiona las nuevas entradas sin recrear todo el índice. + +**P: ¿GroupDocs.Search puede manejar diferentes formatos de archivo?** +R: Sí, admite PDFs, Word, Excel, PowerPoint, texto plano y muchos otros formatos comunes. + +**P: ¿Cuáles son los requisitos del sistema para usar GroupDocs.Search?** +R: Entorno Java 8+ en tiempo de ejecución, RAM suficiente (al menos 2 GB para colecciones moderadas) y acceso de lectura/escritura a la carpeta del índice. + +**P: ¿Cómo puedo solucionar problemas de rendimiento en la búsqueda?** +R: Asegúrate de que el índice esté actualizado, perfila tus consultas y revisa la configuración de memoria de la JVM. Reducir la cantidad de campos indexados también puede mejorar la velocidad. + +**P: ¿Existe una forma de buscar con sinónimos o coincidencia difusa?** +R: Sí, GroupDocs.Search proporciona diccionarios de sinónimos y opciones de búsqueda difusa que pueden habilitarse mediante la clase `SearchOptions`. + +## Conclusión +Ahora tienes una comprensión sólida de **cómo indexar documentos** usando GroupDocs.Search para Java, cómo **agregar documentos al índice** y cómo ejecutar consultas tanto basadas en texto como en objetos. Al integrar estas técnicas, tus aplicaciones Java ofrecerán experiencias de búsqueda rápidas y precisas en cualquier repositorio de documentos. + +¿Listo para el siguiente paso? Explora la búsqueda facetada, el manejo de sinónimos o integra el índice con una API REST para exponer capacidades de búsqueda a otros servicios. + +--- + +**Última actualización:** 2026-02-06 +**Probado con:** GroupDocs.Search 25.4 para Java +**Autor:** GroupDocs \ No newline at end of file diff --git a/content/swedish/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/swedish/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..c3c8ab33 --- /dev/null +++ b/content/swedish/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,185 @@ +--- +date: '2026-02-06' +description: Lär dig hur du lägger till dokument i indexet och aktiverar skiftlägeskänslig + sökning i Java med GroupDocs.Search, vilket ökar noggrannheten i din applikation. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'Lägg till dokument i indexet: skiftlägeskänslig Java‑sökning med GroupDocs' +type: docs +url: /sv/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# Lägg till dokument i index: Mästra skiftlägeskänsliga sökningar i Java med GroupDocs + +Att hämta rätt information från en enorm samling dokument är ett grundläggande krav för moderna applikationer. I den här guiden lär du dig **hur du lägger till dokument i index** och utför **skiftlägeskänsliga sökningar** med GroupDocs.Search för Java. Oavsett om du bygger ett juridiskt dokumentarkiv, en e‑handelskatalog eller ett innehållshanteringssystem, ger precisa sökresultat nöjda användare och pålitliga data. + +## Snabba svar +- **Vad är det första steget för att börja söka?** Lägg till dokument i ett index med `index.add(...)`. +- **Hur aktiverar man skiftlägeskänslig sökning?** Sätt `options.setUseCaseSensitiveSearch(true)`. +- **Kan jag söka i flera kataloger?** Ja – anropa `index.add()` för varje mapp du vill inkludera. +- **Vilken metod låter mig söka med objekt?** Använd `SearchQuery.createWordQuery(...)`. +- **Behöver jag en licens för testning?** En tillfällig licens finns tillgänglig för provändamål. + +## Vad betyder “lägga till dokument i index”? +Att lägga till dokument i ett index innebär att mata dina källfiler (PDF‑filer, Word‑dokument, vanlig text osv.) till GroupDocs.Search så att den kan bygga en sökbar datastruktur. När de är indexerade kan motorn utföra snabba frågor, inklusive skiftlägeskänsliga. + +## Varför aktivera skiftlägeskänslig sökning i Java? +- **Exakt termmatchning** – skilj mellan “Apple” (företaget) och “apple” (frukten). +- **Regulatorisk efterlevnad** – vissa branscher kräver exakt frasmatchning. +- **Förbättrad relevans** – användare förväntar sig ofta skiftlägespecifika resultat i tekniska eller juridiska sammanhang. + +## Förutsättningar +- JDK (Java 17 eller senare rekommenderas) +- Maven för beroendehantering +- En IDE som IntelliJ IDEA eller Eclipse +- Grundläggande kunskap om Java‑programmering + +## Konfigurera GroupDocs.Search för Java +Börja med att lägga till GroupDocs‑arkivet och beroendet i din `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Alternativt kan du ladda ner den senaste versionen direkt från [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Licensiering +För att komma igång med en provperiod, besök GroupDocs för att skaffa en tillfällig licens. Detta gör att du kan testa alla funktioner utan några begränsningar. + +## Så lägger du till dokument i index – Textfrågesökning + +### Steg 1: Skapa ett index och lägg till dina dokument +Skapa en mapp där indexfilerna ska lagras, och lägg sedan till källkatalogen som innehåller de dokument du vill söka i. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **Proffstips:** Du kan anropa `index.add()` flera gånger för att **söka i flera kataloger** i ett enda index. + +### Steg 2: Aktivera skiftlägeskänslig sökning +Konfigurera sökalternativen så att de respekterar bokstavsstorlek. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Steg 3: Utför en skiftlägeskänslig textfråga +Kör en fråga som skiljer “Advantages” från “advantages”. + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Loopen skriver ut hela sökvägen för varje dokument som innehåller den exakt skiftlägesmatchade termen. + +## Så lägger du till dokument i index – Objektfrågesökning + +Objektfrågor ger dig mer flexibilitet, särskilt när du behöver kombinera flera kriterier. + +### Steg 1: Initiera ett andra index (valfritt) +Om du föredrar att hålla objektbaserade sökningar separata, skapa en annan indexmapp. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Steg 2: Återanvänd det skiftlägeskänsliga alternativet +Samma `SearchOptions`‑instans fungerar för objektfrågor. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Steg 3: Bygg och kör en objektfråga +Skapa ett ordfrågeobjekt och skicka det till sökmotorn. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Att använda `createWordQuery` låter dig senare kombinera det med fras-, jokertecken- eller booleska frågor för mer komplexa scenarier. + +## Praktiska tillämpningar +- **Juridisk dokumenthantering:** Hämta fall‑specifika lagar där versalisering är viktig. +- **E‑handelsplattformar:** Skilj mellan produkt‑SKU:er som “PRO‑X” och “pro‑x”. +- **Content Management Systems (CMS):** Säkerställ att författare hittar exakta rubriker eller taggar. + +## Prestandaöverväganden +- **Håll indexet uppdaterat** – återindexera när nya filer läggs till eller befintliga ändras. +- **Övervaka minnesanvändning** – stora korpusar drar nytta av inkrementell indexering och korrekt JVM‑heap‑storlek. +- **Utnyttja Javas skräpsamlare** – frigör `Index`‑objekt när de inte längre behövs. + +## Vanliga problem och lösningar +| Problem | Lösning | +|-------|----------| +| `useCaseSensitiveSearch` verkar ignoreras | Verifiera att du använder den senaste versionen av GroupDocs.Search och att indexet byggdes om efter att alternativet ändrats. | +| Inga resultat returnerades för en känd term | Säkerställ att termens skiftläge matchar exakt och att dokumentet har lagts till i indexet. | +| Sökning i många mappar blir långsam | Lägg till varje mapp individuellt med `index.add()` och överväg att dela upp indexet i shards för mycket stora datamängder. | + +## Vanliga frågor + +**Q:** Hur hanterar jag stora datamängder med GroupDocs.Search? +**A:** Använd indexpartitionering, justera JVM‑minnesinställningar och komprimera indexet periodiskt för att hålla prestandan optimal. + +**Q:** Kan jag söka i flera kataloger samtidigt? +**A:** Ja – anropa `index.add()` för varje katalog du vill inkludera, och kör sedan en enda fråga mot det kombinerade indexet. + +**Q:** Vilka vanliga fallgropar finns vid konfiguration av skiftlägeskänsliga sökningar? +**A:** Att glömma att återindexera efter att ha aktiverat `useCaseSensitiveSearch`, eller att använda fel skiftläge i frågesträngen. + +**Q:** Hur kan jag felsöka sökfel? +**A:** Kontrollera loggfilerna som genereras av GroupDocs.Search för stackspår, och bekräfta att alla Maven‑beroenden är korrekt lösta. + +**Q:** Är GroupDocs.Search lämplig för realtidstillämpningar? +**A:** Med rätt indexeringsstrategier (inkrementella uppdateringar och cache i minnet) kan den leverera nästan realtidsresultat. + +## Resurser +- **Dokumentation:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **API‑referens:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **Nedladdning:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **GitHub‑arkiv:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Supportforum:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Tillfällig licens:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Senast uppdaterad:** 2026-02-06 +**Testad med:** GroupDocs.Search 25.4 +**Författare:** GroupDocs \ No newline at end of file diff --git a/content/swedish/java/searching/master-document-search-groupdocs-java/_index.md b/content/swedish/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..997902dd --- /dev/null +++ b/content/swedish/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,182 @@ +--- +date: '2026-02-06' +description: Lär dig hur du indexerar dokument och lägger till dokument i indexet + med GroupDocs.Search för Java. Bygg kraftfulla sökappar med text‑ och objektfrågor. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Hur man indexerar dokument med GroupDocs.Search för Java +type: docs +url: /sv/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# Så indexerar du dokument med GroupDocs.Search för Java + +I dagens datadrivna värld är **hur man indexerar dokument** effektivt en kritisk färdighet för alla Java‑utvecklare som hanterar stora samlingar av filer. Oavsett om du arbetar med juridiska kontrakt, finansiella rapporter eller interna dokument kan förmågan att snabbt hitta rätt information spara timmar av manuellt arbete. I den här handledningen lär du dig **hur man indexerar dokument** med GroupDocs.Search‑biblioteket och sedan utför både text‑baserade och objekt‑baserade frågor på det skapade indexet. Låt oss komma igång! + +## Snabba svar +- **Vad är det första steget för att indexera dokument?** Initiera ett `Index`‑objekt som pekar på en mapp där indexet ska lagras. +- **Vilken metod lägger till dokument i ett index?** Använd `index.add("PATH_TO_DOCUMENTS")`. +- **Kan jag söka i numeriska intervall?** Ja, med en textfråga som `"400 ~~ 4000"` eller en objektfråga via `SearchQuery.createNumericRangeQuery`. +- **Behöver jag en licens?** En gratis provversion finns tillgänglig; en kommersiell licens låser upp alla funktioner. +- **Vilken Java‑version krävs?** JDK 8 eller högre. + +## Vad är “hur man indexerar dokument” med GroupDocs.Search? +Att indexera dokument innebär att skanna innehållet i filer i en mapp och lagra sökbara token i en dedikerad indexmapp. Detta förbehandlingssteg möjliggör blixtsnabba uppslag senare, eftersom biblioteket söker i det förberedda indexet istället för i de råa filerna varje gång. + +## Varför använda GroupDocs.Search för Java? +- **Prestanda:** Sökningar körs på millisekunder även på tusentals filer. +- **Formatstöd:** Hanterar PDF, Word, Excel, PowerPoint och många fler. +- **Flexibilitet:** Stöder ren‑text‑frågor, numeriska intervall och komplexa objekt‑frågor. +- **Skalbarhet:** Uppdatera enkelt indexet genom att lägga till nya dokument utan att bygga om från början. + +## Förutsättningar +- Maven installerat för beroendehantering. +- En IDE såsom IntelliJ IDEA eller Eclipse. +- Grundläggande kunskaper i Java (OOP‑koncept, undantagshantering). + +## Installera GroupDocs.Search för Java +### Maven‑inställning +Lägg till repository och beroende i din `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Direkt nedladdning +Du kan också ladda ner den senaste JAR‑filen från [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +#### Steg för att skaffa licens +1. **Gratis prov** – utforska biblioteket utan kostnad. +2. **Tillfällig licens** – begär en korttidsnyckel för förlängd utvärdering. +3. **Köp** – skaffa en full licens för produktionsanvändning. + +## Grundläggande initiering och konfiguration +För att **lägga till dokument i index** skapar du först ett `Index`‑objekt som pekar på den mapp där indexfilerna ska lagras: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +Denna rad skapar (eller öppnar) ett index som är redo att ta emot dokument. + +## Implementeringsguide +### Skapa och indexera dokument +#### Hur man lägger till dokument i index +`add`‑metoden skannar en mapp och lagrar sökbar data för varje fil. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Parametrar:** Sträng‑vägen pekar på mappen som innehåller filerna du vill indexera. +- **Syfte:** Efter detta steg innehåller indexet token från alla stödda dokumenttyper, vilket möjliggör snabba sökningar. + +### Textfrågesökning +#### Hur man utför en text‑baserad numerisk intervallsökning +Du kan söka med en enkel sträng som definierar ett intervall. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Parametrar:** Frågesträngen `"400 ~~ 4000"` instruerar motorn att hitta tal mellan 400 och 4000. +- **Returvärde:** `SearchResult` innehåller listan med matchande dokument och markeringar. + +### Objektfrågesökning +#### Hur man använder en objektfråga för numeriska intervall +Objekt‑baserade frågor ger dig programmatisk kontroll över sökkriterierna. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Parametrar:** `createNumericRangeQuery` tar emot start‑ och slut‑heltal. +- **Syfte:** Denna metod är idealisk när du behöver kombinera flera villkor eller bygga frågor dynamiskt. + +## Praktiska tillämpningar +Här är några verkliga scenarier där **hur man indexerar dokument** blir en spelväxlare: + +1. **Juridisk dokumenthantering** – lokalisera klausuler, ärendenummer eller datum i tusentals kontrakt. +2. **Finansiell rapportering** – hämta transaktioner som faller inom ett specifikt penningintervall. +3. **Inventarie‑spårning** – hitta artiklar efter serienummer, batchkoder eller SKU‑intervall. + +Att integrera GroupDocs.Search med databaser, molnlagring eller meddelandeköer kan ytterligare automatisera dokumentarbetsflöden. + +## Prestandaöverväganden +- **Regelbundna indexuppdateringar:** Kör `index.add` igen för nya filer så att indexet hålls aktuellt. +- **Resurshantering:** Övervaka heap‑användning; stora index drar nytta av finjusterade JVM‑garbage‑collection‑inställningar. +- **Frågeoptimering:** Använd objekt‑frågor för komplexa filter för att minska onödig skanning. + +## Vanliga problem och lösningar +| Problem | Varför det händer | Lösning | +|-------|----------------|-----| +| **Sökning ger inga resultat** | Indexet är inte byggt eller mappvägen är felaktig | Verifiera att `index.add` kördes på rätt katalog och att indexmappen är skrivbar. | +| **OutOfMemoryError under indexering** | Mycket stora filer eller otillräcklig heap | Öka JVM‑parametern `-Xmx` eller indexera filer i mindre batcher. | +| **Ej stödd filformat** | Filtypen känns inte igen av GroupDocs.Search | Säkerställ att filändelsen finns med i den stödda listan (PDF, DOCX, XLSX osv.). | + +## Vanliga frågor +**Q: Hur uppdaterar jag ett befintligt index med nya dokument?** +A: Anropa `index.add("NEW_DOCUMENT_PATH")` igen; biblioteket sammanslår nya poster utan att återskapa hela indexet. + +**Q: Kan GroupDocs.Search hantera olika filformat?** +A: Ja, det stöder PDF, Word, Excel, PowerPoint, ren text och många andra vanliga format. + +**Q: Vilka systemkrav finns för att använda GroupDocs.Search?** +A: Java 8+ runtime, tillräckligt med RAM (minst 2 GB för måttliga samlingar) och läs‑/skrivrättigheter till indexmappen. + +**Q: Hur felsöker jag prestandaproblem vid sökning?** +A: Säkerställ att indexet är uppdaterat, profilera dina frågor och granska JVM‑minnesinställningarna. Att minska antalet fält som indexeras kan också förbättra hastigheten. + +**Q: Finns det ett sätt att söka med synonymer eller fuzzy matching?** +A: Ja, GroupDocs.Search erbjuder synonymordböcker och fuzzy‑sökalternativ som kan aktiveras via `SearchOptions`‑klassen. + +## Slutsats +Du har nu en solid förståelse för **hur man indexerar dokument** med GroupDocs.Search för Java, hur du **lägger till dokument i index** och hur du kör både text‑baserade och objekt‑baserade frågor. Genom att integrera dessa tekniker kommer dina Java‑applikationer att leverera snabba, precisa sökupplevelser över vilket dokumentarkiv som helst. + +Redo för nästa steg? Utforska facetterad sökning, synonymhantering eller integrera indexet med ett REST‑API för att exponera sökfunktioner till andra tjänster. + +--- + +**Senast uppdaterad:** 2026-02-06 +**Testat med:** GroupDocs.Search 25.4 för Java +**Författare:** GroupDocs \ No newline at end of file diff --git a/content/thai/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/thai/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..613568e2 --- /dev/null +++ b/content/thai/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,187 @@ +--- +date: '2026-02-06' +description: เรียนรู้วิธีเพิ่มเอกสารลงในดัชนีและเปิดใช้งานการค้นหาที่แยกแยะตัวพิมพ์ใหญ่‑เล็กใน + Java ด้วย GroupDocs.Search เพื่อเพิ่มความแม่นยำของแอปพลิเคชันของคุณ +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'เพิ่มเอกสารลงในดัชนี: การค้นหา Java ที่แยกแยะตัวพิมพ์ใหญ่‑เล็กด้วย GroupDocs' +type: docs +url: /th/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# เพิ่มเอกสารลงในดัชนี: การเชี่ยวชาญการค้นหาแบบแยกแยะตัวพิมพ์ใหญ่‑เล็กใน Java ด้วย GroupDocs + +การดึงข้อมูลที่ต้องการจากคอลเลกชันเอกสารขนาดมหาศาลเป็นความต้องการหลักของแอปพลิเคชันสมัยใหม่ ในคู่มือนี้คุณจะได้เรียนรู้ **วิธีเพิ่มเอกสารลงในดัชนี** และทำ **การค้นหาแบบแยกแยะตัวพิมพ์ใหญ่‑เล็ก** ด้วย GroupDocs.Search สำหรับ Java ไม่ว่าคุณจะกำลังสร้างคลังเอกสารทางกฎหมาย, แคตาล็อกอี‑คอมเมิร์ซ หรือระบบจัดการเนื้อหา ผลการค้นหาที่แม่นยำจะทำให้ผู้ใช้พอใจและข้อมูลของคุณเชื่อถือได้ + +## Quick Answers +- **ขั้นตอนแรกที่สำคัญในการเริ่มการค้นหาคืออะไร?** เพิ่มเอกสารลงในดัชนีด้วย `index.add(...)` +- **จะเปิดใช้งานการค้นหาแบบแยกแยะตัวพิมพ์ใหญ่‑เล็กอย่างไร?** ตั้งค่า `options.setUseCaseSensitiveSearch(true)` +- **ฉันสามารถค้นหาข้ามหลายไดเรกทอรีได้หรือไม่?** ได้ – เรียก `index.add()` สำหรับแต่ละโฟลเดอร์ที่ต้องการรวม +- **เมธอดใดที่ให้ฉันค้นหาด้วยอ็อบเจกต์?** ใช้ `SearchQuery.createWordQuery(...)` +- **ต้องการไลเซนส์สำหรับการทดสอบหรือไม่?** มีไลเซนส์ชั่วคราวให้ใช้สำหรับการทดลอง + +## What does “add documents to index” mean? +การเพิ่มเอกสารลงในดัชนีหมายถึงการป้อนไฟล์ต้นทางของคุณ (PDF, Word, ข้อความธรรมดา ฯลฯ) เข้าไปใน GroupDocs.Search เพื่อให้ระบบสร้างโครงสร้างข้อมูลที่สามารถค้นหาได้ เมื่อทำการจัดทำดัชนีแล้วเอนจินจะสามารถดำเนินการค้นหาอย่างรวดเร็ว รวมถึงการค้นหาแบบแยกแยะตัวพิมพ์ใหญ่‑เล็กด้วย + +## Why enable case‑sensitive search in Java? +- **การจับคู่คำอย่างแม่นยำ** – แยกความแตกต่างระหว่าง “Apple” (บริษัท) กับ “apple” (ผลไม้) +- **การปฏิบัติตามกฎระเบียบ** – บางอุตสาหกรรมต้องการการจับคู่วลีอย่างแม่นยำ +- **ความเกี่ยวข้องที่ดีขึ้น** – ผู้ใช้มักคาดหวังผลลัพธ์ที่แยกตามตัวพิมพ์ในบริบททางเทคนิคหรือกฎหมาย + +## Prerequisites +- JDK (แนะนำ Java 17 หรือใหม่กว่า) +- Maven สำหรับการจัดการ dependencies +- IDE เช่น IntelliJ IDEA หรือ Eclipse +- ความคุ้นเคยพื้นฐานกับการเขียนโปรแกรม Java + +## Setting Up GroupDocs.Search for Java +ก่อนอื่นให้เพิ่มรีโพสิตอรีของ GroupDocs และ dependency ลงใน `pom.xml` ของคุณ: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +หรือคุณสามารถดาวน์โหลดเวอร์ชันล่าสุดโดยตรงจาก [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +### Licensing +เพื่อเริ่มต้นด้วยรุ่นทดลอง ให้ไปที่ GroupDocs เพื่อรับไลเซนส์ชั่วคราว ซึ่งจะทำให้คุณทดสอบฟีเจอร์ทั้งหมดโดยไม่มีข้อจำกัดใด ๆ + +## How to add documents to index – Text Query Search + +### Step 1: Create an Index and add your documents +สร้างโฟลเดอร์ที่ไฟล์ดัชนีจะถูกเก็บไว้ แล้วเพิ่มไดเรกทอรีต้นทางที่มีเอกสารที่คุณต้องการค้นหา + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **เคล็ดลับ:** คุณสามารถเรียก `index.add()` หลายครั้งเพื่อ **ค้นหาข้ามหลายไดเรกทอรี** ในดัชนีเดียวได้ + +### Step 2: Enable case‑sensitive search +กำหนดค่าตัวเลือกการค้นหาให้คำนึงถึงการใช้ตัวพิมพ์ใหญ่‑เล็ก + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Step 3: Execute a case‑sensitive text query +รันคิวรีที่แยกความแตกต่างระหว่าง “Advantages” กับ “advantages” + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +ลูปนี้จะแสดงพาธเต็มของแต่ละเอกสารที่มีคำที่ตรงกับตัวพิมพ์อย่างแม่นยำ + +## How to add documents to index – Object Query Search + +Object queries ให้ความยืดหยุ่นมากขึ้น โดยเฉพาะเมื่อคุณต้องการรวมหลายเงื่อนไขเข้าด้วยกัน + +### Step 1: Initialize a second index (optional) +หากต้องการแยกการค้นหาแบบอ็อบเจกต์ออกจากกัน ให้สร้างโฟลเดอร์ดัชนีอีกอันหนึ่ง + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Step 2: Re‑use the case‑sensitive option +อินสแตนซ์ `SearchOptions` เดียวกันสามารถใช้กับการค้นหาแบบอ็อบเจกต์ได้ + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Step 3: Build and run an object query +สร้างอ็อบเจกต์ word query แล้วส่งให้เอนจินค้นหา + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +การใช้ `createWordQuery` ทำให้คุณสามารถต่อมาผสานกับ phrase, wildcard หรือ Boolean query เพื่อสร้างสถานการณ์ที่ซับซ้อนได้ + +## Practical Applications +- **การจัดการเอกสารทางกฎหมาย:** ดึงกฎหมายหรือข้อบังคับที่ต้องแยกตามตัวพิมพ์ใหญ่‑เล็ก +- **แพลตฟอร์มอี‑คอมเมิร์ซ:** แยก SKU ของสินค้าเช่น “PRO‑X” กับ “pro‑x” +- **ระบบจัดการเนื้อหา (CMS):** ทำให้ผู้เขียนค้นหาหัวข้อหรือแท็กที่ตรงกันได้อย่างแม่นยำ + +## Performance Considerations +- **รักษาดัชนีให้เป็นปัจจุบัน** – ทำการ re‑index เมื่อไฟล์ใหม่ถูกเพิ่มหรือไฟล์เดิมมีการเปลี่ยนแปลง +- **ตรวจสอบการใช้หน่วยความจำ** – คอลเลกชันขนาดใหญ่จะได้ประโยชน์จากการทำดัชนีแบบ incremental และการกำหนดขนาด heap ของ JVM อย่างเหมาะสม +- **ใช้ประโยชน์จาก garbage collector ของ Java** – ปล่อยอ็อบเจกต์ `Index` เมื่อไม่ต้องการใช้งานแล้ว + +## Common Issues and Solutions +| Issue | Solution | +|-------|----------| +| `useCaseSensitiveSearch` appears ignored | ตรวจสอบว่าคุณใช้เวอร์ชันล่าสุดของ GroupDocs.Search และว่าดัชนีถูกสร้างใหม่หลังจากเปลี่ยนตัวเลือกนี้ | +| No results returned for a known term | ตรวจสอบว่าตัวพิมพ์ของคำตรงกับที่จัดทำดัชนีอย่างแม่นยำและว่าเอกสารถูกเพิ่มลงในดัชนีสำเร็จ | +| Searching many folders slows down | เพิ่มแต่ละโฟลเดอร์แยกกันด้วย `index.add()` และพิจารณาแบ่งดัชนีเป็น shards สำหรับชุดข้อมูลขนาดใหญ่มาก | + +## Frequently Asked Questions + +**Q:** ฉันจะจัดการกับชุดข้อมูลขนาดใหญ่ด้วย GroupDocs.Search อย่างไร? +**A:** ใช้การแบ่งพาร์ทิชันของดัชนี ปรับแต่งการตั้งค่า memory ของ JVM และทำการ compact ดัชนีเป็นระยะเพื่อรักษาประสิทธิภาพให้สูงสุด + +**Q:** ฉันสามารถค้นหาข้ามหลายไดเรกทอรีพร้อมกันได้หรือไม่? +**A:** ได้ – เรียก `index.add()` สำหรับแต่ละไดเรกทอรีที่ต้องการรวม แล้วรันคิวรีเดียวบนดัชนีที่รวมกันแล้ว + +**Q:** ปัญหาที่พบบ่อยเมื่อตั้งค่าการค้นหาแบบแยกแยะตัวพิมพ์ใหญ่‑เล็กคืออะไร? +**A:** ลืมทำการสร้างดัชนีใหม่หลังจากเปิดใช้งาน `useCaseSensitiveSearch` หรือใช้ตัวพิมพ์ผิดในสตริงคิวรี + +**Q:** ฉันจะแก้ไขข้อผิดพลาดการค้นหาอย่างไร? +**A:** ตรวจสอบไฟล์บันทึกที่ GroupDocs.Search สร้างขึ้นเพื่อดู stack trace และยืนยันว่า dependencies ของ Maven ทั้งหมดถูก resolve อย่างถูกต้อง + +**Q:** GroupDocs.Search เหมาะกับแอปพลิเคชันแบบเรียล‑ไทม์หรือไม่? +**A:** ด้วยกลยุทธ์การทำดัชนีที่เหมาะสม (การอัปเดตแบบ incremental และการแคชในหน่วยความจำ) สามารถให้ผลลัพธ์การค้นหาใกล้เคียงกับเรียล‑ไทม์ได้ + +## Resources +- **Documentation:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **API Reference:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **Download:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **GitHub Repository:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Support Forum:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Temporary License:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Last Updated:** 2026-02-06 +**Tested With:** GroupDocs.Search 25.4 +**Author:** GroupDocs + +--- \ No newline at end of file diff --git a/content/thai/java/searching/master-document-search-groupdocs-java/_index.md b/content/thai/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..1aa7368b --- /dev/null +++ b/content/thai/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,182 @@ +--- +date: '2026-02-06' +description: เรียนรู้วิธีทำดัชนีเอกสารและเพิ่มเอกสารลงในดัชนีโดยใช้ GroupDocs.Search + สำหรับ Java สร้างแอปค้นหาที่มีประสิทธิภาพด้วยการค้นหาข้อความและอ็อบเจกต์. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: วิธีทำดัชนีเอกสารด้วย GroupDocs.Search สำหรับ Java +type: docs +url: /th/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# วิธีทำดัชนีเอกสารด้วย GroupDocs.Search สำหรับ Java + +ในโลกที่ขับเคลื่อนด้วยข้อมูลในปัจจุบัน การ **how to index documents** อย่างมีประสิทธิภาพเป็นทักษะสำคัญสำหรับนักพัฒนา Java ที่ต้องจัดการกับคอลเลกชันไฟล์ขนาดใหญ่ ไม่ว่าจะเป็นสัญญากฎหมาย รายการทางการเงิน หรือรายงานภายใน การสามารถค้นหาข้อมูลที่ต้องการได้อย่างรวดเร็วสามารถประหยัดเวลาการทำงานด้วยมือหลายชั่วโมง ในบทเรียนนี้คุณจะได้เรียนรู้ **how to index documents** ด้วยไลบรารี GroupDocs.Search แล้วทำการค้นหาแบบข้อความและแบบอ็อบเจกต์บนดัชนีที่สร้างขึ้น เริ่มกันเลย! + +## คำตอบอย่างรวดเร็ว +- **ขั้นตอนแรกในการทำดัชนีเอกสารคืออะไร?** Initialize a `Index` object pointing to a folder where the index will be stored. +- **เมธอดใดที่ใช้เพิ่มเอกสารลงในดัชนี?** Use `index.add("PATH_TO_DOCUMENTS")`. +- **ฉันสามารถค้นหาช่วงตัวเลขได้หรือไม่?** Yes, with a text query like `"400 ~~ 4000"` or an object query via `SearchQuery.createNumericRangeQuery`. +- **ฉันต้องการไลเซนส์หรือไม่?** A free trial is available; a commercial license unlocks full features. +- **ต้องการเวอร์ชัน Java ใด?** JDK 8 or higher. + +## “how to index documents” กับ GroupDocs.Search คืออะไร? +การทำดัชนีเอกสารหมายถึงการสแกนเนื้อหาของไฟล์ในโฟลเดอร์และจัดเก็บโทเค็นที่สามารถค้นหาได้ในโฟลเดอร์ดัชนีเฉพาะ ขั้นตอนการเตรียมล่วงหน้านี้ทำให้การค้นหาเร็วเหมือนแสงในภายหลัง เนื่องจากไลบรารีจะค้นหาในดัชนีที่เตรียมไว้แทนไฟล์ดิบทุกครั้ง + +## ทำไมต้องใช้ GroupDocs.Search สำหรับ Java? +- **Performance:** การค้นหาทำงานในระดับมิลลิวินาทีแม้กับไฟล์หลายพันไฟล์. +- **Format support:** รองรับ PDF, Word, Excel, PowerPoint และอื่น ๆ อีกมาก. +- **Flexibility:** รองรับการค้นหาแบบ plain‑text, ช่วงตัวเลข, และการค้นหาแบบอ็อบเจกต์ที่ซับซ้อน. +- **Scalability:** สามารถอัปเดตดัชนีได้ง่ายโดยการเพิ่มเอกสารใหม่โดยไม่ต้องสร้างใหม่จากศูนย์. + +## ข้อกำหนดเบื้องต้น +- ติดตั้ง Maven สำหรับการจัดการ dependencies. +- IDE เช่น IntelliJ IDEA หรือ Eclipse. +- ความรู้พื้นฐานของ Java (แนวคิด OOP, การจัดการข้อยกเว้น). + +## การตั้งค่า GroupDocs.Search สำหรับ Java +### การตั้งค่า Maven +เพิ่ม repository และ dependency ลงในไฟล์ `pom.xml` ของคุณ: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### ดาวน์โหลดโดยตรง +คุณยังสามารถดาวน์โหลด JAR ล่าสุดจาก [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +#### ขั้นตอนการรับไลเซนส์ +1. **Free Trial** – ทดลองใช้ไลบรารีโดยไม่มีค่าใช้จ่าย. +2. **Temporary License** – ขอคีย์ระยะสั้นสำหรับการประเมินต่อเนื่อง. +3. **Purchase** – รับไลเซนส์เต็มรูปแบบสำหรับการใช้งานในสภาพแวดล้อมการผลิต. + +## การเริ่มต้นและตั้งค่าเบื้องต้น +เพื่อ **add documents to index**, คุณต้องสร้างอ็อบเจกต์ `Index` ที่ชี้ไปยังโฟลเดอร์ที่ไฟล์ดัชนีจะถูกจัดเก็บ: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +บรรทัดนี้สร้าง (หรือเปิด) ดัชนีที่พร้อมรับเอกสาร. + +## คู่มือการใช้งาน +### การสร้างและทำดัชนีเอกสาร +#### วิธีเพิ่มเอกสารลงในดัชนี +เมธอด `add` จะสแกนโฟลเดอร์และจัดเก็บข้อมูลที่สามารถค้นหาได้สำหรับแต่ละไฟล์. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Parameters:** สตริงพาธชี้ไปยังโฟลเดอร์ที่มีไฟล์ที่คุณต้องการทำดัชนี. +- **Purpose:** หลังจากขั้นตอนนี้ ดัชนีจะมีโทเค็นจากทุกประเภทเอกสารที่รองรับ ทำให้การค้นหาเร็วขึ้น. + +### การค้นหาแบบข้อความ +#### วิธีทำการค้นหาแบบข้อความด้วยช่วงตัวเลข +คุณสามารถค้นหาโดยใช้สตริงง่าย ๆ ที่กำหนดช่วง. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Parameters:** สตริง query `"400 ~~ 4000"` บอกให้เอนจินค้นหาตัวเลขระหว่าง 400 ถึง 4000. +- **Return Value:** `SearchResult` เก็บรายการเอกสารที่ตรงกันและส่วนที่ไฮไลท์. + +### การค้นหาแบบอ็อบเจกต์ +#### วิธีใช้ object query สำหรับช่วงตัวเลข +การค้นหาแบบอ็อบเจกต์ให้คุณควบคุมเกณฑ์การค้นหาแบบโปรแกรมได้. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Parameters:** `createNumericRangeQuery` รับจำนวนเต็มเริ่มต้นและสิ้นสุด. +- **Purpose:** วิธีนี้เหมาะเมื่อคุณต้องการรวมหลายเงื่อนไขหรือสร้าง query อย่างไดนามิก. + +## การประยุกต์ใช้งานจริง +ต่อไปนี้เป็นสถานการณ์จริงที่ **how to index documents** กลายเป็นตัวเปลี่ยนเกม: + +1. **Legal Document Management** – ค้นหาข้อความ, หมายเลขคดี, หรือวันที่ในสัญญาหลายพันฉบับ. +2. **Financial Reporting** – ดึงรายการธุรกรรมที่อยู่ในช่วงจำนวนเงินที่กำหนด. +3. **Inventory Tracking** – ค้นหารายการโดยหมายเลขซีเรียล, รหัสล็อต, หรือช่วง SKU. + +การรวม GroupDocs.Search กับฐานข้อมูล, ที่เก็บข้อมูลบนคลาวด์, หรือคิวข้อความ สามารถทำให้กระบวนการทำงานของเอกสารอัตโนมัติมากยิ่งขึ้น. + +## ข้อควรพิจารณาด้านประสิทธิภาพ +- **Regular Index Updates:** เรียก `index.add` อีกครั้งสำหรับไฟล์ใหม่เพื่อให้ดัชนีเป็นปัจจุบัน. +- **Resource Management:** ตรวจสอบการใช้ heap; ดัชนีขนาดใหญ่จะได้ประโยชน์จากการปรับตั้งค่า garbage‑collection ของ JVM. +- **Query Optimization:** ใช้ object query สำหรับฟิลเตอร์ซับซ้อนเพื่อลดการสแกนที่ไม่จำเป็น. + +## ปัญหาทั่วไปและวิธีแก้ +| ปัญหา | สาเหตุ | วิธีแก้ | +|-------|--------|---------| +| **การค้นหาไม่พบผลลัพธ์** | ดัชนียังไม่ได้สร้างหรือพาธโฟลเดอร์ไม่ถูกต้อง | ตรวจสอบว่าได้เรียก `index.add` ในไดเรกทอรีที่ถูกต้องและโฟลเดอร์ดัชนีสามารถเขียนได้. | +| **OutOfMemoryError during indexing** | ไฟล์ขนาดใหญ่มากหรือ heap ไม่เพียงพอ | เพิ่มค่า JVM `-Xmx` หรือทำการทำดัชนีไฟล์เป็นชุดเล็ก ๆ | +| **Unsupported file format** | ประเภทไฟล์ไม่ถูกจดจำโดย GroupDocs.Search | ตรวจสอบให้แน่ใจว่ามีส่วนขยายไฟล์อยู่ในรายการที่รองรับ (PDF, DOCX, XLSX, ฯลฯ). | + +## คำถามที่พบบ่อย +**Q: ฉันจะอัปเดตดัชนีที่มีอยู่ด้วยเอกสารใหม่ได้อย่างไร?** +A: เรียก `index.add("NEW_DOCUMENT_PATH")` อีกครั้ง; ไลบรารีจะผสานรายการใหม่โดยไม่ต้องสร้างดัชนีใหม่ทั้งหมด. + +**Q: GroupDocs.Search สามารถจัดการกับรูปแบบไฟล์ต่าง ๆ ได้หรือไม่?** +A: ใช่, รองรับ PDF, Word, Excel, PowerPoint, plain text, และรูปแบบทั่วไปอื่น ๆ มากมาย. + +**Q: ข้อกำหนดระบบสำหรับการใช้ GroupDocs.Search คืออะไร?** +A: จำเป็นต้องมี Java 8+ runtime, RAM เพียงพอ (อย่างน้อย 2 GB สำหรับคอลเลกชันระดับปานกลาง), และการเข้าถึงอ่าน/เขียนโฟลเดอร์ดัชนี. + +**Q: ฉันจะแก้ไขปัญหาประสิทธิภาพการค้นหาได้อย่างไร?** +A: ตรวจสอบให้แน่ใจว่าดัชนีเป็นปัจจุบัน, ทำการ profiling query ของคุณ, และตรวจสอบการตั้งค่า memory ของ JVM. การลดจำนวนฟิลด์ที่ทำดัชนีก็สามารถเพิ่มความเร็วได้. + +**Q: มีวิธีการค้นหาด้วยคำพ้องหรือการจับคู่แบบ fuzzy หรือไม่?** +A: มี, GroupDocs.Search มีพจนานุกรมคำพ้องและตัวเลือกการค้นหาแบบ fuzzy ที่สามารถเปิดใช้งานได้ผ่านคลาส `SearchOptions`. + +## สรุป +ตอนนี้คุณมีความเข้าใจที่มั่นคงเกี่ยวกับ **how to index documents** ด้วย GroupDocs.Search สำหรับ Java, วิธี **add documents to index**, และวิธีรันการค้นหาแบบข้อความและแบบอ็อบเจกต์ การผสานเทคนิคเหล่านี้เข้าด้วยกัน แอปพลิเคชัน Java ของคุณจะมอบประสบการณ์การค้นหาที่เร็วและแม่นยำในทุกคลังเอกสาร. + +พร้อมสำหรับขั้นตอนต่อไปหรือยัง? สำรวจการค้นหาแบบ faceted, การจัดการคำพ้อง, หรือผสานดัชนีกับ REST API เพื่อเปิดเผยความสามารถการค้นหาให้กับบริการอื่น ๆ. + +--- + +**อัปเดตล่าสุด:** 2026-02-06 +**ทดสอบด้วย:** GroupDocs.Search 25.4 for Java +**ผู้เขียน:** GroupDocs \ No newline at end of file diff --git a/content/turkish/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/turkish/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..bdec407c --- /dev/null +++ b/content/turkish/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,187 @@ +--- +date: '2026-02-06' +description: GroupDocs.Search kullanarak Java'da belgeleri indekse eklemeyi ve büyük/küçük + harfe duyarlı aramayı etkinleştirmeyi öğrenin, uygulamanızın doğruluğunu artırın. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'Belgeleri indekse ekle: GroupDocs ile büyük/küçük harf duyarlı Java araması' +type: docs +url: /tr/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# Dizin'e belge ekleme: Java'da GroupDocs ile Büyük/Küçük Harfe Duyarlı Aramaları Ustalıkla Kullanma + +Büyük bir belge koleksiyonundan doğru bilgiyi elde etmek, modern uygulamaların temel gereksinimlerinden biridir. Bu rehberde **belge ekleme** ve **büyük/küçük harfe duyarlı aramaları** GroupDocs.Search for Java kullanarak nasıl yapacağınızı öğreneceksiniz. İster bir hukuk belgesi deposu, bir e‑ticaret kataloğu ya da bir içerik yönetim sistemi oluşturuyor olun, kesin arama sonuçları kullanıcıları mutlu eder ve verinizin güvenilirliğini artırır. + +## Hızlı Yanıtlar +- **Aramaya başlamak için temel adım nedir?** `index.add(...)` ile bir dizine belge ekleyin. +- **Büyük/küçük harfe duyarlı arama nasıl etkinleştirilir?** `options.setUseCaseSensitiveSearch(true)` ayarlayın. +- **Birden fazla klasörde arama yapabilir miyim?** Evet – dahil etmek istediğiniz her klasör için `index.add()` çağırın. +- **Nesnelerle arama yapmamı sağlayan yöntem hangisidir?** `SearchQuery.createWordQuery(...)` kullanın. +- **Test için lisansa ihtiyacım var mı?** Deneme amaçlı geçici bir lisans mevcuttur. + +## “Dizin'e belge ekleme” ne anlama geliyor? +Belge ekleme, kaynak dosyalarınızı (PDF, Word belgeleri, düz metin vb.) GroupDocs.Search’e besleyerek arama yapılabilir bir veri yapısı oluşturması demektir. Dizin oluşturulduktan sonra motor, büyük/küçük harfe duyarlı sorgular da dahil olmak üzere hızlı sorgular çalıştırabilir. + +## Java’da büyük/küçük harfe duyarlı arama neden etkinleştirilmeli? +- **Tam terim eşleşmesi** – “Apple” (şirket) ile “apple” (meyve) arasını ayırır. +- **Düzenleyici uyumluluk** – bazı sektörler tam ifade eşleşmesi gerektirir. +- **Gelişmiş alaka düzeyi** – kullanıcılar teknik veya hukuki bağlamlarda büyük/küçük harfe duyarlı sonuçlar bekler. + +## Önkoşullar +- JDK (Java 17 veya daha yeni sürüm önerilir) +- Bağımlılık yönetimi için Maven +- IntelliJ IDEA veya Eclipse gibi bir IDE +- Java programlamaya temel aşinalık + +## GroupDocs.Search for Java Kurulumu +İlk olarak, GroupDocs deposunu ve bağımlılığı `pom.xml` dosyanıza ekleyin: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Alternatif olarak, en yeni sürümü doğrudan [GroupDocs.Search for Java sürümleri](https://releases.groupdocs.com/search/java/) adresinden indirebilirsiniz. + +### Lisanslama +Deneme sürümüyle başlamak için GroupDocs sitesinden geçici bir lisans edinin. Bu, tüm özellikleri sınırlama olmadan test etmenizi sağlar. + +## Dizin'e belge ekleme – Metin Sorgusu Arama + +### Adım 1: Bir Dizin Oluşturun ve Belgelerinizi Ekleyin +Dizin dosyalarının saklanacağı bir klasör oluşturun, ardından aramak istediğiniz belgeleri içeren kaynak klasörü ekleyin. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **İpucu:** Tek bir dizinde **birden fazla klasörde arama** yapmak için `index.add()` metodunu birden çok kez çağırabilirsiniz. + +### Adım 2: Büyük/küçük harfe duyarlı aramayı etkinleştirin +Arama seçeneklerini harf duyarlılığını koruyacak şekilde yapılandırın. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Adım 3: Büyük/küçük harfe duyarlı bir metin sorgusu çalıştırın +“Advantages” ile “advantages” arasını ayıran bir sorgu yürütün. + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Döngü, tam olarak büyük/küçük harfe uyan terimi içeren her belgenin tam yolunu yazdırır. + +## Dizin'e belge ekleme – Nesne Sorgusu Arama + +Nesne sorguları, özellikle birden fazla kriteri birleştirmeniz gerektiğinde daha fazla esneklik sağlar. + +### Adım 1: İkinci bir dizin başlatın (isteğe bağlı) +Nesne‑tabanlı aramaları ayrı tutmak isterseniz, başka bir dizin klasörü oluşturun. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Adım 2: Büyük/küçük harfe duyarlı seçeneği yeniden kullanın +Aynı `SearchOptions` örneği nesne sorguları için de çalışır. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Adım 3: Bir nesne sorgusu oluşturun ve çalıştırın +Bir kelime sorgusu nesnesi oluşturun ve arama motoruna gönderin. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +`createWordQuery` kullanmak, daha sonra ifadeler, joker karakterler veya Boolean sorgularla birleştirerek daha karmaşık senaryolar oluşturmanıza olanak tanır. + +## Pratik Uygulamalar +- **Hukuki Belge Yönetimi:** Büyük/küçük harf duyarlılığının önemli olduğu durum‑özel kanun maddelerini geri getirin. +- **E‑ticaret Platformları:** “PRO‑X” ile “pro‑x” gibi ürün SKU’larını ayırın. +- **İçerik Yönetim Sistemleri (CMS):** Yazarların tam başlıkları veya etiketleri bulmasını sağlayın. + +## Performans Düşünceleri +- **Dizini güncel tutun** – yeni dosyalar eklendiğinde veya mevcut dosyalar değiştiğinde yeniden indeksleyin. +- **Bellek kullanımını izleyin** – büyük veri kümeleri, artımlı indeksleme ve uygun JVM yığın boyutu ile fayda sağlar. +- **Java’nın çöp toplayıcısını kullanın** – `Index` nesnelerini artık ihtiyaç duyulmadığında serbest bırakın. + +## Yaygın Sorunlar ve Çözümler +| Sorun | Çözüm | +|-------|----------| +| `useCaseSensitiveSearch` göz ardı ediliyor gibi görünüyor | En yeni GroupDocs.Search sürümünü kullandığınızdan ve seçeneği değiştirdikten sonra dizinin yeniden oluşturulduğundan emin olun. | +| Bilinen bir terim için sonuç gelmiyor | Terimin büyük/küçük harfinin tam olarak eşleştiğini ve belgenin dizine başarıyla eklendiğini kontrol edin. | +| Çok sayıda klasör aramak yavaşlıyor | Her klasörü ayrı ayrı `index.add()` ile ekleyin ve çok büyük veri setleri için dizini parçalar (shard) halinde bölmeyi düşünün. | + +## Sıkça Sorulan Sorular + +**S:** GroupDocs.Search ile büyük veri setlerini nasıl yönetebilirim? +**C:** Dizin bölümlendirmesini kullanın, JVM bellek ayarlarını optimize edin ve performansı korumak için periyodik olarak dizini sıkıştırın. + +**S:** Aynı anda birden fazla klasörde arama yapabilir miyim? +**C:** Evet – dahil etmek istediğiniz her klasör için `index.add()` çağırın, ardından birleşik dizin üzerinde tek bir sorgu çalıştırın. + +**S:** Büyük/küçük harfe duyarlı aramaları ayarlarken sık karşılaşılan tuzaklar nelerdir? +**C:** `useCaseSensitiveSearch` etkinleştirildikten sonra dizinin yeniden oluşturulmasını unutmak veya sorgu dizesinde yanlış harf kullanmak. + +**S:** Arama hatalarını nasıl gideririm? +**C:** GroupDocs.Search tarafından oluşturulan log dosyalarını inceleyin, yığın izlerini (stack trace) kontrol edin ve tüm Maven bağımlılıklarının doğru çözüldüğünden emin olun. + +**S:** GroupDocs.Search gerçek‑zaman uygulamaları için uygun mu? +**C:** Doğru indeksleme stratejileri (artımlı güncellemeler ve bellek içi önbellekleme) ile neredeyse gerçek‑zaman arama sonuçları sağlayabilir. + +## Kaynaklar +- **Dokümantasyon:** [GroupDocs.Search Java Docs](https://docs.groupdocs.com/search/java/) +- **API Referansı:** [Java API Reference](https://reference.groupdocs.com/search/java) +- **İndirme:** [Latest Releases](https://releases.groupdocs.com/search/java/) +- **GitHub Deposu:** [GroupDocs.Search for Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Destek Forumu:** [GroupDocs Free Support](https://forum.groupdocs.com/c/search/10) +- **Geçici Lisans:** [Acquire a Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Son Güncelleme:** 2026-02-06 +**Test Edilen Versiyon:** GroupDocs.Search 25.4 +**Yazar:** GroupDocs + +--- \ No newline at end of file diff --git a/content/turkish/java/searching/master-document-search-groupdocs-java/_index.md b/content/turkish/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..43553f47 --- /dev/null +++ b/content/turkish/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,183 @@ +--- +date: '2026-02-06' +description: GroupDocs.Search for Java kullanarak belgeleri nasıl indeksleyeceğinizi + ve indekslere belge ekleyeceğinizi öğrenin. Metin ve nesne sorgularıyla güçlü arama + uygulamaları oluşturun. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: GroupDocs.Search for Java ile Belgeleri Nasıl Dizinlersiniz +type: docs +url: /tr/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# Java için GroupDocs.Search ile Belgeleri Dizinleme + +Günümüzün veri odaklı dünyasında, **belgeleri nasıl dizinleyebileceğinizi** verimli bir şekilde yapmak, büyük dosya koleksiyonlarıyla çalışan her Java geliştiricisi için kritik bir beceridir. İster yasal sözleşmeler, finansal tablolar ya da iç raporlarla çalışıyor olun, doğru bilgiyi hızlı bir şekilde bulabilmek saatlerce manuel çalışmayı tasarruf ettirebilir. Bu öğreticide GroupDocs.Search kütüphanesini kullanarak **belgeleri nasıl dizinleyebileceğinizi** öğrenecek, ardından oluşturulan dizin üzerinde hem metin tabanlı hem de nesne tabanlı sorgular gerçekleştireceksiniz. Hadi başlayalım! + +## Hızlı Yanıtlar +- **Belgeleri dizinlemek için ilk adım nedir?** Dizinin saklanacağı bir klasöre işaret eden bir `Index` nesnesi başlatın. +- **Hangi yöntem dizine belgeleri ekler?** `index.add("PATH_TO_DOCUMENTS")` kullanın. +- **Sayısal aralıkları arayabilir miyim?** Evet, `"400 ~~ 4000"` gibi bir metin sorgusu ya da `SearchQuery.createNumericRangeQuery` aracılığıyla bir nesne sorgusu ile. +- **Lisans gerekiyor mu?** Ücretsiz bir deneme mevcuttur; ticari bir lisans tam özellikleri açar. +- **Hangi Java sürümü gereklidir?** JDK 8 veya üzeri. + +## GroupDocs.Search ile “belgeleri nasıl dizinleyebileceğiniz” nedir? +Belgeleri dizinlemek, bir klasördeki dosyaların içeriğini taramak ve aranabilir tokenları ayrı bir dizin klasöründe depolamak anlamına gelir. Bu ön işleme adımı, daha sonra yıldırım hızıyla arama yapmayı sağlar, çünkü kütüphane her seferinde ham dosyalar yerine hazırlanmış dizini arar. + +## Neden Java için GroupDocs.Search kullanmalı? +- **Performans:** Binlerce dosyada bile aramalar milisaniyeler içinde gerçekleşir. +- **Format desteği:** PDF, Word, Excel, PowerPoint ve daha birçok formatı işler. +- **Esneklik:** Düz metin sorgularını, sayısal aralıkları ve karmaşık nesne sorgularını destekler. +- **Ölçeklenebilirlik:** Sıfırdan yeniden oluşturmak zorunda kalmadan yeni belgeler ekleyerek dizini kolayca güncelleyebilirsiniz. + +## Önkoşullar +- Bağımlılık yönetimi için Maven yüklü olmalı. +- IntelliJ IDEA veya Eclipse gibi bir IDE. +- Temel Java bilgisi (OOP kavramları, istisna yönetimi). + +## Java için GroupDocs.Search Kurulumu +### Maven Kurulumu +Add the repository and dependency to your `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Doğrudan İndirme +Ayrıca en son JAR dosyasını [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) adresinden indirebilirsiniz. + +#### Lisans Edinme Adımları +1. **Ücretsiz Deneme** – kütüphaneyi ücretsiz olarak keşfedin. +2. **Geçici Lisans** – genişletilmiş değerlendirme için kısa vadeli bir anahtar isteyin. +3. **Satın Alma** – üretim kullanımı için tam lisans edinin. + +## Temel Başlatma ve Kurulum +**Dizine belge ekleme** için önce dizin dosyalarının saklanacağı klasöre işaret eden bir `Index` nesnesi oluşturursunuz: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +Bu satır, belgeleri almaya hazır bir dizin oluşturur (veya açar). + +## Uygulama Kılavuzu +### Belgeleri Oluşturma ve Dizinleme +#### Dizine belge ekleme +`add` yöntemi bir klasörü tarar ve her dosya için aranabilir verileri depolar. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Parametreler:** Yol dizesi, dizinlemek istediğiniz dosyaları içeren klasöre işaret eder. +- **Amaç:** Bu adımın ardından dizin, tüm desteklenen belge türlerinden tokenları içerir ve hızlı aramaları mümkün kılar. + +### Metin Sorgusu Arama +#### Metin tabanlı sayısal aralık araması nasıl yapılır +Bir aralık tanımlayan basit bir dizeyle arama yapabilirsiniz. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Parametreler:** `"400 ~~ 4000"` sorgu dizesi, motorun 400 ile 4000 arasındaki sayıları bulmasını söyler. +- **Dönüş Değeri:** `SearchResult`, eşleşen belgelerin listesini ve vurgulamaları tutar. + +### Nesne Sorgusu Arama +#### Sayısal aralıklar için nesne sorgusu nasıl kullanılır +Nesne tabanlı sorgular, arama kriterleri üzerinde programatik kontrol sağlar. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Parametreler:** `createNumericRangeQuery`, başlangıç ve bitiş tam sayılarını alır. +- **Amaç:** Bu yöntem, birden fazla koşulu birleştirmeniz veya sorguları dinamik olarak oluşturmanız gerektiğinde idealdir. + +## Pratik Uygulamalar +İşte **belgeleri nasıl dizinleyeceğinizin** oyun değiştirici olduğu bazı gerçek dünya senaryoları: + +1. **Hukuki Belge Yönetimi** – binlerce sözleşme içinde maddeleri, dava numaralarını veya tarihleri bulun. +2. **Finansal Raporlama** – belirli bir para aralığına düşen işlemleri çekin. +3. **Envanter Takibi** – seri numaraları, parti kodları veya SKU aralıklarıyla öğeleri bulun. + +GroupDocs.Search'ü veritabanları, bulut depolama veya mesaj kuyruğu sistemleriyle entegre etmek, belge iş akışlarını daha da otomatikleştirebilir. + +## Performans Düşünceleri +- **Düzenli Dizin Güncellemeleri:** Yeni dosyalar için `index.add` komutunu yeniden çalıştırarak dizini güncel tutun. +- **Kaynak Yönetimi:** Yığın kullanımını izleyin; büyük dizinler ayarlanmış JVM çöp toplama ayarlarından faydalanır. +- **Sorgu Optimizasyonu:** Gereksiz taramaları azaltmak için karmaşık filtrelerde nesne sorgularını kullanın. + +## Yaygın Sorunlar ve Çözümler +| Sorun | Neden Oluşur | Çözüm | +|-------|----------------|-----| +| **Arama sonuç döndürmüyor** | Dizin oluşturulmamış veya klasör yolu yanlış | `index.add`'in doğru dizinde çalıştırıldığını ve dizin klasörünün yazılabilir olduğunu doğrulayın. | +| **Dizinleme sırasında OutOfMemoryError** | Çok büyük dosyalar veya yetersiz yığın | JVM `-Xmx` değerini artırın veya dosyaları daha küçük partiler halinde dizinleyin. | +| **Desteklenmeyen dosya formatı** | Dosya türü GroupDocs.Search tarafından tanınmıyor | Dosya uzantısının desteklenen listede (PDF, DOCX, XLSX, vb.) olduğundan emin olun. | + +## Sıkça Sorulan Sorular +**Q:** Mevcut bir dizini yeni belgelerle nasıl güncellerim? +**A:** `index.add("NEW_DOCUMENT_PATH")`'i tekrar çağırın; kütüphane tüm dizini yeniden oluşturmadan yeni girişleri birleştirir. + +**Q:** GroupDocs.Search farklı dosya formatlarını işleyebilir mi? +**A:** Evet, PDF, Word, Excel, PowerPoint, düz metin ve birçok diğer yaygın formatı destekler. + +**Q:** GroupDocs.Search kullanmak için sistem gereksinimleri nelerdir? +**A:** Java 8+ çalışma zamanı, yeterli RAM (orta ölçekli koleksiyonlar için en az 2 GB), ve dizin klasörüne okuma/yazma erişimi. + +**Q:** Arama performans sorunlarını nasıl gideririm? +**A:** Dizinin güncel olduğundan emin olun, sorgularınızı profilleyin ve JVM bellek ayarlarını gözden geçirin. Dizinlenen alan sayısını azaltmak da hızı artırabilir. + +**Q:** Eşanlamlılar veya bulanık eşleşme ile arama yapmanın bir yolu var mı? +**A:** Evet, GroupDocs.Search eşanlamlı sözlükleri ve `SearchOptions` sınıfı aracılığıyla etkinleştirilebilen bulanık arama seçenekleri sunar. + +## Sonuç +Artık Java için GroupDocs.Search kullanarak **belgeleri nasıl dizinleyeceğiniz**, **belgeleri dizine nasıl ekleyeceğiniz** ve hem metin tabanlı hem de nesne tabanlı sorguları nasıl çalıştıracağınız konusunda sağlam bir anlayışa sahipsiniz. Bu teknikleri entegre ederek, Java uygulamalarınız herhangi bir belge deposunda hızlı ve doğru arama deneyimleri sunacaktır. + +Bir sonraki adıma hazır mısınız? Facetli aramayı, eşanlamlı yönetimini keşfedin veya dizini bir REST API ile entegre ederek arama yeteneklerini diğer hizmetlere sunun. + +--- + +**Son Güncelleme:** 2026-02-06 +**Test Edilen Versiyon:** GroupDocs.Search 25.4 for Java +**Yazar:** GroupDocs \ No newline at end of file diff --git a/content/vietnamese/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md b/content/vietnamese/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md new file mode 100644 index 00000000..7b1b89f0 --- /dev/null +++ b/content/vietnamese/java/searching/master-case-sensitive-searches-java-groupdocs/_index.md @@ -0,0 +1,187 @@ +--- +date: '2026-02-06' +description: Tìm hiểu cách thêm tài liệu vào chỉ mục và bật tìm kiếm phân biệt chữ + hoa chữ thường trong Java với GroupDocs.Search, nâng cao độ chính xác của ứng dụng + của bạn. +keywords: +- case-sensitive searches in Java +- GroupDocs.Search Java tutorial +- Java text query search +- object query search in Java +title: 'Thêm tài liệu vào chỉ mục: tìm kiếm Java phân biệt chữ hoa chữ thường với + GroupDocs' +type: docs +url: /vi/java/searching/master-case-sensitive-searches-java-groupdocs/ +weight: 1 +--- + +# Thêm tài liệu vào chỉ mục: Thành thạo tìm kiếm phân biệt chữ hoa‑thường trong Java với GroupDocs + +Việc truy xuất đúng thông tin từ một bộ sưu tập tài liệu khổng lồ là yêu cầu cốt lõi của các ứng dụng hiện đại. Trong hướng dẫn này, bạn sẽ học **cách thêm tài liệu vào chỉ mục** và thực hiện **các tìm kiếm phân biệt chữ hoa‑thường** bằng GroupDocs.Search cho Java. Dù bạn đang xây dựng kho lưu trữ tài liệu pháp lý, danh mục thương mại điện tử, hay hệ thống quản lý nội dung, kết quả tìm kiếm chính xác sẽ làm người dùng hài lòng và dữ liệu của bạn đáng tin cậy. + +## Câu trả lời nhanh +- **Bước chính để bắt đầu tìm kiếm là gì?** Thêm tài liệu vào một chỉ mục bằng `index.add(...)`. +- **Làm thế nào để bật tìm kiếm phân biệt chữ hoa‑thường?** Đặt `options.setUseCaseSensitiveSearch(true)`. +- **Tôi có thể tìm kiếm trên nhiều thư mục không?** Có – gọi `index.add()` cho mỗi thư mục bạn muốn bao gồm. +- **Phương thức nào cho phép tôi tìm kiếm bằng đối tượng?** Sử dụng `SearchQuery.createWordQuery(...)`. +- **Tôi có cần giấy phép để thử nghiệm không?** Một giấy phép tạm thời có sẵn cho mục đích dùng thử. + +## “Thêm tài liệu vào chỉ mục” có nghĩa là gì? +Thêm tài liệu vào chỉ mục có nghĩa là đưa các tệp nguồn của bạn (PDF, tài liệu Word, văn bản thuần, v.v.) vào GroupDocs.Search để nó có thể xây dựng một cấu trúc dữ liệu có thể tìm kiếm được. Khi đã được lập chỉ mục, công cụ sẽ thực thi các truy vấn nhanh, bao gồm cả các truy vấn phân biệt chữ hoa‑thường. + +## Tại sao cần bật tìm kiếm phân biệt chữ hoa‑thường trong Java? +- **Khớp chính xác từ khóa** – phân biệt “Apple” (công ty) với “apple” (trái cây). +- **Tuân thủ quy định** – một số ngành yêu cầu khớp chính xác cụm từ. +- **Cải thiện độ liên quan** – người dùng thường mong đợi kết quả phân biệt chữ hoa‑thường trong các ngữ cảnh kỹ thuật hoặc pháp lý. + +## Yêu cầu trước +- JDK (khuyến nghị Java 17 hoặc mới hơn) +- Maven để quản lý phụ thuộc +- Một IDE như IntelliJ IDEA hoặc Eclipse +- Kiến thức cơ bản về lập trình Java + +## Cài đặt GroupDocs.Search cho Java +Đầu tiên, thêm kho lưu trữ GroupDocs và phụ thuộc vào tệp `pom.xml` của bạn: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +Bạn cũng có thể tải phiên bản mới nhất trực tiếp từ [GroupDocs.Search cho Java](https://releases.groupdocs.com/search/java/). + +### Cấp phép +Để bắt đầu dùng thử, truy cập GroupDocs để nhận giấy phép tạm thời. Điều này sẽ cho phép bạn thử nghiệm tất cả các tính năng mà không có bất kỳ hạn chế nào. + +## Cách thêm tài liệu vào chỉ mục – Tìm kiếm bằng Truy vấn Văn bản + +### Bước 1: Tạo một Chỉ mục và thêm tài liệu của bạn +Tạo một thư mục để lưu các tệp chỉ mục, sau đó thêm thư mục nguồn chứa các tài liệu bạn muốn tìm kiếm. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInTextForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +> **Mẹo chuyên nghiệp:** Bạn có thể gọi `index.add()` nhiều lần để **tìm kiếm trên nhiều thư mục** trong một chỉ mục duy nhất. + +### Bước 2: Bật tìm kiếm phân biệt chữ hoa‑thường +Cấu hình các tùy chọn tìm kiếm để tôn trọng việc phân biệt chữ hoa và chữ thường. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Bước 3: Thực thi truy vấn văn bản phân biệt chữ hoa‑thường +Thực hiện một truy vấn phân biệt “Advantages” với “advantages”. + +```java +String query = "Advantages"; +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Vòng lặp sẽ in ra đường dẫn đầy đủ của mỗi tài liệu chứa đúng cụm từ phân biệt chữ hoa‑thường. + +## Cách thêm tài liệu vào chỉ mục – Tìm kiếm bằng Truy vấn Đối tượng + +Các truy vấn đối tượng cung cấp cho bạn nhiều linh hoạt hơn, đặc biệt khi bạn cần kết hợp nhiều tiêu chí. + +### Bước 1: Khởi tạo một chỉ mục thứ hai (tùy chọn) +Nếu bạn muốn giữ các tìm kiếm dựa trên đối tượng riêng biệt, hãy tạo một thư mục chỉ mục khác. + +```java +String indexFolder = YOUR_OUTPUT_DIRECTORY + "/CaseSensitiveSearch/QueryInObjectForm"; +Index index = new Index(indexFolder); +index.add(YOUR_DOCUMENT_DIRECTORY); // Add documents to the index +``` + +### Bước 2: Tái sử dụng tùy chọn phân biệt chữ hoa‑thường +Cùng một thể hiện `SearchOptions` cũng hoạt động cho các truy vấn đối tượng. + +```java +SearchOptions options = new SearchOptions(); +options.setUseCaseSensitiveSearch(true); +``` + +### Bước 3: Xây dựng và chạy một truy vấn đối tượng +Tạo một đối tượng truy vấn từ khóa và truyền nó cho công cụ tìm kiếm. + +```java +SearchQuery query = SearchQuery.createWordQuery("Advantages"); +SearchResult result = index.search(query, options); + +// Output results +for (FoundDocument doc : result.getDocuments()) { + System.out.println("Document: " + doc.getDocumentInfo().getFilePath()); +} +``` + +Sử dụng `createWordQuery` cho phép bạn sau này kết hợp nó với truy vấn cụm từ, ký tự đại diện, hoặc Boolean để tạo các kịch bản phức tạp hơn. + +## Ứng dụng thực tiễn +- **Quản lý tài liệu pháp lý:** Truy xuất các quy định cụ thể theo vụ án nơi việc viết hoa là quan trọng. +- **Nền tảng thương mại điện tử:** Phân biệt các SKU sản phẩm như “PRO‑X” và “pro‑x”. +- **Hệ thống quản lý nội dung (CMS):** Đảm bảo các tác giả tìm thấy đúng tiêu đề hoặc thẻ. + +## Các cân nhắc về hiệu năng +- **Giữ chỉ mục luôn cập nhật** – lập chỉ mục lại khi có tệp mới được thêm hoặc tệp hiện có thay đổi. +- **Giám sát việc sử dụng bộ nhớ** – các tập dữ liệu lớn hưởng lợi từ việc lập chỉ mục tăng dần và kích thước heap JVM phù hợp. +- **Tận dụng bộ thu gom rác của Java** – giải phóng các đối tượng `Index` khi không còn cần thiết. + +## Các vấn đề thường gặp và giải pháp +| Vấn đề | Giải pháp | +|-------|----------| +| `useCaseSensitiveSearch` dường như bị bỏ qua | Xác minh bạn đang sử dụng phiên bản GroupDocs.Search mới nhất và chỉ mục đã được xây dựng lại sau khi thay đổi tùy chọn. | +| Không có kết quả nào trả về cho một từ đã biết | Đảm bảo chữ hoa‑thường của từ khớp chính xác và tài liệu đã được thêm thành công vào chỉ mục. | +| Tìm kiếm nhiều thư mục làm chậm | Thêm mỗi thư mục riêng lẻ bằng `index.add()` và cân nhắc chia chỉ mục thành các shard cho các tập dữ liệu rất lớn. | + +## Câu hỏi thường gặp + +**Q:** Làm thế nào để tôi xử lý các tập dữ liệu lớn với GroupDocs.Search? +**A:** Sử dụng phân vùng chỉ mục, điều chỉnh cài đặt bộ nhớ JVM, và định kỳ nén chỉ mục để duy trì hiệu năng tối ưu. + +**Q:** Tôi có thể tìm kiếm trên nhiều thư mục cùng lúc không? +**A:** Có – gọi `index.add()` cho mỗi thư mục bạn muốn bao gồm, sau đó thực hiện một truy vấn duy nhất trên chỉ mục đã kết hợp. + +**Q:** Những sai lầm phổ biến khi thiết lập tìm kiếm phân biệt chữ hoa‑thường là gì? +**A:** Quên xây dựng lại chỉ mục sau khi bật `useCaseSensitiveSearch`, hoặc sử dụng chữ hoa‑thường sai trong chuỗi truy vấn. + +**Q:** Làm sao tôi có thể khắc phục lỗi tìm kiếm? +**A:** Kiểm tra các tệp log do GroupDocs.Search tạo ra để xem stack trace, và xác nhận rằng tất cả các phụ thuộc Maven đã được giải quyết đúng cách. + +**Q:** GroupDocs.Search có phù hợp cho các ứng dụng thời gian thực không? +**A:** Với các chiến lược lập chỉ mục phù hợp (cập nhật tăng dần và bộ nhớ đệm trong RAM), nó có thể cung cấp kết quả tìm kiếm gần thời gian thực. + +## Tài nguyên +- **Tài liệu:** [Tài liệu GroupDocs.Search Java](https://docs.groupdocs.com/search/java/) +- **Tham chiếu API:** [Tham chiếu API Java](https://reference.groupdocs.com/search/java) +- **Tải xuống:** [Phiên bản mới nhất](https://releases.groupdocs.com/search/java/) +- **Kho GitHub:** [GroupDocs.Search cho Java](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- **Diễn đàn hỗ trợ:** [Hỗ trợ miễn phí GroupDocs](https://forum.groupdocs.com/c/search/10) +- **Giấy phép tạm thời:** [Nhận Giấy phép Tạm thời](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Cập nhật lần cuối:** 2026-02-06 +**Đã kiểm tra với:** GroupDocs.Search 25.4 +**Tác giả:** GroupDocs \ No newline at end of file diff --git a/content/vietnamese/java/searching/master-document-search-groupdocs-java/_index.md b/content/vietnamese/java/searching/master-document-search-groupdocs-java/_index.md new file mode 100644 index 00000000..cb30ffeb --- /dev/null +++ b/content/vietnamese/java/searching/master-document-search-groupdocs-java/_index.md @@ -0,0 +1,183 @@ +--- +date: '2026-02-06' +description: Tìm hiểu cách lập chỉ mục tài liệu và thêm tài liệu vào chỉ mục bằng + GroupDocs.Search cho Java. Xây dựng các ứng dụng tìm kiếm mạnh mẽ với các truy vấn + văn bản và đối tượng. +keywords: +- GroupDocs.Search Java +- document indexing in Java +- Java document search +title: Cách lập chỉ mục tài liệu bằng GroupDocs.Search cho Java +type: docs +url: /vi/java/searching/master-document-search-groupdocs-java/ +weight: 1 +--- + +# Cách lập chỉ mục tài liệu với GroupDocs.Search cho Java + +Trong thế giới hiện đại dựa trên dữ liệu, **cách lập chỉ mục tài liệu** một cách hiệu quả là kỹ năng quan trọng đối với bất kỳ nhà phát triển Java nào làm việc với bộ sưu tập lớn các tệp. Dù bạn đang xử lý hợp đồng pháp lý, báo cáo tài chính hay các báo cáo nội bộ, khả năng nhanh chóng tìm thấy thông tin đúng có thể tiết kiệm hàng giờ công việc thủ công. Trong hướng dẫn này, bạn sẽ học **cách lập chỉ mục tài liệu** bằng thư viện GroupDocs.Search, sau đó thực hiện cả truy vấn dựa trên văn bản và truy vấn dựa trên đối tượng trên chỉ mục đã tạo. Hãy bắt đầu! + +## Câu trả lời nhanh +- **Bước đầu tiên để lập chỉ mục tài liệu là gì?** Khởi tạo một đối tượng `Index` chỉ tới thư mục nơi chỉ mục sẽ được lưu trữ. +- **Phương thức nào thêm tài liệu vào chỉ mục?** Sử dụng `index.add("PATH_TO_DOCUMENTS")`. +- **Tôi có thể tìm kiếm các khoảng số không?** Có, bằng truy vấn văn bản như `"400 ~~ 4000"` hoặc truy vấn đối tượng qua `SearchQuery.createNumericRangeQuery`. +- **Tôi có cần giấy phép không?** Bản dùng thử miễn phí có sẵn; giấy phép thương mại mở khóa đầy đủ tính năng. +- **Phiên bản Java nào được yêu cầu?** JDK 8 hoặc cao hơn. + +## “Cách lập chỉ mục tài liệu” với GroupDocs.Search là gì? +Lập chỉ mục tài liệu có nghĩa là quét nội dung của các tệp trong một thư mục và lưu trữ các token có thể tìm kiếm trong một thư mục chỉ mục riêng. Bước tiền xử lý này cho phép tra cứu siêu nhanh sau này, vì thư viện tìm kiếm trong chỉ mục đã chuẩn bị thay vì trong các tệp thô mỗi lần. + +## Tại sao nên sử dụng GroupDocs.Search cho Java? +- **Hiệu suất:** Các tìm kiếm chạy trong mili giây ngay cả với hàng ngàn tệp. +- **Hỗ trợ định dạng:** Xử lý PDF, Word, Excel, PowerPoint và nhiều hơn nữa. +- **Linh hoạt:** Hỗ trợ truy vấn văn bản thuần, các khoảng số và truy vấn đối tượng phức tạp. +- **Khả năng mở rộng:** Dễ dàng cập nhật chỉ mục bằng cách thêm tài liệu mới mà không cần xây dựng lại từ đầu. + +## Yêu cầu trước +- Maven đã được cài đặt để quản lý phụ thuộc. +- Một IDE như IntelliJ IDEA hoặc Eclipse. +- Kiến thức Java cơ bản (khái niệm OOP, xử lý ngoại lệ). + +## Cài đặt GroupDocs.Search cho Java +### Cài đặt Maven +Add the repository and dependency to your `pom.xml`: + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Tải trực tiếp +Bạn cũng có thể tải JAR mới nhất từ [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +#### Các bước lấy giấy phép +1. **Free Trial** – khám phá thư viện mà không tốn phí. +2. **Temporary License** – yêu cầu khóa ngắn hạn để đánh giá mở rộng. +3. **Purchase** – mua giấy phép đầy đủ để sử dụng trong môi trường sản xuất. + +## Khởi tạo và Cài đặt Cơ bản +Để **thêm tài liệu vào chỉ mục**, trước tiên bạn tạo một đối tượng `Index` chỉ tới thư mục nơi các tệp chỉ mục sẽ được lưu trữ: + +```java +import com.groupdocs.search.Index; + +// Initialize the index by specifying a directory path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); +``` + +Dòng này tạo (hoặc mở) một chỉ mục sẵn sàng nhận tài liệu. + +## Hướng dẫn Triển khai +### Tạo và Lập chỉ mục Tài liệu +#### Cách thêm tài liệu vào chỉ mục +Phương thức `add` quét một thư mục và lưu trữ dữ liệu có thể tìm kiếm cho mỗi tệp. + +```java +import com.groupdocs.search.Index; + +// Initialize an index at the specified path +Index index = new Index("YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\NumericRangeSearch"); + +// Add documents from a directory for indexing +index.add("YOUR_DOCUMENT_DIRECTORY"); +``` + +- **Tham số:** Chuỗi đường dẫn chỉ tới thư mục chứa các tệp bạn muốn lập chỉ mục. +- **Mục đích:** Sau bước này, chỉ mục chứa các token từ tất cả các loại tài liệu được hỗ trợ, cho phép tìm kiếm nhanh chóng. + +### Tìm kiếm bằng Truy vấn Văn bản +#### Cách thực hiện tìm kiếm khoảng số dựa trên văn bản +Bạn có thể tìm kiếm bằng một chuỗi đơn giản định nghĩa một khoảng. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Define a query for numeric values within a specific range +String query1 = "400 ~~ 4000"; + +// Execute text-based search on indexed data +SearchResult result1 = index.search(query1); +``` + +- **Tham số:** Chuỗi truy vấn `"400 ~~ 4000"` chỉ cho engine tìm các số nằm trong khoảng từ 400 đến 4000. +- **Giá trị trả về:** `SearchResult` chứa danh sách các tài liệu khớp và phần nổi bật. + +### Tìm kiếm bằng Truy vấn Đối tượng +#### Cách sử dụng truy vấn đối tượng cho các khoảng số +Các truy vấn dựa trên đối tượng cung cấp cho bạn khả năng kiểm soát chương trình đối với tiêu chí tìm kiếm. + +```java +import com.groupdocs.search.*; +import com.groupdocs.search.results.*; + +// Create a numeric range query object +SearchQuery query2 = SearchQuery.createNumericRangeQuery(400, 4000); + +// Perform search using the query object +SearchResult result2 = index.search(query2); +``` + +- **Tham số:** `createNumericRangeQuery` nhận các số nguyên bắt đầu và kết thúc. +- **Mục đích:** Phương thức này lý tưởng khi bạn cần kết hợp nhiều điều kiện hoặc xây dựng truy vấn một cách động. + +## Ứng dụng Thực tế +Dưới đây là một số kịch bản thực tế nơi **cách lập chỉ mục tài liệu** trở thành yếu tố quyết định: + +1. **Quản lý Tài liệu Pháp lý** – tìm các điều khoản, số vụ án hoặc ngày tháng trong hàng ngàn hợp đồng. +2. **Báo cáo Tài chính** – trích xuất các giao dịch nằm trong một khoảng tiền cụ thể. +3. **Theo dõi Hàng tồn kho** – tìm các mục bằng số sê-ri, mã lô hoặc khoảng SKU. + +Việc tích hợp GroupDocs.Search với cơ sở dữ liệu, lưu trữ đám mây hoặc hàng đợi tin nhắn có thể tự động hoá quy trình làm việc với tài liệu hơn nữa. + +## Các yếu tố về Hiệu năng +- **Cập nhật chỉ mục thường xuyên:** Chạy lại `index.add` cho các tệp mới để giữ chỉ mục luôn cập nhật. +- **Quản lý tài nguyên:** Giám sát việc sử dụng heap; các chỉ mục lớn hưởng lợi từ việc tinh chỉnh cài đặt thu gom rác của JVM. +- **Tối ưu hoá truy vấn:** Sử dụng truy vấn đối tượng cho các bộ lọc phức tạp để giảm việc quét không cần thiết. + +## Các vấn đề thường gặp và Giải pháp +| Vấn đề | Nguyên nhân | Giải pháp | +|-------|------------|----------| +| **Tìm kiếm không trả về kết quả** | Chưa xây dựng chỉ mục hoặc đường dẫn thư mục không đúng | Xác minh `index.add` đã được thực thi trên thư mục đúng và thư mục chỉ mục có quyền ghi. | +| **OutOfMemoryError khi lập chỉ mục** | Các tệp quá lớn hoặc heap không đủ | Tăng giá trị JVM `-Xmx` hoặc lập chỉ mục các tệp theo lô nhỏ hơn. | +| **Định dạng tệp không được hỗ trợ** | Loại tệp không được GroupDocs.Search nhận dạng | Đảm bảo phần mở rộng tệp nằm trong danh sách được hỗ trợ (PDF, DOCX, XLSX, v.v.). | + +## Câu hỏi thường gặp +**Q: Làm thế nào để cập nhật một chỉ mục hiện có với tài liệu mới?** +A: Gọi lại `index.add("NEW_DOCUMENT_PATH")`; thư viện sẽ hợp nhất các mục mới mà không tạo lại toàn bộ chỉ mục. + +**Q: GroupDocs.Search có thể xử lý các định dạng tệp khác nhau không?** +A: Có, nó hỗ trợ PDF, Word, Excel, PowerPoint, văn bản thuần và nhiều định dạng phổ biến khác. + +**Q: Yêu cầu hệ thống để sử dụng GroupDocs.Search là gì?** +A: Môi trường chạy Java 8+, RAM đủ (tối thiểu 2 GB cho bộ sưu tập vừa), và quyền đọc/ghi tới thư mục chỉ mục. + +**Q: Làm sao để khắc phục các vấn đề về hiệu năng tìm kiếm?** +A: Đảm bảo chỉ mục luôn cập nhật, phân tích hiệu suất các truy vấn, và xem lại cài đặt bộ nhớ JVM. Giảm số trường được lập chỉ mục cũng có thể cải thiện tốc độ. + +**Q: Có cách nào để tìm kiếm với từ đồng nghĩa hoặc tìm kiếm mờ không?** +A: Có, GroupDocs.Search cung cấp từ điển đồng nghĩa và tùy chọn tìm kiếm mờ có thể bật qua lớp `SearchOptions`. + +## Kết luận +Bây giờ bạn đã nắm vững cách **lập chỉ mục tài liệu** bằng GroupDocs.Search cho Java, cách **thêm tài liệu vào chỉ mục**, và cách thực hiện cả truy vấn dựa trên văn bản và truy vấn dựa trên đối tượng. Bằng cách tích hợp những kỹ thuật này, các ứng dụng Java của bạn sẽ cung cấp trải nghiệm tìm kiếm nhanh chóng và chính xác trên bất kỳ kho tài liệu nào. + +Sẵn sàng cho bước tiếp theo? Khám phá tìm kiếm phân lớp, xử lý đồng nghĩa, hoặc tích hợp chỉ mục với API REST để cung cấp khả năng tìm kiếm cho các dịch vụ khác. + +--- + +**Cập nhật lần cuối:** 2026-02-06 +**Kiểm tra với:** GroupDocs.Search 25.4 for Java +**Tác giả:** GroupDocs \ No newline at end of file