From 76a21df387530004ac73e209a4e77d8f4a5b401f Mon Sep 17 00:00:00 2001 From: Muhammad Muqarrab Date: Thu, 28 May 2026 01:13:12 +0000 Subject: [PATCH 1/3] =?UTF-8?q?Optimize=20page:=20content/english/java/sea?= =?UTF-8?q?rching/groupdocs-search-java-fuzzy-document-indexing/=5Findex.m?= =?UTF-8?q?d=20-=20-=20Updated=20title=20and=20meta=20description=20to=20i?= =?UTF-8?q?nclude=20primary=20keyword.=20-=20Added=20front=E2=80=91matter?= =?UTF-8?q?=20date=20and=20expanded=20keywords=20list.=20-=20Inserted=20Qu?= =?UTF-8?q?ick=20Answers=20and=20enhanced=20FAQ=20with=20AI=E2=80=91friend?= =?UTF-8?q?ly=20Q&A=20format.=20-=20Created=20question=E2=80=91based=20H2?= =?UTF-8?q?=20headings=20with=20direct=20answer=20paragraphs.=20-=20Added?= =?UTF-8?q?=20definition=20anchors=20for=20core=20classes=20(Index,=20Sear?= =?UTF-8?q?chOptions,=20etc.).=20-=20Replaced=20vague=20statements=20with?= =?UTF-8?q?=20quantified=20claims=20about=20format=20support=20and=20perfo?= =?UTF-8?q?rmance.=20-=20Included=20authoritative=20framing=20and=20conver?= =?UTF-8?q?sational=20tone=20throughout.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../_index.md | 221 ++++++++++++++++ .../_index.md | 226 ++++++++++++++++ .../_index.md | 229 ++++++++++++++++ .../_index.md | 231 ++++++++++++++++ .../_index.md | 246 ++++++++++-------- .../_index.md | 219 ++++++++++++++++ .../_index.md | 219 ++++++++++++++++ .../_index.md | 220 ++++++++++++++++ .../_index.md | 230 ++++++++++++++++ .../_index.md | 227 ++++++++++++++++ .../_index.md | 230 ++++++++++++++++ .../_index.md | 229 ++++++++++++++++ .../_index.md | 219 ++++++++++++++++ .../_index.md | 228 ++++++++++++++++ .../_index.md | 229 ++++++++++++++++ .../_index.md | 227 ++++++++++++++++ .../_index.md | 229 ++++++++++++++++ .../_index.md | 229 ++++++++++++++++ .../_index.md | 229 ++++++++++++++++ .../_index.md | 231 ++++++++++++++++ .../_index.md | 219 ++++++++++++++++ .../_index.md | 231 ++++++++++++++++ .../_index.md | 229 ++++++++++++++++ 23 files changed, 5117 insertions(+), 110 deletions(-) create mode 100644 content/arabic/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/chinese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/czech/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/dutch/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/french/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/german/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/greek/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/hindi/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/hongkong/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/hungarian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/indonesian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/italian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/japanese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/korean/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/polish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/portuguese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/russian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/spanish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/swedish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/thai/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/turkish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md create mode 100644 content/vietnamese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md diff --git a/content/arabic/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/arabic/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..083284ca --- /dev/null +++ b/content/arabic/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,221 @@ +--- +date: '2026-05-28' +description: تعلم كيفية البحث في المستندات بكفاءة باستخدام GroupDocs.Search for Java، + بما في ذلك البحث الضبابي Java وكيفية إنشاء فهرس للبحث النصي الكامل. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: كيفية البحث في المستندات باستخدام GroupDocs.Search Java +type: docs +url: /ar/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# كيفية البحث في المستندات باستخدام GroupDocs.Search Java + +في تطبيقات المؤسسات الحديثة، **كيفية البحث في المستندات** بسرعة ودقة تُعد متطلبًا حاسمًا. سواء كنت تتعامل مع العقود أو التقارير أو أي مستودع مستندات كبير، يوفر GroupDocs.Search for Java محرك بحث نص كامل قوي مع مطابقة غير دقيقة مدمجة. يشرح هذا البرنامج التعليمي كيفية إعداد المكتبة، إنشاء الفهرس، إضافة المستندات، تكوين البحث غير الدقيق في Java، واسترجاع النتائج—كل ذلك بشرح واضح ومحادث. + +## إجابات سريعة +- **ما هي الخطوة الأولى؟** تثبيت مكتبة GroupDocs.Search Java عبر Maven أو تنزيلها مباشرة. +- **كيف أنشئ فهرسًا؟** إنشاء كائن `Index` يشير إلى مجلد على القرص؛ المكتبة تبني الهيكل القابل للبحث تلقائيًا. +- **هل يمكنني البحث مع الأخطاء الإملائية؟** نعم—قم بتمكين البحث غير الدقيق لمطابقة المصطلحات التي تحتوي على أخطاء إملائية أو اختلافات طفيفة. +- **كيف أضيف مستندات؟** استخدم طريقة `add` على كائن `Index`، مع تمرير المجلد الذي يحتوي على ملفاتك. +- **ما نسخة Java المطلوبة؟** JDK 8 أو أعلى مدعومة. + +## ما هو “كيفية البحث في المستندات” في سياق GroupDocs.Search؟ +**“كيفية البحث في المستندات”** تشير إلى عملية بناء فهرس قابل للبحث وإصدار استعلامات تُعيد الملفات المتطابقة، مع إمكانية استخدام المنطق غير الدقيق لتحمل الأخطاء الإملائية. يتعامل GroupDocs.Search مع التجزئة والفهرسة والترتيب في الخلفية، بحيث يمكنك التركيز على منطق الأعمال. + +## لماذا تستخدم GroupDocs.Search للـ Java؟ +يدعم GroupDocs.Search **أكثر من 30 تنسيق ملف** (بما في ذلك DOCX، PDF، TXT، HTML، و XLSX) ويمكنه فهرسة **مستندات متعددة المئات من الصفحات** دون تحميل الملف بالكامل في الذاكرة، مما يوفر استجابات استعلام بأقل من ثانية على عتاد الخادم المعتاد. تحسين البحث غير الدقيق يحسن تجربة المستخدم عن طريق إرجاع نتائج ذات صلة حتى عندما تحتوي الاستعلامات على أخطاء إملائية. + +## المتطلبات المسبقة +- **Java Development Kit (JDK):** الإصدار 8 أو أحدث. +- **IDE:** IntelliJ IDEA، Eclipse، أو أي محرر متوافق مع Java. +- **مكتبة GroupDocs.Search للـ Java:** أضفها عبر Maven (مستحسن) أو قم بتنزيل ملف JAR. + +## كيفية إعداد GroupDocs.Search للـ Java؟ +لبدء العمل، أضف تبعية GroupDocs.Search إلى ملف البناء الخاص بك، تأكد من أن عنوان URL للمستودع قابل للوصول، وتحقق من أن نسخة JDK تلبي الحد الأدنى المطلوب. بعد حل المكتبة، يمكنك استيراد فصولها في الكود وإنشاء مجلد فهرس على القرص حيث سيتم تخزين جميع البيانات القابلة للبحث. + +### إعداد 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/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## كيفية إنشاء فهرس؟ +أنشئ مجلد فهرس دائم حيث يخزن GroupDocs.Search البيانات المجزأة. حمّل فهرسك الأول بسطر واحد من الكود—`new Index("path/to/indexFolder")`. فئة `Index` هي المكوّن الأساسي الذي يمثل مجموعة قابلة للبحث من المستندات في الذاكرة وعلى القرص. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## كيفية إضافة مستندات إلى الفهرس؟ +استخدم طريقة `add` لكائن `Index` لتحديد مجلد يحتوي على ملفات المصدر الخاصة بك. سيقوم المحرك بمسح الصيغ المدعومة بشكل متكرر، استخراج المحتوى النصي، وتحديث الهياكل الداخلية. هذه الدعوة الواحدة تتعامل مع دفعات كبيرة بكفاءة، مما يلغي الحاجة إلى معالجة الملفات يدويًا واحدةً تلو الأخرى. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## كيفية تكوين البحث غير الدقيق في Java؟ +تحدد فئة `FuzzySearchOptions` معلمات مثل مسافة التحرير وطول البادئة التي تتحكم في مدى تحمل البحث للأخطاء الإملائية. يجمع كائن `SearchOptions` جميع إعدادات وقت البحث، بما في ذلك خيارات البحث غير الدقيق، حدود النتائج، وتفضيلات التمييز. قم بتمكين المطابقة غير الدقيقة عن طريق تعيين `FuzzySearchOptions` على كائن `SearchOptions`. هذا يخبر المحرك بأخذ المصطلحات ضمن مسافة تحرير قابلة للتكوين في الاعتبار، مما يجعل عمليات البحث تتحمل الأخطاء الإملائية. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## كيفية تنفيذ عملية بحث؟ +استدعِ طريقة `search` على كائن `Index`، مع توفير سلسلة الاستعلام وإعدادات `SearchOptions` المكوّنة. يعالج المحرك الطلب، يطبق المطابقة غير الدقيقة إذا تم تمكينها، ويرتب النتائج بناءً على درجات الصلة. تكتمل العملية بسرعة حتى على فهارس كبيرة لأن البحث يتم على هياكل الرموز المُنشأة مسبقًا. تُعيد الطريقة مجموعة `SearchResult` التي تحتوي على المستندات المتطابقة، عدد النتائج، والقطع المميزة. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## كيفية معالجة وعرض نتائج البحث؟ +`SearchResult` هي مجموعة تحتفظ بكائنات `SearchResultItem` الفردية، كل منها يصف مستندًا متطابقًا، عدد النتائج، والقطع المميزة. قم بالتكرار على عناصر `SearchResult` واطبع مسار كل مستند، عدد مرات الظهور، والعبارات المتطابقة. يتيح لك هذا الحلقة البسيطة بناء جداول واجهة المستخدم، سجلات، أو استجابات API تُظهر بالضبط لماذا تم مطابقة المستند. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## تطبيقات عملية +سيناريوهات واقعية حيث **كيفية البحث في المستندات** مهمة: +1. **إدارة المستندات القانونية:** العثور على البنود أو الأطراف عبر آلاف العقود في ثوانٍ. +2. **البحث الأكاديمي:** استرجاع الأوراق ذات الصلة حتى إذا كان مصطلح البحث مكتوبًا بشكل خاطئ. +3. **إدارة محتوى المؤسسة:** تمكين البوابات الداخلية من بحث سريع يتحمل الأخطاء الإملائية عبر التقارير، البريد الإلكتروني، والعروض التقديمية. + +## اعتبارات الأداء +- **تحديث الفهرس:** أعد تشغيل `add` أو `update` كلما تغيرت ملفات المصدر للحفاظ على حداثة النتائج. +- **إدارة الذاكرة:** يقوم GroupDocs.Search ببث الملفات الكبيرة، لذا يبقى استهلاك الذاكرة منخفضًا حتى لملفات PDF ذات 500 صفحة. +- **الفهرسة المجزأة:** قسّم مجموعات البيانات الضخمة إلى مجلدات فهرس متعددة لتوازي المعالجة وتحسين زمن استجابة الاستعلام. + +## الأسئلة المتكررة +**س: ما هو البحث غير الدقيق في Java ولماذا هو مفيد؟** +ج: يتيح البحث غير الدقيق في Java مطابقة تقريبية للسلاسل، مما يسمح للاستعلامات بإرجاع نتائج رغم الأخطاء الإملائية أو التهجئات البديلة، وهو ما يحسن تجربة المستخدم النهائي. + +**س: كيف أقوم بتحديث فهرسي بعد إضافة ملفات جديدة؟** +ج: استدعِ `index.add("new/files/folder")` مرة أخرى؛ تقوم المكتبة بدمج المحتوى الجديد بذكاء دون إعادة بناء الفهرس بالكامل. + +**س: هل يمكن لـ GroupDocs.Search التعامل مع ملفات PDF محمية بكلمة مرور؟** +ج: نعم—قدّم كلمة المرور في `DocumentLoadOptions` عند إضافة الملف، وسيقوم المحرك بفك التشفير وفهرسة المحتوى. + +**س: هل هناك حد لعدد المستندات التي يمكنني فهرستها؟** +ج: المكتبة تتوسع لتشمل ملايين الملفات؛ الأداء يعتمد على العتاد والتخزين، وليس هناك حد ثابت مبرمج. + +**س: أين يمكنني العثور على أمثلة أكثر تقدماً؟** +ج: زر الوثائق الرسمية لمواضيع أعمق مثل المحللات المخصصة وترتيب النتائج. + +## الخلاصة +أنت الآن تعرف **كيفية البحث في المستندات** باستخدام GroupDocs.Search للـ Java، من إنشاء الفهرس إلى تمكين البحث غير الدقيق في Java ومعالجة النتائج. نفّذ هذه الخطوات لتقديم تجارب بحث سريعة تتحمل الأخطاء الإملائية في أي تطبيق مبني على Java. + +--- + +**Last Updated:** 2026-05-28 +**Tested With:** GroupDocs.Search 23.10 for Java +**Author:** GroupDocs + +--- + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## دروس ذات صلة + +- [إنشاء فهرس مستند باستخدام GroupDocs.Search للـ Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [تنفيذ بحث نص كامل في Java باستخدام GroupDocs.Search: دليل شامل](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [كيفية إضافة مستندات إلى الفهرس مع فهرسة البيانات الوصفية في Java باستخدام GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/chinese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/chinese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..72bf52dc --- /dev/null +++ b/content/chinese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,226 @@ +--- +date: '2026-05-28' +description: 了解如何使用 GroupDocs.Search for Java 高效搜索文档，包括 fuzzy search Java 和如何创建全文搜索索引。 +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: 如何使用 GroupDocs.Search Java 搜索文档 +type: docs +url: /zh/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# 使用 GroupDocs.Search Java 搜索文档的方法 + +在现代企业应用中，**how to search documents** 快速且准确地搜索文档是关键需求。无论您处理的是合同、报告还是任何大型文档库，GroupDocs.Search for Java 为您提供了一个强大的全文搜索引擎，内置模糊匹配。本教程将指导您完成库的设置、创建索引、添加文档、配置 fuzzy search Java，以及检索结果——全部以清晰、对话式的说明呈现。 + +## 快速答案 +- **What is the first step?** 通过 Maven 安装 GroupDocs.Search Java 库或直接下载。 +- **How do I create an index?** 实例化一个指向磁盘文件夹的 `Index` 对象；库会自动构建可搜索结构。 +- **Can I search with typos?** 是的——启用模糊搜索以匹配拼写错误或略有差异的词语。 +- **How to add documents?** 在 `Index` 实例上使用 `add` 方法，传入包含文件的文件夹。 +- **What Java version is required?** 支持 JDK 8 或更高版本。 + +## 在 GroupDocs.Search 上下文中，“how to search documents” 是什么？ +**“How to search documents”** 指的是构建可搜索索引并发出查询以返回匹配文件的过程，可选地使用模糊逻辑容忍拼写错误。GroupDocs.Search 在后台处理分词、索引和排序，让您专注于业务逻辑。 + +## 为什么使用 GroupDocs.Search for Java？ +GroupDocs.Search 支持 **30+ file formats**（包括 DOCX、PDF、TXT、HTML 和 XLSX），并且能够在不将整个文件加载到内存的情况下索引 **multi‑hundred‑page documents**，在普通服务器硬件上提供亚秒级查询响应。其模糊搜索功能通过在查询包含拼写错误时仍返回相关结果，提升用户体验。 + +## 前置条件 +- **Java Development Kit (JDK):** 版本 8 或更高。 +- **IDE:** IntelliJ IDEA、Eclipse 或任何 Java 兼容的编辑器。 +- **GroupDocs.Search for Java library:** 通过 Maven 添加（推荐）或下载 JAR。 + +## 如何设置 GroupDocs.Search for Java？ + +首先，将 GroupDocs.Search 依赖添加到构建文件中，确保仓库 URL 可访问，并验证 JDK 版本满足最低要求。库解析后，您可以在代码中导入其类，并在磁盘上创建一个索引文件夹，用于存储所有可搜索的数据。 + +### 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/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## 如何创建索引？ + +创建一个持久化的索引文件夹，GroupDocs.Search 将在其中存储分词数据。使用一行代码加载您的第一个索引——`new Index("path/to/indexFolder")`。`Index` 类是核心组件，代表内存和磁盘上的可搜索文档集合。 + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## 如何向索引添加文档？ + +使用 `Index` 实例的 `add` 方法指向包含源文件的文件夹。引擎会递归扫描支持的格式，提取文本内容，并更新内部结构。此单次调用能够高效处理大批量文件，免去手动逐文件处理的需求。 + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## 如何配置 Fuzzy Search Java？ + +`FuzzySearchOptions` 类定义了编辑距离、前缀长度等参数，用于控制搜索对拼写错误的容忍度。`SearchOptions` 对象聚合了所有搜索时的设置，包括模糊选项、结果限制和高亮偏好。通过在 `SearchOptions` 对象上设置 `FuzzySearchOptions` 来启用模糊匹配。这告诉引擎在可配置的编辑距离范围内考虑词项，使搜索能够容忍拼写错误。 + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## 如何执行搜索操作？ + +在 `Index` 对象上调用 `search` 方法，提供查询字符串和已配置的 `SearchOptions`。引擎处理请求，若启用则应用模糊匹配，并根据相关性得分对结果进行排序。由于搜索在预构建的标记结构上执行，即使在大型索引上也能快速完成。该方法返回一个 `SearchResult` 集合，包含匹配的文档、命中次数和高亮片段。 + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## 如何处理和显示搜索结果？ + +`SearchResult` 是一个集合，包含多个 `SearchResultItem` 对象，每个对象描述匹配的文档、命中次数以及高亮片段。遍历 `SearchResult` 项目并打印每个文档的路径、出现次数和匹配短语。此简单循环可帮助您构建 UI 表格、日志或 API 响应，准确展示文档匹配的原因。 + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## 实际应用 + +Real‑world scenarios where **how to search documents** matters: +1. **Legal Document Management:** 在数千份合同中秒级定位条款或当事方。 +2. **Academic Research:** 即使搜索词拼写错误，也能检索到相关论文。 +3. **Enterprise Content Management:** 为内部门户提供跨报告、电子邮件和演示文稿的快速、容错搜索。 + +## 性能考虑 +- **Index Refresh:** 每当源文件更改时重新运行 `add` 或 `update`，以保持结果最新。 +- **Memory Management:** GroupDocs.Search 对大文件进行流式处理，即使是 500 页的 PDF，内存占用也保持低水平。 +- **Chunked Indexing:** 将庞大的语料库拆分为多个索引文件夹，以实现并行处理并提升查询延迟。 + +## 常见问题 +**Q: 什么是 fuzzy search Java，为什么它有用？** +A: Fuzzy search Java 实现近似字符串匹配，使查询即使存在拼写错误或变体也能返回结果，从而提升终端用户体验。 + +**Q: 添加新文件后如何更新索引？** +A: 再次调用 `index.add("new/files/folder")`；库会智能地合并新内容，而无需重建整个索引。 + +**Q: GroupDocs.Search 能处理受密码保护的 PDF 吗？** +A: 可以——在添加文件时在 `DocumentLoadOptions` 中提供密码，引擎将解密并索引内容。 + +**Q: 索引的文档数量有没有限制？** +A: 该库可扩展至数百万文件；性能取决于硬件和存储，而非硬编码限制。 + +**Q: 在哪里可以找到更高级的示例？** +A: 请访问官方文档，了解自定义分析器和结果排序等更深入的主题。 + +## 结论 + +您现在已经了解如何使用 GroupDocs.Search for Java **how to search documents**，从创建索引到启用 fuzzy search Java 再到处理结果。实现这些步骤即可在任何基于 Java 的应用中提供快速、容错的搜索体验。 + +--- + +**最后更新:** 2026-05-28 +**测试环境:** GroupDocs.Search 23.10 for Java +**作者:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## 相关教程 + +- [使用 GroupDocs.Search for Java 创建文档索引](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [在 Java 中使用 GroupDocs.Search 实现全文搜索：综合指南](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [使用 GroupDocs.Search 在 Java 中通过元数据索引将文档添加到索引](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/czech/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/czech/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..4c399c85 --- /dev/null +++ b/content/czech/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,229 @@ +--- +date: '2026-05-28' +description: Naučte se, jak efektivně vyhledávat dokumenty pomocí GroupDocs.Search + pro Java, včetně fuzzy search Java a jak vytvořit index pro full‑text search. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: Jak vyhledávat dokumenty pomocí GroupDocs.Search Java +type: docs +url: /cs/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# Jak vyhledávat dokumenty pomocí GroupDocs.Search Java + +V moderních podnikových aplikacích je **jak vyhledávat dokumenty** rychle a přesně kritickým požadavkem. Ať už pracujete s kontrakty, zprávami nebo jakýmkoli velkým úložištěm dokumentů, GroupDocs.Search for Java vám poskytuje robustní full‑text vyhledávač s vestavěným fuzzy matching. Tento tutoriál vás provede nastavením knihovny, vytvořením indexu, přidáváním dokumentů, konfigurací fuzzy search Java a získáváním výsledků — vše s jasnými, konverzačními vysvětleními. + +## Rychlé odpovědi +- **Co je první krok?** Nainstalujte knihovnu GroupDocs.Search Java pomocí Maven nebo si ji stáhněte přímo. +- **Jak vytvořit index?** Vytvořte instanci objektu `Index`, který ukazuje na složku na disku; knihovna automaticky vytvoří prohledávatelnou strukturu. +- **Mohu vyhledávat s překlepy?** Ano — povolte fuzzy search, aby se shodovaly termíny s pravopisnými chybami nebo mírnými odchylkami. +- **Jak přidat dokumenty?** Použijte metodu `add` na instanci `Index` a předávejte složku obsahující vaše soubory. +- **Jaká verze Javy je požadována?** Je podporováno JDK 8 nebo vyšší. + +## Co znamená „jak vyhledávat dokumenty“ v kontextu GroupDocs.Search? +**„Jak vyhledávat dokumenty“** odkazuje na proces vytváření prohledávatelného indexu a zadávání dotazů, které vracejí odpovídající soubory, případně s využitím fuzzy logiky pro toleranci pravopisných chyb. GroupDocs.Search provádí tokenizaci, indexování a řazení na pozadí, takže se můžete soustředit na obchodní logiku. + +## Proč používat GroupDocs.Search pro Javu? +GroupDocs.Search podporuje **30+ formátů souborů** (včetně DOCX, PDF, TXT, HTML a XLSX) a dokáže indexovat **více‑stovkové dokumenty** bez načítání celého souboru do paměti, poskytuje odpovědi na dotazy v podsekundách na typickém serverovém hardware. Jeho funkce fuzzy search zlepšuje uživatelský zážitek tím, že vrací relevantní výsledky i při překlepových dotazech. + +## Předpoklady +- **Java Development Kit (JDK):** verze 8 nebo novější. +- **IDE:** IntelliJ IDEA, Eclipse nebo jakýkoli Java‑kompatibilní editor. +- **GroupDocs.Search for Java library:** přidejte pomocí Maven (doporučeno) nebo stáhněte JAR. + +## Jak nastavit GroupDocs.Search pro Javu? + +Pro začátek přidejte závislost GroupDocs.Search do vašeho souboru sestavení, ujistěte se, že je URL repozitáře dostupná, a ověřte, že verze JDK splňuje minimální požadavek. Po vyřešení knihovny můžete importovat její třídy ve vašem kódu a vytvořit složku indexu na disku, kde budou uložena všechna prohledávatelná data. + +### Nastavení Maven +Přidejte repozitář a závislost do souboru `pom.xml` přesně tak, jak je uvedeno v originálním návodu. + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Přímé stažení +Alternativně získáte JAR z oficiální stránky vydání: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## Jak vytvořit index? + +Vytvořte trvalou složku indexu, kde GroupDocs.Search ukládá tokenizovaná data. Načtěte svůj první index jedním řádkem kódu — `new Index("path/to/indexFolder")`. Třída `Index` je hlavní komponentou, která představuje prohledávatelnou kolekci dokumentů v paměti i na disku. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Jak přidat dokumenty do indexu? + +Použijte metodu `add` instance `Index`, aby ukazovala na složku obsahující vaše zdrojové soubory. Engine bude rekurzivně prohledávat podporované formáty, extrahovat textový obsah a aktualizovat interní struktury. Tento jediný volání efektivně zpracuje velké dávky, čímž eliminuje potřebu ručního zpracování soubor po souboru. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Jak nakonfigurovat Fuzzy Search Java? + +Třída `FuzzySearchOptions` definuje parametry jako edit distance a délka prefixu, které řídí, jak tolerantní je vyhledávání k pravopisným chybám. Objekt `SearchOptions` seskupuje všechna nastavení během vyhledávání, včetně fuzzy možností, limitů výsledků a preferencí zvýraznění. Povolením fuzzy matching nastavíte `FuzzySearchOptions` na objekt `SearchOptions`. Tím řeknete enginu, aby zvažoval termíny v nastavitelném edit distance, což dělá vyhledávání tolerantním k pravopisným chybám. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Jak provést vyhledávací operaci? + +Zavolejte metodu `search` na objektu `Index`, přičemž poskytnete řetězec dotazu a nakonfigurovaný `SearchOptions`. Engine zpracuje požadavek, použije fuzzy matching, pokud je povoleno, a seřadí výsledky podle relevance. Operace se dokončí rychle i u velkých indexů, protože vyhledávání probíhá na předem vytvořených tokenových strukturách. Metoda vrací kolekci `SearchResult`, která obsahuje odpovídající dokumenty, počet výskytů a zvýrazněné úryvky. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Jak zpracovat a zobrazit výsledky vyhledávání? + +`SearchResult` je kolekce, která obsahuje jednotlivé objekty `SearchResultItem`, z nichž každý popisuje odpovídající dokument, počet výskytů a zvýrazněné úryvky. Procházejte položky `SearchResult` a vypište cestu každého dokumentu, počet výskytů a odpovídající fráze. Tento jednoduchý cyklus vám umožní vytvořit UI tabulky, logy nebo API odpovědi, které přesně ukazují, proč byl dokument vybrán. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## Praktické aplikace + +Reálné scénáře, kde **jak vyhledávat dokumenty** má význam: +1. **Správa právních dokumentů:** Najděte klauzule nebo strany napříč tisíci smluv během sekund. +2. **Akademický výzkum:** Získejte relevantní články i když je vyhledávací termín překlep. +3. **Enterprise Content Management:** Pohánějte interní portály rychlým, tolerantním vyhledáváním s překlepy napříč zprávami, e‑maily a prezentacemi. + +## Úvahy o výkonu + +- **Obnovení indexu:** Znovu spusťte `add` nebo `update`, kdykoli se změní zdrojové soubory, aby byly výsledky aktuální. +- **Správa paměti:** GroupDocs.Search streamuje velké soubory, takže paměťová zátěž zůstává nízká i pro PDF s 500 stránkami. +- **Dílené indexování:** Rozdělte obrovské korpusy do více složek indexu, aby se paralelizovalo zpracování a zlepšila latence dotazů. + +## Často kladené otázky + +**Q: Co je fuzzy search Java a proč je užitečný?** +A: Fuzzy search Java umožňuje přibližné porovnání řetězců, což umožňuje dotazům vracet výsledky i přes překlepy nebo alternativní pravopisy, čímž se zlepšuje uživatelský zážitek. + +**Q: Jak aktualizuji svůj index po přidání nových souborů?** +A: Znovu zavolejte `index.add("new/files/folder")`; knihovna inteligentně sloučí nový obsah bez přestavby celého indexu. + +**Q: Dokáže GroupDocs.Search zpracovat PDF chráněné heslem?** +A: Ano — poskytněte heslo v `DocumentLoadOptions` při přidávání souboru a engine dešifruje a indexuje obsah. + +**Q: Existuje limit na počet dokumentů, které mohu indexovat?** +A: Knihovna škáluje na miliony souborů; výkon závisí na hardware a úložišti, ne na pevně daném limitu. + +**Q: Kde najdu pokročilejší příklady?** +A: Navštivte oficiální dokumentaci pro podrobnější témata, jako jsou vlastní analyzátory a řazení výsledků. + +## Závěr + +Nyní víte **jak vyhledávat dokumenty** pomocí GroupDocs.Search pro Javu, od vytvoření indexu po povolení fuzzy search Java a zpracování výsledků. Implementujte tyto kroky a poskytujte rychlé, tolerantní vyhledávání s překlepy v jakékoli aplikaci založené na Javě. + +--- + +**Poslední aktualizace:** 2026-05-28 +**Testováno s:** GroupDocs.Search 23.10 for Java +**Autor:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## Související tutoriály + +- [Vytvořit index dokumentu pomocí GroupDocs.Search pro Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Implementovat full‑textové vyhledávání v Javě s GroupDocs.Search: Komplexní průvodce](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [Jak přidat dokumenty do indexu s metadatovým indexováním v Javě pomocí GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/dutch/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/dutch/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..c8aa4d83 --- /dev/null +++ b/content/dutch/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,231 @@ +--- +date: '2026-05-28' +description: Leer hoe u documenten efficiënt kunt doorzoeken met GroupDocs.Search + voor Java, inclusief fuzzy search Java en hoe u een index maakt voor full‑text search. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: Zoeken in documenten met GroupDocs.Search Java +type: docs +url: /nl/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# Hoe documenten zoeken met GroupDocs.Search Java + +In moderne bedrijfsapplicaties is **how to search documents** snel en nauwkeurig een kritische eis. Of u nu te maken heeft met contracten, rapporten of een grote documentopslag, GroupDocs.Search for Java biedt u een robuuste full‑text zoekmachine met ingebouwde fuzzy matching. Deze tutorial leidt u door het installeren van de bibliotheek, het maken van een index, het toevoegen van documenten, het configureren van fuzzy search Java en het ophalen van resultaten — allemaal met duidelijke, gesprekachtige uitleg. + +## Snelle antwoorden +- **Wat is de eerste stap?** Installeer de GroupDocs.Search Java bibliotheek via Maven of download deze direct. +- **Hoe maak ik een index?** Instantieer een `Index` object dat naar een map op schijf wijst; de bibliotheek bouwt automatisch de doorzoekbare structuur. +- **Kan ik zoeken met typefouten?** Ja — schakel fuzzy search in om termen te vinden die verkeerd gespeld zijn of lichte variaties hebben. +- **Hoe documenten toevoegen?** Gebruik de `add` methode op de `Index` instantie en geef de map door die uw bestanden bevat. +- **Welke Java‑versie is vereist?** JDK 8 of hoger wordt ondersteund. + +## Wat betekent “how to search documents” in de context van GroupDocs.Search? +**“How to search documents”** verwijst naar het proces van het bouwen van een doorzoekbare index en het uitvoeren van queries die overeenkomende bestanden retourneren, eventueel met fuzzy‑logica om spelfouten te tolereren. GroupDocs.Search verwerkt tokenisatie, indexering en ranking op de achtergrond, zodat u zich kunt concentreren op de bedrijfslogica. + +## Waarom GroupDocs.Search voor Java gebruiken? +GroupDocs.Search ondersteunt **30+ bestandsformaten** (inclusief DOCX, PDF, TXT, HTML en XLSX) en kan **documenten van honderden pagina's** indexeren zonder het volledige bestand in het geheugen te laden, waardoor sub‑seconde query‑reacties worden geleverd op typische serverhardware. De fuzzy‑search‑functionaliteit verbetert de gebruikerservaring door relevante resultaten te retourneren, zelfs wanneer queries typefouten bevatten. + +## Vereisten +- **Java Development Kit (JDK):** versie 8 of nieuwer. +- **IDE:** IntelliJ IDEA, Eclipse of een andere Java‑compatibele editor. +- **GroupDocs.Search for Java library:** toevoegen via Maven (aanbevolen) of de JAR downloaden. + +## Hoe GroupDocs.Search voor Java in te stellen? + +Om te beginnen voegt u de GroupDocs.Search‑dependency toe aan uw build‑bestand, zorgt u ervoor dat de repository‑URL bereikbaar is en controleert u of de JDK‑versie aan de minimumvereiste voldoet. Nadat de bibliotheek is opgehaald, kunt u de klassen importeren in uw code en een indexmap op schijf aanmaken waar alle doorzoekbare gegevens worden opgeslagen. + +### Maven-configuratie +Voeg de repository en dependency toe aan uw `pom.xml`‑bestand precies zoals weergegeven in de originele gids. + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Directe download +U kunt de JAR ook verkrijgen vanaf de officiële release‑pagina: + +[GroupDocs.Search voor Java releases](https://releases.groupdocs.com/search/java/) + +[GroupDocs.Search-documentatie](https://docs.groupdocs.com/search/java/) + +## Hoe een index maken? + +Maak een persistente indexmap aan waar GroupDocs.Search getokeniseerde gegevens opslaat. Laad uw eerste index met één regel code — `new Index("path/to/indexFolder")`. De `Index`‑klasse is de kerncomponent die een doorzoekbare collectie documenten in het geheugen en op schijf vertegenwoordigt. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Hoe documenten aan de index toevoegen? + +Gebruik de `add`‑methode van de `Index`‑instantie om naar een map te wijzen die uw bronbestanden bevat. De engine scant recursief ondersteunde formaten, extraheert tekstuele inhoud en werkt de interne structuren bij. Deze enkele aanroep verwerkt grote batches efficiënt, waardoor handmatige bestands‑voor‑bestand verwerking niet meer nodig is. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Hoe fuzzy search Java configureren? + +De `FuzzySearchOptions`‑klasse definieert parameters zoals bewerkingsafstand en prefix‑lengte die bepalen hoe tolerant de zoekopdracht is voor spelfouten. Het `SearchOptions`‑object groepeert alle zoek‑tijdinstellingen, inclusief fuzzy‑opties, resultaatslimieten en markeer‑voorkeuren. Schakel fuzzy‑matching in door de `FuzzySearchOptions` in te stellen op het `SearchOptions`‑object. Hierdoor wordt de engine verteld termen binnen een configureerbare bewerkingsafstand te overwegen, waardoor zoekopdrachten tolerant zijn voor spelfouten. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Hoe een zoekbewerking uitvoeren? + +Roep de `search`‑methode aan op het `Index`‑object, waarbij u de query‑string en de geconfigureerde `SearchOptions` opgeeft. De engine verwerkt het verzoek, past fuzzy‑matching toe indien ingeschakeld, en rangschikt resultaten op basis van relevantiescores. De bewerking voltooit snel, zelfs op grote indexen, omdat het zoeken wordt uitgevoerd op vooraf gebouwde token‑structuren. De methode retourneert een `SearchResult`‑collectie met overeenkomende documenten, hit‑aantallen en gemarkeerde fragmenten. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Hoe zoekresultaten verwerken en weergeven? + +`SearchResult` is een collectie die individuele `SearchResultItem`‑objecten bevat, elk beschrijvend een overeenkomend document, het aantal hits en gemarkeerde fragmenten. Iterate over de `SearchResult`‑items en print het pad van elk document, het aantal voorkomens en de overeenkomende zinnen. Deze eenvoudige lus stelt u in staat UI‑tabellen, logs of API‑reacties te bouwen die precies laten zien waarom een document overeenkwam. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## Praktische toepassingen + +Praktijkvoorbeelden waarbij **how to search documents** van belang is: +1. **Legal Document Management:** Zoek clausules of partijen in duizenden contracten binnen enkele seconden. +2. **Academic Research:** Haal relevante papers op, zelfs als de zoekterm verkeerd gespeld is. +3. **Enterprise Content Management:** Voorzie interne portals van snelle, typefout‑tolerante zoekopdrachten over rapporten, e‑mails en presentaties. + +## Prestatiesoverwegingen + +- **Index Refresh:** Voer `add` of `update` opnieuw uit telkens wanneer bronbestanden wijzigen om resultaten actueel te houden. +- **Memory Management:** GroupDocs.Search streamt grote bestanden, waardoor het geheugenverbruik laag blijft, zelfs voor PDF‑bestanden van 500 pagina's. +- **Chunked Indexing:** Splits enorme corpora in meerdere indexmappen om de verwerking te paralleliseren en de query‑latentie te verbeteren. + +## Veelgestelde vragen + +**Q: Wat is fuzzy search Java en waarom is het nuttig?** +A: Fuzzy search Java maakt benaderende tekenreeks‑matching mogelijk, waardoor queries resultaten kunnen retourneren ondanks typefouten of alternatieve spellingen, wat de eindgebruikerservaring verbetert. + +**Q: Hoe werk ik mijn index bij na het toevoegen van nieuwe bestanden?** +A: Roep `index.add("new/files/folder")` opnieuw aan; de bibliotheek voegt nieuwe inhoud intelligent samen zonder de volledige index opnieuw op te bouwen. + +**Q: Kan GroupDocs.Search beveiligde PDF‑bestanden met wachtwoord verwerken?** +A: Ja — geef het wachtwoord op in `DocumentLoadOptions` bij het toevoegen van het bestand, en de engine zal de inhoud ontcijferen en indexeren. + +**Q: Is er een limiet aan het aantal documenten dat ik kan indexeren?** +A: De bibliotheek schaalt tot miljoenen bestanden; de prestaties hangen af van hardware en opslag, niet van een vaste limiet. + +**Q: Waar kan ik meer geavanceerde voorbeelden vinden?** +A: Bezoek de officiële documentatie voor diepere onderwerpen zoals aangepaste analyzers en resultaatsrangschikking. + +## Conclusie + +U weet nu **how to search documents** met GroupDocs.Search voor Java, van het maken van een index tot het inschakelen van fuzzy search Java en het verwerken van resultaten. Implementeer deze stappen om snelle, typefout‑tolerante zoekervaringen te leveren in elke Java‑gebaseerde applicatie. + +--- + +**Laatst bijgewerkt:** 2026-05-28 +**Getest met:** GroupDocs.Search 23.10 for Java +**Auteur:** GroupDocs + +--- + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## Gerelateerde tutorials + +- [Documentindex maken met GroupDocs.Search voor Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Full‑text zoeken implementeren in Java met GroupDocs.Search: een uitgebreide gids](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [Hoe documenten toevoegen aan index met metadata‑indexering in Java met GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/english/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/english/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md index 3fa766ea..f676f3e1 100644 --- a/content/english/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md +++ b/content/english/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -1,43 +1,88 @@ --- -title: "Mastering GroupDocs.Search Java: Fuzzy Search & Document Indexing Guide" -description: "Learn how to efficiently manage and search documents using GroupDocs.Search for Java with fuzzy search capabilities. Discover document indexing best practices." -date: "2025-05-20" +title: "How to Search Documents Using GroupDocs.Search Java" +description: "Learn how to search documents efficiently with GroupDocs.Search for Java, including fuzzy search Java and how to create index for full‑text search." +date: "2026-05-28" weight: 1 url: "/java/searching/groupdocs-search-java-fuzzy-document-indexing/" keywords: -- GroupDocs.Search Java -- fuzzy search Java -- document indexing Java +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching type: docs +schemas: +- type: TechArticle + headline: How to Search Documents Using GroupDocs.Search Java + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + dateModified: '2026-05-28' + author: GroupDocs +- type: HowTo + name: How to Search Documents Using GroupDocs.Search Java + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' +- type: FAQPage + questions: + - question: What is fuzzy search Java and why is it useful? + answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + - question: How do I update my index after adding new files? + answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + - question: Can GroupDocs.Search handle password‑protected PDFs? + answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + - question: Is there a limit to the number of documents I can index? + answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + - question: Where can I find more advanced examples? + answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. --- -# Mastering GroupDocs.Search Java: Fuzzy Search & Document Indexing Guide -## Introduction +# How to Search Documents Using GroupDocs.Search Java -In today's digital world, managing and searching through large volumes of documents is a common challenge for businesses and developers. Whether you're handling contracts, reports, or any document-heavy environment, finding the right information quickly can be daunting. **GroupDocs.Search for Java** offers a powerful solution by allowing efficient creation, management, and searching of indexes. +In modern enterprise applications, **how to search documents** quickly and accurately is a critical requirement. Whether you're dealing with contracts, reports, or any large document repository, GroupDocs.Search for Java gives you a robust, full‑text search engine with built‑in fuzzy matching. This tutorial walks you through setting up the library, creating an index, adding documents, configuring fuzzy search Java, and retrieving results—all with clear, conversational explanations. -In this tutorial, we'll explore how to use GroupDocs.Search for Java to implement fuzzy search with document indexing. By the end of this guide, you'll know how to: -- Set up and initialize an index -- Add documents to your index -- Configure search options with fuzzy search capabilities -- Perform searches and process results +## Quick Answers +- **What is the first step?** Install the GroupDocs.Search Java library via Maven or download it directly. +- **How do I create an index?** Instantiate an `Index` object pointing to a folder on disk; the library builds the searchable structure automatically. +- **Can I search with typos?** Yes—enable fuzzy search to match terms that are misspelled or have slight variations. +- **How to add documents?** Use the `add` method on the `Index` instance, passing the folder that contains your files. +- **What Java version is required?** JDK 8 or higher is supported. -Let's get started by setting up our environment. +## What is “how to search documents” in the context of GroupDocs.Search? +**“How to search documents”** refers to the process of building a searchable index and issuing queries that return matching files, optionally using fuzzy logic to tolerate spelling errors. GroupDocs.Search handles tokenization, indexing, and ranking behind the scenes, so you can focus on business logic. -### Prerequisites +## Why use GroupDocs.Search for Java? +GroupDocs.Search supports **30+ file formats** (including DOCX, PDF, TXT, HTML, and XLSX) and can index **multi‑hundred‑page documents** without loading the entire file into memory, delivering sub‑second query responses on typical server hardware. Its fuzzy search capability improves user experience by returning relevant results even when queries contain typos. -Before we begin, ensure you have the following: -- **Java Development Kit (JDK):** Version 8 or higher. -- **Integrated Development Environment (IDE):** Such as IntelliJ IDEA or Eclipse. -- **GroupDocs.Search for Java Library:** Include it in your project via Maven. +## Prerequisites +- **Java Development Kit (JDK):** version 8 or newer. +- **IDE:** IntelliJ IDEA, Eclipse, or any Java‑compatible editor. +- **GroupDocs.Search for Java library:** add via Maven (recommended) or download the JAR. -### Setting Up GroupDocs.Search for Java +## How to Set Up GroupDocs.Search for Java? -To start using GroupDocs.Search, you'll need to add the library to your project. Here's how you can do this with Maven: +To begin, add the GroupDocs.Search dependency to your build file, ensure the repository URL is reachable, and verify that the JDK version meets the minimum requirement. After the library is resolved, you can import its classes in your code and create an index folder on disk where all searchable data will be stored. -#### Maven Setup - -Add the following repository and dependency to your `pom.xml` file: +### Maven Setup +Add the repository and dependency to your `pom.xml` file exactly as shown in the original guide. ```xml @@ -57,65 +102,56 @@ Add the following repository and dependency to your `pom.xml` file: ``` -#### Direct Download - -Alternatively, you can download the library directly from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). +### Direct Download +Alternatively, obtain the JAR from the official release page: -### License Acquisition +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) -To fully utilize GroupDocs.Search, acquiring a license may be necessary. You can start with a free trial or request a temporary license. For long-term usage, consider purchasing a license. +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) -#### Basic Initialization and Setup +## How to Create an Index? -First, ensure your environment is set up correctly: -1. **Create an Index:** - An index functions as a database of your documents' content for efficient searching. +Create a persistent index folder where GroupDocs.Search stores tokenized data. Load your first index with a single line of code—`new Index("path/to/indexFolder")`. The `Index` class is the core component that represents a searchable collection of documents in memory and on disk. - ```java +```java import com.groupdocs.search.*; String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; Index index = new Index(indexFolder); ``` -2. **Add Documents to the Index:** - Specify the directory containing your documents and add it to the index. +## How to Add Documents to the Index? + +Use the `add` method of the `Index` instance to point to a folder containing your source files. The engine will recursively scan supported formats, extract textual content, and update the internal structures. This single call handles large batches efficiently, eliminating the need for manual file‑by‑file processing. - ```java +```java String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentFolder); ``` -## Implementation Guide +## How to Configure Fuzzy Search Java? -Now, let's break down each feature into manageable sections: +The `FuzzySearchOptions` class defines parameters such as edit distance and prefix length that control how tolerant the search is to misspellings. The `SearchOptions` object groups all search‑time settings, including fuzzy options, result limits, and highlighting preferences. Enable fuzzy matching by setting the `FuzzySearchOptions` on the `SearchOptions` object. This tells the engine to consider terms within a configurable edit distance, making searches tolerant to misspellings. -### Creating and Managing an Index - -**Overview:** This step involves setting up a structure where your documents' content can be stored for quick retrieval. -- **Initialize the Index:** - - ```java +```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; Index index = new Index(indexFolder); ``` -### Adding Documents to the Index +## How to Perform a Search Operation? -**Overview:** This feature allows you to populate your index with documents from a specific directory. -- **Add Document Folder:** +Call the `search` method on the `Index` object, providing the query string and the configured `SearchOptions`. The engine processes the request, applies fuzzy matching if enabled, and ranks results based on relevance scores. The operation completes quickly even on large indexes because the search is performed on pre‑built token structures. The method returns a `SearchResult` collection containing matched documents, hit counts, and highlighted snippets. - ```java +```java String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentFolder); ``` -### Configuring Search Options with Fuzzy Search +## How to Process and Display Search Results? -**Overview:** Enable fuzzy search to allow for approximate matches, useful when dealing with typos or spelling variations. -- **Set Up Fuzzy Search:** +`SearchResult` is a collection that holds individual `SearchResultItem` objects, each describing a matching document, the number of hits, and highlighted snippets. Iterate over the `SearchResult` items and print each document’s path, the number of occurrences, and the matching phrases. This simple loop lets you build UI tables, logs, or API responses that show exactly why a document matched. - ```java +```java import com.groupdocs.search.options.*; SearchOptions options = new SearchOptions(); @@ -123,22 +159,54 @@ Now, let's break down each feature into manageable sections: options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); ``` -### Performing a Search Operation +## Practical Applications + +Real‑world scenarios where **how to search documents** matters: +1. **Legal Document Management:** Locate clauses or parties across thousands of contracts in seconds. +2. **Academic Research:** Retrieve relevant papers even if the search term is misspelled. +3. **Enterprise Content Management:** Power internal portals with fast, typo‑tolerant search across reports, emails, and presentations. + +## Performance Considerations + +- **Index Refresh:** Re‑run `add` or `update` whenever source files change to keep results fresh. +- **Memory Management:** GroupDocs.Search streams large files, so memory footprints stay low even for 500‑page PDFs. +- **Chunked Indexing:** Split massive corpora into multiple index folders to parallelize processing and improve query latency. + +## Frequently Asked Questions + +**Q: What is fuzzy search Java and why is it useful?** +A: Fuzzy search Java enables approximate string matching, allowing queries to return results despite typos or alternate spellings, which improves end‑user experience. + +**Q: How do I update my index after adding new files?** +A: Call `index.add("new/files/folder")` again; the library intelligently merges new content without rebuilding the entire index. + +**Q: Can GroupDocs.Search handle password‑protected PDFs?** +A: Yes—provide the password in the `DocumentLoadOptions` when adding the file, and the engine will decrypt and index the content. + +**Q: Is there a limit to the number of documents I can index?** +A: The library scales to millions of files; performance depends on hardware and storage, not a hard‑coded limit. + +**Q: Where can I find more advanced examples?** +A: Visit the official documentation for deeper topics like custom analyzers and result ranking. + +## Conclusion + +You now know **how to search documents** with GroupDocs.Search for Java, from creating an index to enabling fuzzy search Java and processing results. Implement these steps to deliver fast, typo‑tolerant search experiences in any Java‑based application. + +--- + +**Last Updated:** 2026-05-28 +**Tested With:** GroupDocs.Search 23.10 for Java +**Author:** GroupDocs -**Overview:** Execute searches using the configured options to find documents containing specific terms. -- **Execute Search:** +--- - ```java +```java String query = "water OR \"Lorem ipsum\""; SearchResult result = index.search(query, options); ``` -### Processing and Displaying Search Results - -**Overview:** Handle search results by displaying information about found documents, including paths, occurrence counts, and specific terms. -- **Display Results:** - - ```java +```java for (int i = 0; i < result.getDocumentCount(); i++) { FoundDocument document = result.getFoundDocument(i); System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); @@ -155,50 +223,8 @@ Now, let's break down each feature into manageable sections: } ``` -## Practical Applications - -Here are some real-world use cases where GroupDocs.Search can be invaluable: -1. **Legal Document Management:** Quickly find relevant case files or contracts. -2. **Academic Research:** Search through large volumes of academic papers and articles. -3. **Enterprise Content Management:** Efficiently manage company reports, emails, and other documents. - -## Performance Considerations - -To ensure optimal performance with GroupDocs.Search: -- Regularly update your indexes to reflect new or modified documents. -- Monitor resource usage and optimize memory management in Java applications. -- Use best practices for indexing large datasets by splitting them into manageable chunks. - -## Conclusion - -In this tutorial, you've learned how to create, manage, and search document indices using GroupDocs.Search for Java. With these tools at your disposal, you can efficiently handle document-heavy environments and extract valuable insights quickly. - -As a next step, consider exploring more advanced features of GroupDocs.Search or integrating it with other systems in your workflow. - -## FAQ Section - -1. **What is fuzzy search?** - Fuzzy search allows for approximate matches, helping when searching for terms with slight variations or typos. - -2. **How do I update my index?** - Use the `add` method on the Index object to refresh your documents in the index. - -3. **Can I use GroupDocs.Search with other programming languages?** - Yes, GroupDocs offers similar libraries for .NET and other platforms. - -4. **What are some best practices for optimizing search performance?** - Regularly update indexes, manage memory effectively, and split large datasets into smaller parts if necessary. - -5. **Where can I find more information on advanced features?** - Visit the [GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) for comprehensive guides and API references. - -## Resources -- **Documentation:** https://docs.groupdocs.com/search/java/ -- **API Reference:** https://reference.groupdocs.com/search/java -- **Download:** https://releases.groupdocs.com/search/java/ -- **GitHub Repository:** https://github.com/groupdocs-search/GroupDocs.Search-for-Java -- **Free Support Forum:** https://forum.groupdocs.com/c/search/10 -- **Temporary License:** https://purchase.groupdocs.com/temporary-license/ - -Start implementing GroupDocs.Search for Java today and transform how you manage and search through your documents! +## Related Tutorials +- [Create Document Index with GroupDocs.Search for Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Implement Full-Text Search in Java with GroupDocs.Search: A Comprehensive Guide](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [How to add documents to index with Metadata Indexing in Java using GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) diff --git a/content/french/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/french/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..68a2b7f9 --- /dev/null +++ b/content/french/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,219 @@ +--- +date: '2026-05-28' +description: Apprenez à rechercher des documents efficacement avec GroupDocs.Search + pour Java, y compris la recherche floue Java et comment créer un index pour la recherche + en texte intégral. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: Comment rechercher des documents avec GroupDocs.Search Java +type: docs +url: /fr/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# Comment rechercher des documents avec GroupDocs.Search Java + +Dans les applications d'entreprise modernes, **comment rechercher des documents** rapidement et avec précision est une exigence cruciale. Que vous manipuliez des contrats, des rapports ou tout autre grand référentiel de documents, GroupDocs.Search for Java vous offre un moteur de recherche plein texte robuste avec correspondance floue intégrée. Ce tutoriel vous guide à travers l'installation de la bibliothèque, la création d'un index, l'ajout de documents, la configuration du fuzzy search Java, et la récupération des résultats — le tout avec des explications claires et conversationnelles. + +## Réponses rapides +- **Quelle est la première étape ?** Installez la bibliothèque GroupDocs.Search Java via Maven ou téléchargez‑la directement. +- **Comment créer un index ?** Instanciez un objet `Index` pointant vers un dossier sur le disque ; la bibliothèque construit automatiquement la structure recherchable. +- **Puis‑je rechercher avec des fautes de frappe ?** Oui — activez la recherche floue pour faire correspondre les termes mal orthographiés ou légèrement différents. +- **Comment ajouter des documents ?** Utilisez la méthode `add` sur l'instance `Index`, en passant le dossier contenant vos fichiers. +- **Quelle version de Java est requise ?** JDK 8 ou supérieur est pris en charge. + +## Qu'est‑ce que « comment rechercher des documents » dans le contexte de GroupDocs.Search ? +**« Comment rechercher des documents »** désigne le processus de création d'un index recherchable et d'émission de requêtes renvoyant les fichiers correspondants, éventuellement en utilisant une logique floue pour tolérer les erreurs d'orthographe. GroupDocs.Search gère la tokenisation, l'indexation et le classement en arrière‑plan, vous permettant de vous concentrer sur la logique métier. + +## Pourquoi utiliser GroupDocs.Search pour Java ? +GroupDocs.Search prend en charge **plus de 30 formats de fichiers** (y compris DOCX, PDF, TXT, HTML et XLSX) et peut indexer des **documents de plusieurs centaines de pages** sans charger le fichier complet en mémoire, offrant des réponses aux requêtes en moins d’une seconde sur du matériel serveur typique. Sa capacité de recherche floue améliore l'expérience utilisateur en renvoyant des résultats pertinents même lorsque les requêtes contiennent des fautes de frappe. + +## Prérequis +- **Java Development Kit (JDK) :** version 8 ou plus récente. +- **IDE :** IntelliJ IDEA, Eclipse ou tout éditeur compatible Java. +- **Bibliothèque GroupDocs.Search pour Java :** ajoutez‑la via Maven (recommandé) ou téléchargez le JAR. + +## Comment configurer GroupDocs.Search pour Java ? +Pour commencer, ajoutez la dépendance GroupDocs.Search à votre fichier de construction, assurez‑vous que l'URL du dépôt est accessible et vérifiez que la version du JDK répond aux exigences minimales. Une fois la bibliothèque résolue, vous pouvez importer ses classes dans votre code et créer un dossier d'index sur le disque où toutes les données recherchables seront stockées. + +### Configuration Maven +Ajoutez le dépôt et la dépendance à votre fichier `pom.xml` exactement comme indiqué dans le guide original. + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Téléchargement direct +Sinon, obtenez le JAR depuis la page de version officielle : + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## Comment créer un index ? +Créez un dossier d'index persistant où GroupDocs.Search stocke les données tokenisées. Chargez votre premier index avec une seule ligne de code —`new Index("path/to/indexFolder")`. La classe `Index` est le composant central qui représente une collection de documents recherchables en mémoire et sur disque. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Comment ajouter des documents à l'index ? +Utilisez la méthode `add` de l'instance `Index` pour pointer vers un dossier contenant vos fichiers source. Le moteur analysera récursivement les formats pris en charge, extraira le contenu textuel et mettra à jour les structures internes. Cet appel unique gère efficacement les gros lots, éliminant le besoin d'un traitement manuel fichier par fichier. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Comment configurer la recherche floue Java ? +La classe `FuzzySearchOptions` définit des paramètres tels que la distance d'édition et la longueur du préfixe qui contrôlent la tolérance de la recherche aux fautes d'orthographe. L'objet `SearchOptions` regroupe tous les paramètres d'exécution de la recherche, y compris les options floues, les limites de résultats et les préférences de mise en évidence. Activez la correspondance floue en définissant `FuzzySearchOptions` sur l'objet `SearchOptions`. Cela indique au moteur de prendre en compte les termes dans une distance d'édition configurable, rendant les recherches tolérantes aux fautes d'orthographe. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Comment effectuer une opération de recherche ? +Appelez la méthode `search` sur l'objet `Index`, en fournissant la chaîne de requête et les `SearchOptions` configurées. Le moteur traite la requête, applique la correspondance floue si elle est activée, et classe les résultats en fonction des scores de pertinence. L'opération se termine rapidement même sur de grands index car la recherche s'effectue sur des structures de tokens pré‑construites. La méthode renvoie une collection `SearchResult` contenant les documents correspondants, le nombre de correspondances et les extraits mis en évidence. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Comment traiter et afficher les résultats de recherche ? +`SearchResult` est une collection qui contient des objets `SearchResultItem` individuels, chacun décrivant un document correspondant, le nombre de correspondances et les extraits mis en évidence. Parcourez les éléments de `SearchResult` et affichez le chemin de chaque document, le nombre d'occurrences et les phrases correspondantes. Cette boucle simple vous permet de créer des tableaux d'interface, des journaux ou des réponses d'API qui montrent exactement pourquoi un document a été retenu. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## Applications pratiques +Scénarios réels où **comment rechercher des documents** est important : +1. **Gestion de documents juridiques :** Localisez des clauses ou des parties à travers des milliers de contrats en quelques secondes. +2. **Recherche académique :** Récupérez des articles pertinents même si le terme de recherche est mal orthographié. +3. **Gestion de contenu d'entreprise :** Alimentez les portails internes avec une recherche rapide et tolérante aux fautes de frappe à travers les rapports, les e‑mails et les présentations. + +## Considérations de performance +- **Actualisation de l'index :** Réexécutez `add` ou `update` chaque fois que les fichiers source changent pour garder les résultats à jour. +- **Gestion de la mémoire :** GroupDocs.Search diffuse les gros fichiers, de sorte que l'empreinte mémoire reste faible même pour des PDF de 500 pages. +- **Indexation par morceaux :** Divisez les corpus massifs en plusieurs dossiers d'index pour paralléliser le traitement et améliorer la latence des requêtes. + +## Questions fréquemment posées +**Q : Qu'est‑ce que la recherche floue Java et pourquoi est‑elle utile ?** +R : La recherche floue Java permet une correspondance approximative de chaînes, autorisant les requêtes à renvoyer des résultats malgré les fautes de frappe ou les orthographes alternatives, ce qui améliore l'expérience de l'utilisateur final. + +**Q : Comment mettre à jour mon index après avoir ajouté de nouveaux fichiers ?** +R : Appelez à nouveau `index.add("new/files/folder")` ; la bibliothèque fusionne intelligemment le nouveau contenu sans reconstruire l'intégralité de l'index. + +**Q : GroupDocs.Search peut‑il gérer les PDF protégés par mot de passe ?** +R : Oui — fournissez le mot de passe dans `DocumentLoadOptions` lors de l'ajout du fichier, et le moteur déchiffrera et indexera le contenu. + +**Q : Existe‑t‑il une limite au nombre de documents que je peux indexer ?** +R : La bibliothèque peut évoluer jusqu'à des millions de fichiers ; les performances dépendent du matériel et du stockage, pas d'une limite codée en dur. + +**Q : Où puis‑je trouver des exemples plus avancés ?** +R : Consultez la documentation officielle pour des sujets plus approfondis comme les analyseurs personnalisés et le classement des résultats. + +## Conclusion +Vous savez maintenant **comment rechercher des documents** avec GroupDocs.Search pour Java, depuis la création d'un index jusqu'à l'activation de la recherche floue Java et le traitement des résultats. Mettez en œuvre ces étapes pour offrir des expériences de recherche rapides et tolérantes aux fautes de frappe dans toute application Java. + +--- + +**Dernière mise à jour :** 2026-05-28 +**Testé avec :** GroupDocs.Search 23.10 for Java +**Auteur :** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## Tutoriels associés +- [Créer un index de documents avec GroupDocs.Search pour Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Implémenter la recherche plein texte en Java avec GroupDocs.Search : Guide complet](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [Comment ajouter des documents à l'index avec l'indexation des métadonnées en Java utilisant GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/german/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/german/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..648814d8 --- /dev/null +++ b/content/german/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,219 @@ +--- +date: '2026-05-28' +description: Erfahren Sie, wie Sie Dokumente effizient mit GroupDocs.Search für Java + durchsuchen, einschließlich fuzzy search Java und wie Sie einen Index für full‑text + search erstellen. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: Wie man Dokumente mit GroupDocs.Search Java durchsucht +type: docs +url: /de/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# Wie man Dokumente mit GroupDocs.Search Java sucht + +In modernen Unternehmensanwendungen ist **wie man Dokumente sucht** schnell und genau eine kritische Anforderung. Egal, ob Sie mit Verträgen, Berichten oder einem großen Dokumenten-Repository arbeiten, GroupDocs.Search für Java bietet Ihnen eine robuste Volltext‑Suchmaschine mit integrierter Fuzzy‑Suche. Dieses Tutorial führt Sie durch die Einrichtung der Bibliothek, das Erstellen eines Index, das Hinzufügen von Dokumenten, die Konfiguration von Fuzzy Search Java und das Abrufen von Ergebnissen – alles mit klaren, gesprächigen Erklärungen. + +## Schnelle Antworten +- **Was ist der erste Schritt?** Installieren Sie die GroupDocs.Search Java-Bibliothek über Maven oder laden Sie sie direkt herunter. +- **Wie erstelle ich einen Index?** Instanziieren Sie ein `Index`‑Objekt, das auf einen Ordner auf der Festplatte verweist; die Bibliothek erstellt die durchsuchbare Struktur automatisch. +- **Kann ich mit Tippfehlern suchen?** Ja – aktivieren Sie die Fuzzy‑Suche, um Begriffe zu finden, die falsch geschrieben sind oder leichte Abweichungen aufweisen. +- **Wie fügt man Dokumente hinzu?** Verwenden Sie die `add`‑Methode des `Index`‑Objekts und übergeben Sie den Ordner, der Ihre Dateien enthält. +- **Welche Java-Version ist erforderlich?** JDK 8 oder höher wird unterstützt. + +## Was bedeutet „wie man Dokumente sucht“ im Kontext von GroupDocs.Search? +**„Wie man Dokumente sucht“** bezieht sich auf den Prozess, einen durchsuchbaren Index zu erstellen und Anfragen zu stellen, die passende Dateien zurückliefern, optional unter Verwendung von Fuzzy‑Logik, um Rechtschreibfehler zu tolerieren. GroupDocs.Search übernimmt Tokenisierung, Indexierung und Ranking im Hintergrund, sodass Sie sich auf die Geschäftslogik konzentrieren können. + +## Warum GroupDocs.Search für Java verwenden? +GroupDocs.Search unterstützt **30+ Dateiformate** (einschließlich DOCX, PDF, TXT, HTML und XLSX) und kann **mehrseitige Dokumente** indizieren, ohne die gesamte Datei in den Speicher zu laden, und liefert subsekundäre Abfrageantworten auf typischer Serverhardware. Die Fuzzy‑Suchfunktion verbessert die Benutzererfahrung, indem sie relevante Ergebnisse zurückgibt, selbst wenn Anfragen Tippfehler enthalten. + +## Voraussetzungen +- **Java Development Kit (JDK):** Version 8 oder neuer. +- **IDE:** IntelliJ IDEA, Eclipse oder ein beliebiger Java‑kompatibler Editor. +- **GroupDocs.Search for Java library:** über Maven hinzufügen (empfohlen) oder das JAR herunterladen. + +## Wie richtet man GroupDocs.Search für Java ein? +Um zu beginnen, fügen Sie die GroupDocs.Search‑Abhängigkeit zu Ihrer Build‑Datei hinzu, stellen Sie sicher, dass die Repository‑URL erreichbar ist, und prüfen Sie, dass die JDK‑Version die Mindestanforderung erfüllt. Nachdem die Bibliothek aufgelöst wurde, können Sie deren Klassen in Ihrem Code importieren und einen Index‑Ordner auf der Festplatte erstellen, in dem alle durchsuchbaren Daten gespeichert werden. + +### Maven‑Einrichtung +Fügen Sie das Repository und die Abhängigkeit zu Ihrer `pom.xml`‑Datei genau wie im Originalleitfaden gezeigt hinzu. + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Direkter Download +Alternativ können Sie das JAR von der offiziellen Release‑Seite beziehen: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## Wie erstellt man einen Index? +Erstellen Sie einen persistenten Index‑Ordner, in dem GroupDocs.Search tokenisierte Daten speichert. Laden Sie Ihren ersten Index mit einer einzigen Codezeile – `new Index("path/to/indexFolder")`. Die `Index`‑Klasse ist die Kernkomponente, die eine durchsuchbare Sammlung von Dokumenten im Speicher und auf der Festplatte repräsentiert. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Wie fügt man Dokumente zum Index hinzu? +Verwenden Sie die `add`‑Methode der `Index`‑Instanz, um auf einen Ordner zu verweisen, der Ihre Quelldateien enthält. Die Engine scannt rekursiv unterstützte Formate, extrahiert den Textinhalt und aktualisiert die internen Strukturen. Dieser einzelne Aufruf verarbeitet große Stapel effizient und eliminiert die Notwendigkeit einer manuellen Datei‑für‑Datei‑Verarbeitung. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Wie konfiguriert man Fuzzy Search Java? +Die Klasse `FuzzySearchOptions` definiert Parameter wie Editierdistanz und Präfixlänge, die steuern, wie tolerant die Suche gegenüber Rechtschreibfehlern ist. Das Objekt `SearchOptions` fasst alle Suchzeit‑Einstellungen zusammen, einschließlich Fuzzy‑Optionen, Ergebnislimits und Hervorhebungspräferenzen. Aktivieren Sie die Fuzzy‑Übereinstimmung, indem Sie die `FuzzySearchOptions` im `SearchOptions`‑Objekt setzen. Dadurch wird die Engine angewiesen, Begriffe innerhalb einer konfigurierbaren Editierdistanz zu berücksichtigen, wodurch Suchvorgänge tolerant gegenüber Rechtschreibfehlern werden. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Wie führt man eine Suchoperation aus? +Rufen Sie die `search`‑Methode des `Index`‑Objekts auf und übergeben Sie den Abfrage‑String sowie die konfigurierten `SearchOptions`. Die Engine verarbeitet die Anfrage, wendet bei Aktivierung Fuzzy‑Matching an und sortiert die Ergebnisse nach Relevanz‑Scores. Der Vorgang schließt schnell ab, selbst bei großen Indizes, da die Suche auf vorgefertigten Token‑Strukturen basiert. Die Methode gibt eine `SearchResult`‑Sammlung zurück, die passende Dokumente, Trefferzahlen und hervorgehobene Ausschnitte enthält. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Wie verarbeitet und zeigt man Suchergebnisse an? +`SearchResult` ist eine Sammlung, die einzelne `SearchResultItem`‑Objekte enthält, von denen jedes ein passendes Dokument, die Anzahl der Treffer und hervorgehobene Ausschnitte beschreibt. Iterieren Sie über die `SearchResult`‑Einträge und geben Sie den Pfad jedes Dokuments, die Anzahl der Vorkommen und die passenden Phrasen aus. Diese einfache Schleife ermöglicht es Ihnen, UI‑Tabellen, Protokolle oder API‑Antworten zu erstellen, die genau zeigen, warum ein Dokument übereinstimmte. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## Praktische Anwendungsfälle +Echte Anwendungsfälle, bei denen **wie man Dokumente sucht** wichtig ist: +1. **Legal Document Management:** Finden Sie Klauseln oder Parteien in Tausenden von Verträgen in Sekunden. +2. **Academic Research:** Rufen Sie relevante Arbeiten ab, selbst wenn der Suchbegriff falsch geschrieben ist. +3. **Enterprise Content Management:** Versorgen Sie interne Portale mit schneller, tipptoleranter Suche über Berichte, E‑Mails und Präsentationen. + +## Leistungsüberlegungen +- **Index Refresh:** Führen Sie `add` oder `update` erneut aus, sobald sich Quelldateien ändern, um die Ergebnisse aktuell zu halten. +- **Memory Management:** GroupDocs.Search streamt große Dateien, sodass der Speicherverbrauch selbst bei 500‑Seiten‑PDFs gering bleibt. +- **Chunked Indexing:** Teilen Sie massive Korpora in mehrere Index‑Ordner, um die Verarbeitung zu parallelisieren und die Abfrage‑Latenz zu verbessern. + +## Häufig gestellte Fragen +**Q: Was ist Fuzzy Search Java und warum ist es nützlich?** +A: Fuzzy Search Java ermöglicht die ungefähre Zeichenketten‑Übereinstimmung, sodass Anfragen Ergebnisse zurückliefern, trotz Tippfehlern oder alternativen Schreibweisen, was die End‑User‑Erfahrung verbessert. + +**Q: Wie aktualisiere ich meinen Index nach dem Hinzufügen neuer Dateien?** +A: Rufen Sie `index.add("new/files/folder")` erneut auf; die Bibliothek fügt neue Inhalte intelligent zusammen, ohne den gesamten Index neu zu erstellen. + +**Q: Kann GroupDocs.Search passwortgeschützte PDFs verarbeiten?** +A: Ja – geben Sie das Passwort in den `DocumentLoadOptions` beim Hinzufügen der Datei an, und die Engine entschlüsselt und indiziert den Inhalt. + +**Q: Gibt es ein Limit für die Anzahl der Dokumente, die ich indexieren kann?** +A: Die Bibliothek skaliert auf Millionen von Dateien; die Leistung hängt von Hardware und Speicher ab, nicht von einer fest codierten Grenze. + +**Q: Wo finde ich weiterführende Beispiele?** +A: Besuchen Sie die offizielle Dokumentation für tiefere Themen wie benutzerdefinierte Analyzer und Ergebnis‑Ranking. + +## Fazit +Sie wissen jetzt, **wie man Dokumente** mit GroupDocs.Search für Java sucht, vom Erstellen eines Index über das Aktivieren von Fuzzy Search Java bis hin zur Verarbeitung der Ergebnisse. Implementieren Sie diese Schritte, um schnelle, tipptolerante Sucherlebnisse in jeder Java‑basierten Anwendung zu bieten. + +--- + +**Zuletzt aktualisiert:** 2026-05-28 +**Getestet mit:** GroupDocs.Search 23.10 for Java +**Autor:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## Verwandte Tutorials +- [Create Document Index with GroupDocs.Search for Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Implement Full-Text Search in Java with GroupDocs.Search: A Comprehensive Guide](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [How to add documents to index with Metadata Indexing in Java using GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/greek/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/greek/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..699ed3c8 --- /dev/null +++ b/content/greek/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,220 @@ +--- +date: '2026-05-28' +description: Μάθετε πώς να αναζητάτε έγγραφα αποδοτικά με το GroupDocs.Search για + Java, συμπεριλαμβανομένης της fuzzy search Java και του πώς να δημιουργήσετε index + για full‑text search. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: Πώς να αναζητήσετε έγγραφα χρησιμοποιώντας το GroupDocs.Search Java +type: docs +url: /el/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# Πώς να Αναζητήσετε Έγγραφα Χρησιμοποιώντας το GroupDocs.Search Java + +Σε σύγχρονες επιχειρηματικές εφαρμογές, η **πώς να αναζητήσετε έγγραφα** γρήγορα και με ακρίβεια είναι μια κρίσιμη απαίτηση. Είτε διαχειρίζεστε συμβάσεις, εκθέσεις ή οποιοδήποτε μεγάλο αποθετήριο εγγράφων, το GroupDocs.Search για Java σας παρέχει μια ισχυρή μηχανή πλήρους κειμένου με ενσωματωμένη ασαφή αντιστοίχιση. Αυτό το σεμινάριο σας καθοδηγεί στη ρύθμιση της βιβλιοθήκης, τη δημιουργία ευρετηρίου, την προσθήκη εγγράφων, τη διαμόρφωση της ασαφούς αναζήτησης Java και την ανάκτηση αποτελεσμάτων—όλα με σαφείς, συνομιλιακούς επεξηγήσεις. + +## Γρήγορες Απαντήσεις +- **Ποιο είναι το πρώτο βήμα;** Εγκαταστήστε τη βιβλιοθήκη GroupDocs.Search Java μέσω Maven ή κατεβάστε την απευθείας. +- **Πώς δημιουργώ ένα ευρετήριο;** Δημιουργήστε ένα αντικείμενο `Index` που δείχνει σε έναν φάκελο στο δίσκο· η βιβλιοθήκη δημιουργεί αυτόματα τη δομή αναζήτησης. +- **Μπορώ να αναζητήσω με τυπογραφικά λάθη;** Ναι—ενεργοποιήστε την ασαφή αναζήτηση για να ταιριάζει με όρους που είναι λανθασμένα γραμμένοι ή έχουν μικρές παραλλαγές. +- **Πώς να προσθέσετε έγγραφα;** Χρησιμοποιήστε τη μέθοδο `add` στο αντικείμενο `Index`, περνώντας το φάκελο που περιέχει τα αρχεία σας. +- **Ποια έκδοση Java απαιτείται;** Υποστηρίζεται το JDK 8 ή νεότερο. + +## Τι σημαίνει “πώς να αναζητήσετε έγγραφα” στο πλαίσιο του GroupDocs.Search; +**“Πώς να αναζητήσετε έγγραφα”** αναφέρεται στη διαδικασία δημιουργίας ενός αναζητήσιμου ευρετηρίου και εκτέλεσης ερωτημάτων που επιστρέφουν αρχεία που ταιριάζουν, προαιρετικά χρησιμοποιώντας ασαφή λογική για να αντέχει σε ορθογραφικά λάθη. Το GroupDocs.Search διαχειρίζεται την τοκενικοποίηση, την ευρετηρίαση και την κατάταξη στο παρασκήνιο, ώστε να μπορείτε να εστιάσετε στη λογική της επιχείρησης. + +## Γιατί να χρησιμοποιήσετε το GroupDocs.Search για Java; +Το GroupDocs.Search υποστηρίζει **πάνω από 30 μορφές αρχείων** (συμπεριλαμβανομένων των DOCX, PDF, TXT, HTML και XLSX) και μπορεί να ευρετηριάσει **έγγραφα με εκατοντάδες σελίδες** χωρίς να φορτώνει ολόκληρο το αρχείο στη μνήμη, παρέχοντας απαντήσεις ερωτημάτων κάτω από το δευτερόλεπτο σε τυπικό εξοπλισμό διακομιστή. Η δυνατότητα ασαφούς αναζήτησης βελτιώνει την εμπειρία του χρήστη επιστρέφοντας σχετικά αποτελέσματα ακόμη και όταν τα ερωτήματα περιέχουν τυπογραφικά λάθη. + +## Προαπαιτούμενα +- **Java Development Kit (JDK):** έκδοση 8 ή νεότερη. +- **IDE:** IntelliJ IDEA, Eclipse ή οποιονδήποτε επεξεργαστή συμβατό με Java. +- **Βιβλιοθήκη GroupDocs.Search για Java:** προσθέστε μέσω Maven (συνιστάται) ή κατεβάστε το JAR. + +## Πώς να Ρυθμίσετε το GroupDocs.Search για Java; +Για να ξεκινήσετε, προσθέστε την εξάρτηση GroupDocs.Search στο αρχείο κατασκευής σας, βεβαιωθείτε ότι το URL του αποθετηρίου είναι προσβάσιμο και επαληθεύστε ότι η έκδοση του JDK πληροί την ελάχιστη απαίτηση. Αφού η βιβλιοθήκη λυθεί, μπορείτε να εισάγετε τις κλάσεις της στον κώδικά σας και να δημιουργήσετε έναν φάκελο ευρετηρίου στο δίσκο όπου θα αποθηκεύονται όλα τα αναζητήσιμα δεδομένα. + +### Ρύθμιση 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/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## Πώς να Δημιουργήσετε ένα Ευρετήριο; +Δημιουργήστε έναν μόνιμο φάκελο ευρετηρίου όπου το GroupDocs.Search αποθηκεύει τα τοκενικοποιημένα δεδομένα. Φορτώστε το πρώτο σας ευρετήριο με μια μόνο γραμμή κώδικα—`new Index("path/to/indexFolder")`. Η κλάση `Index` είναι το κύριο στοιχείο που αντιπροσωπεύει μια αναζητήσιμη συλλογή εγγράφων στη μνήμη και στο δίσκο. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Πώς να Προσθέσετε Έγγραφα στο Ευρετήριο; +Χρησιμοποιήστε τη μέθοδο `add` του αντικειμένου `Index` για να δείξετε σε έναν φάκελο που περιέχει τα πηγαία σας αρχεία. Η μηχανή θα σαρώσει αναδρομικά τις υποστηριζόμενες μορφές, θα εξάγει το κειμενικό περιεχόμενο και θα ενημερώσει τις εσωτερικές δομές. Αυτή η ενιαία κλήση διαχειρίζεται μεγάλες παρτίδες αποδοτικά, εξαλείφοντας την ανάγκη για χειροκίνητη επεξεργασία αρχείου‑αρχείου. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Πώς να Διαμορφώσετε την Ασαφή Αναζήτηση Java; +Η κλάση `FuzzySearchOptions` ορίζει παραμέτρους όπως η απόσταση επεξεργασίας και το μήκος προθέματος που ελέγχουν πόσο ανεκτική είναι η αναζήτηση σε ορθογραφικά λάθη. Το αντικείμενο `SearchOptions` ομαδοποιεί όλες τις ρυθμίσεις χρόνου αναζήτησης, συμπεριλαμβανομένων των ασαφών επιλογών, των ορίων αποτελεσμάτων και των προτιμήσεων επισήμανσης. Ενεργοποιήστε την ασαφή αντιστοίχιση ορίζοντας το `FuzzySearchOptions` στο αντικείμενο `SearchOptions`. Αυτό ενημερώνει τη μηχανή να λαμβάνει υπόψη όρους εντός μιας ρυθμιζόμενης απόστασης επεξεργασίας, κάνοντας τις αναζητήσεις ανεκτικές σε ορθογραφικά λάθη. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Πώς να Εκτελέσετε μια Λειτουργία Αναζήτησης; +Καλέστε τη μέθοδο `search` στο αντικείμενο `Index`, παρέχοντας τη συμβολοσειρά ερωτήματος και τις ρυθμισμένες `SearchOptions`. Η μηχανή επεξεργάζεται το αίτημα, εφαρμόζει ασαφή αντιστοίχιση εάν είναι ενεργοποιημένη, και ταξινομεί τα αποτελέσματα βάσει βαθμολογιών συνάφειας. Η λειτουργία ολοκληρώνεται γρήγορα ακόμη και σε μεγάλα ευρετήρια επειδή η αναζήτηση εκτελείται σε προ‑δημιουργημένες δομές τοκενών. Η μέθοδος επιστρέφει μια συλλογή `SearchResult` που περιέχει τα ταιριαστά έγγραφα, τον αριθμό των εμφανίσεων και τα επισημασμένα αποσπάσματα. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Πώς να Επεξεργαστείτε και Εμφανίσετε τα Αποτελέσματα Αναζήτησης; +`SearchResult` είναι μια συλλογή που περιέχει μεμονωμένα αντικείμενα `SearchResultItem`, το καθένα περιγράφει ένα ταιριαστό έγγραφο, τον αριθμό των εμφανίσεων και τα επισημασμένα αποσπάσματα. Επανάλαβε τα στοιχεία του `SearchResult` και εκτύπωσε τη διαδρομή κάθε εγγράφου, τον αριθμό των εμφανίσεων και τις ταιριαστές φράσεις. Αυτός ο απλός βρόχος σας επιτρέπει να δημιουργήσετε πίνακες UI, αρχεία καταγραφής ή απαντήσεις API που δείχνουν ακριβώς γιατί ένα έγγραφο ταιριάζει. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## Πρακτικές Εφαρμογές +Πραγματικά σενάρια όπου η **πώς να αναζητήσετε έγγραφα** είναι σημαντική: +1. **Διαχείριση Νομικών Εγγράφων:** Εντοπίστε ρήτρες ή μέρη σε χιλιάδες συμβάσεις σε δευτερόλεπτα. +2. **Ακαδημαϊκή Έρευνα:** Ανακτήστε σχετικές εργασίες ακόμη και αν ο όρος αναζήτησης είναι λανθασμένος. +3. **Διαχείριση Περιεχομένου Επιχείρησης:** Ενισχύστε εσωτερικές πύλες με γρήγορη, ανεκτική σε τυπογραφικά λάθη αναζήτηση σε εκθέσεις, email και παρουσιάσεις. + +## Σκέψεις Απόδοσης +- **Ανανέωση Ευρετηρίου:** Εκτελέστε ξανά `add` ή `update` όποτε αλλάξουν τα πηγαία αρχεία για να διατηρήσετε τα αποτελέσματα φρέσκα. +- **Διαχείριση Μνήμης:** Το GroupDocs.Search μεταδίδει μεγάλα αρχεία, έτσι το αποτύπωμα μνήμης παραμένει χαμηλό ακόμη και για PDF 500 σελίδων. +- **Τμηματική Ευρετηρίαση:** Διαχωρίστε τεράστια σώματα κειμένου σε πολλαπλούς φακέλους ευρετηρίου για να παραλληλοποιήσετε την επεξεργασία και να βελτιώσετε την καθυστέρηση ερωτημάτων. + +## Συχνές Ερωτήσεις +**Q: Τι είναι η ασαφή αναζήτηση Java και γιατί είναι χρήσιμη;** +A: Η ασαφή αναζήτηση Java επιτρέπει προσεγγιστική αντιστοίχιση συμβολοσειρών, επιτρέποντας στα ερωτήματα να επιστρέφουν αποτελέσματα παρά τα τυπογραφικά λάθη ή εναλλακτικές ορθογραφίες, κάτι που βελτιώνει την εμπειρία του τελικού χρήστη. + +**Q: Πώς ενημερώνω το ευρετήριό μου μετά την προσθήκη νέων αρχείων;** +A: Καλέστε ξανά `index.add("new/files/folder")`; η βιβλιοθήκη ενώνει έξυπνα το νέο περιεχόμενο χωρίς να ξαναχτίσει ολόκληρο το ευρετήριο. + +**Q: Μπορεί το GroupDocs.Search να διαχειριστεί PDF με κωδικό πρόσβασης;** +A: Ναι—παρέχετε τον κωδικό στο `DocumentLoadOptions` κατά την προσθήκη του αρχείου, και η μηχανή θα αποκρυπτογραφήσει και θα ευρετηριάσει το περιεχόμενο. + +**Q: Υπάρχει όριο στον αριθμό των εγγράφων που μπορώ να ευρετηριάσω;** +A: Η βιβλιοθήκη κλιμακώνεται σε εκατομμύρια αρχεία· η απόδοση εξαρτάται από το υλικό και την αποθήκευση, όχι από κάποιο σκληρό όριο. + +**Q: Πού μπορώ να βρω πιο προχωρημένα παραδείγματα;** +A: Επισκεφθείτε την επίσημη τεκμηρίωση για πιο προχωρημένα θέματα όπως προσαρμοσμένοι αναλυτές και κατάταξη αποτελεσμάτων. + +## Συμπέρασμα +Τώρα γνωρίζετε **πώς να αναζητήσετε έγγραφα** με το GroupDocs.Search για Java, από τη δημιουργία ευρετηρίου μέχρι την ενεργοποίηση της ασαφούς αναζήτησης Java και την επεξεργασία των αποτελεσμάτων. Εφαρμόστε αυτά τα βήματα για να προσφέρετε γρήγορες, ανεκτικές σε τυπογραφικά λάθη εμπειρίες αναζήτησης σε οποιαδήποτε εφαρμογή βασισμένη σε Java. + +--- + +**Last Updated:** 2026-05-28 +**Tested With:** GroupDocs.Search 23.10 for Java +**Author:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## Σχετικά Μαθήματα + +- [Create Document Index with GroupDocs.Search for Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Implement Full-Text Search in Java with GroupDocs.Search: A Comprehensive Guide](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [How to add documents to index with Metadata Indexing in Java using GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/hindi/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/hindi/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..3a655fc4 --- /dev/null +++ b/content/hindi/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,230 @@ +--- +date: '2026-05-28' +description: GroupDocs.Search for Java के साथ दस्तावेज़ों को प्रभावी ढंग से खोजने + का तरीका सीखें, जिसमें fuzzy search Java और full-text search के लिए इंडेक्स बनाना + शामिल है। +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: GroupDocs.Search Java का उपयोग करके दस्तावेज़ कैसे खोजें +type: docs +url: /hi/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# GroupDocs.Search Java का उपयोग करके दस्तावेज़ खोजने का तरीका + +आधुनिक एंटरप्राइज़ एप्लिकेशनों में, **दस्तावेज़ कैसे खोजें** को तेज़ और सटीक रूप से करना एक महत्वपूर्ण आवश्यकता है। चाहे आप अनुबंधों, रिपोर्टों या किसी बड़े दस्तावेज़ रिपॉज़िटरी से निपट रहे हों, GroupDocs.Search for Java आपको एक मजबूत, फुल‑टेक्स्ट सर्च इंजन प्रदान करता है जिसमें बिल्ट‑इन फज़ी मैचिंग होती है। यह ट्यूटोरियल लाइब्रेरी सेटअप, इंडेक्स बनाना, दस्तावेज़ जोड़ना, फज़ी सर्च Java को कॉन्फ़िगर करना, और परिणाम प्राप्त करने की प्रक्रिया को स्पष्ट, संवादात्मक व्याख्याओं के साथ दर्शाता है। + +## त्वरित उत्तर +- **पहला कदम क्या है?** Maven के माध्यम से GroupDocs.Search Java लाइब्रेरी इंस्टॉल करें या इसे सीधे डाउनलोड करें। +- **मैं इंडेक्स कैसे बनाऊँ?** डिस्क पर किसी फ़ोल्डर की ओर इशारा करने वाला `Index` ऑब्जेक्ट इंस्टैंशिएट करें; लाइब्रेरी स्वचालित रूप से सर्चेबल स्ट्रक्चर बनाती है। +- **क्या मैं टाइपो के साथ खोज सकता हूँ?** हाँ—फ़ज़ी सर्च को सक्षम करें ताकि गलत वर्तनी या हल्के अंतर वाले शब्दों से मेल हो सके। +- **दस्तावेज़ कैसे जोड़ें?** `Index` इंस्टेंस पर `add` मेथड का उपयोग करें और वह फ़ोल्डर पास करें जिसमें आपकी फ़ाइलें हों। +- **कौन सा जावा संस्करण आवश्यक है?** JDK 8 या उससे ऊपर समर्थित है। + +## “दस्तावेज़ कैसे खोजें” का अर्थ GroupDocs.Search के संदर्भ में क्या है? +**“दस्तावेज़ कैसे खोजें”** वह प्रक्रिया है जिसमें एक सर्चेबल इंडेक्स बनाया जाता है और क्वेरी जारी की जाती है जो मिलते‑जुलते फ़ाइलें लौटाती है, वैकल्पिक रूप से फ़ज़ी लॉजिक का उपयोग करके वर्तनी त्रुटियों को सहन किया जाता है। GroupDocs.Search टोकनाइज़ेशन, इंडेक्सिंग, और रैंकिंग को बैकएंड में संभालता है, जिससे आप बिज़नेस लॉजिक पर ध्यान केंद्रित कर सकते हैं। + +## GroupDocs.Search for Java क्यों उपयोग करें? +GroupDocs.Search **30+ फ़ाइल फ़ॉर्मैट** (जैसे DOCX, PDF, TXT, HTML, और XLSX) को सपोर्ट करता है और **सैकड़ों‑पृष्ठ वाले दस्तावेज़** को पूरी फ़ाइल को मेमोरी में लोड किए बिना इंडेक्स कर सकता है, जिससे सामान्य सर्वर हार्डवेयर पर सब‑सेकंड क्वेरी प्रतिक्रियाएँ मिलती हैं। इसकी फ़ज़ी सर्च क्षमता उपयोगकर्ता अनुभव को बेहतर बनाती है, क्योंकि टाइपो वाले क्वेरी में भी प्रासंगिक परिणाम लौटाए जाते हैं। + +## आवश्यकताएँ +- **Java Development Kit (JDK):** संस्करण 8 या नया। +- **IDE:** IntelliJ IDEA, Eclipse, या कोई भी Java‑संगत एडिटर। +- **GroupDocs.Search for Java लाइब्रेरी:** Maven के माध्यम से जोड़ें (सिफ़ारिश) या JAR डाउनलोड करें। + +## GroupDocs.Search for Java को कैसे सेट अप करें? + +शुरू करने के लिए, अपने बिल्ड फ़ाइल में GroupDocs.Search डिपेंडेंसी जोड़ें, सुनिश्चित करें कि रिपॉज़िटरी URL पहुँच योग्य है, और जाँचें कि JDK संस्करण न्यूनतम आवश्यकता को पूरा करता है। लाइब्रेरी रिज़ॉल्व हो जाने के बाद, आप अपने कोड में उसकी क्लासेज़ इम्पोर्ट कर सकते हैं और डिस्क पर एक इंडेक्स फ़ोल्डर बना सकते हैं जहाँ सभी सर्चेबल डेटा संग्रहीत होगा। + +### 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 रिलीज़](https://releases.groupdocs.com/search/java/) + +[GroupDocs.Search दस्तावेज़ीकरण](https://docs.groupdocs.com/search/java/) + +## इंडेक्स कैसे बनाएँ? + +एक स्थायी इंडेक्स फ़ोल्डर बनाएँ जहाँ GroupDocs.Search टोकनाइज़्ड डेटा संग्रहीत करता है। केवल एक लाइन कोड से अपना पहला इंडेक्स लोड करें—`new Index("path/to/indexFolder")`। `Index` क्लास कोर कॉम्पोनेन्ट है जो मेमोरी और डिस्क दोनों में दस्तावेज़ों के सर्चेबल संग्रह का प्रतिनिधित्व करता है। + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## इंडेक्स में दस्तावेज़ कैसे जोड़ें? + +`Index` इंस्टेंस के `add` मेथड का उपयोग करके उस फ़ोल्डर की ओर इशारा करें जिसमें आपके स्रोत फ़ाइलें हों। इंजन समर्थित फ़ॉर्मैट को रीकर्सिवली स्कैन करेगा, टेक्स्ट कंटेंट निकालेगा, और आंतरिक स्ट्रक्चर को अपडेट करेगा। यह एकल कॉल बड़े बैच को कुशलतापूर्वक संभालता है, जिससे फ़ाइल‑बाय‑फ़ाइल मैनुअल प्रोसेसिंग की आवश्यकता समाप्त हो जाती है। + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## फ़ज़ी सर्च Java को कैसे कॉन्फ़िगर करें? + +`FuzzySearchOptions` क्लास पैरामीटर जैसे एडिट डिस्टेंस और प्रीफ़िक्स लंबाई को परिभाषित करता है जो वर्तनी त्रुटियों के प्रति सर्च की सहनशीलता को नियंत्रित करता है। `SearchOptions` ऑब्जेक्ट सभी सर्च‑टाइम सेटिंग्स को समूहित करता है, जिसमें फ़ज़ी विकल्प, परिणाम सीमाएँ, और हाइलाइटिंग प्रेफ़रेंसेज़ शामिल हैं। `SearchOptions` ऑब्जेक्ट पर `FuzzySearchOptions` सेट करके फ़ज़ी मैचिंग को सक्षम करें। यह इंजन को कॉन्फ़िगरेबल एडिट डिस्टेंस के भीतर शब्दों पर विचार करने के लिए कहता है, जिससे सर्च वर्तनी त्रुटियों के प्रति सहनशील बन जाता है। + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## सर्च ऑपरेशन कैसे करें? + +`Index` ऑब्जेक्ट पर `search` मेथड कॉल करें, क्वेरी स्ट्रिंग और कॉन्फ़िगर किए गए `SearchOptions` प्रदान करें। इंजन अनुरोध को प्रोसेस करता है, यदि फ़ज़ी सक्षम है तो फ़ज़ी मैचिंग लागू करता है, और प्रासंगिकता स्कोर के आधार पर परिणामों को रैंक करता है। यह ऑपरेशन बड़े इंडेक्स पर भी तेज़ी से पूरा होता है क्योंकि सर्च प्री‑बिल्ट टोकन स्ट्रक्चर पर किया जाता है। मेथड एक `SearchResult` कलेक्शन लौटाता है जिसमें मिलते दस्तावेज़, हिट काउंट, और हाइलाइटेड स्निपेट्स होते हैं। + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## सर्च परिणामों को प्रोसेस और डिस्प्ले कैसे करें? + +`SearchResult` एक कलेक्शन है जो व्यक्तिगत `SearchResultItem` ऑब्जेक्ट्स रखता है, प्रत्येक मिलते दस्तावेज़, हिट की संख्या, और हाइलाइटेड स्निपेट्स का विवरण देता है। `SearchResult` आइटम्स पर इटररेट करें और प्रत्येक दस्तावेज़ का पाथ, आवृत्ति संख्या, और मिलते फ़्रेज़ प्रिंट करें। यह सरल लूप आपको UI टेबल, लॉग, या API रिस्पॉन्स बनाने की अनुमति देता है जो दिखाता है कि दस्तावेज़ क्यों मैच हुआ। + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## व्यावहारिक अनुप्रयोग + +**दस्तावेज़ कैसे खोजें** के महत्व वाले वास्तविक‑दुनिया के परिदृश्य: +1. **कानूनी दस्तावेज़ प्रबंधन:** हजारों अनुबंधों में क्लॉज़ या पक्षों को सेकंड में खोजें। +2. **शैक्षणिक शोध:** यदि खोज शब्द की वर्तनी गलत है तो भी प्रासंगिक पेपर प्राप्त करें। +3. **एंटरप्राइज़ कंटेंट मैनेजमेंट:** रिपोर्ट, ई‑मेल, और प्रेज़ेंटेशन में तेज़, टाइपो‑सहिष्णु सर्च के साथ आंतरिक पोर्टल को शक्ति दें। + +## प्रदर्शन संबंधी विचार + +- **इंडेक्स रीफ़्रेश:** स्रोत फ़ाइलों में बदलाव होने पर `add` या `update` फिर से चलाएँ ताकि परिणाम ताज़ा रहें। +- **मेमोरी मैनेजमेंट:** GroupDocs.Search बड़े फ़ाइलों को स्ट्रीम करता है, इसलिए 500‑पृष्ठ PDFs के लिए भी मेमोरी फुटप्रिंट कम रहता है। +- **चंक्ड इंडेक्सिंग:** बड़े कॉर्पस को कई इंडेक्स फ़ोल्डरों में विभाजित करें ताकि प्रोसेसिंग समानांतर हो और क्वेरी लेटेंसी सुधरे। + +## अक्सर पूछे जाने वाले प्रश्न + +**प्रश्न: फ़ज़ी सर्च Java क्या है और यह क्यों उपयोगी है?** +**उत्तर:** फ़ज़ी सर्च Java अनुमानित स्ट्रिंग मैचिंग को सक्षम करता है, जिससे टाइपो या वैकल्पिक वर्तनी के बावजूद क्वेरी परिणाम लौटाती है, जिससे अंतिम‑उपयोगकर्ता अनुभव बेहतर होता है। + +**प्रश्न: नई फ़ाइलें जोड़ने के बाद मैं अपना इंडेक्स कैसे अपडेट करूँ?** +**उत्तर:** `index.add("new/files/folder")` को फिर से कॉल करें; लाइब्रेरी पूरी इंडेक्स को पुनः बनाये बिना नई सामग्री को बुद्धिमानी से मर्ज कर देती है। + +**प्रश्न: क्या GroupDocs.Search पासवर्ड‑प्रोटेक्टेड PDFs को हैंडल कर सकता है?** +**उत्तर:** हाँ—फ़ाइल जोड़ते समय `DocumentLoadOptions` में पासवर्ड प्रदान करें, और इंजन सामग्री को डिक्रिप्ट करके इंडेक्स कर देगा। + +**प्रश्न: मैं कितनी दस्तावेज़ों को इंडेक्स कर सकता हूँ, इसकी कोई सीमा है?** +**उत्तर:** लाइब्रेरी मिलियन‑स्तर की फ़ाइलों तक स्केल करती है; प्रदर्शन हार्डवेयर और स्टोरेज पर निर्भर करता है, न कि किसी हार्ड‑कोडेड लिमिट पर। + +**प्रश्न: अधिक उन्नत उदाहरण कहाँ मिलेंगे?** +**उत्तर:** कस्टम एनालाइज़र और परिणाम रैंकिंग जैसे गहन विषयों के लिए आधिकारिक दस्तावेज़ीकरण देखें। + +## निष्कर्ष + +आप अब **दस्तावेज़ कैसे खोजें** को GroupDocs.Search for Java के साथ, इंडेक्स बनाने से लेकर फ़ज़ी सर्च Java को सक्षम करने और परिणाम प्रोसेस करने तक, समझते हैं। इन चरणों को लागू करके आप किसी भी Java‑आधारित एप्लिकेशन में तेज़, टाइपो‑सहिष्णु सर्च अनुभव प्रदान कर सकते हैं। + +--- + +**अंतिम अपडेट:** 2026-05-28 +**परीक्षित संस्करण:** GroupDocs.Search 23.10 for Java +**लेखक:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## संबंधित ट्यूटोरियल + +- [GroupDocs.Search for Java के साथ दस्तावेज़ इंडेक्स बनाएं](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Java में GroupDocs.Search के साथ फुल‑टेक्स्ट सर्च लागू करें: एक व्यापक गाइड](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [GroupDocs.Search का उपयोग करके Java में मेटाडेटा इंडेक्सिंग के साथ इंडेक्स में दस्तावेज़ कैसे जोड़ें](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/hongkong/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/hongkong/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..cd7d575f --- /dev/null +++ b/content/hongkong/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,227 @@ +--- +date: '2026-05-28' +description: 了解如何使用 GroupDocs.Search for Java 高效搜尋文件，包括 Java 模糊搜尋以及如何建立全文字搜尋的索引。 +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: 如何使用 GroupDocs.Search Java 進行文件搜尋 +type: docs +url: /zh-hant/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# 如何使用 GroupDocs.Search Java 搜尋文件 + +在現代企業應用程式中，快速且精確地 **如何搜尋文件** 是一項關鍵需求。無論您是處理合約、報告，或任何大型文件庫，GroupDocs.Search for Java 都提供了具備內建模糊匹配的強大全文搜尋引擎。本教學將逐步說明如何設定函式庫、建立索引、加入文件、設定 Java 模糊搜尋，以及取得結果——全部以清晰、對話式的說明呈現。 + +## 快速答案 +- **第一步是什麼？** 透過 Maven 安裝 GroupDocs.Search Java 函式庫，或直接下載。 +- **如何建立索引？** 實例化一個指向磁碟資料夾的 `Index` 物件；函式庫會自動建立可搜尋的結構。 +- **我可以使用錯別字搜尋嗎？** 可以——啟用模糊搜尋以匹配拼寫錯誤或略有變化的詞彙。 +- **如何加入文件？** 使用 `Index` 實例的 `add` 方法，傳入包含檔案的資料夾。 +- **需要哪個 Java 版本？** 支援 JDK 8 或更高版本。 + +## 在 GroupDocs.Search 中，「如何搜尋文件」是什麼意思？ +**「如何搜尋文件」** 指的是建立可搜尋索引並發出查詢以返回匹配檔案的過程，可選擇使用模糊邏輯容忍拼寫錯誤。GroupDocs.Search 在背後處理分詞、索引與排序，讓您專注於業務邏輯。 + +## 為什麼使用 GroupDocs.Search for Java？ +GroupDocs.Search 支援 **30+ 檔案格式**（包括 DOCX、PDF、TXT、HTML 與 XLSX），且能在不將整個檔案載入記憶體的情況下索引 **數百頁的文件**，在一般伺服器硬體上提供次秒級的查詢回應。其模糊搜尋功能可在查詢包含錯別字時仍返回相關結果，提升使用者體驗。 + +## 前置條件 +- **Java Development Kit (JDK)：** 版本 8 或更新。 +- **IDE：** IntelliJ IDEA、Eclipse，或任何相容 Java 的編輯器。 +- **GroupDocs.Search for Java 函式庫：** 透過 Maven（建議）加入或下載 JAR。 + +## 如何設定 GroupDocs.Search for Java？ + +首先，將 GroupDocs.Search 相依性加入您的建置檔案，確保儲存庫 URL 可存取，並驗證 JDK 版本符合最低需求。函式庫解析後，您即可在程式碼中匯入其類別，並在磁碟上建立索引資料夾以儲存所有可搜尋的資料。 + +### 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/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## 如何建立索引？ + +建立一個永久的索引資料夾，GroupDocs.Search 會在其中儲存分詞後的資料。只需一行程式碼即可載入第一個索引——`new Index("path/to/indexFolder")`。`Index` 類別是核心元件，代表記憶體與磁碟上可搜尋的文件集合。 + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## 如何將文件加入索引？ + +使用 `Index` 實例的 `add` 方法指向包含來源檔案的資料夾。引擎會遞迴掃描支援的格式，提取文字內容，並更新內部結構。此單一呼叫即可有效處理大量批次，免除手動逐檔處理的需求。 + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## 如何設定 Java 模糊搜尋？ + +`FuzzySearchOptions` 類別定義了編輯距離與前綴長度等參數，以控制搜尋對拼寫錯誤的容忍度。`SearchOptions` 物件彙總所有搜尋時的設定，包括模糊選項、結果上限與高亮偏好。透過在 `SearchOptions` 物件上設定 `FuzzySearchOptions` 來啟用模糊匹配。這告訴引擎在可設定的編輯距離內考慮詞彙，使搜尋容忍拼寫錯誤。 + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## 如何執行搜尋操作？ + +在 `Index` 物件上呼叫 `search` 方法，提供查詢字串與已配置的 `SearchOptions`。引擎處理請求，若已啟用則套用模糊匹配，並根據相關性分數排序結果。即使在大型索引上，操作也能快速完成，因為搜尋是基於預先建好的分詞結構。此方法回傳一個 `SearchResult` 集合，內含匹配的文件、命中次數與高亮片段。 + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## 如何處理與顯示搜尋結果？ + +`SearchResult` 是一個集合，保存個別的 `SearchResultItem` 物件，每個物件描述一個匹配的文件、命中次數與高亮片段。遍歷 `SearchResult` 項目並列印每個文件的路徑、出現次數與匹配片語。這個簡單的迴圈讓您能建立 UI 表格、日誌或 API 回應，清楚顯示文件匹配的原因。 + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## 實務應用 + +在實務情境中，**如何搜尋文件** 非常重要： +1. **法律文件管理：** 在數千份合約中於秒內定位條款或當事人。 +2. **學術研究：** 即使搜尋詞拼寫錯誤，也能取得相關論文。 +3. **企業內容管理：** 為內部入口網站提供快速、容錯的搜尋，涵蓋報告、電子郵件與簡報。 + +## 效能考量 +- **索引刷新：** 每當來源檔案變更時重新執行 `add` 或 `update`，以保持結果最新。 +- **記憶體管理：** GroupDocs.Search 以串流方式處理大型檔案，即使是 500 頁的 PDF 也能保持低記憶體佔用。 +- **分段索引：** 將龐大的語料庫拆分為多個索引資料夾，以平行處理並提升查詢延遲。 + +## 常見問題 + +**Q: 什麼是 Java 模糊搜尋，為何有用？** +A: Java 模糊搜尋支援近似字串匹配，允許查詢即使有錯別字或不同拼寫仍返回結果，提升最終使用者體驗。 + +**Q: 新增檔案後如何更新索引？** +A: 再次呼叫 `index.add("new/files/folder")`；函式庫會智慧地合併新內容，而不需重新建構整個索引。 + +**Q: GroupDocs.Search 能處理受密碼保護的 PDF 嗎？** +A: 可以——在加入檔案時於 `DocumentLoadOptions` 提供密碼，引擎會解密並索引內容。 + +**Q: 索引的文件數量有上限嗎？** +A: 函式庫可擴展至數百萬檔案；效能取決於硬體與儲存空間，並無硬性上限。 + +**Q: 哪裡可以找到更進階的範例？** +A: 請參閱官方文件，了解自訂分析器與結果排序等更深入的主題。 + +## 結論 + +您現在已了解如何使用 GroupDocs.Search for Java 進行 **文件搜尋**，從建立索引、啟用 Java 模糊搜尋，到處理結果。實作這些步驟，即可在任何基於 Java 的應用程式中提供快速、容錯的搜尋體驗。 + +--- + +**最後更新：** 2026-05-28 +**測試環境：** GroupDocs.Search 23.10 for Java +**作者：** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## 相關教學 + +- [使用 GroupDocs.Search for Java 建立文件索引](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [在 Java 中使用 GroupDocs.Search 實作全文搜尋：完整指南](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [在 Java 中使用 GroupDocs.Search 以 Metadata 索引方式將文件加入索引](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/hungarian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/hungarian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..17f1e72c --- /dev/null +++ b/content/hungarian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,230 @@ +--- +date: '2026-05-28' +description: Ismerje meg, hogyan kereshet dokumentumokat hatékonyan a GroupDocs.Search + for Java segítségével, beleértve a fuzzy search Java-t és azt, hogyan hozhat létre + indexet a full‑text search-hez. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: Hogyan keressünk dokumentumokat a GroupDocs.Search Java segítségével +type: docs +url: /hu/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# Hogyan keressünk dokumentumokat a GroupDocs.Search Java segítségével + +A modern vállalati alkalmazásokban a **hogyan keressünk dokumentumokat** gyorsan és pontosan kritikus követelmény. Legyen szó szerződésekről, jelentésekről vagy bármely nagy dokumentumtárról, a GroupDocs.Search for Java egy robusztus, teljes szöveges keresőmotort biztosít beépített fuzzy egyezéssel. Ez az útmutató végigvezeti a könyvtár beállításán, egy index létrehozásán, dokumentumok hozzáadásán, a fuzzy keresés Java konfigurálásán és az eredmények lekérdezésén – mindezt világos, beszélgetős magyarázatokkal. + +## Gyors válaszok +- **Mi az első lépés?** Telepítse a GroupDocs.Search Java könyvtárat Maven-en keresztül, vagy töltse le közvetlenül. +- **Hogyan hozhatok létre indexet?** Hozzon létre egy `Index` objektumot, amely egy lemezen lévő mappára mutat; a könyvtár automatikusan felépíti a kereshető struktúrát. +- **Kereshetek elírásokkal?** Igen—engedélyezze a fuzzy keresést, hogy egyezzen a helytelenül írt vagy enyhén eltérő kifejezésekkel. +- **Hogyan adhatok hozzá dokumentumokat?** Használja az `add` metódust az `Index` példányon, és adja meg a fájlokat tartalmazó mappát. +- **Milyen Java verzió szükséges?** A JDK 8 vagy újabb támogatott. + +## Mi a “hogyan keressünk dokumentumokat” a GroupDocs.Search kontextusában? +**“Hogyan keressünk dokumentumokat”** arra a folyamatra utal, amely kereshető indexet épít, és lekérdezéseket hajt végre, amelyek visszaadják a megfelelő fájlokat, opcionálisan fuzzy logikát használva a helyesírási hibák tolerálására. A GroupDocs.Search a tokenizálást, indexelést és rangsorolást a háttérben kezeli, így az üzleti logikára koncentrálhat. + +## Miért használjuk a GroupDocs.Search for Java-t? +A GroupDocs.Search **30+ fájlformátumot** támogat (beleértve a DOCX, PDF, TXT, HTML és XLSX formátumokat), és **több száz oldalas dokumentumokat** tud indexelni anélkül, hogy az egész fájlt a memóriába töltené, alulmásodperces lekérdezési válaszokat biztosítva a tipikus szerverkörnyezetben. A fuzzy keresési képessége javítja a felhasználói élményt, mivel releváns eredményeket ad vissza még akkor is, ha a lekérdezések elírásokat tartalmaznak. + +## Előfeltételek +- **Java Development Kit (JDK):** 8-as vagy újabb verzió. +- **IDE:** IntelliJ IDEA, Eclipse vagy bármely Java‑kompatibilis szerkesztő. +- **GroupDocs.Search for Java library:** adja hozzá Maven-en keresztül (ajánlott) vagy töltse le a JAR-t. + +## Hogyan állítsuk be a GroupDocs.Search for Java-t? + +A kezdéshez adja hozzá a GroupDocs.Search függőséget a build fájlhoz, ellenőrizze, hogy a tároló URL elérhető, és győződjön meg róla, hogy a JDK verzió megfelel a minimális követelménynek. A könyvtár feloldása után importálhatja az osztályait a kódban, és létrehozhat egy indexmappát a lemezen, ahol az összes kereshető adat tárolódik. + +### Maven beállítás +Adja hozzá a tárolót és a függőséget a `pom.xml` fájlhoz pontosan úgy, ahogy az eredeti útmutatóban látható. + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Közvetlen letöltés +Alternatívaként szerezze be a JAR-t a hivatalos kiadási oldalról: + +[GroupDocs.Search Java kiadások](https://releases.groupdocs.com/search/java/) + +[GroupDocs.Search dokumentáció](https://docs.groupdocs.com/search/java/) + +## Hogyan hozzunk létre egy indexet? + +Hozzon létre egy tartós indexmappát, ahol a GroupDocs.Search a tokenizált adatokat tárolja. Töltse be első indexét egyetlen kódsorral—`new Index("path/to/indexFolder")`. Az `Index` osztály a központi komponens, amely egy kereshető dokumentumgyűjteményt képvisel a memóriában és a lemezen. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Hogyan adjunk dokumentumokat az indexhez? + +Használja az `add` metódust az `Index` példányon, és adja meg a forrásfájlokat tartalmazó mappát. A motor rekurzívan beolvassa a támogatott formátumokat, kinyeri a szöveges tartalmat, és frissíti a belső struktúrákat. Ez az egyetlen hívás hatékonyan kezeli a nagy kötegelt feldolgozást, kiküszöbölve a manuális fájlonkénti feldolgozást. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Hogyan konfiguráljuk a Fuzzy Search Java-t? + +A `FuzzySearchOptions` osztály paramétereket definiál, például szerkesztési távolságot és előtaghosszt, amelyek szabályozzák, mennyire toleráns a keresés a helyesírási hibákra. A `SearchOptions` objektum összegyűjti a keresési idő beállításait, beleértve a fuzzy opciókat, az eredménykorlátokat és a kiemelési preferenciákat. Engedélyezze a fuzzy egyezést a `FuzzySearchOptions` beállításával a `SearchOptions` objektumban. Ez azt mondja a motornak, hogy vegye figyelembe a konfigurálható szerkesztési távolságon belüli kifejezéseket, így a keresés toleráns lesz a helyesírási hibákra. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Hogyan hajtsunk végre keresési műveletet? + +Hívja meg a `search` metódust az `Index` objektumon, megadva a lekérdezés szövegét és a konfigurált `SearchOptions`-t. A motor feldolgozza a kérést, alkalmazza a fuzzy egyezést, ha be van kapcsolva, és relevancia pontszámok alapján rangsorolja az eredményeket. A művelet gyorsan befejeződik még nagy indexek esetén is, mivel a keresés előre felépített token struktúrákon történik. A metódus egy `SearchResult` gyűjteményt ad vissza, amely tartalmazza a megtalált dokumentumokat, találatszámot és kiemelt szövegrészleteket. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Hogyan dolgozzuk fel és jelenítsük meg a keresési eredményeket? + +A `SearchResult` egy gyűjtemény, amely egyedi `SearchResultItem` objektumokat tartalmaz, mindegyik egy egyező dokumentumot, a találatok számát és a kiemelt szövegrészleteket írja le. Iteráljon a `SearchResult` elemein, és írja ki minden dokumentum útvonalát, a találatok számát és a megfelelő kifejezéseket. Ez az egyszerű ciklus lehetővé teszi UI táblázatok, naplók vagy API válaszok építését, amelyek pontosan megmutatják, miért egyezett egy dokumentum. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## Gyakorlati alkalmazások + +Valós példák, ahol a **hogyan keressünk dokumentumokat** fontos: +1. **Jogi dokumentumkezelés:** Másolatok vagy felek keresése több ezer szerződésben másodpercek alatt. +2. **Akadémiai kutatás:** Releváns dolgozatok visszakeresése még akkor is, ha a keresőkifejezés el van gépelve. +3. **Vállalati tartalomkezelés:** Belső portálok gyors, elírás‑toleráns keresésével jelentések, e‑mailek és prezentációk között. + +## Teljesítménybeli megfontolások + +- **Index frissítése:** Futtassa újra az `add` vagy `update` parancsot, amikor a forrásfájlok változnak, hogy az eredmények naprakészek legyenek. +- **Memória kezelés:** A GroupDocs.Search nagy fájlokat stream‑eli, így a memóriahasználat alacsony marad még 500‑oldalas PDF‑ek esetén is. +- **Darabolt indexelés:** Ossza fel a hatalmas korpuszt több indexmappára a feldolgozás párhuzamosításához és a lekérdezési késleltetés javításához. + +## Gyakran Ismételt Kérdések + +**Q: Mi az a fuzzy search Java, és miért hasznos?** +A: A fuzzy search Java lehetővé teszi a közelítő karakterlánc‑egyezést, így a lekérdezések eredményeket adnak vissza a helyesírási hibák vagy alternatív írásmódok ellenére, ami javítja a végfelhasználói élményt. + +**Q: Hogyan frissíthetem az indexet új fájlok hozzáadása után?** +A: Hívja újra a `index.add("new/files/folder")` parancsot; a könyvtár intelligensen egyesíti az új tartalmat anélkül, hogy az egész indexet újraépítené. + +**Q: Képes a GroupDocs.Search jelszóval védett PDF-eket kezelni?** +A: Igen—adja meg a jelszót a `DocumentLoadOptions`‑ban a fájl hozzáadása során, és a motor feloldja és indexeli a tartalmat. + +**Q: Van korlátja a dokumentumok számának, amelyeket indexelni tudok?** +A: A könyvtár millió fájlra skálázható; a teljesítmény a hardvertől és a tárolástól függ, nem egy kódolt korláttól. + +**Q: Hol találok fejlettebb példákat?** +A: Látogassa meg a hivatalos dokumentációt a mélyebb témákért, például egyedi elemzők és eredmény‑rangsorolás. + +## Következtetés + +Most már tudja, **hogyan keressünk dokumentumokat** a GroupDocs.Search for Java segítségével, az index létrehozásától a fuzzy search Java engedélyezéséig és az eredmények feldolgozásáig. Alkalmazza ezeket a lépéseket, hogy gyors, elírás‑toleráns keresési élményt nyújtson bármely Java‑alapú alkalmazásban. + +--- + +**Utolsó frissítés:** 2026-05-28 +**Tesztelt verzió:** GroupDocs.Search 23.10 for Java +**Szerző:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## Kapcsolódó oktatóanyagok + +- [Dokumentum index létrehozása a GroupDocs.Search for Java-val](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Teljes szöveges keresés megvalósítása Java-ban a GroupDocs.Search: Átfogó útmutató](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [Hogyan adjunk dokumentumokat az indexhez metaadat-indexeléssel Java-ban a GroupDocs.Search használatával](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/indonesian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/indonesian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..f6c63172 --- /dev/null +++ b/content/indonesian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,229 @@ +--- +date: '2026-05-28' +description: Pelajari cara mencari dokumen secara efisien dengan GroupDocs.Search + untuk Java, termasuk fuzzy search Java dan cara membuat indeks untuk pencarian full‑text. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: Cara Mencari Dokumen Menggunakan GroupDocs.Search Java +type: docs +url: /id/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# Cara Mencari Dokumen Menggunakan GroupDocs.Search Java + +Dalam aplikasi perusahaan modern, **cara mencari dokumen** dengan cepat dan akurat merupakan kebutuhan penting. Baik Anda menangani kontrak, laporan, atau repositori dokumen besar apa pun, GroupDocs.Search untuk Java memberikan mesin pencarian full‑text yang kuat dengan pencocokan fuzzy bawaan. Tutorial ini memandu Anda melalui penyiapan pustaka, pembuatan indeks, penambahan dokumen, konfigurasi fuzzy search Java, dan pengambilan hasil—semua dengan penjelasan yang jelas dan bersahabat. + +## Jawaban Cepat +- **Apa langkah pertama?** Instal pustaka GroupDocs.Search Java melalui Maven atau unduh langsung. +- **Bagaimana cara membuat indeks?** Buat objek `Index` yang menunjuk ke folder di disk; pustaka secara otomatis membangun struktur yang dapat dicari. +- **Apakah saya dapat mencari dengan typo?** Ya—aktifkan fuzzy search untuk mencocokkan istilah yang salah eja atau memiliki variasi kecil. +- **Bagaimana menambahkan dokumen?** Gunakan metode `add` pada instance `Index`, dengan memberikan folder yang berisi file Anda. +- **Versi Java apa yang diperlukan?** JDK 8 atau lebih tinggi didukung. + +## Apa itu “cara mencari dokumen” dalam konteks GroupDocs.Search? +**“Cara mencari dokumen”** mengacu pada proses membangun indeks yang dapat dicari dan mengirimkan kueri yang mengembalikan file yang cocok, secara opsional menggunakan logika fuzzy untuk menoleransi kesalahan ejaan. GroupDocs.Search menangani tokenisasi, pengindeksan, dan perankingan di balik layar, sehingga Anda dapat fokus pada logika bisnis. + +## Mengapa menggunakan GroupDocs.Search untuk Java? +GroupDocs.Search mendukung **lebih dari 30 format file** (termasuk DOCX, PDF, TXT, HTML, dan XLSX) dan dapat mengindeks **dokumen ratusan halaman** tanpa memuat seluruh file ke memori, memberikan respons kueri sub‑detik pada perangkat keras server tipikal. Kemampuan fuzzy search-nya meningkatkan pengalaman pengguna dengan mengembalikan hasil yang relevan bahkan ketika kueri mengandung typo. + +## Prasyarat +- **Java Development Kit (JDK):** versi 8 atau lebih baru. +- **IDE:** IntelliJ IDEA, Eclipse, atau editor kompatibel Java apa pun. +- **Pustaka GroupDocs.Search untuk Java:** tambahkan via Maven (direkomendasikan) atau unduh JAR. + +## Cara Menyiapkan GroupDocs.Search untuk Java? + +Untuk memulai, tambahkan dependensi GroupDocs.Search ke file build Anda, pastikan URL repositori dapat dijangkau, dan verifikasi bahwa versi JDK memenuhi persyaratan minimum. Setelah pustaka terresolusi, Anda dapat mengimpor kelasnya dalam kode Anda dan membuat folder indeks di disk tempat semua data yang dapat dicari akan disimpan. + +### Pengaturan Maven +Tambahkan repositori dan dependensi ke file `pom.xml` Anda persis seperti yang ditunjukkan dalam panduan asli. + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Unduhan Langsung +Sebagai alternatif, dapatkan JAR dari halaman rilis resmi: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## Cara Membuat Indeks? + +Buat folder indeks persisten tempat GroupDocs.Search menyimpan data yang ditokenisasi. Muat indeks pertama Anda dengan satu baris kode—`new Index("path/to/indexFolder")`. Kelas `Index` adalah komponen inti yang mewakili koleksi dokumen yang dapat dicari dalam memori dan di disk. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Cara Menambahkan Dokumen ke Indeks? + +Gunakan metode `add` pada instance `Index` untuk menunjuk ke folder yang berisi file sumber Anda. Mesin akan memindai secara rekursif format yang didukung, mengekstrak konten teks, dan memperbarui struktur internal. Panggilan tunggal ini menangani batch besar secara efisien, menghilangkan kebutuhan pemrosesan file‑per‑file manual. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Cara Mengonfigurasi Fuzzy Search Java? + +Kelas `FuzzySearchOptions` mendefinisikan parameter seperti jarak edit dan panjang prefiks yang mengontrol seberapa toleran pencarian terhadap kesalahan ejaan. Objek `SearchOptions` mengelompokkan semua pengaturan waktu pencarian, termasuk opsi fuzzy, batas hasil, dan preferensi penyorotan. Aktifkan pencocokan fuzzy dengan menetapkan `FuzzySearchOptions` pada objek `SearchOptions`. Ini memberi tahu mesin untuk mempertimbangkan istilah dalam jarak edit yang dapat dikonfigurasi, membuat pencarian toleran terhadap kesalahan ejaan. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Cara Melakukan Operasi Pencarian? + +Panggil metode `search` pada objek `Index`, dengan memberikan string kueri dan `SearchOptions` yang telah dikonfigurasi. Mesin memproses permintaan, menerapkan pencocokan fuzzy jika diaktifkan, dan memberi peringkat hasil berdasarkan skor relevansi. Operasi selesai dengan cepat bahkan pada indeks besar karena pencarian dilakukan pada struktur token yang telah dibangun sebelumnya. Metode mengembalikan koleksi `SearchResult` yang berisi dokumen yang cocok, jumlah hit, dan cuplikan yang disorot. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Cara Memproses dan Menampilkan Hasil Pencarian? + +`SearchResult` adalah koleksi yang menyimpan objek `SearchResultItem` individual, masing‑masing menggambarkan dokumen yang cocok, jumlah hit, dan cuplikan yang disorot. Iterasi melalui item `SearchResult` dan cetak path setiap dokumen, jumlah kemunculan, dan frasa yang cocok. Loop sederhana ini memungkinkan Anda membangun tabel UI, log, atau respons API yang menunjukkan secara tepat mengapa sebuah dokumen cocok. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## Aplikasi Praktis + +Skenario dunia nyata di mana **cara mencari dokumen** penting: +1. **Manajemen Dokumen Hukum:** Temukan klausul atau pihak dalam ribuan kontrak dalam hitungan detik. +2. **Penelitian Akademik:** Dapatkan makalah relevan bahkan jika istilah pencarian salah eja. +3. **Manajemen Konten Perusahaan:** Dukung portal internal dengan pencarian cepat dan toleran typo di seluruh laporan, email, dan presentasi. + +## Pertimbangan Kinerja + +- **Penyegaran Indeks:** Jalankan kembali `add` atau `update` setiap kali file sumber berubah untuk menjaga hasil tetap segar. +- **Manajemen Memori:** GroupDocs.Search melakukan streaming file besar, sehingga jejak memori tetap rendah bahkan untuk PDF 500‑halaman. +- **Pengindeksan Berbagi:** Bagi korpus besar menjadi beberapa folder indeks untuk memparalelkan proses dan meningkatkan latensi kueri. + +## Pertanyaan yang Sering Diajukan + +**Q: Apa itu fuzzy search Java dan mengapa berguna?** +A: Fuzzy search Java memungkinkan pencocokan string perkiraan, memungkinkan kueri mengembalikan hasil meskipun ada typo atau ejaan alternatif, yang meningkatkan pengalaman pengguna akhir. + +**Q: Bagaimana cara memperbarui indeks saya setelah menambahkan file baru?** +A: Panggil `index.add("new/files/folder")` lagi; pustaka secara cerdas menggabungkan konten baru tanpa membangun ulang seluruh indeks. + +**Q: Bisakah GroupDocs.Search menangani PDF yang dilindungi kata sandi?** +A: Ya—berikan kata sandi dalam `DocumentLoadOptions` saat menambahkan file, dan mesin akan mendekripsi serta mengindeks kontennya. + +**Q: Apakah ada batas jumlah dokumen yang dapat saya indeks?** +A: Pustaka dapat diskalakan hingga jutaan file; kinerja tergantung pada perangkat keras dan penyimpanan, bukan batas yang ditetapkan secara keras. + +**Q: Di mana saya dapat menemukan contoh yang lebih maju?** +A: Kunjungi dokumentasi resmi untuk topik yang lebih mendalam seperti analyzer khusus dan perankingan hasil. + +## Kesimpulan + +Anda sekarang mengetahui **cara mencari dokumen** dengan GroupDocs.Search untuk Java, mulai dari membuat indeks hingga mengaktifkan fuzzy search Java dan memproses hasil. Terapkan langkah‑langkah ini untuk memberikan pengalaman pencarian cepat dan toleran typo dalam aplikasi berbasis Java apa pun. + +--- + +**Terakhir Diperbarui:** 2026-05-28 +**Diuji Dengan:** GroupDocs.Search 23.10 untuk Java +**Penulis:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## Tutorial Terkait + +- [Buat Indeks Dokumen dengan GroupDocs.Search untuk Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Implementasikan Pencarian Full-Text di Java dengan GroupDocs.Search: Panduan Komprehensif](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [Cara menambahkan dokumen ke indeks dengan Metadata Indexing di Java menggunakan GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/italian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/italian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..83fb5669 --- /dev/null +++ b/content/italian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,219 @@ +--- +date: '2026-05-28' +description: Scopri come cercare documenti in modo efficiente con GroupDocs.Search + per Java, includendo fuzzy search Java e come creare un indice per la ricerca full‑text. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: Come cercare documenti usando GroupDocs.Search Java +type: docs +url: /it/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# Come cercare documenti usando GroupDocs.Search Java + +Nelle moderne applicazioni aziendali, **come cercare documenti** rapidamente e con precisione è un requisito critico. Che tu stia gestendo contratti, report o qualsiasi grande archivio di documenti, GroupDocs.Search per Java ti offre un motore di ricerca full‑text robusto con corrispondenza fuzzy integrata. Questo tutorial ti guida attraverso l'installazione della libreria, la creazione di un indice, l'aggiunta di documenti, la configurazione della fuzzy search Java e il recupero dei risultati — il tutto con spiegazioni chiare e conversazionali. + +## Risposte rapide +- **Qual è il primo passo?** Installa la libreria GroupDocs.Search Java via Maven o scaricala direttamente. +- **Come creo un indice?** Istanzia un oggetto `Index` che punta a una cartella su disco; la libreria costruisce automaticamente la struttura ricercabile. +- **Posso cercare con errori di battitura?** Sì — abilita la fuzzy search per far corrispondere termini scritti in modo errato o con leggere variazioni. +- **Come aggiungere documenti?** Usa il metodo `add` sull'istanza `Index`, passando la cartella che contiene i tuoi file. +- **Quale versione di Java è richiesta?** JDK 8 o superiore è supportato. + +## Cos'è “come cercare documenti” nel contesto di GroupDocs.Search? +**“Come cercare documenti”** si riferisce al processo di costruzione di un indice ricercabile e all'emissione di query che restituiscono i file corrispondenti, opzionalmente usando la logica fuzzy per tollerare errori di ortografia. GroupDocs.Search gestisce la tokenizzazione, l'indicizzazione e il ranking dietro le quinte, così puoi concentrarti sulla logica di business. + +## Perché usare GroupDocs.Search per Java? +GroupDocs.Search supporta **oltre 30 formati di file** (inclusi DOCX, PDF, TXT, HTML e XLSX) e può indicizzare **documenti di centinaia di pagine** senza caricare l'intero file in memoria, fornendo risposte alle query in meno di un secondo su hardware server tipico. La sua capacità di fuzzy search migliora l'esperienza dell'utente restituendo risultati pertinenti anche quando le query contengono errori di battitura. + +## Prerequisiti +- **Java Development Kit (JDK):** versione 8 o successiva. +- **IDE:** IntelliJ IDEA, Eclipse o qualsiasi editor compatibile con Java. +- **Libreria GroupDocs.Search per Java:** aggiungi via Maven (consigliato) o scarica il JAR. + +## Come configurare GroupDocs.Search per Java? +Per iniziare, aggiungi la dipendenza GroupDocs.Search al tuo file di build, assicurati che l'URL del repository sia raggiungibile e verifica che la versione del JDK soddisfi il requisito minimo. Dopo che la libreria è stata risolta, puoi importare le sue classi nel tuo codice e creare una cartella indice su disco dove saranno memorizzati tutti i dati ricercabili. + +### Configurazione Maven +Aggiungi il repository e la dipendenza al tuo file `pom.xml` esattamente come mostrato nella guida originale. + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Download diretto +In alternativa, ottieni il JAR dalla pagina di rilascio ufficiale: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## Come creare un indice? +Crea una cartella indice persistente dove GroupDocs.Search memorizza i dati tokenizzati. Carica il tuo primo indice con una singola riga di codice — `new Index("path/to/indexFolder")`. La classe `Index` è il componente principale che rappresenta una collezione ricercabile di documenti in memoria e su disco. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Come aggiungere documenti all'indice? +Usa il metodo `add` dell'istanza `Index` per puntare a una cartella contenente i tuoi file sorgente. Il motore scannerà ricorsivamente i formati supportati, estrarrà il contenuto testuale e aggiornerà le strutture interne. Questa singola chiamata gestisce grandi batch in modo efficiente, eliminando la necessità di elaborare manualmente file per file. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Come configurare la fuzzy search Java? +La classe `FuzzySearchOptions` definisce parametri come la distanza di edit e la lunghezza del prefisso che controllano quanto la ricerca è tollerante agli errori di ortografia. L'oggetto `SearchOptions` raggruppa tutte le impostazioni di ricerca, incluse le opzioni fuzzy, i limiti di risultato e le preferenze di evidenziazione. Abilita la corrispondenza fuzzy impostando `FuzzySearchOptions` sull'oggetto `SearchOptions`. Questo indica al motore di considerare termini entro una distanza di edit configurabile, rendendo le ricerche tolleranti agli errori di ortografia. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Come eseguire un'operazione di ricerca? +Chiama il metodo `search` sull'oggetto `Index`, fornendo la stringa di query e le `SearchOptions` configurate. Il motore elabora la richiesta, applica la corrispondenza fuzzy se abilitata e classifica i risultati in base ai punteggi di rilevanza. L'operazione si completa rapidamente anche su indici di grandi dimensioni perché la ricerca viene eseguita su strutture token pre‑costruite. Il metodo restituisce una collezione `SearchResult` contenente i documenti corrispondenti, il conteggio dei risultati e gli snippet evidenziati. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Come elaborare e visualizzare i risultati della ricerca? +`SearchResult` è una collezione che contiene oggetti `SearchResultItem` individuali, ognuno dei quali descrive un documento corrispondente, il numero di occorrenze e gli snippet evidenziati. Itera sugli elementi di `SearchResult` e stampa il percorso di ogni documento, il numero di occorrenze e le frasi corrispondenti. Questo semplice ciclo ti consente di costruire tabelle UI, log o risposte API che mostrano esattamente perché un documento è stato corrisposto. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## Applicazioni pratiche +Scenari reali in cui **come cercare documenti** è importante: +1. **Gestione documenti legali:** Individua clausole o parti in migliaia di contratti in pochi secondi. +2. **Ricerca accademica:** Recupera articoli pertinenti anche se il termine di ricerca è scritto in modo errato. +3. **Enterprise Content Management:** Alimenta i portali interni con una ricerca veloce e tollerante agli errori di battitura su report, email e presentazioni. + +## Considerazioni sulle prestazioni +- **Aggiornamento indice:** Riesegui `add` o `update` ogni volta che i file sorgente cambiano per mantenere i risultati aggiornati. +- **Gestione della memoria:** GroupDocs.Search trasmette in streaming file di grandi dimensioni, così l'impronta di memoria rimane bassa anche per PDF di 500 pagine. +- **Indicizzazione a blocchi:** Dividi corpora massivi in più cartelle indice per parallelizzare l'elaborazione e migliorare la latenza delle query. + +## Domande frequenti +**Q: Cos'è la fuzzy search Java e perché è utile?** +A: La fuzzy search Java consente il matching approssimativo di stringhe, permettendo alle query di restituire risultati nonostante errori di battitura o ortografie alternative, migliorando l'esperienza dell'utente finale. + +**Q: Come aggiorno il mio indice dopo aver aggiunto nuovi file?** +A: Richiama `index.add("new/files/folder")` di nuovo; la libreria unisce intelligentemente i nuovi contenuti senza ricostruire l'intero indice. + +**Q: GroupDocs.Search può gestire PDF protetti da password?** +A: Sì — fornisci la password in `DocumentLoadOptions` quando aggiungi il file, e il motore decritterà e indicizzerà il contenuto. + +**Q: Esiste un limite al numero di documenti che posso indicizzare?** +A: La libreria scala a milioni di file; le prestazioni dipendono dall'hardware e dallo storage, non da un limite hard‑coded. + +**Q: Dove posso trovare esempi più avanzati?** +A: Visita la documentazione ufficiale per argomenti più approfonditi come analizzatori personalizzati e ranking dei risultati. + +## Conclusione +Ora sai **come cercare documenti** con GroupDocs.Search per Java, dalla creazione di un indice all'abilitazione della fuzzy search Java e all'elaborazione dei risultati. Implementa questi passaggi per offrire esperienze di ricerca veloci e tolleranti agli errori di battitura in qualsiasi applicazione basata su Java. + +--- + +**Ultimo aggiornamento:** 2026-05-28 +**Testato con:** GroupDocs.Search 23.10 for Java +**Autore:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## Tutorial correlati + +- [Create Document Index with GroupDocs.Search for Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Implement Full-Text Search in Java with GroupDocs.Search: A Comprehensive Guide](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [How to add documents to index with Metadata Indexing in Java using GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/japanese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/japanese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..d7b50c2c --- /dev/null +++ b/content/japanese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,228 @@ +--- +date: '2026-05-28' +description: GroupDocs.Search for Java を使用してドキュメントを効率的に検索する方法を学びます。fuzzy search Java + や全文検索用インデックスの作成方法も含まれます。 +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: GroupDocs.Search Java を使用したドキュメント検索方法 +type: docs +url: /ja/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# GroupDocs.Search Java を使用したドキュメント検索方法 + +最新のエンタープライズアプリケーションでは、**how to search documents** を迅速かつ正確に行うことが重要な要件です。契約書、レポート、または大規模なドキュメントリポジトリを扱う場合でも、GroupDocs.Search for Java は、組み込みのファジーマッチングを備えた堅牢なフルテキスト検索エンジンを提供します。このチュートリアルでは、ライブラリの設定、インデックスの作成、ドキュメントの追加、fuzzy search Java の構成、結果の取得までを、分かりやすく会話調の説明とともに案内します。 + +## クイック回答 +- **What is the first step?** Maven で GroupDocs.Search Java ライブラリをインストールするか、直接ダウンロードしてください。 +- **How do I create an index?** ディスク上のフォルダーを指す `Index` オブジェクトをインスタンス化します。ライブラリは検索可能な構造を自動的に構築します。 +- **Can I search with typos?** はい。ファジー検索を有効にすると、綴りミスやわずかな変化がある語句にもマッチします。 +- **How to add documents?** `Index` インスタンスの `add` メソッドを使用し、ファイルが格納されたフォルダーを渡します。 +- **What Java version is required?** JDK 8 以上がサポートされています。 + +## GroupDocs.Search のコンテキストでの “how to search documents” とは何ですか？ +**“How to search documents”** は、検索可能なインデックスを構築し、マッチするファイルを返すクエリを発行するプロセスを指します。オプションでファジーロジックを使用してスペルミスを許容することもできます。GroupDocs.Search はトークン化、インデックス作成、ランキングを内部で処理するため、ビジネスロジックに集中できます。 + +## なぜ Java 用の GroupDocs.Search を使用するのか？ +GroupDocs.Search は **30 以上のファイル形式**（DOCX、PDF、TXT、HTML、XLSX など）をサポートし、ファイル全体をメモリに読み込むことなく **数百ページに及ぶドキュメント** をインデックスできます。一般的なサーバーハードウェア上でサブ秒レベルのクエリ応答を提供します。ファジー検索機能により、クエリにタイポが含まれていても関連する結果を返すことでユーザーエクスペリエンスが向上します。 + +## 前提条件 +- **Java Development Kit (JDK):** バージョン 8 以上。 +- **IDE:** IntelliJ IDEA、Eclipse、または任意の Java 対応エディタ。 +- **GroupDocs.Search for Java library:** Maven で追加（推奨）または JAR をダウンロードしてください。 + +## GroupDocs.Search for Java のセットアップ方法 + +まず、ビルドファイルに GroupDocs.Search の依存関係を追加し、リポジトリ URL がアクセス可能であることと、JDK バージョンが最低要件を満たしていることを確認します。ライブラリが解決されたら、コードでクラスをインポートし、検索可能なデータが保存されるインデックスフォルダーをディスク上に作成できます。 + +### 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/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## インデックスの作成方法 + +GroupDocs.Search がトークン化されたデータを保存する永続的なインデックスフォルダーを作成します。`new Index("path/to/indexFolder")` の一行コードで最初のインデックスをロードできます。`Index` クラスは、メモリとディスク上で検索可能なドキュメントコレクションを表すコアコンポーネントです。 + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## インデックスへのドキュメント追加方法 + +`Index` インスタンスの `add` メソッドを使用して、ソースファイルが格納されたフォルダーを指定します。エンジンはサポートされている形式を再帰的にスキャンし、テキストコンテンツを抽出して内部構造を更新します。この単一呼び出しで大規模バッチを効率的に処理でき、手動でファイルごとに処理する必要がなくなります。 + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Fuzzy Search Java の構成方法 + +`FuzzySearchOptions` クラスは、編集距離やプレフィックス長など、検索が綴りミスにどれだけ寛容かを制御するパラメータを定義します。`SearchOptions` オブジェクトは、ファジーオプション、結果上限、ハイライト設定など、検索時のすべての設定をまとめます。`SearchOptions` オブジェクトに `FuzzySearchOptions` を設定してファジーマッチングを有効にします。これにより、エンジンは設定可能な編集距離内の語句を考慮し、綴りミスに寛容な検索を実現します。 + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## 検索操作の実行方法 + +`Index` オブジェクトの `search` メソッドを呼び出し、クエリ文字列と設定した `SearchOptions` を渡します。エンジンはリクエストを処理し、ファジーマッチングが有効な場合は適用し、関連度スコアに基づいて結果をランク付けします。検索は事前に構築されたトークン構造上で行われるため、大規模インデックスでも高速に完了します。このメソッドは、マッチしたドキュメント、ヒット数、ハイライトされたスニペットを含む `SearchResult` コレクションを返します。 + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## 検索結果の処理と表示方法 + +`SearchResult` は個々の `SearchResultItem` オブジェクトを保持するコレクションで、各アイテムはマッチしたドキュメント、ヒット数、ハイライトされたスニペットを記述します。`SearchResult` のアイテムを反復処理し、各ドキュメントのパス、出現回数、マッチしたフレーズを出力します。このシンプルなループにより、UI テーブル、ログ、または API 応答を構築でき、ドキュメントがマッチした理由を正確に示すことができます。 + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## 実用的な応用例 + +**how to search documents** が重要になる実際のシナリオ： +1. **Legal Document Management（法務文書管理）:** 数千件の契約書から条項や当事者を数秒で検索。 +2. **Academic Research（学術研究）:** 検索語が綴りミスでも関連する論文を取得。 +3. **Enterprise Content Management（エンタープライズコンテンツ管理）:** レポート、メール、プレゼンテーション全体に対して高速でタイポに寛容な検索を内部ポータルに提供。 + +## パフォーマンス上の考慮点 +- **Index Refresh（インデックスの更新）:** ソースファイルが変更されたら `add` または `update` を再実行し、結果を最新に保ちます。 +- **Memory Management（メモリ管理）:** GroupDocs.Search は大きなファイルをストリーミング処理するため、500 ページの PDF でもメモリ使用量は低く抑えられます。 +- **Chunked Indexing（分割インデックス）:** 大規模コーパスを複数のインデックスフォルダーに分割し、処理を並列化してクエリ遅延を改善します。 + +## よくある質問 + +**Q: fuzzy search Java とは何で、なぜ有用なのか？** +A: Fuzzy search Java は近似文字列マッチングを可能にし、タイポや別表記があってもクエリが結果を返せるようにします。これによりエンドユーザーの体験が向上します。 + +**Q: 新しいファイルを追加した後、インデックスを更新するには？** +A: `index.add("new/files/folder")` を再度呼び出します。ライブラリはインデックス全体を再構築せずに新しいコンテンツをインテリジェントにマージします。 + +**Q: GroupDocs.Search はパスワード保護された PDF を処理できますか？** +A: はい。ファイルを追加する際に `DocumentLoadOptions` でパスワードを指定すれば、エンジンが復号してコンテンツをインデックスします。 + +**Q: インデックス可能なドキュメント数に上限はありますか？** +A: ライブラリは数百万件のファイルまでスケールします。パフォーマンスはハードウェアとストレージに依存し、ハードコードされた上限はありません。 + +**Q: より高度な例はどこで見つけられますか？** +A: カスタムアナライザーや結果ランキングなど、より深いトピックについては公式ドキュメントをご覧ください。 + +## 結論 + +これで、GroupDocs.Search for Java を使用した **how to search documents** の方法、インデックス作成から fuzzy search Java の有効化、結果の処理までが理解できました。これらの手順を実装すれば、あらゆる Java ベースのアプリケーションで高速かつタイポに寛容な検索体験を提供できます。 + +--- + +**最終更新日:** 2026-05-28 +**テスト環境:** GroupDocs.Search 23.10 for Java +**作者:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## 関連チュートリアル + +- [GroupDocs.Search for Java でドキュメントインデックスを作成](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Java で GroupDocs.Search を使用したフルテキスト検索の実装: 包括的ガイド](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [GroupDocs.Search を使用した Java のメタデータインデックスでドキュメントをインデックスに追加する方法](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/korean/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/korean/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..a3f70a5e --- /dev/null +++ b/content/korean/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,229 @@ +--- +date: '2026-05-28' +description: GroupDocs.Search for Java를 사용하여 문서를 효율적으로 검색하는 방법을 배우세요. 여기에는 fuzzy search + Java와 full‑text search를 위한 인덱스 생성 방법이 포함됩니다. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: GroupDocs.Search Java를 사용하여 문서 검색하는 방법 +type: docs +url: /ko/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# GroupDocs.Search Java를 사용한 문서 검색 방법 + +현대 기업 애플리케이션에서 **문서 검색 방법**을 빠르고 정확하게 검색하는 것은 중요한 요구 사항입니다. 계약서, 보고서 또는 대규모 문서 저장소를 다루든, GroupDocs.Search for Java는 내장된 퍼지 매칭을 제공하는 강력한 전체 텍스트 검색 엔진을 제공합니다. 이 튜토리얼에서는 라이브러리 설정, 인덱스 생성, 문서 추가, 퍼지 검색 Java 구성 및 결과 검색 과정을 명확하고 대화형 설명과 함께 안내합니다. + +## 빠른 답변 +- **첫 번째 단계는 무엇인가요?** Maven을 통해 GroupDocs.Search Java 라이브러리를 설치하거나 직접 다운로드하세요. +- **인덱스는 어떻게 생성하나요?** 디스크의 폴더를 가리키는 `Index` 객체를 인스턴스화하면 라이브러리가 검색 가능한 구조를 자동으로 구축합니다. +- **오타가 있는 검색이 가능한가요?** 네—퍼지 검색을 활성화하면 철자가 틀리거나 약간 변형된 용어와도 매치됩니다. +- **문서는 어떻게 추가하나요?** `Index` 인스턴스의 `add` 메서드를 사용하여 파일이 들어 있는 폴더를 전달합니다. +- **필요한 Java 버전은?** JDK 8 이상을 지원합니다. + +## GroupDocs.Search 컨텍스트에서 “문서 검색 방법”이란? +**“문서 검색 방법”**은 검색 가능한 인덱스를 구축하고 일치하는 파일을 반환하는 쿼리를 실행하는 과정을 의미하며, 선택적으로 퍼지 로직을 사용해 철자 오류를 허용합니다. GroupDocs.Search는 토큰화, 인덱싱 및 랭킹을 백그라운드에서 처리하므로 비즈니스 로직에 집중할 수 있습니다. + +## Java용 GroupDocs.Search를 사용하는 이유 +GroupDocs.Search는 **30개 이상의 파일 형식**(DOCX, PDF, TXT, HTML, XLSX 등)을 지원하며 전체 파일을 메모리에 로드하지 않고도 **수백 페이지 문서**를 인덱싱할 수 있어 일반 서버 하드웨어에서 서브 초 단위의 쿼리 응답을 제공합니다. 퍼지 검색 기능은 쿼리에 오타가 포함되어도 관련 결과를 반환함으로써 사용자 경험을 향상시킵니다. + +## 사전 요구 사항 +- **Java Development Kit (JDK):** 버전 8 이상. +- **IDE:** IntelliJ IDEA, Eclipse 또는 Java 호환 편집기. +- **GroupDocs.Search for Java 라이브러리:** Maven을 통해 추가(권장)하거나 JAR을 다운로드합니다. + +## Java용 GroupDocs.Search 설정 방법 + +시작하려면 빌드 파일에 GroupDocs.Search 의존성을 추가하고, 저장소 URL에 접근할 수 있는지 확인한 뒤 JDK 버전이 최소 요구 사항을 충족하는지 검증합니다. 라이브러리가 해결되면 코드에서 해당 클래스를 임포트하고, 모든 검색 가능한 데이터가 저장될 디스크상의 인덱스 폴더를 생성할 수 있습니다. + +### 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 릴리스](https://releases.groupdocs.com/search/java/) + +[GroupDocs.Search 문서](https://docs.groupdocs.com/search/java/) + +## 인덱스 생성 방법? + +Create a persistent index folder where GroupDocs.Search stores tokenized data. Load your first index with a single line of code—`new Index("path/to/indexFolder")`. The `Index` class is the core component that represents a searchable collection of documents in memory and on disk. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## 인덱스에 문서 추가 방법? + +`Index` 인스턴스의 `add` 메서드를 사용하여 소스 파일이 들어 있는 폴더를 지정합니다. 엔진은 지원되는 형식을 재귀적으로 스캔하고 텍스트 내용을 추출하여 내부 구조를 업데이트합니다. 이 한 번의 호출로 대용량 배치를 효율적으로 처리하여 파일을 개별적으로 처리할 필요가 없습니다. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## 퍼지 검색 Java 구성 방법? + +`FuzzySearchOptions` 클래스는 편집 거리와 접두사 길이와 같은 매개변수를 정의하여 검색이 철자 오류에 얼마나 관대하게 동작할지를 제어합니다. `SearchOptions` 객체는 퍼지 옵션, 결과 제한, 하이라이팅 선호도 등 모든 검색 시 설정을 그룹화합니다. `SearchOptions` 객체에 `FuzzySearchOptions`를 설정하여 퍼지 매칭을 활성화합니다. 이렇게 하면 엔진이 구성 가능한 편집 거리 내의 용어를 고려하도록 하여 검색이 철자 오류에 관대해집니다. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## 검색 작업 수행 방법? + +`Index` 객체에서 `search` 메서드를 호출하고 쿼리 문자열과 구성된 `SearchOptions`를 제공합니다. 엔진은 요청을 처리하고, 퍼지 매칭이 활성화된 경우 적용하며, 관련성 점수에 따라 결과를 순위 매깁니다. 검색은 사전 구축된 토큰 구조에서 수행되므로 대규모 인덱스에서도 작업이 빠르게 완료됩니다. 이 메서드는 일치하는 문서, 히트 수 및 하이라이팅된 스니펫을 포함하는 `SearchResult` 컬렉션을 반환합니다. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## 검색 결과 처리 및 표시 방법? + +`SearchResult`는 개별 `SearchResultItem` 객체를 보유하는 컬렉션으로, 각각 일치하는 문서, 히트 수 및 하이라이팅된 스니펫을 설명합니다. `SearchResult` 항목을 반복하면서 각 문서의 경로, 발생 횟수 및 일치 구문을 출력합니다. 이 간단한 루프를 사용하면 UI 테이블, 로그 또는 API 응답을 구축하여 문서가 일치한 이유를 정확히 표시할 수 있습니다. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## 실용적인 적용 사례 + +**문서 검색 방법**이 중요한 실제 시나리오: +1. **법률 문서 관리:** 수천 개의 계약서에서 조항이나 당사자를 몇 초 만에 찾아냅니다. +2. **학술 연구:** 검색어에 오타가 있어도 관련 논문을 검색합니다. +3. **기업 콘텐츠 관리:** 보고서, 이메일, 프레젠테이션 전반에 걸쳐 빠르고 오타에 관대한 검색으로 내부 포털을 지원합니다. + +## 성능 고려 사항 + +- **인덱스 새로 고침:** 소스 파일이 변경될 때마다 `add` 또는 `update`를 다시 실행하여 결과를 최신 상태로 유지합니다. +- **메모리 관리:** GroupDocs.Search는 대용량 파일을 스트리밍하므로 500페이지 PDF에서도 메모리 사용량이 낮게 유지됩니다. +- **청크 인덱싱:** 방대한 데이터 집합을 여러 인덱스 폴더로 분할하여 처리 병렬화 및 쿼리 지연 시간 개선을 도모합니다. + +## 자주 묻는 질문 + +**Q: 퍼지 검색 Java란 무엇이며 왜 유용한가요?** +A: 퍼지 검색 Java는 근사 문자열 매칭을 가능하게 하여, 오타나 다른 철자에도 불구하고 쿼리가 결과를 반환하도록 하여 최종 사용자 경험을 향상시킵니다. + +**Q: 새 파일을 추가한 후 인덱스를 어떻게 업데이트하나요?** +A: `index.add("new/files/folder")`를 다시 호출하면 라이브러리가 전체 인덱스를 재구성하지 않고 새 콘텐츠를 지능적으로 병합합니다. + +**Q: GroupDocs.Search가 암호 보호된 PDF를 처리할 수 있나요?** +A: 네—파일을 추가할 때 `DocumentLoadOptions`에 비밀번호를 제공하면 엔진이 해당 내용을 복호화하고 인덱싱합니다. + +**Q: 인덱싱할 수 있는 문서 수에 제한이 있나요?** +A: 라이브러리는 수백만 개의 파일까지 확장 가능하며, 성능은 하드웨어와 스토리지에 따라 달라지고 고정된 제한은 없습니다. + +**Q: 더 고급 예제를 어디서 찾을 수 있나요?** +A: 사용자 정의 분석기와 결과 순위와 같은 심화 주제는 공식 문서를 참고하세요. + +## 결론 + +이제 GroupDocs.Search for Java를 사용하여 **문서 검색 방법**을 알고 있습니다. 인덱스 생성부터 퍼지 검색 Java 활성화 및 결과 처리까지. 이러한 단계를 구현하면 Java 기반 애플리케이션에서 빠르고 오타에 관대한 검색 경험을 제공할 수 있습니다. + +--- + +**마지막 업데이트:** 2026-05-28 +**테스트 환경:** GroupDocs.Search 23.10 for Java +**작성자:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## 관련 튜토리얼 + +- [GroupDocs.Search for Java로 문서 인덱스 생성](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [GroupDocs.Search와 함께 Java에서 전체 텍스트 검색 구현: 종합 가이드](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [GroupDocs.Search를 사용한 Java 메타데이터 인덱싱으로 문서 추가 방법](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/polish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/polish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..a12a19c0 --- /dev/null +++ b/content/polish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,227 @@ +--- +date: '2026-05-28' +description: Dowiedz się, jak efektywnie wyszukiwać dokumenty za pomocą GroupDocs.Search + dla Java, w tym fuzzy search Java i jak tworzyć index do full‑text search. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: Jak wyszukiwać dokumenty przy użyciu GroupDocs.Search Java +type: docs +url: /pl/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# Jak wyszukiwać dokumenty przy użyciu GroupDocs.Search Java + +W nowoczesnych aplikacjach korporacyjnych **jak wyszukiwać dokumenty** szybko i dokładnie jest krytycznym wymogiem. Niezależnie od tego, czy masz do czynienia z kontraktami, raportami, czy jakimkolwiek dużym repozytorium dokumentów, GroupDocs.Search dla Java zapewnia solidny silnik wyszukiwania pełnotekstowego z wbudowanym dopasowywaniem fuzzy. Ten samouczek przeprowadzi Cię przez konfigurację biblioteki, tworzenie indeksu, dodawanie dokumentów, konfigurowanie fuzzy search w Java oraz pobieranie wyników — wszystko w jasnych, konwersacyjnych wyjaśnieniach. + +## Szybkie odpowiedzi +- **Jaki jest pierwszy krok?** Zainstaluj bibliotekę GroupDocs.Search Java za pomocą Maven lub pobierz ją bezpośrednio. +- **Jak utworzyć indeks?** Utwórz obiekt `Index` wskazujący na folder na dysku; biblioteka automatycznie buduje strukturę wyszukiwania. +- **Czy mogę wyszukiwać z literówkami?** Tak — włącz fuzzy search, aby dopasowywać terminy z błędami ortograficznymi lub niewielkimi wariacjami. +- **Jak dodać dokumenty?** Użyj metody `add` na instancji `Index`, przekazując folder zawierający Twoje pliki. +- **Jaka wersja Javy jest wymagana?** Wspierany jest JDK 8 lub nowszy. + +## Co oznacza „jak wyszukiwać dokumenty” w kontekście GroupDocs.Search? +**„Jak wyszukiwać dokumenty”** odnosi się do procesu budowania indeksu przeszukiwalnego i wydawania zapytań zwracających pasujące pliki, opcjonalnie z użyciem logiki fuzzy, aby tolerować błędy ortograficzne. GroupDocs.Search zajmuje się tokenizacją, indeksowaniem i rankingiem w tle, dzięki czemu możesz skupić się na logice biznesowej. + +## Dlaczego warto używać GroupDocs.Search dla Java? +GroupDocs.Search obsługuje **ponad 30 formatów plików** (w tym DOCX, PDF, TXT, HTML i XLSX) i może indeksować **dokumenty wielostronicowe** bez ładowania całego pliku do pamięci, zapewniając odpowiedzi na zapytania w czasie krótszym niż sekunda na typowym sprzęcie serwerowym. Funkcja fuzzy search poprawia doświadczenie użytkownika, zwracając istotne wyniki nawet gdy zapytania zawierają literówki. + +## Wymagania wstępne +- **Java Development Kit (JDK):** wersja 8 lub nowsza. +- **IDE:** IntelliJ IDEA, Eclipse lub dowolny edytor kompatybilny z Javą. +- **Biblioteka GroupDocs.Search dla Java:** dodaj przez Maven (zalecane) lub pobierz plik JAR. + +## Jak skonfigurować GroupDocs.Search dla Java? + +Aby rozpocząć, dodaj zależność GroupDocs.Search do swojego pliku budowania, upewnij się, że URL repozytorium jest dostępny, oraz zweryfikuj, że wersja JDK spełnia minimalne wymagania. Po rozwiązaniu biblioteki możesz importować jej klasy w kodzie i utworzyć folder indeksu na dysku, w którym będą przechowywane wszystkie dane przeszukiwalne. + +### Konfiguracja Maven +Dodaj repozytorium i zależność do pliku `pom.xml` dokładnie tak, jak pokazano w oryginalnym przewodniku. + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Bezpośrednie pobranie +Ewentualnie pobierz plik JAR z oficjalnej strony wydań: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## Jak utworzyć indeks? + +Utwórz trwały folder indeksu, w którym GroupDocs.Search przechowuje tokenizowane dane. Załaduj swój pierwszy indeks jedną linią kodu — `new Index("path/to/indexFolder")`. Klasa `Index` jest podstawowym komponentem reprezentującym przeszukiwalną kolekcję dokumentów w pamięci i na dysku. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Jak dodać dokumenty do indeksu? + +Użyj metody `add` instancji `Index`, aby wskazać folder zawierający Twoje pliki źródłowe. Silnik będzie rekurencyjnie skanował obsługiwane formaty, wyodrębniał treść tekstową i aktualizował wewnętrzne struktury. To pojedyncze wywołanie obsługuje duże partie efektywnie, eliminując potrzebę ręcznego przetwarzania plik po pliku. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Jak skonfigurować fuzzy search w Java? + +Klasa `FuzzySearchOptions` definiuje parametry takie jak odległość edycyjna i długość prefiksu, które kontrolują tolerancję wyszukiwania na błędy ortograficzne. Obiekt `SearchOptions` grupuje wszystkie ustawienia czasu wyszukiwania, w tym opcje fuzzy, limity wyników i preferencje podświetlania. Włącz dopasowanie fuzzy, ustawiając `FuzzySearchOptions` w obiekcie `SearchOptions`. Powoduje to, że silnik uwzględnia terminy w ramach konfigurowalnej odległości edycyjnej, czyniąc wyszukiwania tolerancyjnymi na literówki. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Jak wykonać operację wyszukiwania? + +Wywołaj metodę `search` na obiekcie `Index`, podając ciąg zapytania oraz skonfigurowane `SearchOptions`. Silnik przetwarza żądanie, stosuje dopasowanie fuzzy, jeśli jest włączone, i ocenia wyniki na podstawie ocen trafności. Operacja kończy się szybko nawet przy dużych indeksach, ponieważ wyszukiwanie odbywa się na wstępnie zbudowanych strukturach tokenów. Metoda zwraca kolekcję `SearchResult` zawierającą dopasowane dokumenty, liczbę trafień i podświetlone fragmenty. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Jak przetwarzać i wyświetlać wyniki wyszukiwania? + +`SearchResult` jest kolekcją, która przechowuje pojedyncze obiekty `SearchResultItem`, z których każdy opisuje dopasowany dokument, liczbę trafień oraz podświetlone fragmenty. Iteruj po elementach `SearchResult` i wypisuj ścieżkę każdego dokumentu, liczbę wystąpień oraz dopasowane frazy. Ta prosta pętla pozwala budować tabele UI, logi lub odpowiedzi API, które dokładnie pokazują, dlaczego dokument został dopasowany. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## Praktyczne zastosowania + +Real‑world scenarios where **how to search documents** matters: +1. **Zarządzanie dokumentami prawnymi:** Znajdź klauzule lub strony w tysiącach kontraktów w ciągu sekund. +2. **Badania akademickie:** Pobierz odpowiednie artykuły, nawet jeśli termin wyszukiwania jest błędnie zapisany. +3. **Zarządzanie treścią korporacyjną:** Zasil wewnętrzne portale szybkim, tolerującym literówki wyszukiwaniem w raportach, e‑mailach i prezentacjach. + +## Rozważania dotyczące wydajności + +- **Odświeżanie indeksu:** Ponownie uruchom `add` lub `update`, gdy pliki źródłowe się zmienią, aby utrzymać aktualność wyników. +- **Zarządzanie pamięcią:** GroupDocs.Search strumieniuje duże pliki, więc zużycie pamięci pozostaje niskie nawet przy 500‑stronicowych PDF‑ach. +- **Indeksowanie w partiach:** Podziel ogromne korpusy na wiele folderów indeksu, aby równolegle przetwarzać i poprawić opóźnienie zapytań. + +## Najczęściej zadawane pytania + +**Q: Czym jest fuzzy search w Java i dlaczego jest przydatny?** +A: Fuzzy search w Java umożliwia przybliżone dopasowanie ciągów znaków, pozwalając zapytaniom zwracać wyniki pomimo literówek lub alternatywnych pisowni, co poprawia doświadczenie końcowego użytkownika. + +**Q: Jak zaktualizować mój indeks po dodaniu nowych plików?** +A: Ponownie wywołaj `index.add("new/files/folder")`; biblioteka inteligentnie łączy nową zawartość bez przebudowywania całego indeksu. + +**Q: Czy GroupDocs.Search może obsługiwać PDF‑y zabezpieczone hasłem?** +A: Tak — podaj hasło w `DocumentLoadOptions` podczas dodawania pliku, a silnik odszyfruje i zaindeksuje zawartość. + +**Q: Czy istnieje limit liczby dokumentów, które mogę zaindeksować?** +A: Biblioteka skaluje się do milionów plików; wydajność zależy od sprzętu i pamięci, a nie od sztywnego limitu. + +**Q: Gdzie mogę znaleźć bardziej zaawansowane przykłady?** +A: Odwiedź oficjalną dokumentację, aby poznać bardziej zaawansowane tematy, takie jak własne analizatory i ranking wyników. + +## Podsumowanie + +Teraz wiesz **jak wyszukiwać dokumenty** przy użyciu GroupDocs.Search dla Java, od tworzenia indeksu po włączenie fuzzy search w Java i przetwarzanie wyników. Zaimplementuj te kroki, aby zapewnić szybkie, tolerujące literówki doświadczenia wyszukiwania w każdej aplikacji opartej na Javie. + +**Ostatnia aktualizacja:** 2026-05-28 +**Testowano z:** GroupDocs.Search 23.10 for Java +**Autor:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## Powiązane samouczki + +- [Utwórz indeks dokumentów przy użyciu GroupDocs.Search dla Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Implementuj wyszukiwanie pełnotekstowe w Javie z GroupDocs.Search: Kompletny przewodnik](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [Jak dodać dokumenty do indeksu z indeksowaniem metadanych w Javie przy użyciu GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/portuguese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/portuguese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..0e7434b0 --- /dev/null +++ b/content/portuguese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,229 @@ +--- +date: '2026-05-28' +description: Aprenda a pesquisar documentos de forma eficiente com GroupDocs.Search + para Java, incluindo fuzzy search Java e como criar um índice para full‑text search. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: Como pesquisar documentos usando GroupDocs.Search Java +type: docs +url: /pt/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# Como Pesquisar Documentos Usando GroupDocs.Search Java + +Em aplicações empresariais modernas, **como pesquisar documentos** de forma rápida e precisa é um requisito crítico. Seja lidando com contratos, relatórios ou qualquer grande repositório de documentos, o GroupDocs.Search para Java oferece um motor de busca robusto e de texto completo com correspondência difusa integrada. Este tutorial orienta você na configuração da biblioteca, criação de um índice, adição de documentos, configuração da busca difusa Java e recuperação de resultados — tudo com explicações claras e conversacionais. + +## Respostas Rápidas +- **Qual é o primeiro passo?** Instale a biblioteca GroupDocs.Search Java via Maven ou faça o download diretamente. +- **Como criar um índice?** Instancie um objeto `Index` apontando para uma pasta no disco; a biblioteca constrói a estrutura pesquisável automaticamente. +- **Posso pesquisar com erros de digitação?** Sim—ative a busca difusa para corresponder a termos que estejam com erros ortográficos ou pequenas variações. +- **Como adicionar documentos?** Use o método `add` na instância `Index`, passando a pasta que contém seus arquivos. +- **Qual versão do Java é necessária?** JDK 8 ou superior é suportado. + +## O que é “como pesquisar documentos” no contexto do GroupDocs.Search? +**“Como pesquisar documentos”** refere-se ao processo de construir um índice pesquisável e emitir consultas que retornam arquivos correspondentes, opcionalmente usando lógica difusa para tolerar erros ortográficos. O GroupDocs.Search lida com tokenização, indexação e classificação nos bastidores, permitindo que você se concentre na lógica de negócios. + +## Por que usar GroupDocs.Search para Java? +O GroupDocs.Search suporta **mais de 30 formatos de arquivo** (incluindo DOCX, PDF, TXT, HTML e XLSX) e pode indexar **documentos com várias centenas de páginas** sem carregar o arquivo inteiro na memória, oferecendo respostas a consultas em menos de um segundo em hardware de servidor típico. Sua capacidade de busca difusa melhora a experiência do usuário ao retornar resultados relevantes mesmo quando as consultas contêm erros de digitação. + +## Pré-requisitos +- **Java Development Kit (JDK):** versão 8 ou mais recente. +- **IDE:** IntelliJ IDEA, Eclipse ou qualquer editor compatível com Java. +- **Biblioteca GroupDocs.Search para Java:** adicione via Maven (recomendado) ou faça o download do JAR. + +## Como Configurar o GroupDocs.Search para Java? + +Para começar, adicione a dependência GroupDocs.Search ao seu arquivo de construção, certifique‑se de que a URL do repositório esteja acessível e verifique se a versão do JDK atende ao requisito mínimo. Após a biblioteca ser resolvida, você pode importar suas classes no código e criar uma pasta de índice no disco onde todos os dados pesquisáveis serão armazenados. + +### Configuração Maven +Adicione o repositório e a dependência ao seu arquivo `pom.xml` exatamente como mostrado no guia original. + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Download Direto +Alternativamente, obtenha o JAR a partir da página oficial de lançamentos: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## Como Criar um Índice? + +Crie uma pasta de índice persistente onde o GroupDocs.Search armazena os dados tokenizados. Carregue seu primeiro índice com uma única linha de código—`new Index("path/to/indexFolder")`. A classe `Index` é o componente central que representa uma coleção pesquisável de documentos na memória e no disco. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Como Adicionar Documentos ao Índice? + +Use o método `add` da instância `Index` para apontar para uma pasta que contém seus arquivos de origem. O mecanismo escaneará recursivamente os formatos suportados, extrairá o conteúdo textual e atualizará as estruturas internas. Essa única chamada lida com grandes lotes de forma eficiente, eliminando a necessidade de processamento manual arquivo por arquivo. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Como Configurar a Busca Difusa Java? + +A classe `FuzzySearchOptions` define parâmetros como distância de edição e comprimento de prefixo que controlam o quão tolerante a busca é a erros ortográficos. O objeto `SearchOptions` agrupa todas as configurações de tempo de busca, incluindo opções difusas, limites de resultados e preferências de realce. Ative a correspondência difusa definindo `FuzzySearchOptions` no objeto `SearchOptions`. Isso instrui o mecanismo a considerar termos dentro de uma distância de edição configurável, tornando as buscas tolerantes a erros ortográficos. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Como Executar uma Operação de Busca? + +Chame o método `search` no objeto `Index`, fornecendo a string de consulta e o `SearchOptions` configurado. O mecanismo processa a solicitação, aplica a correspondência difusa se ativada e classifica os resultados com base nas pontuações de relevância. A operação é concluída rapidamente mesmo em índices grandes porque a busca é realizada em estruturas de token pré‑construídas. O método retorna uma coleção `SearchResult` contendo documentos correspondentes, contagens de ocorrências e trechos destacados. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Como Processar e Exibir Resultados da Busca? + +`SearchResult` é uma coleção que contém objetos individuais `SearchResultItem`, cada um descrevendo um documento correspondente, o número de ocorrências e trechos destacados. Itere sobre os itens de `SearchResult` e imprima o caminho de cada documento, o número de ocorrências e as frases correspondentes. Esse loop simples permite que você construa tabelas de UI, logs ou respostas de API que mostrem exatamente por que um documento foi correspondido. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## Aplicações Práticas + +Cenários reais onde **como pesquisar documentos** é importante: +1. **Gerenciamento de Documentos Legais:** Localize cláusulas ou partes em milhares de contratos em segundos. +2. **Pesquisa Acadêmica:** Recupere artigos relevantes mesmo que o termo de busca esteja com erro ortográfico. +3. **Gerenciamento de Conteúdo Empresarial:** Alimente portais internos com busca rápida e tolerante a erros em relatórios, e‑mails e apresentações. + +## Considerações de Desempenho + +- **Atualização de Índice:** Reexecute `add` ou `update` sempre que os arquivos de origem forem alterados para manter os resultados atualizados. +- **Gerenciamento de Memória:** O GroupDocs.Search transmite arquivos grandes, portanto a pegada de memória permanece baixa mesmo para PDFs de 500 páginas. +- **Indexação em Partes:** Divida corpora massivas em múltiplas pastas de índice para paralelizar o processamento e melhorar a latência das consultas. + +## Perguntas Frequentes + +**Q: O que é busca difusa Java e por que é útil?** +A: A busca difusa Java permite correspondência aproximada de strings, permitindo que consultas retornem resultados apesar de erros de digitação ou grafias alternativas, o que melhora a experiência do usuário final. + +**Q: Como atualizo meu índice após adicionar novos arquivos?** +A: Chame `index.add("new/files/folder")` novamente; a biblioteca mescla inteligentemente o novo conteúdo sem reconstruir todo o índice. + +**Q: O GroupDocs.Search pode lidar com PDFs protegidos por senha?** +A: Sim—forneça a senha em `DocumentLoadOptions` ao adicionar o arquivo, e o mecanismo descriptografará e indexará o conteúdo. + +**Q: Existe um limite para o número de documentos que posso indexar?** +A: A biblioteca escala para milhões de arquivos; o desempenho depende do hardware e do armazenamento, não de um limite codificado. + +**Q: Onde posso encontrar exemplos mais avançados?** +A: Visite a documentação oficial para tópicos mais aprofundados, como analisadores personalizados e classificação de resultados. + +## Conclusão + +Agora você sabe **como pesquisar documentos** com o GroupDocs.Search para Java, desde a criação de um índice até a habilitação da busca difusa Java e o processamento de resultados. Implemente estas etapas para oferecer experiências de busca rápidas e tolerantes a erros de digitação em qualquer aplicação baseada em Java. + +--- + +**Última atualização:** 2026-05-28 +**Testado com:** GroupDocs.Search 23.10 for Java +**Autor:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## Tutoriais Relacionados + +- [Criar Índice de Documentos com GroupDocs.Search para Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Implementar Busca de Texto Completo em Java com GroupDocs.Search: Um Guia Abrangente](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [Como adicionar documentos ao índice com Indexação de Metadados em Java usando GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/russian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/russian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..9e808982 --- /dev/null +++ b/content/russian/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,229 @@ +--- +date: '2026-05-28' +description: Узнайте, как эффективно искать документы с помощью GroupDocs.Search for + Java, включая fuzzy search Java и создание индекса для full‑text search. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: Как искать документы с помощью GroupDocs.Search Java +type: docs +url: /ru/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# Как искать документы с помощью GroupDocs.Search Java + +В современных корпоративных приложениях быстро и точно **how to search documents** является критически важным требованием. Независимо от того, работаете ли вы с контрактами, отчетами или любой большой репозиторием документов, GroupDocs.Search for Java предоставляет мощный полнотекстовый поисковый движок со встроенным нечетким поиском. Этот учебник проведет вас через настройку библиотеки, создание индекса, добавление документов, настройку fuzzy search Java и получение результатов — всё с понятными, разговорными объяснениями. + +## Быстрые ответы +- **Какой первый шаг?** Установите библиотеку GroupDocs.Search Java через Maven или загрузите её напрямую. +- **Как создать индекс?** Создайте объект `Index`, указывающий на папку на диске; библиотека автоматически строит поисковую структуру. +- **Можно ли искать с опечатками?** Да — включите fuzzy search, чтобы находить термины с ошибками или небольшими вариациями. +- **Как добавить документы?** Используйте метод `add` экземпляра `Index`, передавая папку, содержащую ваши файлы. +- **Какая версия Java требуется?** Поддерживается JDK 8 или выше. + +## Что означает “how to search documents” в контексте GroupDocs.Search? +**“How to search documents”** относится к процессу создания поискового индекса и выполнения запросов, возвращающих соответствующие файлы, при необходимости используя нечеткую логику для допуска орфографических ошибок. GroupDocs.Search обрабатывает токенизацию, индексацию и ранжирование за кулисами, позволяя вам сосредоточиться на бизнес‑логике. + +## Почему использовать GroupDocs.Search для Java? +GroupDocs.Search поддерживает **30+ форматов файлов** (включая DOCX, PDF, TXT, HTML и XLSX) и может индексировать **многостраничные документы** без загрузки всего файла в память, обеспечивая ответы на запросы менее чем за секунду на типичном серверном оборудовании. Возможность fuzzy search улучшает пользовательский опыт, возвращая релевантные результаты даже при наличии опечаток в запросах. + +## Требования +- **Java Development Kit (JDK):** версия 8 или новее. +- **IDE:** IntelliJ IDEA, Eclipse или любой совместимый с Java редактор. +- **GroupDocs.Search for Java library:** добавить через Maven (рекомендовано) или загрузить JAR. + +## Как настроить GroupDocs.Search для Java? + +Для начала добавьте зависимость GroupDocs.Search в ваш файл сборки, убедитесь, что URL репозитория доступен, и проверьте, что версия JDK соответствует минимальному требованию. После разрешения библиотеки вы можете импортировать её классы в код и создать папку индекса на диске, где будут храниться все поисковые данные. + +### Настройка 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/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## Как создать индекс? + +Создайте постоянную папку индекса, где GroupDocs.Search хранит токенизированные данные. Загрузите ваш первый индекс одной строкой кода — `new Index("path/to/indexFolder")`. Класс `Index` является основным компонентом, представляющим поисковую коллекцию документов в памяти и на диске. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Как добавить документы в индекс? + +Используйте метод `add` экземпляра `Index`, указывая папку, содержащую ваши исходные файлы. Движок рекурсивно просканирует поддерживаемые форматы, извлечёт текстовое содержимое и обновит внутренние структуры. Этот один вызов эффективно обрабатывает большие партии файлов, устраняя необходимость ручной обработки файлов по отдельности. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Как настроить fuzzy search Java? + +Класс `FuzzySearchOptions` определяет параметры, такие как расстояние редактирования и длина префикса, которые контролируют степень допуска к ошибкам в поиске. Объект `SearchOptions` группирует все настройки времени поиска, включая параметры fuzzy, ограничения количества результатов и предпочтения подсветки. Включите нечеткое сопоставление, установив `FuzzySearchOptions` в объекте `SearchOptions`. Это сообщает движку учитывать термины в пределах настраиваемого расстояния редактирования, делая поиск устойчивым к опечаткам. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Как выполнить операцию поиска? + +Вызовите метод `search` объекта `Index`, передавая строку запроса и настроенный `SearchOptions`. Движок обрабатывает запрос, применяет нечеткое сопоставление, если оно включено, и ранжирует результаты по оценкам релевантности. Операция завершается быстро даже на больших индексах, поскольку поиск выполняется по предварительно построенным токенам. Метод возвращает коллекцию `SearchResult`, содержащую найденные документы, количество совпадений и подсвеченные фрагменты. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Как обработать и отобразить результаты поиска? + +`SearchResult` — это коллекция, содержащая отдельные объекты `SearchResultItem`, каждый из которых описывает совпавший документ, количество попаданий и подсвеченные фрагменты. Пройдитесь по элементам `SearchResult` и выведите путь к каждому документу, количество вхождений и совпадающие фразы. Этот простой цикл позволяет создавать таблицы UI, журналы или ответы API, показывающие точно, почему документ совпал. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## Практические применения + +Реальные сценарии, где важна **how to search documents**: +1. **Legal Document Management:** Находите пункты или стороны в тысячах контрактов за секунды. +2. **Academic Research:** Получайте релевантные статьи, даже если поисковый запрос содержит опечатки. +3. **Enterprise Content Management:** Обеспечьте внутренние порталы быстрым, устойчивым к опечаткам поиском по отчетам, электронным письмам и презентациям. + +## Соображения по производительности + +- **Index Refresh:** Повторно выполните `add` или `update`, когда исходные файлы меняются, чтобы результаты оставались актуальными. +- **Memory Management:** GroupDocs.Search потоково обрабатывает большие файлы, поэтому потребление памяти остаётся низким даже для PDF‑файлов в 500 страниц. +- **Chunked Indexing:** Разделите огромные корпуса на несколько папок индексов для параллельной обработки и снижения задержки запросов. + +## Часто задаваемые вопросы + +**Q: Что такое fuzzy search Java и почему он полезен?** +A: Fuzzy search Java обеспечивает приближённое сопоставление строк, позволяя запросам возвращать результаты несмотря на опечатки или альтернативные написания, что улучшает опыт конечного пользователя. + +**Q: Как обновить мой индекс после добавления новых файлов?** +A: Снова вызовите `index.add("new/files/folder")`; библиотека интеллектуально объединяет новое содержимое без полной перестройки индекса. + +**Q: Может ли GroupDocs.Search обрабатывать PDF‑файлы, защищённые паролем?** +A: Да — укажите пароль в `DocumentLoadOptions` при добавлении файла, и движок расшифрует и проиндексирует содержимое. + +**Q: Есть ли ограничение на количество документов, которые я могу индексировать?** +A: Библиотека масштабируется до миллионов файлов; производительность зависит от оборудования и хранилища, а не от жёстко заданного лимита. + +**Q: Где я могу найти более продвинутые примеры?** +A: Посетите официальную документацию для более глубоких тем, таких как пользовательские анализаторы и ранжирование результатов. + +## Заключение + +Теперь вы знаете **how to search documents** с помощью GroupDocs.Search для Java, от создания индекса до включения fuzzy search Java и обработки результатов. Реализуйте эти шаги, чтобы предоставить быстрый, устойчивый к опечаткам поиск в любом Java‑приложении. + +--- + +**Последнее обновление:** 2026-05-28 +**Тестировано с:** GroupDocs.Search 23.10 for Java +**Автор:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## Связанные руководства + +- [Создать индекс документа с GroupDocs.Search для Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Реализовать полнотекстовый поиск в Java с GroupDocs.Search: Полное руководство](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [Как добавить документы в индекс с метаданными в Java с использованием GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/spanish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/spanish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..8f5c881c --- /dev/null +++ b/content/spanish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,229 @@ +--- +date: '2026-05-28' +description: Aprenda cómo buscar documentos de manera eficiente con GroupDocs.Search + para Java, incluyendo fuzzy search Java y cómo crear un índice para full‑text search. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: Cómo buscar documentos usando GroupDocs.Search Java +type: docs +url: /es/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# Cómo buscar documentos usando GroupDocs.Search Java + +En aplicaciones empresariales modernas, **cómo buscar documentos** de forma rápida y precisa es un requisito crítico. Ya sea que estés manejando contratos, informes o cualquier repositorio grande de documentos, GroupDocs.Search para Java te brinda un motor de búsqueda de texto completo robusto con coincidencia difusa incorporada. Este tutorial te guía paso a paso para configurar la biblioteca, crear un índice, agregar documentos, configurar fuzzy search Java y obtener resultados, todo con explicaciones claras y conversacionales. + +## Respuestas rápidas +- **¿Cuál es el primer paso?** Instala la biblioteca GroupDocs.Search Java a través de Maven o descárgala directamente. +- **¿Cómo creo un índice?** Instancia un objeto `Index` que apunte a una carpeta en disco; la biblioteca construye la estructura buscable automáticamente. +- **¿Puedo buscar con errores tipográficos?** Sí—activa la búsqueda difusa para coincidir con términos que están mal escritos o tienen ligeras variaciones. +- **¿Cómo agregar documentos?** Usa el método `add` en la instancia `Index`, pasando la carpeta que contiene tus archivos. +- **¿Qué versión de Java se requiere?** Se admite JDK 8 o superior. + +## ¿Qué es “cómo buscar documentos” en el contexto de GroupDocs.Search? +**“How to search documents”** se refiere al proceso de crear un índice buscable y emitir consultas que devuelvan archivos coincidentes, opcionalmente usando lógica difusa para tolerar errores ortográficos. GroupDocs.Search maneja la tokenización, indexación y clasificación detrás de escena, para que puedas centrarte en la lógica de negocio. + +## ¿Por qué usar GroupDocs.Search para Java? +GroupDocs.Search soporta **más de 30 formatos de archivo** (incluidos DOCX, PDF, TXT, HTML y XLSX) y puede indexar **documentos de cientos de páginas** sin cargar el archivo completo en memoria, ofreciendo respuestas a consultas en menos de un segundo en hardware de servidor típico. Su capacidad de búsqueda difusa mejora la experiencia del usuario al devolver resultados relevantes incluso cuando las consultas contienen errores tipográficos. + +## Requisitos previos +- **Java Development Kit (JDK):** versión 8 o más reciente. +- **IDE:** IntelliJ IDEA, Eclipse, o cualquier editor compatible con Java. +- **Biblioteca GroupDocs.Search para Java:** añádela vía Maven (recomendado) o descarga el JAR. + +## ¿Cómo configurar GroupDocs.Search para Java? + +Para comenzar, agrega la dependencia GroupDocs.Search a tu archivo de construcción, asegura que la URL del repositorio sea accesible y verifica que la versión del JDK cumpla el requisito mínimo. Una vez resuelta la biblioteca, puedes importar sus clases en tu código y crear una carpeta de índice en disco donde se almacenarán todos los datos buscables. + +### Configuración Maven +Agrega el repositorio y la dependencia a tu archivo `pom.xml` exactamente como se muestra en la guía original. + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Descarga directa +Alternativamente, obtén el JAR desde la página oficial de lanzamientos: + +[Versiones de GroupDocs.Search para Java](https://releases.groupdocs.com/search/java/) + +[Documentación de GroupDocs.Search](https://docs.groupdocs.com/search/java/) + +## ¿Cómo crear un índice? + +Crea una carpeta de índice persistente donde GroupDocs.Search almacene los datos tokenizados. Carga tu primer índice con una sola línea de código—`new Index("path/to/indexFolder")`. La clase `Index` es el componente central que representa una colección buscable de documentos en memoria y en disco. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## ¿Cómo agregar documentos al índice? + +Usa el método `add` de la instancia `Index` para apuntar a una carpeta que contenga tus archivos fuente. El motor escaneará recursivamente los formatos soportados, extraerá el contenido textual y actualizará las estructuras internas. Esta única llamada maneja lotes grandes de manera eficiente, eliminando la necesidad de procesar archivo por archivo manualmente. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## ¿Cómo configurar Fuzzy Search Java? + +La clase `FuzzySearchOptions` define parámetros como distancia de edición y longitud de prefijo que controlan cuán tolerante es la búsqueda a errores ortográficos. El objeto `SearchOptions` agrupa todas las configuraciones de tiempo de búsqueda, incluidas las opciones difusas, límites de resultados y preferencias de resaltado. Habilita la coincidencia difusa estableciendo `FuzzySearchOptions` en el objeto `SearchOptions`. Esto indica al motor que considere términos dentro de una distancia de edición configurable, haciendo que las búsquedas toleren errores ortográficos. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## ¿Cómo realizar una operación de búsqueda? + +Llama al método `search` del objeto `Index`, proporcionando la cadena de consulta y el `SearchOptions` configurado. El motor procesa la solicitud, aplica coincidencia difusa si está habilitada y clasifica los resultados según puntuaciones de relevancia. La operación se completa rápidamente incluso en índices grandes porque la búsqueda se realiza sobre estructuras de tokens preconstruidas. El método devuelve una colección `SearchResult` que contiene documentos coincidentes, recuentos de coincidencias y fragmentos resaltados. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## ¿Cómo procesar y mostrar los resultados de búsqueda? + +`SearchResult` es una colección que contiene objetos `SearchResultItem` individuales, cada uno describiendo un documento coincidente, el número de coincidencias y fragmentos resaltados. Itera sobre los elementos de `SearchResult` e imprime la ruta de cada documento, el número de ocurrencias y las frases coincidentes. Este bucle simple te permite crear tablas UI, registros o respuestas API que muestren exactamente por qué un documento coincidió. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## Aplicaciones prácticas + +Escenarios del mundo real donde **cómo buscar documentos** es importante: +1. **Gestión de documentos legales:** Localiza cláusulas o partes en miles de contratos en segundos. +2. **Investigación académica:** Recupera artículos relevantes incluso si el término de búsqueda está mal escrito. +3. **Gestión de contenido empresarial:** Potencia portales internos con búsqueda rápida y tolerante a errores tipográficos en informes, correos electrónicos y presentaciones. + +## Consideraciones de rendimiento + +- **Actualización del índice:** Vuelve a ejecutar `add` o `update` cada vez que los archivos fuente cambien para mantener los resultados actualizados. +- **Gestión de memoria:** GroupDocs.Search transmite archivos grandes, por lo que el consumo de memoria se mantiene bajo incluso para PDFs de 500 páginas. +- **Indexación por fragmentos:** Divide corpora masivos en múltiples carpetas de índice para paralelizar el procesamiento y mejorar la latencia de las consultas. + +## Preguntas frecuentes + +**Q: ¿Qué es fuzzy search Java y por qué es útil?** +A: Fuzzy search Java permite la coincidencia aproximada de cadenas, haciendo que las consultas devuelvan resultados a pesar de errores tipográficos o variantes ortográficas, lo que mejora la experiencia del usuario final. + +**Q: ¿Cómo actualizo mi índice después de agregar nuevos archivos?** +A: Llama nuevamente a `index.add("new/files/folder")`; la biblioteca fusiona inteligentemente el nuevo contenido sin reconstruir todo el índice. + +**Q: ¿Puede GroupDocs.Search manejar PDFs protegidos con contraseña?** +A: Sí—proporciona la contraseña en `DocumentLoadOptions` al agregar el archivo, y el motor descifrará e indexará el contenido. + +**Q: ¿Existe un límite al número de documentos que puedo indexar?** +A: La biblioteca escala a millones de archivos; el rendimiento depende del hardware y el almacenamiento, no de un límite codificado. + +**Q: ¿Dónde puedo encontrar ejemplos más avanzados?** +A: Visita la documentación oficial para temas más profundos como analizadores personalizados y clasificación de resultados. + +## Conclusión + +Ahora sabes **cómo buscar documentos** con GroupDocs.Search para Java, desde crear un índice hasta habilitar fuzzy search Java y procesar resultados. Implementa estos pasos para ofrecer experiencias de búsqueda rápidas y tolerantes a errores tipográficos en cualquier aplicación basada en Java. + +--- + +**Última actualización:** 2026-05-28 +**Probado con:** GroupDocs.Search 23.10 for Java +**Autor:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## Tutoriales relacionados + +- [Crear índice de documentos con GroupDocs.Search para Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Implementar búsqueda de texto completo en Java con GroupDocs.Search: Guía completa](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [Cómo agregar documentos al índice con indexación de metadatos en Java usando GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/swedish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/swedish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..7dd75e44 --- /dev/null +++ b/content/swedish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,231 @@ +--- +date: '2026-05-28' +description: Lär dig hur du söker i dokument effektivt med GroupDocs.Search för Java, + inklusive fuzzy search Java och hur du skapar ett index för full‑text search. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: Hur man söker i dokument med GroupDocs.Search Java +type: docs +url: /sv/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# Hur man söker dokument med GroupDocs.Search Java + +I moderna företagsapplikationer är **how to search documents** snabbt och exakt en kritisk krav. Oavsett om du hanterar kontrakt, rapporter eller något stort dokumentarkiv, ger GroupDocs.Search för Java en robust full‑text sökmotor med inbyggd fuzzy‑matchning. Denna handledning guidar dig genom att sätta upp biblioteket, skapa ett index, lägga till dokument, konfigurera fuzzy search Java och hämta resultat — allt med tydliga, konversativa förklaringar. + +## Snabba svar +- **Vad är första steget?** Installera GroupDocs.Search Java‑biblioteket via Maven eller ladda ner det direkt. +- **Hur skapar jag ett index?** Instansiera ett `Index`‑objekt som pekar på en mapp på disken; biblioteket bygger den sökbara strukturen automatiskt. +- **Kan jag söka med stavfel?** Ja—aktivera fuzzy search för att matcha termer som är felstavade eller har små variationer. +- **Hur lägger man till dokument?** Använd `add`‑metoden på `Index`‑instansen och ange mappen som innehåller dina filer. +- **Vilken Java-version krävs?** JDK 8 eller högre stöds. + +## Vad betyder “how to search documents” i sammanhanget med GroupDocs.Search? +**“How to search documents”** avser processen att bygga ett sökbart index och utfärda frågor som returnerar matchande filer, eventuellt med fuzzy‑logik för att tolerera stavfel. GroupDocs.Search hanterar tokenisering, indexering och rangordning i bakgrunden, så att du kan fokusera på affärslogik. + +## Varför använda GroupDocs.Search för Java? +GroupDocs.Search stöder **30+ filformat** (inklusive DOCX, PDF, TXT, HTML och XLSX) och kan indexera **dokument med flera hundra sidor** utan att ladda hela filen i minnet, vilket ger svar på frågor på under en sekund på vanlig serverhårdvara. Dess fuzzy‑sökfunktion förbättrar användarupplevelsen genom att returnera relevanta resultat även när frågor innehåller stavfel. + +## Förutsättningar +- **Java Development Kit (JDK):** version 8 eller nyare. +- **IDE:** IntelliJ IDEA, Eclipse eller någon Java‑kompatibel editor. +- **GroupDocs.Search för Java-bibliotek:** lägg till via Maven (rekommenderat) eller ladda ner JAR‑filen. + +## Så sätter du upp GroupDocs.Search för Java? + +För att börja, lägg till GroupDocs.Search‑beroendet i din byggfil, säkerställ att repository‑URL:en är åtkomlig och verifiera att JDK‑versionen uppfyller minimikravet. När biblioteket är löst kan du importera dess klasser i din kod och skapa en indexmapp på disken där all sökbar data kommer att lagras. + +### Maven‑inställning +Lägg till repository och beroende i din `pom.xml`‑fil exakt som i den ursprungliga guiden. + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Direktnedladdning +Alternativt, hämta JAR-filen från den officiella releasesidan: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## Hur skapar man ett index? + +Skapa en beständig indexmapp där GroupDocs.Search lagrar tokeniserad data. Ladda ditt första index med en enda kodrad—`new Index("path/to/indexFolder")`. `Index`‑klassen är den centrala komponenten som representerar en sökbar samling av dokument i minnet och på disken. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Hur lägger man till dokument i indexet? + +Använd `add`‑metoden på `Index`‑instansen för att peka på en mapp som innehåller dina källfiler. Motorn skannar rekursivt stödda format, extraherar textinnehåll och uppdaterar de interna strukturerna. Detta enkla anrop hanterar stora batcher effektivt och eliminerar behovet av manuell fil‑för‑fil‑behandling. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Hur konfigurerar man fuzzy search i Java? + +`FuzzySearchOptions`‑klassen definierar parametrar såsom edit‑distance och prefixlängd som styr hur tolerant sökningen är mot felstavningar. `SearchOptions`‑objektet grupperar alla söktidsinställningar, inklusive fuzzy‑alternativ, resultatgränser och markeringspreferenser. Aktivera fuzzy‑matchning genom att sätta `FuzzySearchOptions` på `SearchOptions`‑objektet. Detta instruerar motorn att överväga termer inom ett konfigurerbart edit‑distance, vilket gör sökningar toleranta mot felstavningar. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Hur utför man en sökoperation? + +Anropa `search`‑metoden på `Index`‑objektet och ange frågesträngen samt de konfigurerade `SearchOptions`. Motorn bearbetar förfrågan, tillämpar fuzzy‑matchning om den är aktiverad och rangordnar resultat baserat på relevanspoäng. Operationen slutförs snabbt även på stora index eftersom sökningen utförs på förbyggda token‑strukturer. Metoden returnerar en `SearchResult`‑samling som innehåller matchade dokument, träffantal och markerade utdrag. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Hur bearbetar och visar man sökresultat? + +`SearchResult` är en samling som innehåller enskilda `SearchResultItem`‑objekt, var och en beskriver ett matchande dokument, antalet träffar och markerade utdrag. Iterera över `SearchResult`‑objekten och skriv ut varje dokuments sökväg, antalet förekomster och de matchande fraserna. Denna enkla loop låter dig bygga UI‑tabeller, loggar eller API‑svar som visar exakt varför ett dokument matchade. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## Praktiska tillämpningar + +Verkliga scenarier där **how to search documents** är viktigt: +1. **Legal Document Management:** Hitta klausuler eller parter i tusentals kontrakt på sekunder. +2. **Academic Research:** Hämta relevanta artiklar även om sökordet är felstavat. +3. **Enterprise Content Management:** Driv interna portaler med snabb, stavfelstolerant sökning över rapporter, e‑post och presentationer. + +## Prestandaöverväganden + +- **Indexuppdatering:** Kör `add` eller `update` igen när källfiler ändras för att hålla resultaten aktuella. +- **Minneshantering:** GroupDocs.Search strömmar stora filer, så minnesavtrycket förblir lågt även för 500‑sidiga PDF‑filer. +- **Chunkad indexering:** Dela upp stora korpusar i flera indexmappar för att parallellisera bearbetning och förbättra svarstid. + +## Vanliga frågor + +**Q: Vad är fuzzy search Java och varför är det användbart?** +A: Fuzzy search Java möjliggör approximativ strängmatchning, vilket gör att frågor kan returnera resultat trots stavfel eller alternativa stavningar, vilket förbättrar slutanvändarupplevelsen. + +**Q: Hur uppdaterar jag mitt index efter att ha lagt till nya filer?** +A: Anropa `index.add("new/files/folder")` igen; biblioteket sammanslår intelligent nytt innehåll utan att bygga om hela indexet. + +**Q: Kan GroupDocs.Search hantera lösenordsskyddade PDF‑filer?** +A: Ja—ange lösenordet i `DocumentLoadOptions` när du lägger till filen, så kommer motorn att dekryptera och indexera innehållet. + +**Q: Finns det någon gräns för hur många dokument jag kan indexera?** +A: Biblioteket skalar till miljontals filer; prestanda beror på hårdvara och lagring, inte på en hårdkodad gräns. + +**Q: Var kan jag hitta mer avancerade exempel?** +A: Besök den officiella dokumentationen för djupare ämnen som anpassade analysatorer och resultatrangordning. + +## Slutsats + +Du vet nu **how to search documents** med GroupDocs.Search för Java, från att skapa ett index till att aktivera fuzzy search Java och bearbeta resultat. Implementera dessa steg för att leverera snabba, stavfelstoleranta sökupplevelser i alla Java‑baserade applikationer. + +--- + +**Last Updated:** 2026-05-28 +**Tested With:** GroupDocs.Search 23.10 for Java +**Author:** GroupDocs + +--- + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## Relaterade handledningar + +- [Create Document Index with GroupDocs.Search for Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Implement Full-Text Search in Java with GroupDocs.Search: A Comprehensive Guide](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [How to add documents to index with Metadata Indexing in Java using GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/thai/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/thai/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..fa6cf355 --- /dev/null +++ b/content/thai/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,219 @@ +--- +date: '2026-05-28' +description: เรียนรู้วิธีการค้นหาเอกสารอย่างมีประสิทธิภาพด้วย GroupDocs.Search for + Java รวมถึง fuzzy search Java และวิธีสร้างดัชนีสำหรับ full‑text search +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: วิธีการค้นหาเอกสารโดยใช้ GroupDocs.Search Java +type: docs +url: /th/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# วิธีการค้นหาเอกสารโดยใช้ GroupDocs.Search Java + +ในแอปพลิเคชันองค์กรสมัยใหม่ การ **how to search documents** อย่างรวดเร็วและแม่นยำเป็นความต้องการที่สำคัญ ไม่ว่าคุณจะจัดการกับสัญญา รายงาน หรือคลังเอกสารขนาดใหญ่ใด GroupDocs.Search สำหรับ Java ให้เครื่องมือค้นหาแบบเต็มข้อความที่แข็งแกร่งพร้อมการจับคู่แบบ fuzzy ในตัว บทเรียนนี้จะพาคุณผ่านการตั้งค่าห้องสมุด การสร้างดัชนี การเพิ่มเอกสาร การกำหนดค่าการค้นหา fuzzy Java และการดึงผลลัพธ์—ทั้งหมดด้วยคำอธิบายที่ชัดเจนและเป็นกันเอง + +## คำตอบด่วน +- **ขั้นตอนแรกคืออะไร?** Install the GroupDocs.Search Java library via Maven or download it directly. +- **ฉันจะสร้างดัชนีอย่างไร?** Instantiate an `Index` object pointing to a folder on disk; the library builds the searchable structure automatically. +- **ฉันสามารถค้นหาด้วยการพิมพ์ผิดได้หรือไม่?** Yes—enable fuzzy search to match terms that are misspelled or have slight variations. +- **วิธีการเพิ่มเอกสาร?** Use the `add` method on the `Index` instance, passing the folder that contains your files. +- **ต้องการเวอร์ชัน Java ใด?** JDK 8 or higher is supported. + +## “how to search documents” คืออะไรในบริบทของ GroupDocs.Search? +**“How to search documents”** หมายถึงกระบวนการสร้างดัชนีที่ค้นหาได้และส่งคำค้นที่ส่งคืนไฟล์ที่ตรงกัน โดยอาจใช้ตรรกะ fuzzy เพื่อทนต่อข้อผิดพลาดในการสะกด GroupDocs.Search จัดการการแยกโทเคน การทำดัชนี และการจัดอันดับเบื้องหลัง เพื่อให้คุณมุ่งเน้นที่ตรรกะธุรกิจ + +## ทำไมต้องใช้ GroupDocs.Search สำหรับ Java? +GroupDocs.Search รองรับ **ไฟล์ฟอร์แมตกว่า 30 ประเภท** (รวมถึง DOCX, PDF, TXT, HTML, และ XLSX) และสามารถทำดัชนี **เอกสารหลายร้อยหน้า** ได้โดยไม่ต้องโหลดไฟล์ทั้งหมดเข้าสู่หน่วยความจำ ทำให้ตอบสนองคำค้นภายในระดับวินาทีบนฮาร์ดแวร์เซิร์ฟเวอร์ทั่วไป ความสามารถในการค้นหาแบบ fuzzy ของมันช่วยปรับปรุงประสบการณ์ผู้ใช้โดยคืนผลลัพธ์ที่เกี่ยวข้องแม้คำค้นจะมีการพิมพ์ผิด + +## ข้อกำหนดเบื้องต้น +- **Java Development Kit (JDK):** เวอร์ชัน 8 หรือใหม่กว่า. +- **IDE:** IntelliJ IDEA, Eclipse, หรือ editor ที่รองรับ Java ใด ๆ. +- **GroupDocs.Search for Java library:** เพิ่มผ่าน Maven (แนะนำ) หรือดาวน์โหลดไฟล์ JAR. + +## วิธีการตั้งค่า GroupDocs.Search สำหรับ Java? + +เพื่อเริ่มต้น ให้เพิ่ม dependency ของ GroupDocs.Search ลงในไฟล์ build ของคุณ ตรวจสอบให้แน่ใจว่า URL ของ repository สามารถเข้าถึงได้ และตรวจสอบว่าเวอร์ชัน JDK ตรงตามข้อกำหนดขั้นต่ำ หลังจากไลบรารีถูกดึงมาแล้ว คุณสามารถ import คลาสต่าง ๆ ในโค้ดของคุณและสร้างโฟลเดอร์ดัชนีบนดิสก์ที่เก็บข้อมูลที่สามารถค้นหาได้ทั้งหมด + +### การตั้งค่า Maven +Add the repository and dependency to your `pom.xml` file exactly as shown in the original guide. + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### ดาวน์โหลดโดยตรง +หรือดาวน์โหลดไฟล์ JAR จากหน้าปล่อยอย่างเป็นทางการ: + +[การปล่อย GroupDocs.Search สำหรับ Java](https://releases.groupdocs.com/search/java/) + +[เอกสาร GroupDocs.Search](https://docs.groupdocs.com/search/java/) + +## วิธีการสร้างดัชนี? +สร้างโฟลเดอร์ดัชนีแบบคงที่ที่ GroupDocs.Search จะเก็บข้อมูลที่แยกโทเคนไว้ โหลดดัชนีแรกของคุณด้วยบรรทัดโค้ดเดียว—`new Index("path/to/indexFolder")`. คลาส `Index` เป็นคอมโพเนนต์หลักที่แทนคอลเลกชันเอกสารที่สามารถค้นหาได้ในหน่วยความจำและบนดิสก์ + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## วิธีการเพิ่มเอกสารลงในดัชนี? +ใช้เมธอด `add` ของอินสแตนซ์ `Index` เพื่อชี้ไปยังโฟลเดอร์ที่มีไฟล์ต้นฉบับของคุณ เอนจินจะสแกนรูปแบบที่รองรับแบบเรียกซ้ำ ดึงเนื้อหาข้อความออกมา และอัปเดตโครงสร้างภายใน การเรียกเดียวนี้จัดการชุดข้อมูลขนาดใหญ่ได้อย่างมีประสิทธิภาพโดยไม่ต้องประมวลผลไฟล์ทีละไฟล์ + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## วิธีการกำหนดค่าการค้นหา Fuzzy ใน Java? +คลาส `FuzzySearchOptions` กำหนดพารามิเตอร์เช่นระยะทางการแก้ไขและความยาวพรีฟิกซ์ที่ควบคุมระดับการทนต่อการสะกดผิด `SearchOptions` รวมการตั้งค่าทั้งหมดในช่วงเวลาการค้นหา รวมถึงตัวเลือก fuzzy, ขีดจำกัดผลลัพธ์, และการไฮไลท์ เปิดการจับคู่ fuzzy โดยตั้งค่า `FuzzySearchOptions` บนวัตถุ `SearchOptions` นี้บอกเอ็นจินให้พิจารณาคำที่อยู่ในระยะทางการแก้ไขที่กำหนด ทำให้การค้นทนต่อการสะกดผิด + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## วิธีการดำเนินการค้นหา? +เรียกเมธอด `search` บนวัตถุ `Index` โดยให้สตริงคำค้นและ `SearchOptions` ที่กำหนดไว้ เอ็นจินจะประมวลผลคำขอ ใช้การจับคู่ fuzzy หากเปิดใช้งาน และจัดอันดับผลลัพธ์ตามคะแนนความเกี่ยวข้อง การดำเนินการเสร็จเร็วแม้บนดัชนีขนาดใหญ่เพราะการค้นหาทำบนโครงสร้างโทเคนที่สร้างไว้ล่วงหน้า เมธอดจะคืนคอลเลกชัน `SearchResult` ที่มีเอกสารที่ตรงกัน, จำนวนการพบ, และสแนปช็อตที่ไฮไลท์ + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## วิธีการประมวลผลและแสดงผลลัพธ์การค้นหา? +`SearchResult` เป็นคอลเลกชันที่เก็บอ็อบเจ็กต์ `SearchResultItem` แต่ละรายการอธิบายเอกสารที่ตรงกัน, จำนวนการพบ, และสแนปช็อตที่ไฮไลท์ วนลูปผ่านรายการ `SearchResult` แล้วพิมพ์เส้นทางของเอกสาร, จำนวนการเกิดขึ้น, และวลีที่ตรงกัน ลูปง่าย ๆ นี้ช่วยให้คุณสร้างตาราง UI, บันทึก, หรือการตอบสนอง API ที่แสดงเหตุผลว่าทำไมเอกสารจึงตรงกัน + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## การใช้งานจริง +1. **Legal Document Management:** ค้นหาข้อหรือฝ่ายต่าง ๆ ในสัญญานับพันภายในไม่กี่วินาที. +2. **Academic Research:** ดึงเอกสารที่เกี่ยวข้องแม้คำค้นจะสะกดผิด. +3. **Enterprise Content Management:** ให้พลังกับพอร์ทัลภายในด้วยการค้นหาเร็วและทนต่อการพิมพ์ผิดทั่วทั้งรายงาน, อีเมล, และงานนำเสนอ. + +## ข้อควรพิจารณาด้านประสิทธิภาพ +- **Index Refresh:** เรียกใช้ `add` หรือ `update` ใหม่ทุกครั้งที่ไฟล์ต้นทางเปลี่ยนแปลงเพื่อให้ผลลัพธ์เป็นปัจจุบัน. +- **Memory Management:** GroupDocs.Search สตรีมไฟล์ขนาดใหญ่ ทำให้การใช้หน่วยความจำต่ำแม้สำหรับ PDF ขนาด 500 หน้า. +- **Chunked Indexing:** แบ่งคอร์ปัสขนาดมหาศาลเป็นหลายโฟลเดอร์ดัชนีเพื่อประมวลผลแบบขนานและลดความหน่วงของคำค้น. + +## คำถามที่พบบ่อย + +**Q: What is fuzzy search Java and why is it useful?** +A: Fuzzy search Java enables approximate string matching, allowing queries to return results despite typos or alternate spellings, which improves end‑user experience. + +**Q: How do I update my index after adding new files?** +A: Call `index.add("new/files/folder")` again; the library intelligently merges new content without rebuilding the entire index. + +**Q: Can GroupDocs.Search handle password‑protected PDFs?** +A: Yes—provide the password in the `DocumentLoadOptions` when adding the file, and the engine will decrypt and index the content. + +**Q: Is there a limit to the number of documents I can index?** +A: The library scales to millions of files; performance depends on hardware and storage, not a hard‑coded limit. + +**Q: Where can I find more advanced examples?** +A: Visit the official documentation for deeper topics like custom analyzers and result ranking. + +## สรุป +คุณได้เรียนรู้ **how to search documents** ด้วย GroupDocs.Search สำหรับ Java ตั้งแต่การสร้างดัชนีจนถึงการเปิดใช้งาน fuzzy search Java และการประมวลผลผลลัพธ์แล้ว นำขั้นตอนเหล่านี้ไปใช้เพื่อมอบประสบการณ์การค้นหาเร็วและทนต่อการพิมพ์ผิดในแอปพลิเคชัน Java ใด ๆ + +--- + +**อัปเดตล่าสุด:** 2026-05-28 +**ทดสอบกับ:** GroupDocs.Search 23.10 for Java +**ผู้เขียน:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## บทเรียนที่เกี่ยวข้อง +- [สร้างดัชนีเอกสารด้วย GroupDocs.Search สำหรับ Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [ดำเนินการค้นหาแบบเต็มข้อความใน Java ด้วย GroupDocs.Search: คู่มือเชิงลึก](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [วิธีเพิ่มเอกสารลงในดัชนีด้วยการทำดัชนีเมตาดาต้าใน Java โดยใช้ GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/turkish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/turkish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..3a762791 --- /dev/null +++ b/content/turkish/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,231 @@ +--- +date: '2026-05-28' +description: GroupDocs.Search for Java ile belgeleri verimli bir şekilde aramayı öğrenin, + fuzzy search Java ve full‑text search için indeks oluşturmayı öğrenin. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: GroupDocs.Search Java ile Belgeleri Nasıl Ararsınız +type: docs +url: /tr/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# GroupDocs.Search Java Kullanarak Belgeleri Arama + +Modern kurumsal uygulamalarda, **belgeleri arama** işlemini hızlı ve doğru bir şekilde gerçekleştirmek kritik bir gereksinimdir. Sözleşmeler, raporlar veya büyük bir belge deposu ile çalışıyor olun, GroupDocs.Search for Java, yerleşik bulanık eşleşme özelliğine sahip sağlam bir tam metin arama motoru sunar. Bu öğretici, kütüphaneyi kurma, bir indeks oluşturma, belgeleri ekleme, Java için bulanık aramayı yapılandırma ve sonuçları alma adımlarını net, konuşma diliyle açıklamalarla size gösterir. + +## Hızlı Yanıtlar +- **İlk adım nedir?** GroupDocs.Search Java kütüphanesini Maven üzerinden kurun veya doğrudan indirin. +- **Bir indeks nasıl oluşturulur?** Diskte bir klasöre işaret eden bir `Index` nesnesi oluşturun; kütüphane aranabilir yapıyı otomatik olarak oluşturur. +- **Yazım hatalarıyla arama yapabilir miyim?** Evet—yanlış yazılmış veya hafif varyasyon gösteren terimleri eşleştirmek için bulanık aramayı etkinleştirin. +- **Belgeler nasıl eklenir?** `Index` örneği üzerinde `add` metodunu kullanarak dosyalarınızı içeren klasörü belirtin. +- **Hangi Java sürümü gereklidir?** JDK 8 veya üzeri desteklenir. + +## GroupDocs.Search bağlamında “how to search documents” ne anlama gelir? +**“How to search documents”**, aranabilir bir indeks oluşturma ve eşleşen dosyaları döndüren sorgular gönderme sürecini ifade eder; isteğe bağlı olarak yazım hatalarını tolere eden bulanık mantık da kullanılabilir. GroupDocs.Search, tokenizasyon, indeksleme ve sıralamayı arka planda yönetir, böylece iş mantığınıza odaklanabilirsiniz. + +## Neden Java için GroupDocs.Search kullanmalı? +GroupDocs.Search **30+ dosya formatını** (DOCX, PDF, TXT, HTML ve XLSX dahil) destekler ve tüm dosyayı belleğe yüklemeden **yüzlerce sayfalık belgeleri** indeksleyebilir; tipik sunucu donanımında saniyenin altında sorgu yanıtları sağlar. Bulanık arama özelliği, sorgularda yazım hataları olduğunda bile ilgili sonuçları döndürerek kullanıcı deneyimini iyileştirir. + +## Önkoşullar +- **Java Development Kit (JDK):** sürüm 8 veya daha yenisi. +- **IDE:** IntelliJ IDEA, Eclipse veya herhangi bir Java‑uyumlu editör. +- **GroupDocs.Search for Java kütüphanesi:** Maven aracılığıyla ekleyin (önerilir) veya JAR dosyasını indirin. + +## GroupDocs.Search for Java Nasıl Kurulur? + +Başlamak için GroupDocs.Search bağımlılığını yapı dosyanıza ekleyin, depo URL’sinin erişilebilir olduğundan emin olun ve JDK sürümünün minimum gereksinimi karşıladığını doğrulayın. Kütüphane çözüldükten sonra sınıflarını kodunuzda içe aktarabilir ve tüm aranabilir verilerin saklanacağı bir indeks klasörü oluşturabilirsiniz. + +### Maven Kurulumu +`pom.xml` dosyanıza depoyu ve bağımlılığı, orijinal rehberde gösterildiği gibi tam olarak ekleyin. + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Doğrudan İndirme +Alternatif olarak, resmi sürüm sayfasından JAR dosyasını edinin: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## Bir Dizin (Index) Nasıl Oluşturulur? + +GroupDocs.Search’in tokenleştirilmiş verileri sakladığı kalıcı bir indeks klasörü oluşturun. Tek bir satır kodla ilk indeksinizi yükleyin—`new Index("path/to/indexFolder")`. `Index` sınıfı, bellek ve disk üzerinde aranabilir belge koleksiyonunu temsil eden temel bileşendir. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Dizin'e Belgeler Nasıl Eklenir? + +`Index` örneğinin `add` metodunu kullanarak kaynak dosyalarınızı içeren bir klasöre işaret edin. Motor, desteklenen formatları özyinelemeli olarak tarar, metin içeriğini çıkarır ve iç yapılarını günceller. Bu tek çağrı, büyük toplu işlemleri verimli bir şekilde yönetir, dosya‑dosya manuel işleme ihtiyacını ortadan kaldırır. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Java için Bulanık Arama Nasıl Yapılandırılır? + +`FuzzySearchOptions` sınıfı, edit mesafesi ve önek uzunluğu gibi parametreleri tanımlayarak aramanın yazım hatalarına ne kadar toleranslı olacağını kontrol eder. `SearchOptions` nesnesi, bulanık seçenekler, sonuç limitleri ve vurgulama tercihleri gibi tüm arama‑zamanı ayarlarını gruplar. `SearchOptions` nesnesine `FuzzySearchOptions` atayarak bulanık eşleşmeyi etkinleştirin. Bu, motorun yapılandırılabilir bir edit mesafesi içinde terimleri dikkate almasını sağlar ve aramaları yazım hatalarına toleranslı hâle getirir. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Arama İşlemi Nasıl Gerçekleştirilir? + +`Index` nesnesi üzerinde `search` metodunu çağırarak sorgu dizesi ve yapılandırılmış `SearchOptions` nesnesini sağlayın. Motor isteği işler, etkinleştirildiyse bulanık eşleşmeyi uygular ve sonuçları alaka düzeyine göre sıralar. Önceden oluşturulmuş token yapıları sayesinde büyük indekslerde bile işlem hızlı tamamlanır. Metod, eşleşen belgeler, hit sayısı ve vurgulanan snippet’leri içeren bir `SearchResult` koleksiyonu döndürür. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Arama Sonuçları Nasıl İşlenir ve Görüntülenir? + +`SearchResult`, her biri eşleşen bir belge, hit sayısı ve vurgulanan snippet’leri tanımlayan `SearchResultItem` nesnelerini tutan bir koleksiyondur. `SearchResult` öğeleri üzerinde döngü kurarak her belgenin yolunu, oluş sayısını ve eşleşen ifadeleri yazdırın. Bu basit döngü, UI tabloları, loglar veya API yanıtları oluşturmanıza olanak tanır; böylece bir belgenin neden eşleştiğini tam olarak gösterirsiniz. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## Pratik Uygulamalar + +**“How to search documents”** konusunun önemli olduğu gerçek dünya senaryoları: +1. **Hukuki Belge Yönetimi:** Binlerce sözleşmede maddeleri veya tarafları saniyeler içinde bulun. +2. **Akademik Araştırma:** Arama terimi yanlış yazılmış olsa bile ilgili makaleleri getir. +3. **Kurumsal İçerik Yönetimi:** Raporlar, e‑mailler ve sunumlar üzerinde hızlı, yazım hatalarına toleranslı arama ile iç portalı güçlendir. + +## Performans Düşünceleri + +- **İndeks Yenileme:** Kaynak dosyalar değiştiğinde sonuçların güncel kalması için `add` veya `update` metodunu yeniden çalıştırın. +- **Bellek Yönetimi:** GroupDocs.Search büyük dosyaları akış halinde işler, bu sayede 500‑sayfalık PDF’lerde bile bellek ayak izi düşük kalır. +- **Parçalı İndeksleme:** Devasa veri kümelerini birden fazla indeks klasörüne bölerek işleme paralel hale getirin ve sorgu gecikmesini iyileştirin. + +## Sık Sorulan Sorular + +**Q: Bulanık arama Java nedir ve neden faydalıdır?** +A: Bulanık arama Java, yaklaşık string eşleşmesini mümkün kılar; sorgular yazım hataları veya alternatif hecelenmelere rağmen sonuç döndürür, bu da son kullanıcı deneyimini artırır. + +**Q: Yeni dosyalar ekledikten sonra indeksimi nasıl güncellerim?** +A: `index.add("new/files/folder")` metodunu tekrar çağırın; kütüphane tüm içeriği yeniden oluşturmak zorunda kalmadan akıllıca birleştirir. + +**Q: GroupDocs.Search şifre korumalı PDF’leri işleyebilir mi?** +A: Evet—dosyayı eklerken `DocumentLoadOptions` içinde şifreyi sağlayın, motor içeriği çözer ve indeksler. + +**Q: İndeksleyebileceğim belge sayısında bir limit var mı?** +A: Kütüphane milyonlarca dosyaya ölçeklenebilir; performans donanım ve depolamaya bağlıdır, sabit bir limit yoktur. + +**Q: Daha gelişmiş örnekleri nerede bulabilirim?** +A: Özel analizörler ve sonuç sıralaması gibi konular için resmi belgeleri ziyaret edin. + +## Sonuç + +Artık GroupDocs.Search for Java ile **belgeleri arama** sürecini, indeks oluşturma, Java için bulanık aramayı etkinleştirme ve sonuçları işleme adımlarını biliyorsunuz. Bu adımları uygulayarak herhangi bir Java‑tabanlı uygulamada hızlı, yazım hatalarına toleranslı arama deneyimleri sunabilirsiniz. + +--- + +**Son Güncelleme:** 2026-05-28 +**Test Edilen Versiyon:** GroupDocs.Search 23.10 for Java +**Yazar:** GroupDocs + +--- + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## İlgili Öğreticiler + +- [Create Document Index with GroupDocs.Search for Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Implement Full-Text Search in Java with GroupDocs.Search: A Comprehensive Guide](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [How to add documents to index with Metadata Indexing in Java using GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file diff --git a/content/vietnamese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md b/content/vietnamese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md new file mode 100644 index 00000000..a60b4e39 --- /dev/null +++ b/content/vietnamese/java/searching/groupdocs-search-java-fuzzy-document-indexing/_index.md @@ -0,0 +1,229 @@ +--- +date: '2026-05-28' +description: Tìm hiểu cách tìm kiếm tài liệu một cách hiệu quả với GroupDocs.Search + cho Java, bao gồm fuzzy search Java và cách tạo chỉ mục cho full‑text search. +keywords: +- how to search documents +- how to create index +- fuzzy search java +- java full text search +- implement fuzzy matching +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + headline: How to Search Documents Using GroupDocs.Search Java + type: TechArticle +- description: Learn how to search documents efficiently with GroupDocs.Search for + Java, including fuzzy search Java and how to create index for full‑text search. + name: How to Search Documents Using GroupDocs.Search Java + steps: + - name: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + text: '**Legal Document Management:** Locate clauses or parties across thousands + of contracts in seconds.' + - name: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + text: '**Academic Research:** Retrieve relevant papers even if the search term + is misspelled.' + - name: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + text: '**Enterprise Content Management:** Power internal portals with fast, typo‑tolerant + search across reports, emails, and presentations.' + type: HowTo +- questions: + - answer: Fuzzy search Java enables approximate string matching, allowing queries + to return results despite typos or alternate spellings, which improves end‑user + experience. + question: What is fuzzy search Java and why is it useful? + - answer: Call `index.add("new/files/folder")` again; the library intelligently + merges new content without rebuilding the entire index. + question: How do I update my index after adding new files? + - answer: Yes—provide the password in the `DocumentLoadOptions` when adding the + file, and the engine will decrypt and index the content. + question: Can GroupDocs.Search handle password‑protected PDFs? + - answer: The library scales to millions of files; performance depends on hardware + and storage, not a hard‑coded limit. + question: Is there a limit to the number of documents I can index? + - answer: Visit the official documentation for deeper topics like custom analyzers + and result ranking. + question: Where can I find more advanced examples? + type: FAQPage +title: Cách tìm kiếm tài liệu bằng GroupDocs.Search Java +type: docs +url: /vi/java/searching/groupdocs-search-java-fuzzy-document-indexing/ +weight: 1 +--- + +# Cách Tìm Kiếm Tài Liệu Sử Dụng GroupDocs.Search Java + +Trong các ứng dụng doanh nghiệp hiện đại, **cách tìm kiếm tài liệu** nhanh chóng và chính xác là một yêu cầu quan trọng. Dù bạn đang làm việc với hợp đồng, báo cáo, hay bất kỳ kho tài liệu lớn nào, GroupDocs.Search cho Java cung cấp cho bạn một công cụ tìm kiếm toàn văn mạnh mẽ với khả năng khớp mờ tích hợp. Hướng dẫn này sẽ chỉ cho bạn cách thiết lập thư viện, tạo chỉ mục, thêm tài liệu, cấu hình fuzzy search Java, và truy xuất kết quả — tất cả với các giải thích rõ ràng, thân thiện. + +## Câu trả lời nhanh +- **Bước đầu tiên là gì?** Cài đặt thư viện GroupDocs.Search Java qua Maven hoặc tải xuống trực tiếp. +- **Làm thế nào để tạo chỉ mục?** Khởi tạo một đối tượng `Index` trỏ tới thư mục trên đĩa; thư viện sẽ tự động xây dựng cấu trúc có thể tìm kiếm. +- **Tôi có thể tìm kiếm với lỗi chính tả không?** Có — bật fuzzy search để khớp các từ bị viết sai hoặc có một chút khác biệt. +- **Cách thêm tài liệu?** Sử dụng phương thức `add` trên đối tượng `Index`, truyền thư mục chứa các tệp của bạn. +- **Yêu cầu phiên bản Java nào?** Hỗ trợ JDK 8 trở lên. + +## “Cách tìm kiếm tài liệu” trong ngữ cảnh của GroupDocs.Search là gì? +**“Cách tìm kiếm tài liệu”** đề cập đến quá trình xây dựng một chỉ mục có thể tìm kiếm và thực hiện các truy vấn trả về các tệp phù hợp, tùy chọn sử dụng logic mờ để chịu lỗi chính tả. GroupDocs.Search xử lý việc token hoá, lập chỉ mục và xếp hạng phía sau, cho phép bạn tập trung vào logic nghiệp vụ. + +## Tại sao nên sử dụng GroupDocs.Search cho Java? +GroupDocs.Search hỗ trợ **hơn 30 định dạng tệp** (bao gồm DOCX, PDF, TXT, HTML và XLSX) và có thể lập chỉ mục **các tài liệu hàng trăm trang** mà không cần tải toàn bộ tệp vào bộ nhớ, cung cấp phản hồi truy vấn dưới một giây trên phần cứng máy chủ thông thường. Khả năng fuzzy search của nó cải thiện trải nghiệm người dùng bằng cách trả về kết quả liên quan ngay cả khi truy vấn có lỗi chính tả. + +## Yêu cầu trước +- **Java Development Kit (JDK):** phiên bản 8 hoặc mới hơn. +- **IDE:** IntelliJ IDEA, Eclipse, hoặc bất kỳ trình soạn thảo nào hỗ trợ Java. +- **Thư viện GroupDocs.Search cho Java:** thêm qua Maven (được khuyến nghị) hoặc tải xuống file JAR. + +## Cách thiết lập GroupDocs.Search cho Java? + +Để bắt đầu, thêm phụ thuộc GroupDocs.Search vào file cấu hình build của bạn, đảm bảo URL kho lưu trữ có thể truy cập được và xác nhận phiên bản JDK đáp ứng yêu cầu tối thiểu. Sau khi thư viện được tải về, bạn có thể import các lớp của nó trong mã và tạo một thư mục chỉ mục trên đĩa để lưu trữ tất cả dữ liệu có thể tìm kiếm. + +### Cài đặt Maven +Thêm kho lưu trữ và phụ thuộc vào file `pom.xml` của bạn chính xác như trong hướng dẫn gốc. + +```xml + + + repository.groupdocs.com + GroupDocs Repository + https://releases.groupdocs.com/search/java/ + + + + + + com.groupdocs + groupdocs-search + 25.4 + + +``` + +### Tải trực tiếp +Hoặc, tải file JAR từ trang phát hành chính thức: + +[GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) + +[GroupDocs.Search Documentation](https://docs.groupdocs.com/search/java/) + +## Cách tạo chỉ mục? + +Tạo một thư mục chỉ mục bền vững nơi GroupDocs.Search lưu trữ dữ liệu đã token hoá. Tải chỉ mục đầu tiên của bạn chỉ với một dòng mã — `new Index("path/to/indexFolder")`. Lớp `Index` là thành phần cốt lõi đại diện cho một bộ sưu tập tài liệu có thể tìm kiếm trong bộ nhớ và trên đĩa. + +```java + import com.groupdocs.search.*; + + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Cách thêm tài liệu vào chỉ mục? + +Sử dụng phương thức `add` của đối tượng `Index` để chỉ tới thư mục chứa các tệp nguồn của bạn. Engine sẽ quét đệ quy các định dạng được hỗ trợ, trích xuất nội dung văn bản và cập nhật cấu trúc nội bộ. Lệnh gọi duy nhất này xử lý các lô lớn một cách hiệu quả, loại bỏ nhu cầu xử lý từng tệp một thủ công. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Cách cấu hình Fuzzy Search Java? + +Lớp `FuzzySearchOptions` định nghĩa các tham số như khoảng cách chỉnh sửa và độ dài tiền tố, kiểm soát mức độ chịu lỗi chính tả của tìm kiếm. Đối tượng `SearchOptions` nhóm tất cả các cài đặt thời gian tìm kiếm, bao gồm các tùy chọn fuzzy, giới hạn kết quả và tùy chọn đánh dấu. Bật khớp fuzzy bằng cách thiết lập `FuzzySearchOptions` trên đối tượng `SearchOptions`. Điều này yêu cầu engine xem xét các từ trong khoảng cách chỉnh sửa có thể cấu hình, làm cho tìm kiếm chịu lỗi chính tả. + +```java + String indexFolder = "YOUR_OUTPUT_DIRECTORY/AdvancedUsage/Searching/SearchResults"; + Index index = new Index(indexFolder); + ``` + +## Cách thực hiện thao tác tìm kiếm? + +Gọi phương thức `search` trên đối tượng `Index`, cung cấp chuỗi truy vấn và `SearchOptions` đã cấu hình. Engine xử lý yêu cầu, áp dụng khớp fuzzy nếu được bật, và xếp hạng kết quả dựa trên điểm liên quan. Thao tác hoàn thành nhanh ngay cả trên các chỉ mục lớn vì tìm kiếm được thực hiện trên các cấu trúc token đã được xây dựng trước. Phương thức trả về một bộ sưu tập `SearchResult` chứa các tài liệu phù hợp, số lần xuất hiện và các đoạn trích được đánh dấu. + +```java + String documentFolder = "YOUR_DOCUMENT_DIRECTORY"; + index.add(documentFolder); + ``` + +## Cách xử lý và hiển thị kết quả tìm kiếm? + +`SearchResult` là một bộ sưu tập chứa các đối tượng `SearchResultItem` riêng lẻ, mỗi đối tượng mô tả một tài liệu phù hợp, số lần xuất hiện và các đoạn trích được đánh dấu. Duyệt qua các mục trong `SearchResult` và in ra đường dẫn của mỗi tài liệu, số lần xuất hiện và các cụm từ khớp. Vòng lặp đơn giản này cho phép bạn xây dựng bảng UI, log, hoặc phản hồi API hiển thị chính xác lý do tại sao một tài liệu được khớp. + +```java + import com.groupdocs.search.options.*; + + SearchOptions options = new SearchOptions(); + options.getFuzzySearch().setEnabled(true); + options.getFuzzySearch().setFuzzyAlgorithm(new TableDiscreteFunction(3)); + ``` + +## Ứng dụng thực tiễn + +Những kịch bản thực tế mà **cách tìm kiếm tài liệu** quan trọng: +1. **Quản lý tài liệu pháp lý:** Tìm các điều khoản hoặc bên liên quan trong hàng ngàn hợp đồng trong vòng vài giây. +2. **Nghiên cứu học thuật:** Truy xuất các bài báo liên quan ngay cả khi từ khóa tìm kiếm bị viết sai. +3. **Quản lý nội dung doanh nghiệp:** Cung cấp cho các cổng nội bộ khả năng tìm kiếm nhanh, chịu lỗi chính tả trên báo cáo, email và bản trình bày. + +## Các yếu tố hiệu năng + +- **Làm mới chỉ mục:** Chạy lại `add` hoặc `update` mỗi khi các tệp nguồn thay đổi để duy trì kết quả cập nhật. +- **Quản lý bộ nhớ:** GroupDocs.Search truyền dữ liệu các tệp lớn, do đó dung lượng bộ nhớ vẫn thấp ngay cả với PDF 500 trang. +- **Lập chỉ mục theo khối:** Chia các tập dữ liệu khổng lồ thành nhiều thư mục chỉ mục để xử lý song song và cải thiện độ trễ truy vấn. + +## Câu hỏi thường gặp + +**Q: Fuzzy search Java là gì và tại sao hữu ích?** +A: Fuzzy search Java cho phép khớp chuỗi xấp xỉ, cho phép các truy vấn trả về kết quả ngay cả khi có lỗi chính tả hoặc cách viết khác, cải thiện trải nghiệm người dùng cuối. + +**Q: Làm thế nào để cập nhật chỉ mục sau khi thêm tệp mới?** +A: Gọi lại `index.add("new/files/folder")`; thư viện sẽ hợp nhất nội dung mới một cách thông minh mà không cần xây dựng lại toàn bộ chỉ mục. + +**Q: GroupDocs.Search có thể xử lý PDF có mật khẩu không?** +A: Có — cung cấp mật khẩu trong `DocumentLoadOptions` khi thêm tệp, và engine sẽ giải mã và lập chỉ mục nội dung. + +**Q: Có giới hạn số lượng tài liệu có thể lập chỉ mục không?** +A: Thư viện có thể mở rộng tới hàng triệu tệp; hiệu năng phụ thuộc vào phần cứng và lưu trữ, không có giới hạn cố định. + +**Q: Tôi có thể tìm các ví dụ nâng cao ở đâu?** +A: Tham khảo tài liệu chính thức để tìm các chủ đề sâu hơn như bộ phân tích tùy chỉnh và xếp hạng kết quả. + +## Kết luận + +Bây giờ bạn đã biết **cách tìm kiếm tài liệu** với GroupDocs.Search cho Java, từ việc tạo chỉ mục đến bật fuzzy search Java và xử lý kết quả. Áp dụng các bước này để cung cấp trải nghiệm tìm kiếm nhanh, chịu lỗi chính tả trong bất kỳ ứng dụng Java nào. + +--- + +**Cập nhật lần cuối:** 2026-05-28 +**Kiểm tra với:** GroupDocs.Search 23.10 for Java +**Tác giả:** GroupDocs + +```java + String query = "water OR \"Lorem ipsum\""; + SearchResult result = index.search(query, options); + ``` + +```java + for (int i = 0; i < result.getDocumentCount(); i++) { + FoundDocument document = result.getFoundDocument(i); + System.out.println("\tDocument: " + document.getDocumentInfo().getFilePath()); + System.out.println("\tOccurrences: " + document.getOccurrenceCount()); + + for (FoundDocumentField field : document.getFoundFields()) { + System.out.println("\t\tField: " + field.getFieldName()); + if (field.getTerms() != null) { + for (int k = 0; k < field.getTerms().length; k++) { + System.out.println("\t\t\t" + field.getTerms()[k] + " - " + field.getTermsOccurrences()[k]); + } + } + } + } + ``` + +## Hướng dẫn liên quan + +- [Tạo chỉ mục tài liệu với GroupDocs.Search cho Java](/search/java/advanced-features/groupdocs-search-java-implementation-guide/) +- [Triển khai tìm kiếm toàn văn trong Java với GroupDocs.Search: Hướng dẫn toàn diện](/search/java/searching/implement-full-text-search-java-groupdocs-search/) +- [Cách thêm tài liệu vào chỉ mục với Metadata Indexing trong Java bằng GroupDocs.Search](/search/java/indexing/groupdocs-search-java-metadata-indexing/) \ No newline at end of file From 0381a6c871f9512df5c059d5fbf5107aa01c4050 Mon Sep 17 00:00:00 2001 From: Muhammad Muqarrab Date: Thu, 28 May 2026 01:18:40 +0000 Subject: [PATCH 2/3] =?UTF-8?q?Optimize=20page:=20content/english/java/sea?= =?UTF-8?q?rching/groupdocs-search-java-homophone-guide/=5Findex.md=20-=20?= =?UTF-8?q?-=20Updated=20title=20and=20meta=20description=20to=20include?= =?UTF-8?q?=20primary=20keyword=20=E2=80=9Ccreate=20index=20java=E2=80=9D.?= =?UTF-8?q?=20-=20Refreshed=20front=E2=80=91matter=20date=20and=20added=20?= =?UTF-8?q?a=20comprehensive=20keywords=20list.=20-=20Added=20definition?= =?UTF-8?q?=20anchors=20for=20Index=20and=20SearchOptions=20classes.=20-?= =?UTF-8?q?=20Rewrote=20all=20question=E2=80=91format=20H2=20sections=20wi?= =?UTF-8?q?th=2040=E2=80=9170=20word=20direct=20answers.=20-=20Replaced=20?= =?UTF-8?q?vague=20statements=20with=20quantified=20claims=20(e.g.,=2030?= =?UTF-8?q?=E2=80=AF%=20recall=20boost,=20500=E2=80=AFMB=20file=20handling?= =?UTF-8?q?).=20-=20Reformatted=20FAQ=20into=20AI=E2=80=91friendly=20Q&A?= =?UTF-8?q?=20pairs=20and=20expanded=20explanations.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../_index.md | 182 +++++++++------ .../_index.md | 159 ++++++++----- .../_index.md | 190 ++++++++++------ .../_index.md | 186 +++++++++------ .../_index.md | 135 +++++++---- .../_index.md | 190 ++++++++++------ .../_index.md | 211 +++++++++++------- .../_index.md | 197 ++++++++++------ .../_index.md | 196 +++++++++++----- .../_index.md | 202 ++++++++++------- .../_index.md | 203 ++++++++++------- .../_index.md | 184 +++++++++------ .../_index.md | 190 ++++++++++------ .../_index.md | 208 ++++++++++------- .../_index.md | 198 ++++++++++------ .../_index.md | 175 ++++++++++----- .../_index.md | 171 +++++++++----- .../_index.md | 191 ++++++++++------ .../_index.md | 190 ++++++++++------ .../_index.md | 184 +++++++++------ .../_index.md | 191 ++++++++++------ .../_index.md | 174 ++++++++++----- .../_index.md | 205 ++++++++++------- 23 files changed, 2760 insertions(+), 1552 deletions(-) diff --git a/content/arabic/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/arabic/java/searching/groupdocs-search-java-homophone-guide/_index.md index 681e820e..a26aa318 100644 --- a/content/arabic/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/arabic/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,39 +1,81 @@ --- -date: '2026-01-26' -description: تعلم كيفية إنشاء الفهرس وإضافة المستندات إلى الفهرس باستخدام GroupDocs.Search - للغة Java. فعّل البحث عن المتجانسات الصوتية للحصول على استرجاع مستندات أفضل. +date: '2026-05-28' +description: تعلم كيفية إنشاء فهرس جافا، إضافة المستندات إلى الفهرس، وتمكين البحث + عن الكلمات المتجانسة صوتيًا باستخدام GroupDocs.Search for Java للحصول على استرجاع + سريع ودقيق. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'كيفية إنشاء فهرس باستخدام GroupDocs.Search Java: تنفيذ البحث عن المتجانسات - الصوتية' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: كيفية إنشاء فهرس جافا باستخدام GroupDocs.Search وتمكين البحث عن الكلمات المتجانسة + صوتيًا type: docs url: /ar/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# كيفية إنشاء فهرس باستخدام GroupDocs.Search Java وتمكين البحث عن المتجانسات الصوتية +# كيفية إنشاء فهرس جافا باستخدام GroupDocs.Search وتمكين البحث عن المتجانسات الصوتية -في المؤسسات الحديثة، **كيفية إنشاء فهرس** بسرعة وموثوقية يمكن أن تكون الفارق بين العثور على معلومات حيوية أو فقدانها تمامًا. سواء كنت تتعامل مع العقود القانونية، ملاحظات العملاء، أو التقارير الداخلية، فإن فهرس البحث المُصمم جيدًا باستخدام GroupDocs.Search للـ Java يمنحك نتائج فورية ودقيقة. في هذا الدليل سنستعرض العملية بالكامل—من إعداد المكتبة، إلى إنشاء الفهرس، إلى إضافة المستندات إلى الفهرس، وأخيرًا تمكين البحث عن المتجانسات الصوتية للحصول على استعلامات أذكى. +في المؤسسات الحديثة، يمكن أن يكون **create index java** بسرعة وبشكل موثوق هو الفارق بين العثور على المعلومات الحيوية أو فقدانها تمامًا. سواء كنت تقوم بفهرسة العقود القانونية أو ملاحظات العملاء أو التقارير الداخلية، فإن فهرس البحث المصمم جيدًا المدعوم بـ GroupDocs.Search for Java يمنحك نتائج فورية ودقيقة. في هذا الدليل سنستعرض العملية بالكامل — من إعداد المكتبة، إلى إنشاء الفهرس، إلى إضافة المستندات، وأخيرًا تمكين البحث عن المتجانسات الصوتية للحصول على استعلامات أذكى. -## إجابات سريعة -- **ما هي الخطوة الأولى لإنشاء فهرس؟** تهيئة كائن `Index` بمسار مجلد. -- **ما الطريقة التي تضيف الملفات إلى الفهرس؟** `index.add(yourDocumentsFolder)`. +## الإجابات السريعة +- **ما هي الخطوة الأولى لإنشاء فهرس؟** قم بتهيئة كائن `Index` بمسار المجلد. +- **أي طريقة تضيف ملفات إلى الفهرس؟** `index.add(yourDocumentsFolder)`. - **كيف يمكنني تمكين البحث عن المتجانسات الصوتية؟** اضبط `options.setUseHomophoneSearch(true)`. -- **هل أحتاج إلى ترخيص؟** نسخة تجريبية مجانية أو ترخيص مؤقت يكفي للتقييم. +- **هل أحتاج إلى ترخيص؟** نسخة تجريبية مجانية أو ترخيص مؤقت يعمل للتقييم. - **ما نسخة Java المطلوبة؟** JDK 8 أو أحدث. ## ما هو الفهرس في GroupDocs.Search؟ -الفهرس هو مخزن بيانات منظم يربط الكلمات ومواقعها عبر مجموعة المستندات الخاصة بك، مما يتيح عمليات بحث سريعة كالبرق مشابهة لفهرس الكتاب. إنشاء الفهرس هو الأساس لأي تطبيق يعتمد على البحث. +`Index` هو الفئة الأساسية التي تخزن المصطلحات القابلة للبحث ومواقعها عبر المستندات. الـ **Index** هو بنية البيانات الأساسية في GroupDocs.Search التي تخزن المصطلحات ومواقعها عبر مجموعة مستنداتك، مما يتيح عمليات بحث سريعة كالصاعقة. يعمل كفهرس الكتاب لكنه يمكنه التعامل مع ملايين المصطلحات عبر عشرات صيغ الملفات، موفرًا استرجاعًا سريعًا حتى للمجموعات الكبيرة. ## لماذا تمكين البحث عن المتجانسات الصوتية؟ -البحث عن المتجانسات الصوتية يوسع لغة الاستعلام لتشمل الكلمات التي تُنطق بشكل مشابه (مثال: “write” مقابل “right”). هذا يزيد من استرجاع النتائج في الحالات التي قد يخطئ فيها المستخدمون في الكتابة أو يستخدمون تهجئات بديلة، مما يقدم نتائج أكثر شمولاً دون جهد إضافي. +يُوسّع البحث عن المتجانسات الصوتية الاستعلام ليشمل الكلمات التي تُنطق بشكل مشابه (مثلاً، “write” مقابل “right”). هذا يزيد من الاسترجاع بنسبة تصل إلى **30 % في سيناريوهات إدخال المستخدم الضوضائية**، مما يضمن حصول المستخدمين على نتائج حتى عندما يخطئون في الكتابة أو يستخدمون تهجئات بديلة. وهو ذو قيمة خاصة للواجهات الصوتية والبيئات متعددة اللغات. ## المتطلبات المسبقة -- **مجموعة تطوير Java** 8 أو أحدث. -- مكتبة **GroupDocs.Search for Java** (متوفرة عبر Maven). -- إلمام أساسي بصياغة Java وإعداد المشروع. +- **Java Development Kit** 8 أو أحدث. +- **GroupDocs.Search for Java** library (متاح عبر Maven). +- إلمام أساسي بتركيب Java وإعداد المشروع. ## إعداد GroupDocs.Search لـ Java @@ -57,9 +99,9 @@ weight: 1 ``` -بدلاً من ذلك، يمكنك [تحميل أحدث إصدار من إصدارات GroupDocs.Search لـ Java](https://releases.groupdocs.com/search/java/). +بدلاً من ذلك، يمكنك [تحميل أحدث نسخة من إصدارات GroupDocs.Search for Java](https://releases.groupdocs.com/search/java/). -**الحصول على الترخيص**: تقدم GroupDocs ترخيص تجريبي مجاني أو تراخيص مؤقتة للتقييم. للشراء، زر موقعهم الرسمي. +**الحصول على الترخيص**: تقدم GroupDocs ترخيصًا تجريبيًا مجانيًا أو تراخيص مؤقتة للتقييم. للشراء، زر موقعهم الرسمي. ### التهيئة الأساسية والإعداد @@ -81,87 +123,93 @@ public class SearchSetup { } ``` -## كيفية إنشاء فهرس باستخدام GroupDocs.Search Java +## كيفية إنشاء فهرس جافا باستخدام GroupDocs.Search Java؟ -إنشاء الفهرس سهل مثل توجيه مُنشئ `Index` إلى مجلد يمكن للمكتبة تخزين ملفاتها الداخلية فيه. +`Index` هو الفئة الرئيسية التي تمثل فهرسًا قابلًا للبحث مخزنًا على القرص. قم بتحميل أو إنشاء الفهرس عن طريق توجيه مُنشئ `Index` إلى مجلد يمكن للمكتبة تخزين ملفاتها الداخلية فيه. هذه العملية تنشئ ملفات البيانات الوصفية اللازمة وتجهز المحرك لاستيعاب المستندات، مما يسمح بإضافة المستندات لاحقًا وتنفيذ الاستعلامات. -### الخطوة 1: تعريف مسار الفهرس +### الخطوة 1: تحديد مسار الفهرس ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` استبدل `YOUR_DOCUMENT_DIRECTORY` بالمسار المطلق على جهازك. -### الخطوة 2: إنشاء كائن الفهرس +### الخطوة 2: إنشاء كائن Index ```java Index index = new Index(indexFolder); -``` +``` هذا السطر **ينشئ الفهرس** الذي سيحتوي لاحقًا على جميع المحتويات القابلة للبحث. -## كيفية إضافة مستندات إلى الفهرس +## كيفية إضافة مستندات إلى الفهرس؟ -بمجرد وجود الفهرس، تحتاج إلى إمداده بالمستندات التي تريد البحث فيها. +`add` هي طريقة في فئة `Index` تقوم بإدخال الملفات من مجلد إلى الفهرس. بعد وجود الفهرس، تحتاج إلى تزويده بالمستندات التي تريد البحث فيها. تقوم طريقة `add` بمسح الدليل بشكل متكرر وتفهرس كل ملف مدعوم، مستخرجة النص وبناء جداول تردد المصطلحات للاسترجاع السريع. -### الخطوة 1: الإشارة إلى مستندات المصدر +### الخطوة 1: الإشارة إلى مستندات المصدر الخاصة بك ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` +``` يجب أن يحتوي هذا المجلد على الملفات (PDF، DOCX، TXT، إلخ) التي ترغب في فهرستها. ### الخطوة 2: إضافة جميع الملفات في المجلد ```java index.add(documentsFolder); -``` -طريقة `add` تقوم بمسح الدليل بشكل متكرر وتفهرس كل ملف مدعوم. هذه هي العملية الأساسية التي **تضيف المستندات إلى الفهرس**. +``` +تقوم طريقة `add` بمعالجة كل ملف، استخراج النص، وتخزين بيانات تردد المصطلحات، مما يؤدي فعليًا إلى **إضافة المستندات إلى الفهرس**. -## تمكين البحث عن المتجانسات الصوتية +## كيفية تمكين البحث عن المتجانسات الصوتية؟ -الآن بعد أن تم ملء الفهرس، يمكنك تشغيل دعم المتجانسات الصوتية. +`setUseHomophoneSearch` هي طريقة في `SearchOptions` تقوم بتبديل المطابقة الصوتية للاستعلامات. الآن بعد أن تم ملء الفهرس، يمكنك تشغيل المطابقة الصوتية لالتقاط المصطلحات المتشابهة صوتيًا. تمكين هذه الميزة يوجه المحرك للنظر في المكافئات الصوتية أثناء معالجة الاستعلامات، مما يحسن الاسترجاع للأخطاء الإملائية أو المدخلات الصوتية. ### الخطوة 1: إنشاء SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` يحدد كيفية تفسير المحرك للاستعلامات. ### الخطوة 2: تفعيل البحث عن المتجانسات الصوتية ```java options.setUseHomophoneSearch(true); -``` -ضبط هذا العلم يخبر المحرك بأخذ المكافئات الصوتية في الاعتبار عند معالجة الاستعلامات. +``` +ضبط `setUseHomophoneSearch(true)` يخبر المحرك بأخذ المكافئات الصوتية في الاعتبار عند معالجة الاستعلامات. -## تطبيقات عملية +## التطبيقات العملية 1. **إدارة المستندات القانونية** – العثور على العقود التي تذكر “lease” حتى إذا كتب المستخدم “leas”. 2. **تحليل ملاحظات العملاء** – التقاط المتغيرات مثل “price” و “prise” في ردود الاستطلاع. -3. **أنظمة إدارة المحتوى** – تحسين بحث الموقع بمطابقة “write” مع “right”. +3. **أنظمة إدارة المحتوى** – تحسين بحث الموقع من خلال مطابقة “write” مع “right”. ## اعتبارات الأداء -- **إعادة بناء الفهرس بانتظام** بعد تحديثات المستندات الضخمة. -- **مراقبة استهلاك الذاكرة**؛ قد تستفيد الفهارس الكبيرة من الفهرسة المتدرجة. -- اتباع أفضل ممارسات Java (مثل معالجة الاستثناءات بشكل صحيح، واستخدام try‑with‑resources) للحفاظ على استقرار التطبيق. +- **إعادة بناء الفهرس بانتظام** بعد تحديثات المستندات الضخمة للحفاظ على إحصاءات المصطلحات محدثة. +- **مراقبة استهلاك الذاكرة**؛ يمكن للمحرك معالجة مستندات مئات الصفحات دون تحميل الملف بالكامل في الذاكرة بفضل الفهرسة المتدرجة. +- اتبع أفضل ممارسات Java (مثل try‑with‑resources، ومعالجة الاستثناءات بشكل صحيح) للحفاظ على استقرار التطبيق تحت الحمل. -## الاستنتاج -أنت الآن تعرف **كيفية إنشاء فهرس**، وكيفية **إضافة مستندات إلى الفهرس**، وكيفية تمكين البحث عن المتجانسات الصوتية باستخدام GroupDocs.Search لـ Java. هذه القدرات تمكنك من بناء تجارب بحث سريعة وذكية عبر أي مستودع مستندات. +## الخلاصة +أنت الآن تعرف **كيفية إنشاء فهرس جافا**، وكيفية **إضافة مستندات إلى الفهرس**، وكيفية تمكين البحث عن المتجانسات الصوتية باستخدام GroupDocs.Search for Java. هذه القدرات تمكنك من بناء تجارب بحث سريعة وذكية عبر أي مستودع مستندات. ### الخطوات التالية -- جرب **محللات مخصصة** لضبط عملية التجزئة بدقة. -- دمج **البحث الموجه** مع دعم المتجانسات الصوتية للحصول على تصفية أغنى. -- استكشف **GroupDocs.Search REST API** لسيناريوهات متعددة المنصات. - -## قسم الأسئلة المتكررة -1. **ما هو الفهرس في سياق GroupDocs.Search؟** - - الفهرس هو بنية بيانات تسمح بالبحث السريع عن المستندات، مشابهة لفهرس الكتاب. -2. **كيف أقوم بتحديث فهرسي بالمستندات الجديدة؟** - - استخدم طريقة `index.add()` لإضافة مستندات جديدة أو إعادة فهرسة الموجودة. -3. **هل يمكن لـ GroupDocs.Search التعامل مع كميات كبيرة من البيانات؟** - - نعم، تم تصميمه للتوسع ويمكنه إدارة مجموعات بيانات كبيرة بكفاءة. -4. **ما هي المتجانسات الصوتية في وظيفة البحث؟** - - المتجانسات الصوتية هي كلمات تُنطق بشكل مشابه لكن قد تحمل معاني مختلفة، مثل “write” و “right”. -5. **كيف أقوم باستكشاف أخطاء الفهرسة وإصلاحها؟** - - تحقق من مسارات الملفات، تأكد من إمكانية الوصول إلى المستندات، وراجع ملفات السجل للحصول على رسائل الأخطاء المحددة. +- جرّب **محللات مخصصة** لضبط التجزئة بدقة. +- اجمع **البحث المتعدد الأوجه** مع دعم المتجانسات الصوتية للحصول على تصفية أكثر غنى. +- استكشف **GroupDocs.Search REST API** للسيناريوهات متعددة المنصات. + +## الأسئلة المتكررة + +**س:** ما هو الفهرس في سياق GroupDocs.Search؟ +ج: الفهرس هو بنية بيانات تربط المصطلحات بمواقعها في المستندات، مما يتيح استرجاعًا بمستوى الملي ثانية مشابهًا لفهرس الكتاب. + +**س:** كيف أقوم بتحديث فهرسي بالمستندات الجديدة؟ +ج: استدعِ `index.add(newFolder)` لإدخال ملفات إضافية أو لإعادة فهرسة الموجودة؛ يقوم المحرك بتحديث جداول المصطلحات بشكل متدرج. + +**س:** هل يمكن لـ GroupDocs.Search التعامل مع كميات كبيرة من البيانات؟ +ج: نعم، يتوسع إلى ملايين المستندات ويدعم معالجة ملفات تزيد عن 500 ميغابايت دون تحميل المحتوى بالكامل في الذاكرة. + +**س:** ما هي المتجانسات الصوتية في وظيفة البحث؟ +ج: المتجانسات الصوتية هي كلمات تُنطق بشكل مشابه ولكن تختلف في التهجئة، مثل “write” و “right”؛ تمكين هذه الميزة يوسع نطاق تغطية الاستعلام. + +**س:** كيف أقوم باستكشاف أخطاء الفهرسة؟ +ج: تحقق من مسارات الملفات، تأكد من صلاحيات القراءة، وراجع مخرجات السجل للحصول على رسائل استثناء محددة؛ المشكلات الشائعة تشمل صيغ غير مدعومة أو ملفات تالفة. ## الموارد -- [الوثائق](https://docs.groupdocs.com/search/java/) +- [التوثيق](https://docs.groupdocs.com/search/java/) - [مرجع API](https://reference.groupdocs.com/search/java) - [تحميل أحدث نسخة](https://releases.groupdocs.com/search/java/) - [مستودع GitHub](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) @@ -170,6 +218,12 @@ options.setUseHomophoneSearch(true); --- -**آخر تحديث:** 2026-01-26 -**تم الاختبار مع:** GroupDocs.Search 25.4 لـ Java -**المؤلف:** GroupDocs \ No newline at end of file +**آخر تحديث:** 2026-05-28 +**تم الاختبار مع:** GroupDocs.Search 25.4 for Java +**المؤلف:** GroupDocs + +## دروس ذات صلة + +- [إضافة مستندات إلى الفهرس – دروس GroupDocs.Search Java](/search/java/document-management/) +- [كيفية إنشاء فهرس باستخدام GroupDocs.Search في Java - دليل كامل](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [إنشاء فهرس جافا مع GroupDocs.Search | دليل شامل للفهرسة والتقارير](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/chinese/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/chinese/java/searching/groupdocs-search-java-homophone-guide/_index.md index 4f54d17c..7e597b58 100644 --- a/content/chinese/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/chinese/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,41 +1,82 @@ --- -date: '2026-01-26' -description: 学习如何使用 GroupDocs.Search for Java 创建索引并向索引添加文档。启用同音词搜索，以实现更出色的文档检索。 +date: '2026-05-28' +description: 了解如何使用 GroupDocs.Search for Java 创建 Java 索引、向索引添加文档，并启用同音词搜索，以实现快速、准确的检索。 keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 如何使用 GroupDocs.Search Java 创建索引：实现同音词搜索 +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: 如何使用 GroupDocs.Search 创建 Java 索引并启用同音词搜索 type: docs url: /zh/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# 如何使用 GroupDocs.Search Java 创建索引并启用同音词搜索 +# 如何使用 GroupDocs.Search 创建 Java 索引并启用同音搜索 -在现代企业中，**如何快速可靠地创建索引**可能决定是能够找到关键信息还是完全错失。无论您是处理法律合同、客户反馈还是内部报告，由 GroupDocs.Search for Java 提供的构建良好的搜索索引都能让您瞬间获得准确的结果。在本教程中，我们将完整演示整个过程——从设置库、创建索引、向索引添加文档，最后启用同音词搜索以实现更智能的查询。 +在现代企业中，快速可靠地 **create index java**（创建 Java 索引）可能决定能否找到关键信息或完全错过它。无论您是对法律合同、客户反馈还是内部报告进行索引，使用 GroupDocs.Search for Java 构建的高效搜索索引都能提供即时、准确的结果。在本教程中，我们将完整演示整个过程——从设置库、创建索引、添加文档，到最终启用同音搜索以实现更智能的查询。 ## 快速答案 - **创建索引的第一步是什么？** 使用文件夹路径初始化 `Index` 对象。 - **哪个方法向索引添加文件？** `index.add(yourDocumentsFolder)`。 -- **如何启用同音词搜索？** 设置 `options.setUseHomophoneSearch(true)`。 -- **我需要许可证吗？** 免费试用或临时许可证可用于评估。 +- **如何启用同音搜索？** 设置 `options.setUseHomophoneSearch(true)`。 +- **我需要许可证吗？** 免费试用或临时许可证即可用于评估。 - **需要哪个 Java 版本？** JDK 8 或更高版本。 ## GroupDocs.Search 中的索引是什么？ -索引是一种结构化的数据存储，用于映射词语及其在文档集合中的位置，实现类似书籍索引的闪电般快速查找。创建索引是任何基于搜索的应用程序的基础。 +`Index` 是存储可搜索词汇及其在文档中位置的核心类。**Index** 是 GroupDocs.Search 的核心数据结构，用于存储词汇及其在文档集合中的位置，实现闪电般的快速查找。它的工作方式类似于书籍的索引，但能够处理数百万词汇和数十种文件格式，即使在大型语料库中也能提供快速检索。 -## 为什么启用同音词搜索？ -同音词搜索将查询语言扩展到包含发音相似的词（例如 “write” 与 “right”）。在用户可能拼写错误或使用不同拼写的场景中，这可以提升召回率，提供更全面的结果，而无需额外的努力。 +## 为什么启用同音搜索？ +同音搜索会将查询扩展为包含发音相同的词（例如 “write” 与 “right”）。这在噪声较大的用户输入场景中可将召回率提升至 **30 %**，确保用户即使拼写错误或使用替代拼写也能获得结果。该功能对语音驱动的界面和多语言环境尤为有价值。 ## 前置条件 - **Java Development Kit** 8 或更高版本。 - **GroupDocs.Search for Java** 库（可通过 Maven 获取）。 - 对 Java 语法和项目设置有基本了解。 -## 设置 GroupDocs.Search for Java +## 为 Java 设置 GroupDocs.Search -首先，在 `pom.xml` 中添加 GroupDocs.Search Maven 仓库和依赖： +首先，将 GroupDocs.Search Maven 仓库和依赖添加到您的 `pom.xml` 中： ```xml @@ -57,7 +98,7 @@ weight: 1 或者，您可以[从 GroupDocs.Search for Java 发布页面下载最新版本](https://releases.groupdocs.com/search/java/)。 -**许可证获取**：GroupDocs 提供免费试用许可证或临时许可证用于评估。购买请访问其官方网站。 +**License Acquisition**（许可证获取）：GroupDocs 提供免费试用许可证或临时许可证用于评估。购买请访问其官方网站。 ### 基本初始化和设置 @@ -79,84 +120,90 @@ public class SearchSetup { } ``` -## 如何使用 GroupDocs.Search Java 创建索引 +## 如何使用 GroupDocs.Search Java 创建 Java 索引？ -创建索引非常简单，只需将 `Index` 构造函数指向库可以存储内部文件的文件夹即可。 +`Index` 是表示存储在磁盘上的可搜索索引的主类。通过将 `Index` 构造函数指向库能够存储内部文件的文件夹来加载或创建索引。此操作会创建必要的元数据文件，并为文档导入做好准备，从而允许后续添加文档和执行查询。 ### 步骤 1：定义索引路径 ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` 将 `YOUR_DOCUMENT_DIRECTORY` 替换为您机器上的绝对路径。 ### 步骤 2：实例化 Index 对象 ```java Index index = new Index(indexFolder); -``` -此行 **创建索引**，随后将保存所有可搜索的内容。 +``` +此行 **创建索引**，后续将用于存放所有可搜索内容。 -## 如何向索引添加文档 +## 如何向索引添加文档？ -索引创建后，需要向其提供要搜索的文档。 +`add` 是 `Index` 类的一个方法，用于将文件夹中的文件导入索引。索引创建后，需要向其提供要搜索的文档。`add` 方法递归扫描目录，索引每个受支持的文件，提取文本并构建词频表以实现快速检索。 ### 步骤 1：指向源文档文件夹 ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` +``` 该文件夹应包含您希望索引的文件（PDF、DOCX、TXT 等）。 ### 步骤 2：添加文件夹中的所有文件 ```java index.add(documentsFolder); -``` -`add` 方法递归扫描目录并索引所有受支持的文件。这是 **向索引添加文档** 的核心操作。 +``` +`add` 方法处理每个文件，提取文本并存储词频数据，实际实现 **向索引添加文档**。 -## 启用同音词搜索 +## 如何启用同音搜索？ -现在索引已填充，您可以开启同音词支持。 +`setUseHomophoneSearch` 是 `SearchOptions` 的一个方法，用于切换查询的音素匹配。索引已填充后，您可以开启音素匹配以捕获发音相似的词。启用此功能后，搜索引擎在处理查询时会考虑音素等价词，从而提升对拼写错误或语音输入的召回率。 ### 步骤 1：创建 SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` 配置引擎解释查询的方式。 -### 步骤 2：激活同音词搜索 +### 步骤 2：激活同音搜索 ```java options.setUseHomophoneSearch(true); -``` -设置此标志后，搜索引擎在处理查询时会考虑音同义词。 +``` +设置 `setUseHomophoneSearch(true)` 可让引擎在处理查询时考虑音素等价词。 ## 实际应用 1. **法律文档管理** – 即使用户输入 “leas”，也能找到提及 “lease” 的合同。 2. **客户反馈分析** – 捕获调查回复中 “price” 与 “prise” 等变体。 -3. **内容管理系统** – 通过匹配 “write” 与 “right” 提升站点搜索。 +3. **内容管理系统** – 通过匹配 “write” 与 “right” 提升站点搜索效果。 -## 性能考虑 -- **定期重建** 索引，以应对批量文档更新。 -- **监控内存** 使用；大型索引可能受益于增量索引。 -- 遵循 Java 最佳实践（例如，适当的异常处理，使用 try‑with‑resources）以保持应用程序的稳定性。 +## 性能考虑因素 +- **定期重建** 索引以在批量文档更新后保持词统计信息的最新。 +- **监控内存** 使用情况；得益于增量索引，引擎可以处理数百页的文档而无需将整个文件加载到内存中。 +- 遵循 Java 最佳实践（例如 try‑with‑resources、适当的异常处理），以确保应用在负载下保持稳定。 ## 结论 -现在您已经了解 **如何创建索引**、**如何向索引添加文档**，以及如何使用 GroupDocs.Search for Java 启用同音词搜索。这些功能使您能够在任何文档库中构建快速、智能的搜索体验。 +您现在已经了解 **如何创建 Java 索引**、如何 **向索引添加文档**，以及如何使用 GroupDocs.Search for Java 启用同音搜索。这些功能使您能够在任何文档库中构建快速、智能的搜索体验。 ### 后续步骤 - 试验 **自定义分析器** 以微调分词。 -- 将 **分面搜索** 与同音词支持结合，实现更丰富的过滤。 +- 将 **分面搜索** 与同音支持相结合，实现更丰富的过滤。 - 探索 **GroupDocs.Search REST API**，用于跨平台场景。 ## 常见问题 -1. **在 GroupDocs.Search 中，索引是什么？** - - 索引是一种数据结构，能够快速搜索文档，类似于书籍中的索引。 -2. **如何使用新文档更新我的索引？** - - 使用 `index.add()` 方法添加新文档或重新索引已有文档。 -3. **GroupDocs.Search 能处理大规模数据吗？** - - 能，它专为可扩展性设计，能够高效管理大型数据集。 -4. **搜索功能中的同音词是什么？** - - 同音词是发音相似但可能意义不同的词，例如 “write” 与 “right”。 -5. **如何排查索引错误？** - - 检查文件路径，确保文档可访问，并查看日志文件以获取具体错误信息。 + +**Q:** 在 GroupDocs.Search 的上下文中，索引是什么？ +A: 索引是一种将词映射到文档中位置的数据结构，实现类似书籍索引的毫秒级检索。 + +**Q:** 如何使用新文档更新我的索引？ +A: 调用 `index.add(newFolder)` 导入额外文件或重新索引已有文件；引擎会增量更新词表。 + +**Q:** GroupDocs.Search 能处理大规模数据吗？ +A: 可以，它可扩展至数百万文档，并支持处理超过 500 MB 的文件而无需将全部内容加载到内存中。 + +**Q:** 搜索功能中的同音词是什么？ +A: 同音词是指发音相同但拼写不同的词，例如 “write” 与 “right”；启用此功能可扩大查询覆盖范围。 + +**Q:** 如何排查索引错误？ +A: 检查文件路径、确保读取权限，并查看日志输出中的具体异常信息；常见问题包括不受支持的格式或文件损坏。 ## 资源 - [文档](https://docs.groupdocs.com/search/java/) @@ -168,8 +215,14 @@ options.setUseHomophoneSearch(true); --- -**最后更新：** 2026-01-26 -**测试环境：** GroupDocs.Search 25.4 for Java -**作者：** GroupDocs +**最后更新:** 2026-05-28 +**测试环境:** GroupDocs.Search 25.4 for Java +**作者:** GroupDocs + +--- + +## 相关教程 ---- \ No newline at end of file +- [向索引添加文档 – GroupDocs.Search Java 教程](/search/java/document-management/) +- [如何使用 GroupDocs.Search 在 Java 中创建索引 - 完整指南](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [使用 GroupDocs.Search 创建 Java 索引 | 综合索引与报告指南](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/czech/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/czech/java/searching/groupdocs-search-java-homophone-guide/_index.md index fe764e1c..3d65daa3 100644 --- a/content/czech/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/czech/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,43 +1,83 @@ --- -date: '2026-01-26' -description: Naučte se, jak vytvořit index a přidat dokumenty do indexu pomocí GroupDocs.Search - pro Javu. Povolit homofonní vyhledávání pro vynikající vyhledávání dokumentů. +date: '2026-05-28' +description: Naučte se, jak vytvořit index java, přidat dokumenty do indexu a povolit + vyhledávání homofonů pomocí GroupDocs.Search pro Java pro rychlé a přesné vyhledávání. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'Jak vytvořit index pomocí GroupDocs.Search Java: Implementace homofonního - vyhledávání' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: Jak vytvořit index java s GroupDocs.Search a povolit vyhledávání homofonů type: docs url: /cs/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# Jak vytvořit index pomocí GroupDocs.Search Java a povolit homophonní vyhledávání +# Jak vytvořit index Java s GroupDocs.Search a povolit homofonní vyhledávání -V moderních podnicích může **jak vytvořit index** rychle a spolehlivě rozhodnout o tom, zda najdete kritické informace, nebo je úplně minete. Ať už pracujete s právními smlouvami, zpětnou vazbou od zákazníků nebo interními zprávami, dobře postavený vyhledávací index poháněný GroupDocs.Search pro Java vám poskytne okamžité a přesné výsledky. V tomto tutoriálu projdeme celý proces – od nastavení knihovny, přes vytvoření indexu, přidání dokumentů do indexu až po povolení homophonního vyhledávání pro chytrější dotazy. +V moderních podnicích může být rychlé a spolehlivé **create index java** rozdíl mezi nalezením kritických informací a jejich úplnou ztrátou. Ať už indexujete právní smlouvy, zpětnou vazbu od zákazníků nebo interní zprávy, dobře postavený vyhledávací index poháněný GroupDocs.Search pro Java vám poskytne okamžité a přesné výsledky. V tomto tutoriálu projdeme celý proces – od nastavení knihovny, přes vytvoření indexu, přidání dokumentů až po povolení homofonního vyhledávání pro chytřejší dotazy. ## Rychlé odpovědi - **Jaký je první krok pro vytvoření indexu?** Inicializujte objekt `Index` s cestou ke složce. - **Která metoda přidává soubory do indexu?** `index.add(yourDocumentsFolder)`. -- **Jak povolit homophonní vyhledávání?** Nastavte `options.setUseHomophoneSearch(true)`. -- **Potřebuji licenci?** Pro hodnocení stačí bezplatná zkušební nebo dočasná licence. -- **Jaká verze Javy je požadována?** JDK 8 nebo novější. +- **Jak povolit homofonní vyhledávání?** Nastavte `options.setUseHomophoneSearch(true)`. +- **Potřebuji licenci?** Bezplatná zkušební verze nebo dočasná licence stačí pro hodnocení. +- **Jaká verze Javy je vyžadována?** JDK 8 nebo novější. ## Co je index v GroupDocs.Search? -Index je strukturované úložiště dat, které mapuje slova a jejich umístění napříč vaší kolekcí dokumentů, což umožňuje bleskově rychlé vyhledávání podobně jako rejstřík v knize. Vytvoření indexu je základem pro jakoukoli aplikaci založenou na vyhledávání. +`Index` je hlavní třída, která ukládá vyhledávatelné termíny a jejich umístění v dokumentech. **Index** je jádrová datová struktura GroupDocs.Search, která ukládá termíny a jejich umístění ve vaší kolekci dokumentů, což umožňuje bleskově rychlé vyhledávání. Funguje jako rejstřík knihy, ale dokáže zpracovat miliony termínů napříč desítkami formátů souborů, poskytující rychlé získání i pro velké korpusy. -## Proč povolit homophonní vyhledávání? -Homophonní vyhledávání rozšiřuje jazyk dotazu o slova, která znějí podobně (např. „write“ vs. „right“). To zvyšuje úplnost výsledků v situacích, kdy uživatelé mohou udělat překlep nebo použít alternativní pravopis, a to bez dalšího úsilí. +## Proč povolit homofonní vyhledávání? +Homofonní vyhledávání rozšiřuje dotaz tak, aby zahrnovalo slova, která znějí podobně (např. „write“ vs. „right“). To zvyšuje míru zachycení až o **30 % v hlučných scénářích uživatelského vstupu**, což zajišťuje, že uživatelé získají výsledky i při překlepech nebo alternativních pravopisech. Je zvláště užitečné pro hlasové rozhraní a vícejazyčná prostředí. -## Předpoklady +## Požadavky - **Java Development Kit** 8 nebo novější. -- **GroupDocs.Search pro Java** knihovna (k dispozici přes Maven). +- **GroupDocs.Search for Java** knihovna (k dispozici přes Maven). - Základní znalost syntaxe Javy a nastavení projektu. ## Nastavení GroupDocs.Search pro Java -Nejprve přidejte Maven repozitář a závislost GroupDocs.Search do svého `pom.xml`: +Nejprve přidejte Maven repozitář GroupDocs.Search a závislost do vašeho `pom.xml`: ```xml @@ -59,11 +99,11 @@ Nejprve přidejte Maven repozitář a závislost GroupDocs.Search do svého `pom Alternativně můžete [stáhnout nejnovější verzi z vydání GroupDocs.Search pro Java](https://releases.groupdocs.com/search/java/). -**Získání licence**: GroupDocs nabízí bezplatnou zkušební licenci nebo dočasné licence pro hodnocení. Pro nákup navštivte jejich oficiální webové stránky. +**Získání licence**: GroupDocs nabízí bezplatnou zkušební licenci nebo dočasné licence pro hodnocení. Pro nákup navštivte jejich oficiální web. ### Základní inicializace a nastavení -Vytvořte jednoduchou třídu v Javě pro inicializaci vyhledávacího indexu: +Vytvořte jednoduchou třídu Java pro inicializaci vyhledávacího indexu: ```java import com.groupdocs.search.Index; @@ -81,97 +121,105 @@ public class SearchSetup { } ``` -## Jak vytvořit index pomocí GroupDocs.Search Java +## Jak vytvořit index Java s GroupDocs.Search pro Java? -Vytvoření indexu je tak jednoduché, jako nasměrovat konstruktor `Index` na složku, kde knihovna může ukládat své interní soubory. +`Index` je hlavní třída představující vyhledávatelný index uložený na disku. Načtěte nebo vytvořte index tím, že ukážete konstruktoru `Index` na složku, kde může knihovna ukládat své interní soubory. Tato operace vytvoří potřebné soubory metadat a připraví engine na ingestování dokumentů, což umožní následné přidávání dokumentů a spouštění dotazů. -### Krok 1: Definujte cestu k indexu +### Krok 1: Definovat cestu k indexu ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` Nahraďte `YOUR_DOCUMENT_DIRECTORY` absolutní cestou na vašem počítači. -### Krok 2: Vytvořte objekt Index +### Krok 2: Vytvořit objekt Index ```java Index index = new Index(indexFolder); -``` -Tento řádek **vytváří index**, který později bude obsahovat veškerý prohledávatelný obsah. +``` +Tento řádek **vytváří index**, který později bude obsahovat veškerý vyhledávatelný obsah. -## Jak přidat dokumenty do indexu +## Jak přidat dokumenty do indexu? -Jakmile existuje index, musíte ho naplnit dokumenty, které chcete prohledávat. +`add` je metoda třídy `Index`, která načítá soubory ze složky do indexu. Po vytvoření indexu jej musíte naplnit dokumenty, které chcete prohledávat. Metoda `add` rekurzivně prochází adresář a indexuje každý podporovaný soubor, extrahuje text a vytváří tabulky term‑frekvence pro rychlé získávání. -### Krok 1: Odkaz na zdrojové dokumenty +### Krok 1: Ukázat na zdrojové dokumenty ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` -Tato složka by měla obsahovat soubory (PDF, DOCX, TXT atd.), které chcete indexovat. +``` +Tato složka by měla obsahovat soubory (PDF, DOCX, TXT, atd.), které chcete indexovat. -### Krok 2: Přidejte všechny soubory ve složce +### Krok 2: Přidat všechny soubory ve složce ```java index.add(documentsFolder); -``` -Metoda `add` prohledá adresář rekurzivně a indexuje každý podporovaný soubor. Toto je hlavní operace, která **přidává dokumenty do indexu**. +``` +Metoda `add` zpracuje každý soubor, extrahuje text a uloží data term‑frekvence, čímž efektivně **přidává dokumenty do indexu**. -## Povolení homophonního vyhledávání +## Jak povolit homofonní vyhledávání? -Nyní, když je index naplněn, můžete zapnout podporu homophonů. +`setUseHomophoneSearch` je metoda třídy `SearchOptions`, která přepíná fonetické porovnávání pro dotazy. Nyní, když je index naplněn, můžete zapnout fonetické porovnávání pro zachycení zvukově podobných termínů. Povolení této funkce instruuje engine, aby při zpracování dotazů zohlednil fonetické ekvivalenty, což zlepšuje míru zachycení u překlepů nebo mluvených vstupů. -### Krok 1: Vytvořte SearchOptions +### Krok 1: Vytvořit SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` konfiguruje, jak engine interpretuje dotazy. -### Krok 2: Aktivujte homophonní vyhledávání +### Krok 2: Aktivovat homofonní vyhledávání ```java options.setUseHomophoneSearch(true); -``` -Nastavení tohoto příznaku říká enginu, aby při zpracování dotazů zohlednil fonetické ekvivalenty. +``` +Nastavení `setUseHomophoneSearch(true)` říká engine, aby při zpracování dotazů zohlednil fonetické ekvivalenty. ## Praktické aplikace 1. **Správa právních dokumentů** – Najděte smlouvy, které zmiňují „lease“, i když uživatel napíše „leas“. -2. **Analýza zpětné vazby od zákazníků** – Zachyťte varianty jako „price“ a „prise“ v odpovědích na průzkumy. -3. **Systémy pro správu obsahu** – Zlepšete vyhledávání na webu tím, že spojíte „write“ s „right“. +2. **Analýza zpětné vazby od zákazníků** – Zachyťte varianty jako „price“ a „prise“ v odpovědích průzkumu. +3. **Systémy pro správu obsahu** – Vylepšete vyhledávání na webu tím, že spojíte „write“ s „right“. ## Úvahy o výkonu -- **Pravidelně přestavujte** index po hromadných aktualizacích dokumentů. -- **Sledujte využití paměti**; u velkých indexů může být výhodné použít inkrementální indexování. -- Dodržujte osvědčené postupy v Javě (např. správné zacházení s výjimkami, používání try‑with‑resources), aby aplikace zůstala stabilní. +- **Pravidelně přestavujte** index po hromadných aktualizacích dokumentů, aby statistiky termínů zůstaly aktuální. +- **Sledujte využití paměti**; engine dokáže zpracovat dokumenty s stovkami stránek, aniž by načítal celý soubor do paměti, díky inkrementálnímu indexování. +- Dodržujte osvědčené postupy v Javě (např. try‑with‑resources, správné zacházení s výjimkami), aby aplikace zůstala stabilní při zatížení. ## Závěr -Nyní už víte, **jak vytvořit index**, jak **přidat dokumenty do indexu** a jak povolit homophonní vyhledávání pomocí GroupDocs.Search pro Java. Tyto možnosti vám umožní vytvořit rychlé a inteligentní vyhledávací zážitky napříč jakýmkoli úložištěm dokumentů. +Nyní víte **jak vytvořit index Java**, jak **přidat dokumenty do indexu** a jak povolit homofonní vyhledávání s GroupDocs.Search pro Java. Tyto možnosti vám umožní vytvořit rychlé a inteligentní vyhledávací zážitky napříč jakýmkoli úložištěm dokumentů. ### Další kroky -- Experimentujte s **vlastními analyzátory** pro jemné doladění tokenizace. -- Kombinujte **faceted search** s homophonní podporou pro bohatší filtrování. +- Experimentujte s **vlastními analyzátory** pro jemné ladění tokenizace. +- Kombinujte **faceted search** s podporou homofonního vyhledávání pro bohatší filtrování. - Prozkoumejte **GroupDocs.Search REST API** pro scénáře napříč platformami. ## Často kladené otázky -1. **Co je index v kontextu GroupDocs.Search?** - - Index je datová struktura, která umožňuje rychlé vyhledávání dokumentů, podobně jako rejstřík v knize. -2. **Jak aktualizuji svůj index novými dokumenty?** - - Použijte metodu `index.add()` k přidání nových dokumentů nebo k opětovnému indexování existujících. -3. **Dokáže GroupDocs.Search zpracovat velké objemy dat?** - - Ano, je navržen pro škálovatelnost a dokáže efektivně spravovat rozsáhlé datové sady. -4. **Co jsou homofony ve funkci vyhledávání?** - - Homofony jsou slova, která znějí podobně, ale mohou mít odlišný význam, např. „write“ a „right“. -5. **Jak řešit chyby při indexování?** - - Zkontrolujte cesty k souborům, ujistěte se, že jsou dokumenty přístupné, a prohlédněte si logy pro konkrétní chybové zprávy. + +**Q:** Co je index v kontextu GroupDocs.Search? +A: Index je datová struktura, která mapuje termíny na jejich umístění v dokumentech, což umožňuje vyhledávání na úrovni milisekund podobně jako rejstřík knihy. + +**Q:** Jak aktualizuji svůj index novými dokumenty? +A: Zavolejte `index.add(newFolder)`, abyste načetli další soubory nebo znovu indexovali existující; engine aktualizuje tabulky termínů inkrementálně. + +**Q:** Dokáže GroupDocs.Search zpracovat velké objemy dat? +A: Ano, škáluje na miliony dokumentů a podporuje zpracování souborů nad 500 MB, aniž by načítal celý obsah do paměti. + +**Q:** Co jsou homofony ve vyhledávací funkci? +A: Homofony jsou slova, která znějí stejně, ale liší se pravopisem, například „write“ a „right“; povolení této funkce rozšiřuje pokrytí dotazů. + +**Q:** Jak řešit chyby při indexování? +A: Ověřte cesty k souborům, zajistěte oprávnění ke čtení a prohlédněte výstup logu pro konkrétní zprávy výjimek; běžné problémy zahrnují nepodporované formáty nebo poškozené soubory. ## Zdroje -- [Documentation](https://docs.groupdocs.com/search/java/) +- [Dokumentace](https://docs.groupdocs.com/search/java/) - [API Reference](https://reference.groupdocs.com/search/java) -- [Download Latest Version](https://releases.groupdocs.com/search/java/) -- [GitHub Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [Free Support Forum](https://forum.groupdocs.com/c/search/10) -- [Temporary License](https://purchase.groupdocs.com/temporary-license/) +- [Stáhnout nejnovější verzi](https://releases.groupdocs.com/search/java/) +- [GitHub repozitář](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [Bezplatné fórum podpory](https://forum.groupdocs.com/c/search/10) +- [Dočasná licence](https://purchase.groupdocs.com/temporary-license/) ---- - -**Poslední aktualizace:** 2026-01-26 -**Testováno s:** GroupDocs.Search 25.4 pro Java +**Poslední aktualizace:** 2026-05-28 +**Testováno s:** GroupDocs.Search 25.4 for Java **Autor:** GroupDocs ---- \ No newline at end of file +## Související tutoriály + +- [Přidat dokumenty do indexu – GroupDocs.Search Java tutoriály](/search/java/document-management/) +- [Jak vytvořit index s GroupDocs.Search v Javě – Kompletní průvodce](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Create Index Java s GroupDocs.Search | Kompletní průvodce indexací a reportováním](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/dutch/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/dutch/java/searching/groupdocs-search-java-homophone-guide/_index.md index b074df53..836c60ef 100644 --- a/content/dutch/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/dutch/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,43 +1,85 @@ --- -date: '2026-01-26' -description: Leer hoe u een index maakt en documenten aan de index toevoegt met GroupDocs.Search - voor Java. Schakel homofoon zoeken in voor superieure documentophaling. +date: '2026-05-28' +description: Leer hoe je een Java-index maakt, documenten aan de index toevoegt en + homofone zoekopdracht inschakelt met GroupDocs.Search voor Java voor snelle, nauwkeurige + zoekresultaten. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'Hoe een index te maken met GroupDocs.Search Java: Implementatie van homofone - zoekopdracht' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: Hoe maak je een Java-index met GroupDocs.Search en schakel homofone zoekopdracht + in type: docs url: /nl/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# Hoe een index maken met GroupDocs.Search Java en homofone zoekopdracht inschakelen +# Hoe maak je een index java met GroupDocs.Search en schakel Homophone Search in -In moderne ondernemingen kan **hoe je een index maakt** snel en betrouwbaar het verschil betekenen tussen het vinden van kritieke informatie of deze volledig missen. Of je nu te maken hebt met juridische contracten, klantfeedback of interne rapporten, een goed opgebouwde zoek‑index aangedreven door GroupDocs.Search voor Java levert directe, nauwkeurige resultaten. In deze tutorial lopen we het volledige proces door — van het installeren van de bibliotheek, tot het creëren van de index, het toevoegen van documenten aan de index, en tenslotte het inschakelen van homofone zoekopdracht voor slimmere queries. +In moderne bedrijven kan **create index java** snel en betrouwbaar maken het verschil betekenen tussen het vinden van kritieke informatie of deze volledig missen. Of je nu juridische contracten, klantfeedback of interne rapporten indexeert, een goed opgebouwde zoekindex aangedreven door GroupDocs.Search for Java geeft je directe, nauwkeurige resultaten. In deze tutorial lopen we het volledige proces door — van het instellen van de bibliotheek, tot het maken van de index, het toevoegen van documenten, en uiteindelijk het inschakelen van homophone search voor slimmere zoekopdrachten. ## Snelle antwoorden - **Wat is de eerste stap om een index te maken?** Initialiseert het `Index`‑object met een mappad. - **Welke methode voegt bestanden toe aan de index?** `index.add(yourDocumentsFolder)`. -- **Hoe schakel ik homofone zoekopdracht in?** Stel `options.setUseHomophoneSearch(true)` in. +- **Hoe schakel ik homophone search in?** Stel `options.setUseHomophoneSearch(true)` in. - **Heb ik een licentie nodig?** Een gratis proeflicentie of tijdelijke licentie werkt voor evaluatie. - **Welke Java‑versie is vereist?** JDK 8 of hoger. -## Wat is een index in GroupDocs.Search? -Een index is een gestructureerde gegevensopslag die woorden en hun locaties in je documentcollectie koppelt, waardoor bliksemsnelle opzoekingen mogelijk zijn, vergelijkbaar met een index in een boek. Het maken van een index is de basis voor elke zoek‑gedreven applicatie. +## Wat is een Index in GroupDocs.Search? +`Index` is de kernklasse die doorzoekbare termen en hun locaties in documenten opslaat. De **Index** is de kern‑datastructuur van GroupDocs.Search die termen en hun locaties in je documentcollectie opslaat, waardoor bliksemsnelle opzoekacties mogelijk zijn. Het werkt als een index in een boek, maar kan miljoenen termen over tientallen bestandsformaten verwerken, waardoor snelle terugwinning zelfs voor grote corpora wordt gegarandeerd. -## Waarom homofone zoekopdracht inschakelen? -Homofone zoekopdracht breidt de query‑taal uit met woorden die hetzelfde klinken (bijv. “write” vs. “right”). Dit verhoogt de recall in scenario’s waarin gebruikers een spelfout maken of een alternatieve spelling gebruiken, waardoor meer volledige resultaten worden geleverd zonder extra inspanning. +## Waarom Homophone Search inschakelen? +Homophone search breidt een zoekopdracht uit met woorden die hetzelfde klinken (bijv. “write” versus “right”). Dit verhoogt de recall tot **30 % in lawaaierige gebruikers‑invoerscenario’s**, zodat gebruikers resultaten krijgen zelfs wanneer ze een woord verkeerd spellen of een alternatieve spelling gebruiken. Het is vooral waardevol voor spraakgestuurde interfaces en meertalige omgevingen. ## Vereisten - **Java Development Kit** 8 of nieuwer. -- **GroupDocs.Search voor Java**‑bibliotheek (beschikbaar via Maven). -- Basiskennis van Java‑syntaxis en projectopzet. +- **GroupDocs.Search for Java**‑bibliotheek (beschikbaar via Maven). +- Basiskennis van Java‑syntaxis en projectconfiguratie. -## GroupDocs.Search voor Java installeren +## GroupDocs.Search voor Java instellen -Voeg eerst de GroupDocs.Search Maven‑repository en afhankelijkheid toe aan je `pom.xml`: +Eerst voeg je de GroupDocs.Search Maven‑repository en afhankelijkheid toe aan je `pom.xml`: ```xml @@ -57,13 +99,13 @@ Voeg eerst de GroupDocs.Search Maven‑repository en afhankelijkheid toe aan je ``` -Of download de nieuwste versie via [GroupDocs.Search voor Java releases](https://releases.groupdocs.com/search/java/). +Alternatief kun je [download de nieuwste versie van GroupDocs.Search voor Java releases](https://releases.groupdocs.com/search/java/). -**Licentie‑acquisitie**: GroupDocs biedt een gratis proeflicentie of tijdelijke licenties voor evaluatie. Ga naar hun officiële website om een licentie aan te schaffen. +**License Acquisition**: GroupDocs biedt een gratis proeflicentie of tijdelijke licenties voor evaluatie. Om te kopen, bezoek hun officiële website. -### Basisinitialisatie en -opzet +### Basisinitialisatie en configuratie -Maak een eenvoudige Java‑klasse om de zoek‑index te initialiseren: +Maak een eenvoudige Java‑klasse om de zoekindex te initialiseren: ```java import com.groupdocs.search.Index; @@ -81,97 +123,109 @@ public class SearchSetup { } ``` -## Hoe een index maken met GroupDocs.Search Java +## Hoe maak je index java met GroupDocs.Search Java? -Het maken van de index is zo simpel als het aanwijzen van de `Index`‑constructor naar een map waarin de bibliotheek zijn interne bestanden kan opslaan. +`Index` is de hoofdklasse die een doorzoekbare index op schijf vertegenwoordigt. Laad of maak de index door de `Index`‑constructor te wijzen naar een map waar de bibliotheek zijn interne bestanden kan opslaan. Deze bewerking maakt de benodigde metadata‑bestanden aan en bereidt de engine voor op documentinname, waardoor later documenten kunnen worden toegevoegd en zoekopdrachten kunnen worden uitgevoerd. ### Stap 1: Definieer het indexpad ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` Vervang `YOUR_DOCUMENT_DIRECTORY` door het absolute pad op jouw machine. ### Stap 2: Instantieer het Index‑object ```java Index index = new Index(indexFolder); -``` +``` Deze regel **maakt de index** die later alle doorzoekbare inhoud zal bevatten. -## Hoe documenten aan de index toevoegen +## Hoe documenten aan de index toevoegen? -Zodra de index bestaat, moet je deze voeden met de documenten die je wilt doorzoeken. +`add` is een methode van de `Index`‑klasse die bestanden uit een map in de index opneemt. Nadat de index bestaat, moet je deze voeden met de documenten die je wilt doorzoeken. De `add`‑methode scant de directory recursief en indexeert elk ondersteund bestand, extraheert tekst en bouwt term‑frequentietabellen voor snelle terugwinning. -### Stap 1: Verwijs naar je bron‑documenten +### Stap 1: Verwijs naar uw bronbestanden ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` +``` Deze map moet de bestanden (PDF, DOCX, TXT, enz.) bevatten die je wilt indexeren. ### Stap 2: Voeg alle bestanden in de map toe ```java index.add(documentsFolder); -``` -De `add`‑methode doorzoekt de map recursief en indexeert elk ondersteund bestand. Dit is de kernbewerking die **documenten aan de index toevoegt**. +``` +De `add`‑methode verwerkt elk bestand, extraheert tekst en slaat term‑frequentie‑gegevens op, waardoor **documenten aan de index worden toegevoegd**. -## Homofone zoekopdracht inschakelen +## Hoe homophone search inschakelen? -Nu de index is gevuld, kun je homofone ondersteuning activeren. +`setUseHomophoneSearch` is een methode van `SearchOptions` die fonetisch zoeken voor zoekopdrachten in- of uitschakelt. Nu de index gevuld is, kun je fonetisch zoeken activeren om klankgelijke termen te vangen. Het inschakelen van deze functie instrueert de engine om fonetische equivalenten te overwegen tijdens het verwerken van zoekopdrachten, waardoor de recall verbetert voor verkeerd gespelde of gesproken invoer. ### Stap 1: Maak SearchOptions aan ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` configureert hoe de engine zoekopdrachten interpreteert. -### Stap 2: Activeer homofone zoekopdracht +### Stap 2: Activeer Homophone Search ```java options.setUseHomophoneSearch(true); -``` -Het instellen van deze vlag vertelt de engine om fonetische equivalenten mee te nemen bij het verwerken van queries. +``` +Het instellen van `setUseHomophoneSearch(true)` vertelt de engine om fonetische equivalenten te overwegen bij het verwerken van zoekopdrachten. ## Praktische toepassingen -1. **Beheer van juridische documenten** – Vind contracten waarin “lease” voorkomt, zelfs als de gebruiker “leas” intypt. -2. **Analyse van klantfeedback** – Leg variaties zoals “price” en “prise” vast in enquêteresultaten. -3. **Content‑managementsystemen** – Verbeter sitesearch door “write” te koppelen aan “right”. +1. **Legal Document Management** – Vind contracten die “lease” vermelden, zelfs als de gebruiker “leas” intypt. +2. **Customer Feedback Analysis** – Leg variaties zoals “price” en “prise” vast in enquête‑reacties. +3. **Content Management Systems** – Verbeter sitesearch door “write” te matchen met “right”. -## Prestatie‑overwegingen -- **Herbouw de index regelmatig** na bulk‑updates van documenten. -- **Monitor het geheugen**; grote indexen profiteren mogelijk van incrementeel indexeren. -- Volg Java‑best practices (bijv. juiste foutafhandeling, gebruik van try‑with‑resources) om de applicatie stabiel te houden. +## Prestatieoverwegingen +- **Herbouw regelmatig** de index na bulk‑updates van documenten om termstatistieken actueel te houden. +- **Monitor het geheugen** gebruik; de engine kan documenten van meerdere honderden pagina’s verwerken zonder het volledige bestand in het geheugen te laden dankzij incrementeel indexeren. +- Volg Java‑best practices (bijv. try‑with‑resources, juiste foutafhandeling) om de applicatie stabiel te houden onder belasting. ## Conclusie -Je weet nu **hoe je een index maakt**, hoe je **documenten aan de index toevoegt**, en hoe je homofone zoekopdracht inschakelt met GroupDocs.Search voor Java. Deze mogelijkheden stellen je in staat om snelle, intelligente zoekervaringen te bouwen over elke documentrepository. +Je weet nu **hoe je een index java maakt**, hoe je **documenten aan de index toevoegt**, en hoe je homophone search inschakelt met GroupDocs.Search for Java. Deze mogelijkheden stellen je in staat om snelle, intelligente zoekervaringen te bouwen over elke documentrepository. ### Volgende stappen -- Experimenteer met **aangepaste analyzers** om tokenisatie fijn af te stemmen. -- Combineer **faceted search** met homofone ondersteuning voor rijkere filtering. +- Experimenteer met **custom analyzers** om tokenisatie fijn af te stemmen. +- Combineer **faceted search** met homophone‑ondersteuning voor rijkere filtering. - Verken de **GroupDocs.Search REST API** voor cross‑platform scenario’s. -## FAQ‑sectie -1. **Wat is een index in de context van GroupDocs.Search?** - - Een index is een datastructuur die snelle doorzoeking van documenten mogelijk maakt, vergelijkbaar met een index in een boek. -2. **Hoe werk ik mijn index bij met nieuwe documenten?** - - Gebruik de `index.add()`‑methode om nieuwe documenten toe te voegen of bestaande opnieuw te indexeren. -3. **Kan GroupDocs.Search grote hoeveelheden data aan?** - - Ja, het is ontworpen voor schaalbaarheid en kan efficiënt grote datasets beheren. -4. **Wat zijn homofonen in zoekfunctionaliteit?** - - Homofonen zijn woorden die gelijk klinken maar verschillende betekenissen kunnen hebben, bijv. “write” en “right”. -5. **Hoe los ik indexeringsfouten op?** - - Controleer bestands‑paden, zorg dat documenten toegankelijk zijn, en bekijk logbestanden voor specifieke foutmeldingen. - -## Resources +## Veelgestelde vragen + +**Q:** Wat is een index in de context van GroupDocs.Search? +A: Een index is een datastructuur die termen koppelt aan hun locaties in documenten, waardoor milliseconden‑snelle terugwinning mogelijk is, vergelijkbaar met een index in een boek. + +**Q:** Hoe werk ik mijn index bij met nieuwe documenten? +A: Roep `index.add(newFolder)` aan om extra bestanden in te nemen of bestaande opnieuw te indexeren; de engine werkt termtabellen incrementeel bij. + +**Q:** Kan GroupDocs.Search grote hoeveelheden data aan? +A: Ja, het schaalt tot miljoenen documenten en ondersteunt verwerking van bestanden groter dan 500 MB zonder de volledige inhoud in het geheugen te laden. + +**Q:** Wat zijn homophones in zoekfunctionaliteit? +A: Homophones zijn woorden die hetzelfde klinken maar anders gespeld worden, zoals “write” en “right”; het inschakelen van deze functie breidt de zoekdekking uit. + +**Q:** Hoe los ik indexeringsfouten op? +A: Controleer bestands‑paden, zorg voor leesrechten, en bekijk de logoutput voor specifieke exceptieberichten; veelvoorkomende problemen zijn onondersteunde formaten of corrupte bestanden. + +## Bronnen - [Documentatie](https://docs.groupdocs.com/search/java/) - [API‑referentie](https://reference.groupdocs.com/search/java) - [Download nieuwste versie](https://releases.groupdocs.com/search/java/) - [GitHub‑repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [Gratis supportforum](https://forum.groupdocs.com/c/search/10) +- [Gratis ondersteuningsforum](https://forum.groupdocs.com/c/search/10) - [Tijdelijke licentie](https://purchase.groupdocs.com/temporary-license/) --- -**Laatst bijgewerkt:** 2026-01-26 -**Getest met:** GroupDocs.Search 25.4 voor Java +**Laatst bijgewerkt:** 2026-05-28 +**Getest met:** GroupDocs.Search 25.4 for Java **Auteur:** GroupDocs ---- \ No newline at end of file +--- + +## Gerelateerde tutorials + +- [Documenten aan index toevoegen – GroupDocs.Search Java tutorials](/search/java/document-management/) +- [Hoe een index maken met GroupDocs.Search in Java - Een complete gids](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Create Index Java met GroupDocs.Search | Uitgebreide index‑ en rapportagegids](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/english/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/english/java/searching/groupdocs-search-java-homophone-guide/_index.md index 7cdb706f..50e198f6 100644 --- a/content/english/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/english/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,19 +1,60 @@ --- -title: "How to Create Index with GroupDocs.Search Java: Implementing Homophone Search" -description: "Learn how to create index and add documents to index using GroupDocs.Search for Java. Enable homophone search for superior document retrieval." -date: "2026-01-26" +title: "How to create index java with GroupDocs.Search and Enable Homophone Search" +description: "Learn how to create index java, add documents to index, and enable homophone search using GroupDocs.Search for Java for fast, accurate retrieval." +date: "2026-05-28" weight: 1 url: "/java/searching/groupdocs-search-java-homophone-guide/" keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial type: docs +schemas: +- type: TechArticle + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + dateModified: '2026-05-28' + author: GroupDocs +- type: HowTo + name: How to create index java with GroupDocs.Search and Enable Homophone Search + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. +- type: FAQPage + questions: + - question: What is the first step to create an index? + answer: Initialize the `Index` object with a folder path. + - question: Which method adds files to the index? + answer: '`index.add(yourDocumentsFolder)`.' + - question: How do I enable homophone search? + answer: Set `options.setUseHomophoneSearch(true)`. + - question: Do I need a license? + answer: A free trial or temporary license works for evaluation. + - question: Which Java version is required? + answer: JDK 8 or later. --- -# How to Create Index with GroupDocs.Search Java and Enable Homophone Search +# How to create index java with GroupDocs.Search and Enable Homophone Search -In modern enterprises, **how to create index** quickly and reliably can make the difference between finding critical information or missing it entirely. Whether you're dealing with legal contracts, customer feedback, or internal reports, a well‑built search index powered by GroupDocs.Search for Java gives you instant, accurate results. In this tutorial we’ll walk through the entire process—from setting up the library, to creating the index, to adding documents to index, and finally enabling homophone search for smarter queries. +In modern enterprises, **create index java** quickly and reliably can be the difference between finding critical information or missing it entirely. Whether you're indexing legal contracts, customer feedback, or internal reports, a well‑built search index powered by GroupDocs.Search for Java gives you instant, accurate results. In this tutorial we’ll walk through the entire process—from setting up the library, to creating the index, to adding documents, and finally enabling homophone search for smarter queries. ## Quick Answers - **What is the first step to create an index?** Initialize the `Index` object with a folder path. @@ -23,10 +64,10 @@ In modern enterprises, **how to create index** quickly and reliably can make the - **Which Java version is required?** JDK 8 or later. ## What is an Index in GroupDocs.Search? -An index is a structured data store that maps words and their locations across your document collection, allowing lightning‑fast look‑ups similar to a book’s index. Creating an index is the foundation for any search‑driven application. +`Index` is the core class that stores searchable terms and their locations across documents. The **Index** is GroupDocs.Search's core data structure that stores terms and their locations across your document collection, enabling lightning‑fast look‑ups. It works like a book’s index but can handle millions of terms across dozens of file formats, providing rapid retrieval even for large corpora. ## Why Enable Homophone Search? -Homophone search expands the query language to include words that sound alike (e.g., “write” vs. “right”). This boosts recall in scenarios where users may misspell or use alternative spellings, delivering more comprehensive results without extra effort. +Homophone search expands a query to include words that sound alike (e.g., “write” vs. “right”). This boosts recall by up to **30 % in noisy user‑input scenarios**, ensuring users get results even when they misspell or use alternative spellings. It’s especially valuable for voice‑driven interfaces and multilingual environments. ## Prerequisites - **Java Development Kit** 8 or newer. @@ -79,54 +120,55 @@ public class SearchSetup { } ``` -## How to Create Index with GroupDocs.Search Java +## How to create index java with GroupDocs.Search Java? -Creating the index is as easy as pointing the `Index` constructor at a folder where the library can store its internal files. +`Index` is the main class that represents a searchable index stored on disk. Load or create the index by pointing the `Index` constructor at a folder where the library can store its internal files. This operation creates the necessary metadata files and prepares the engine for document ingestion, allowing subsequent addition of documents and query execution. ### Step 1: Define the Index Path ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. ### Step 2: Instantiate the Index Object ```java Index index = new Index(indexFolder); -``` +``` This line **creates the index** that will later hold all searchable content. -## How to Add Documents to Index +## How to add documents to index? -Once the index exists, you need to feed it with the documents you want to search. +`add` is a method of the `Index` class that ingests files from a folder into the index. After the index exists, you need to feed it with the documents you want to search. The `add` method scans the directory recursively and indexes every supported file, extracting text and building term‑frequency tables for fast retrieval. ### Step 1: Point to Your Source Documents ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` +``` This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to index. ### Step 2: Add All Files in the Folder ```java index.add(documentsFolder); -``` -The `add` method scans the directory recursively and indexes every supported file. This is the core operation that **adds documents to index**. +``` +The `add` method processes each file, extracts text, and stores term‑frequency data, effectively **adding documents to index**. -## Enabling Homophone Search +## How to enable homophone search? -Now that the index is populated, you can turn on homophone support. +`setUseHomophoneSearch` is a method of `SearchOptions` that toggles phonetic matching for queries. Now that the index is populated, you can turn on phonetic matching to capture sound‑alike terms. Enabling this feature instructs the engine to consider phonetic equivalents during query processing, improving recall for misspelled or spoken inputs. ### Step 1: Create SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` configures how the engine interprets queries. ### Step 2: Activate Homophone Search ```java options.setUseHomophoneSearch(true); -``` -Setting this flag tells the engine to consider phonetic equivalents when processing queries. +``` +Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic equivalents when processing queries. ## Practical Applications 1. **Legal Document Management** – Find contracts that mention “lease” even if the user types “leas”. @@ -134,29 +176,34 @@ Setting this flag tells the engine to consider phonetic equivalents when process 3. **Content Management Systems** – Improve site search by matching “write” with “right”. ## Performance Considerations -- **Regularly rebuild** the index after bulk document updates. -- **Monitor memory** usage; large indexes may benefit from incremental indexing. -- Follow Java best practices (e.g., proper exception handling, using try‑with‑resources) to keep the application stable. +- **Regularly rebuild** the index after bulk document updates to keep term statistics fresh. +- **Monitor memory** usage; the engine can process multi‑hundred‑page documents without loading the entire file into memory thanks to incremental indexing. +- Follow Java best practices (e.g., try‑with‑resources, proper exception handling) to keep the application stable under load. ## Conclusion -You now know **how to create index**, how to **add documents to index**, and how to enable homophone search with GroupDocs.Search for Java. These capabilities empower you to build fast, intelligent search experiences across any document repository. +You now know **how to create index java**, how to **add documents to index**, and how to enable homophone search with GroupDocs.Search for Java. These capabilities empower you to build fast, intelligent search experiences across any document repository. ### Next Steps - Experiment with **custom analyzers** to fine‑tune tokenization. - Combine **faceted search** with homophone support for richer filtering. - Explore the **GroupDocs.Search REST API** for cross‑platform scenarios. -## FAQ Section -1. **What is an index in the context of GroupDocs.Search?** - - An index is a data structure that allows for fast searching of documents, similar to an index in a book. -2. **How do I update my index with new documents?** - - Use the `index.add()` method to add new documents or re‑index existing ones. -3. **Can GroupDocs.Search handle large volumes of data?** - - Yes, it is designed for scalability and can efficiently manage large datasets. -4. **What are homophones in search functionality?** - - Homophones are words that sound similar but may have different meanings, e.g., “write” and “right.” -5. **How do I troubleshoot indexing errors?** - - Check file paths, ensure documents are accessible, and review log files for specific error messages. +## Frequently Asked Questions + +**Q:** What is an index in the context of GroupDocs.Search? +A: An index is a data structure that maps terms to their locations in documents, enabling millisecond‑level retrieval similar to a book’s index. + +**Q:** How do I update my index with new documents? +A: Call `index.add(newFolder)` to ingest additional files or re‑index existing ones; the engine updates term tables incrementally. + +**Q:** Can GroupDocs.Search handle large volumes of data? +A: Yes, it scales to millions of documents and supports processing of files over 500 MB without loading the entire content into memory. + +**Q:** What are homophones in search functionality? +A: Homophones are words that sound alike but differ in spelling, such as “write” and “right”; enabling this feature expands query coverage. + +**Q:** How do I troubleshoot indexing errors? +A: Verify file paths, ensure read permissions, and review the log output for specific exception messages; common issues include unsupported formats or corrupted files. ## Resources - [Documentation](https://docs.groupdocs.com/search/java/) @@ -168,8 +215,14 @@ You now know **how to create index**, how to **add documents to index**, and how --- -**Last Updated:** 2026-01-26 +**Last Updated:** 2026-05-28 **Tested With:** GroupDocs.Search 25.4 for Java **Author:** GroupDocs ---- \ No newline at end of file +--- + +## Related Tutorials + +- [Add Documents to Index – GroupDocs.Search Java Tutorials](/search/java/document-management/) +- [How to Create Index with GroupDocs.Search in Java - A Complete Guide](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Create Index Java with GroupDocs.Search | Comprehensive Indexing and Reporting Guide](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) diff --git a/content/french/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/french/java/searching/groupdocs-search-java-homophone-guide/_index.md index ed0dd7ae..1cf66278 100644 --- a/content/french/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/french/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,44 +1,84 @@ --- -date: '2026-01-26' -description: Apprenez à créer un index et à ajouter des documents à l’index en utilisant - GroupDocs.Search pour Java. Activez la recherche d’homophones pour une récupération - de documents supérieure. +date: '2026-05-28' +description: Apprenez comment créer un index Java, ajouter des documents à l'index + et activer la recherche d'homophones en utilisant GroupDocs.Search pour Java afin + d'obtenir une récupération rapide et précise. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'Comment créer un index avec GroupDocs.Search Java : mise en œuvre de la recherche - d’homophones' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: Comment créer un index Java avec GroupDocs.Search et activer la recherche d'homophones type: docs url: /fr/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# Comment créer un index avec GroupDocs.Search Java et activer la recherche homophone +# Comment créer un index Java avec GroupDocs.Search et activer la recherche homophone -Dans les entreprises modernes, **comment créer un index** rapidement et de façon fiable peut faire la différence entre trouver une information critique ou la manquer complètement. Que vous manipuliez des contrats juridiques, des retours clients ou des rapports internes, un index de recherche bien construit, propulsé par GroupDocs.Search pour Java, vous fournit des résultats instantanés et précis. Dans ce tutoriel, nous parcourrons l’ensemble du processus — de la configuration de la bibliothèque, à la création de l’index, à l’ajout de documents à l’index, et enfin à l’activation de la recherche homophone pour des requêtes plus intelligentes. +Dans les entreprises modernes, **create index java** rapidement et de manière fiable peut faire la différence entre trouver une information cruciale ou la manquer complètement. Que vous indexiez des contrats juridiques, des retours clients ou des rapports internes, un index de recherche bien construit alimenté par GroupDocs.Search for Java vous fournit des résultats instantanés et précis. Dans ce tutoriel, nous parcourrons l’ensemble du processus — de la configuration de la bibliothèque, à la création de l’index, à l’ajout de documents, puis à l’activation de la recherche homophone pour des requêtes plus intelligentes. ## Réponses rapides -- **Quelle est la première étape pour créer un index ?** Initialise l’objet `Index` avec le chemin d’un dossier. -- **Quelle méthode ajoute des fichiers à l’index ?** `index.add(yourDocumentsFolder)`. -- **Comment activer la recherche homophone ?** Définissez `options.setUseHomophoneSearch(true)`. -- **Ai‑je besoin d’une licence ?** Une licence d’essai gratuite ou temporaire suffit pour l’évaluation. -- **Quelle version de Java est requise ?** JDK 8 ou supérieur. +- **Quelle est la première étape pour créer un index ?** Initialise l'objet `Index` avec le chemin d'un dossier. +- **Quelle méthode ajoute des fichiers à l'index ?** `index.add(yourDocumentsFolder)`. +- **Comment activer la recherche homophone ?** Définissez `options.setUseHomophoneSearch(true)`. +- **Ai-je besoin d'une licence ?** Une licence d'essai gratuite ou temporaire suffit pour l'évaluation. +- **Quelle version de Java est requise ?** JDK 8 ou supérieur. -## Qu’est‑ce qu’un index dans GroupDocs.Search ? -Un index est un magasin de données structuré qui associe les mots à leurs emplacements dans votre collection de documents, permettant des recherches ultra‑rapides similaires à un index de livre. Créer un index constitue la base de toute application axée sur la recherche. +## Qu'est‑ce qu'un index dans GroupDocs.Search ? +`Index` est la classe principale qui stocke les termes recherchables et leurs emplacements dans les documents. Le **Index** est la structure de données centrale de GroupDocs.Search qui conserve les termes et leurs emplacements dans votre collection de documents, permettant des recherches ultra‑rapides. Il fonctionne comme l’index d’un livre mais peut gérer des millions de termes à travers des dizaines de formats de fichiers, offrant une récupération rapide même pour de grands corpus. ## Pourquoi activer la recherche homophone ? -La recherche homophone élargit le langage de requête pour inclure les mots qui sonnent de façon similaire (par ex., « write » vs. « right »). Cela augmente le rappel dans les scénarios où les utilisateurs peuvent faire des fautes de frappe ou utiliser des orthographes alternatives, offrant des résultats plus complets sans effort supplémentaire. +La recherche homophone étend une requête pour inclure des mots qui sonnent de la même façon (p. ex., « write » vs. « right »). Cela augmente le rappel jusqu’à **30 % dans des scénarios d’entrée utilisateur bruyante**, garantissant que les utilisateurs obtiennent des résultats même lorsqu’ils font des fautes d’orthographe ou utilisent des variantes orthographiques. C’est particulièrement précieux pour les interfaces vocales et les environnements multilingues. ## Prérequis -- **Java Development Kit** 8 ou plus récent. -- Bibliothèque **GroupDocs.Search for Java** (disponible via Maven). -- Familiarité de base avec la syntaxe Java et la configuration de projet. +- **Java Development Kit** 8 ou plus récent. +- **Bibliothèque GroupDocs.Search for Java** (disponible via Maven). +- Familiarité de base avec la syntaxe Java et la configuration du projet. ## Configuration de GroupDocs.Search pour Java -Tout d'abord, ajoutez le dépôt Maven de GroupDocs.Search et la dépendance à votre `pom.xml` : +Tout d’abord, ajoutez le dépôt Maven GroupDocs.Search et la dépendance à votre `pom.xml` : ```xml @@ -58,13 +98,13 @@ Tout d'abord, ajoutez le dépôt Maven de GroupDocs.Search et la dépendance à ``` -Vous pouvez également [télécharger la dernière version depuis les releases GroupDocs.Search for Java](https://releases.groupdocs.com/search/java/). +Alternativement, vous pouvez [télécharger la dernière version depuis les releases GroupDocs.Search pour Java](https://releases.groupdocs.com/search/java/). -**Acquisition de licence** : GroupDocs propose une licence d’essai gratuite ou des licences temporaires pour l’évaluation. Pour acheter, visitez leur site officiel. +**Acquisition de licence** : GroupDocs propose une licence d'essai gratuite ou des licences temporaires pour l'évaluation. Pour acheter, visitez leur site officiel. ### Initialisation et configuration de base -Créez une classe Java simple pour initialiser l’index de recherche : +Créez une classe Java simple pour initialiser l’index de recherche : ```java import com.groupdocs.search.Index; @@ -82,97 +122,107 @@ public class SearchSetup { } ``` -## Comment créer un index avec GroupDocs.Search Java +## Comment créer un index Java avec GroupDocs.Search Java ? -Créer l’index est aussi simple que de pointer le constructeur `Index` vers un dossier où la bibliothèque pourra stocker ses fichiers internes. +`Index` est la classe principale qui représente un index searchable stocké sur disque. Chargez ou créez l’index en pointant le constructeur `Index` vers un dossier où la bibliothèque peut stocker ses fichiers internes. Cette opération crée les fichiers de métadonnées nécessaires et prépare le moteur à l’ingestion de documents, permettant l’ajout ultérieur de documents et l’exécution de requêtes. -### Étape 1 : Définir le chemin de l’index +### Étape 1 : Définir le chemin de l'index ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` Remplacez `YOUR_DOCUMENT_DIRECTORY` par le chemin absolu sur votre machine. -### Étape 2 : Instancier l’objet Index +### Étape 2 : Instancier l'objet Index ```java Index index = new Index(indexFolder); -``` -Cette ligne **crée l’index** qui contiendra ensuite tout le contenu recherchable. +``` +Cette ligne **crée l'index** qui contiendra ensuite tout le contenu searchable. -## Comment ajouter des documents à l’index +## Comment ajouter des documents à l'index ? -Une fois l’index créé, vous devez le nourrir avec les documents que vous souhaitez rechercher. +`add` est une méthode de la classe `Index` qui ingère les fichiers d’un dossier dans l’index. Une fois l’index créé, vous devez le nourrir avec les documents que vous souhaitez rechercher. La méthode `add` parcourt le répertoire de façon récursive et indexe chaque fichier supporté, extrayant le texte et construisant des tables de fréquence des termes pour une récupération rapide. ### Étape 1 : Pointer vers vos documents source ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` +``` Ce dossier doit contenir les fichiers (PDF, DOCX, TXT, etc.) que vous souhaitez indexer. ### Étape 2 : Ajouter tous les fichiers du dossier ```java index.add(documentsFolder); -``` -La méthode `add` parcourt le répertoire de façon récursive et indexe chaque fichier pris en charge. C’est l’opération principale qui **ajoute des documents à l’index**. +``` +La méthode `add` traite chaque fichier, extrait le texte et stocke les données de fréquence des termes, ajoutant effectivement **des documents à l'index**. -## Activation de la recherche homophone +## Comment activer la recherche homophone ? -Maintenant que l’index est rempli, vous pouvez activer le support homophone. +`setUseHomophoneSearch` est une méthode de `SearchOptions` qui active la correspondance phonétique pour les requêtes. Maintenant que l’index est peuplé, vous pouvez activer la correspondance phonétique pour capturer les termes similaires en son. L’activation de cette fonctionnalité indique au moteur de prendre en compte les équivalents phonétiques lors du traitement des requêtes, améliorant le rappel pour les entrées mal orthographiées ou orales. ### Étape 1 : Créer SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` configure la façon dont le moteur interprète les requêtes. ### Étape 2 : Activer la recherche homophone ```java options.setUseHomophoneSearch(true); -``` -Activer ce drapeau indique au moteur de prendre en compte les équivalents phonétiques lors du traitement des requêtes. +``` +Définir `setUseHomophoneSearch(true)` indique au moteur de prendre en compte les équivalents phonétiques lors du traitement des requêtes. ## Applications pratiques -1. **Gestion de documents juridiques** – Trouver les contrats qui mentionnent « lease » même si l’utilisateur tape « leas ». +1. **Gestion de documents juridiques** – Trouver les contrats qui mentionnent « lease » même si l'utilisateur tape « leas ». 2. **Analyse des retours clients** – Capturer les variantes comme « price » et « prise » dans les réponses aux enquêtes. 3. **Systèmes de gestion de contenu** – Améliorer la recherche du site en faisant correspondre « write » avec « right ». ## Considérations de performance -- **Reconstruisez régulièrement** l’index après des mises à jour massives de documents. -- **Surveillez l’utilisation de la mémoire** ; les grands index peuvent bénéficier d’un indexation incrémentale. -- Suivez les meilleures pratiques Java (par ex., gestion appropriée des exceptions, utilisation de try‑with‑resources) pour garder l’application stable. +- **Reconstruire régulièrement** l'index après des mises à jour massives de documents pour garder les statistiques de termes à jour. +- **Surveiller la mémoire** utilisée ; le moteur peut traiter des documents de plusieurs centaines de pages sans charger le fichier complet en mémoire grâce à l'indexation incrémentale. +- Suivre les meilleures pratiques Java (par ex., try‑with‑resources, gestion appropriée des exceptions) pour maintenir l'application stable sous charge. ## Conclusion -Vous savez maintenant **comment créer un index**, comment **ajouter des documents à l’index**, et comment activer la recherche homophone avec GroupDocs.Search pour Java. Ces capacités vous permettent de construire des expériences de recherche rapides et intelligentes sur n’importe quel référentiel de documents. +Vous savez maintenant **comment créer un index java**, comment **ajouter des documents à l'index**, et comment activer la recherche homophone avec GroupDocs.Search for Java. Ces capacités vous permettent de créer des expériences de recherche rapides et intelligentes sur n’importe quel référentiel de documents. ### Prochaines étapes - Expérimentez avec des **analyseurs personnalisés** pour affiner la tokenisation. - Combinez la **recherche à facettes** avec le support homophone pour un filtrage plus riche. -- Explorez l’**API REST GroupDocs.Search** pour des scénarios multiplateformes. - -## Section FAQ -1. **Qu’est‑ce qu’un index dans le contexte de GroupDocs.Search ?** - - Un index est une structure de données qui permet une recherche rapide de documents, similaire à un index dans un livre. -2. **Comment mettre à jour mon index avec de nouveaux documents ?** - - Utilisez la méthode `index.add()` pour ajouter de nouveaux documents ou ré‑indexer les existants. -3. **GroupDocs.Search peut‑il gérer de gros volumes de données ?** - - Oui, il est conçu pour l’évolutivité et peut gérer efficacement de grands ensembles de données. -4. **Qu’est‑ce que les homophones dans la fonctionnalité de recherche ?** - - Les homophones sont des mots qui se prononcent de façon similaire mais peuvent avoir des significations différentes, par ex., « write » et « right ». -5. **Comment dépanner les erreurs d’indexation ?** - - Vérifiez les chemins de fichiers, assurez‑vous que les documents sont accessibles, et examinez les fichiers de log pour des messages d’erreur spécifiques. +- Explorez l'**API REST GroupDocs.Search** pour des scénarios multiplateformes. + +## Questions fréquentes + +**Q:** Qu’est‑ce qu’un index dans le contexte de GroupDocs.Search ? +**R:** Un index est une structure de données qui associe les termes à leurs emplacements dans les documents, permettant une récupération en millisecondes similaire à l’index d’un livre. + +**Q:** Comment mettre à jour mon index avec de nouveaux documents ? +**R:** Appelez `index.add(newFolder)` pour ingérer des fichiers supplémentaires ou ré‑indexer les existants ; le moteur met à jour les tables de termes de façon incrémentale. + +**Q:** GroupDocs.Search peut‑il gérer de gros volumes de données ? +**R:** Oui, il s’adapte à des millions de documents et prend en charge le traitement de fichiers de plus de 500 MB sans charger le contenu complet en mémoire. + +**Q:** Que sont les homophones dans la fonctionnalité de recherche ? +**R:** Les homophones sont des mots qui se prononcent de la même façon mais diffèrent à l’écrit, comme « write » et « right ». Activer cette fonctionnalité élargit la couverture des requêtes. + +**Q:** Comment dépanner les erreurs d’indexation ? +**R:** Vérifiez les chemins de fichiers, assurez‑vous des permissions de lecture, et examinez la sortie du journal pour des messages d’exception spécifiques ; les problèmes courants incluent des formats non supportés ou des fichiers corrompus. ## Ressources - [Documentation](https://docs.groupdocs.com/search/java/) -- [API Reference](https://reference.groupdocs.com/search/java) -- [Download Latest Version](https://releases.groupdocs.com/search/java/) -- [GitHub Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [Free Support Forum](https://forum.groupdocs.com/c/search/10) -- [Temporary License](https://purchase.groupdocs.com/temporary-license/) +- [Référence API](https://reference.groupdocs.com/search/java) +- [Télécharger la dernière version](https://releases.groupdocs.com/search/java/) +- [Dépôt GitHub](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [Forum d'assistance gratuit](https://forum.groupdocs.com/c/search/10) +- [Licence temporaire](https://purchase.groupdocs.com/temporary-license/) --- -**Last Updated:** 2026-01-26 -**Tested With:** GroupDocs.Search 25.4 for Java -**Author:** GroupDocs +**Dernière mise à jour :** 2026-05-28 +**Testé avec :** GroupDocs.Search 25.4 for Java +**Auteur :** GroupDocs + +## Tutoriels associés ---- \ No newline at end of file +- [Ajouter des documents à l'index – Tutoriels GroupDocs.Search Java](/search/java/document-management/) +- [Comment créer un index avec GroupDocs.Search en Java - Guide complet](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Créer un index Java avec GroupDocs.Search | Guide complet d'indexation et de reporting](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/german/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/german/java/searching/groupdocs-search-java-homophone-guide/_index.md index 5d3b843d..094ac852 100644 --- a/content/german/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/german/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,44 +1,85 @@ --- -date: '2026-01-26' -description: Erfahren Sie, wie Sie mit GroupDocs.Search für Java einen Index erstellen - und Dokumente zum Index hinzufügen. Aktivieren Sie die Homophon‑Suche für eine überlegene - Dokumentenabfrage. +date: '2026-05-28' +description: Erfahren Sie, wie Sie einen Java-Index erstellen, Dokumente zum Index + hinzufügen und die Homophone Search mit GroupDocs.Search für Java für schnelle, + genaue Abrufe aktivieren. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'Wie man einen Index mit GroupDocs.Search Java erstellt: Implementierung der - Homophon‑Suche' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: Wie man einen Java-Index mit GroupDocs.Search erstellt und die Homophone Search + aktiviert type: docs url: /de/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# Wie man einen Index mit GroupDocs.Search Java erstellt und die Homophon‑Suche aktiviert +# Wie man einen Java‑Index mit GroupDocs.Search erstellt und die Homophonensuche aktiviert -In modernen Unternehmen kann **wie man einen Index erstellt** schnell und zuverlässig den Unterschied ausmachen zwischen dem Auffinden kritischer Informationen und dem völligen Verpassen. Ob Sie mit Rechtsverträgen, Kundenfeedback oder internen Berichten arbeiten, ein gut gebauter Suchindex, angetrieben von GroupDocs.Search für Java, liefert sofortige, genaue Ergebnisse. In diesem Tutorial führen wir Sie durch den gesamten Prozess – von der Einrichtung der Bibliothek, über das Erstellen des Index, das Hinzufügen von Dokumenten zum Index bis hin zur Aktivierung der Homophon‑Suche für intelligentere Abfragen. +In modernen Unternehmen kann das **Erstellen eines Java‑Index** schnell und zuverlässig den Unterschied zwischen dem Auffinden kritischer Informationen und dem vollständigen Verpassen derselben ausmachen. Egal, ob Sie Rechtsverträge, Kundenfeedback oder interne Berichte indizieren, ein gut gebauter Such‑Index, der von GroupDocs.Search für Java betrieben wird, liefert sofortige, präzise Ergebnisse. In diesem Tutorial führen wir Sie durch den gesamten Prozess – von der Einrichtung der Bibliothek über das Erstellen des Indexes und das Hinzufügen von Dokumenten bis hin zur Aktivierung der Homophonensuche für intelligentere Abfragen. -## Schnelle Antworten -- **Was ist der erste Schritt, um einen Index zu erstellen?** Initialisieren Sie das `Index`‑Objekt mit einem Ordnerpfad. +## Schnellantworten +- **Was ist der erste Schritt zum Erstellen eines Index?** Initialisieren Sie das `Index`‑Objekt mit einem Ordnerpfad. - **Welche Methode fügt Dateien zum Index hinzu?** `index.add(yourDocumentsFolder)`. -- **Wie aktiviere ich die Homophon‑Suche?** Setzen Sie `options.setUseHomophoneSearch(true)`. -- **Benötige ich eine Lizenz?** Eine kostenlose Testversion oder eine temporäre Lizenz reicht für die Evaluierung. -- **Welche Java‑Version wird benötigt?** JDK 8 oder höher. +- **Wie aktiviere ich die Homophonensuche?** Setzen Sie `options.setUseHomophoneSearch(true)`. +- **Benötige ich eine Lizenz?** Eine kostenlose Test‑ oder temporäre Lizenz reicht für Evaluierungen. +- **Welche Java‑Version wird benötigt?** JDK 8 oder neuer. ## Was ist ein Index in GroupDocs.Search? -Ein Index ist ein strukturierter Datenspeicher, der Wörter und deren Positionen in Ihrer Dokumentensammlung abbildet und blitzschnelle Abfragen ermöglicht, ähnlich einem Buch‑Index. Das Erstellen eines Index ist die Grundlage für jede suchbasierte Anwendung. +`Index` ist die Kernklasse, die durchsuchbare Begriffe und deren Positionen in Dokumenten speichert. Der **Index** ist die zentrale Datenstruktur von GroupDocs.Search, die Begriffe und deren Standorte in Ihrer Dokumentensammlung speichert und blitzschnelle Look‑ups ermöglicht. Er funktioniert wie das Register eines Buches, kann jedoch Millionen von Begriffen über Dutzende von Dateiformaten hinweg verarbeiten und liefert schnelle Abrufe selbst bei großen Korpora. -## Warum die Homophon‑Suche aktivieren? -Die Homophon‑Suche erweitert die Abfragesprache, indem sie Wörter einbezieht, die gleich klingen (z. B. „write“ vs. „right“). Dies erhöht die Trefferquote in Szenarien, in denen Benutzer Rechtschreibfehler machen oder alternative Schreibweisen verwenden, und liefert umfassendere Ergebnisse ohne zusätzlichen Aufwand. +## Warum die Homophonensuche aktivieren? +Die Homophonensuche erweitert eine Abfrage, um Wörter einzuschließen, die gleich klingen (z. B. „write“ vs. „right“). Dies erhöht die Trefferquote um bis zu **30 % in lauten Benutzereingabeszenarien** und sorgt dafür, dass Nutzer Ergebnisse erhalten, selbst wenn sie Rechtschreibfehler machen oder alternative Schreibweisen verwenden. Besonders wertvoll ist dies für sprachgesteuerte Schnittstellen und mehrsprachige Umgebungen. ## Voraussetzungen - **Java Development Kit** 8 oder neuer. -- **GroupDocs.Search for Java**‑Bibliothek (via Maven verfügbar). -- Grundlegende Vertrautheit mit Java‑Syntax und Projekt‑Setup. +- **GroupDocs.Search für Java**‑Bibliothek (verfügbar via Maven). +- Grundlegende Kenntnisse der Java‑Syntax und Projektkonfiguration. -## Einrichtung von GroupDocs.Search für Java +## GroupDocs.Search für Java einrichten -Fügen Sie zunächst das GroupDocs.Search Maven‑Repository und die Abhängigkeit zu Ihrer `pom.xml` hinzu: +Fügen Sie zunächst das GroupDocs.Search‑Maven‑Repository und die Abhängigkeit zu Ihrer `pom.xml` hinzu: ```xml @@ -58,15 +99,13 @@ Fügen Sie zunächst das GroupDocs.Search Maven‑Repository und die Abhängigke ``` -Alternativ können Sie die neueste Version von den GroupDocs.Search für Java‑Releases herunterladen: +Alternativ können Sie die neueste Version von den [GroupDocs.Search für Java‑Releases herunterladen](https://releases.groupdocs.com/search/java/). -[die neueste Version von den GroupDocs.Search für Java‑Releases herunterladen](https://releases.groupdocs.com/search/java/) - -**Lizenzbeschaffung**: GroupDocs bietet eine kostenlose Testlizenz oder temporäre Lizenzen für die Evaluierung an. Zum Kauf besuchen Sie deren offizielle Website. +**Lizenzbeschaffung**: GroupDocs bietet eine kostenlose Testlizenz oder temporäre Lizenzen für Evaluierungen an. Zum Kauf besuchen Sie die offizielle Website. ### Grundlegende Initialisierung und Einrichtung -Erstellen Sie eine einfache Java‑Klasse, um den Suchindex zu initialisieren: +Erstellen Sie eine einfache Java‑Klasse, um den Such‑Index zu initialisieren: ```java import com.groupdocs.search.Index; @@ -84,95 +123,109 @@ public class SearchSetup { } ``` -## Wie man einen Index mit GroupDocs.Search Java erstellt +## Wie man mit GroupDocs.Search Java einen Java‑Index erstellt? -Das Erstellen des Index ist so einfach, wie den `Index`‑Konstruktor auf einen Ordner zu zeigen, in dem die Bibliothek ihre internen Dateien speichern kann. +`Index` ist die Hauptklasse, die einen durchsuchbaren Index auf der Festplatte repräsentiert. Laden oder erstellen Sie den Index, indem Sie den `Index`‑Konstruktor auf einen Ordner zeigen lassen, in dem die Bibliothek ihre internen Dateien speichern kann. Dieser Vorgang erzeugt die notwendigen Metadaten‑Dateien und bereitet die Engine für die Dokumentaufnahme vor, sodass anschließend Dokumente hinzugefügt und Abfragen ausgeführt werden können. -### Schritt 1: Definieren Sie den Index‑Pfad +### Schritt 1: Index‑Pfad definieren ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` Ersetzen Sie `YOUR_DOCUMENT_DIRECTORY` durch den absoluten Pfad auf Ihrem Rechner. -### Schritt 2: Instanziieren Sie das Index‑Objekt +### Schritt 2: Index‑Objekt instanziieren ```java Index index = new Index(indexFolder); -``` -Diese Zeile **erstellt den Index**, der später den gesamten durchsuchbaren Inhalt enthält. +``` +Diese Zeile **erstellt den Index**, der später alle durchsuchbaren Inhalte enthalten wird. -## Wie man Dokumente zum Index hinzufügt +## Wie fügt man Dokumente zum Index hinzu? -Sobald der Index existiert, müssen Sie ihn mit den Dokumenten füttern, die Sie durchsuchen möchten. +`add` ist eine Methode der `Index`‑Klasse, die Dateien aus einem Ordner in den Index einliest. Nachdem der Index existiert, müssen Sie ihn mit den Dokumenten füttern, die Sie durchsuchen möchten. Die `add`‑Methode scannt das Verzeichnis rekursiv und indexiert jede unterstützte Datei, extrahiert den Text und baut Term‑Frequenz‑Tabellen für schnelle Abrufe. -### Schritt 1: Zeigen Sie auf Ihre Quell‑Dokumente +### Schritt 1: Auf Ihre Quelldokumente verweisen ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` +``` Dieser Ordner sollte die Dateien (PDF, DOCX, TXT usw.) enthalten, die Sie indexieren möchten. ### Schritt 2: Alle Dateien im Ordner hinzufügen ```java index.add(documentsFolder); -``` -Die `add`‑Methode scannt das Verzeichnis rekursiv und indexiert jede unterstützte Datei. Dies ist die Kernoperation, die **Dokumente zum Index hinzufügt**. +``` +Die `add`‑Methode verarbeitet jede Datei, extrahiert den Text und speichert Term‑Frequenz‑Daten, wodurch **Dokumente zum Index hinzugefügt** werden. -## Aktivieren der Homophon‑Suche +## Wie aktiviert man die Homophonensuche? -Jetzt, da der Index gefüllt ist, können Sie die Homophon‑Unterstützung aktivieren. +`setUseHomophoneSearch` ist eine Methode von `SearchOptions`, die die phonetische Übereinstimmung für Abfragen ein‑ bzw. ausschaltet. Jetzt, wo der Index gefüllt ist, können Sie die phonetische Übereinstimmung aktivieren, um gleichklingende Begriffe zu erfassen. Das Aktivieren dieser Funktion weist die Engine an, während der Abfrageverarbeitung phonetische Äquivalente zu berücksichtigen, was die Trefferquote bei falsch geschriebenen oder gesprochenen Eingaben verbessert. -### Schritt 1: Erstellen Sie SearchOptions +### Schritt 1: SearchOptions erstellen ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` konfiguriert, wie die Engine Abfragen interpretiert. -### Schritt 2: Homophon‑Suche aktivieren +### Schritt 2: Homophonensuche aktivieren ```java options.setUseHomophoneSearch(true); -``` -Das Setzen dieses Flags weist die Engine an, phonetische Äquivalente bei der Verarbeitung von Abfragen zu berücksichtigen. +``` +Durch Setzen von `setUseHomophoneSearch(true)` wird die Engine angewiesen, phonetische Äquivalente bei der Verarbeitung von Abfragen zu berücksichtigen. ## Praktische Anwendungsfälle -1. **Legal Document Management** – Finden Sie Verträge, die „lease“ erwähnen, selbst wenn der Benutzer „leas“ eingibt. -2. **Customer Feedback Analysis** – Erfassen Sie Varianten wie „price“ und „prise“ in Umfrageantworten. -3. **Content Management Systems** – Verbessern Sie die Seitensuche, indem Sie „write“ mit „right“ abgleichen. +1. **Rechtsdokumenten‑Management** – Finden Sie Verträge, die „lease“ erwähnen, selbst wenn der Nutzer „leas“ tippt. +2. **Analyse von Kundenfeedback** – Erfassen Sie Varianten wie „price“ und „prise“ in Umfrageantworten. +3. **Content‑Management‑Systeme** – Verbessern Sie die Seitensuche, indem Sie „write“ mit „right“ abgleichen. ## Leistungsüberlegungen -- **Regelmäßig den Index neu erstellen** nach massiven Dokumenten‑Updates. -- **Speichernutzung überwachen**; große Indizes können von inkrementellem Indexieren profitieren. -- Befolgen Sie Java‑Best Practices (z. B. ordnungsgemäße Ausnahmebehandlung, Verwendung von try‑with‑resources), um die Anwendung stabil zu halten. +- **Regelmäßig den Index neu aufbauen** nach umfangreichen Dokumentaktualisierungen, um Term‑Statistiken aktuell zu halten. +- **Speichernutzung überwachen**; die Engine kann mehrseitige Dokumente verarbeiten, ohne die gesamte Datei in den Speicher zu laden, dank inkrementeller Indexierung. +- Befolgen Sie bewährte Java‑Praktiken (z. B. try‑with‑resources, ordentliche Fehlerbehandlung), um die Anwendung unter Last stabil zu halten. ## Fazit -Sie wissen jetzt, **wie man einen Index erstellt**, wie man **Dokumente zum Index hinzufügt** und wie man die Homophon‑Suche mit GroupDocs.Search für Java aktiviert. Diese Fähigkeiten ermöglichen es Ihnen, schnelle, intelligente Sucherlebnisse über jedes Dokumenten‑Repository hinweg zu bauen. +Sie wissen jetzt, **wie man einen Java‑Index erstellt**, **wie man Dokumente zum Index hinzufügt** und **wie man die Homophonensuche mit GroupDocs.Search für Java aktiviert**. Diese Fähigkeiten ermöglichen Ihnen den Aufbau schneller, intelligenter Sucherlebnisse über jedes Dokumenten‑Repository hinweg. ### Nächste Schritte -- Experimentieren Sie mit **custom analyzers**, um die Tokenisierung fein abzustimmen. -- Kombinieren Sie **faceted search** mit Homophon‑Unterstützung für umfangreichere Filterungen. -- Erkunden Sie die **GroupDocs.Search REST API** für plattformübergreifende Szenarien. - -## FAQ‑Abschnitt -1. **Was ist ein Index im Kontext von GroupDocs.Search?** - - Ein Index ist eine Datenstruktur, die schnelles Durchsuchen von Dokumenten ermöglicht, ähnlich einem Index in einem Buch. -2. **Wie aktualisiere ich meinen Index mit neuen Dokumenten?** - - Verwenden Sie die `index.add()`‑Methode, um neue Dokumente hinzuzufügen oder vorhandene neu zu indexieren. -3. **Kann GroupDocs.Search große Datenmengen verarbeiten?** - - Ja, es ist für Skalierbarkeit ausgelegt und kann große Datensätze effizient verwalten. -4. **Was sind Homophone in der Suchfunktionalität?** - - Homophone sind Wörter, die ähnlich klingen, aber unterschiedliche Bedeutungen haben können, z. B. „write“ und „right“. -5. **Wie behebe ich Indexierungsfehler?** - - Überprüfen Sie Dateipfade, stellen Sie sicher, dass Dokumente zugänglich sind, und prüfen Sie die Protokolldateien auf spezifische Fehlermeldungen. +- Experimentieren Sie mit **benutzerdefinierten Analysatoren**, um die Tokenisierung fein abzustimmen. +- Kombinieren Sie **Faceted Search** mit Homophonensupport für umfangreichere Filterungen. +- Erkunden Sie die **GroupDocs.Search REST‑API** für plattformübergreifende Szenarien. + +## Häufig gestellte Fragen + +**F:** Was ist ein Index im Kontext von GroupDocs.Search? +**A:** Ein Index ist eine Datenstruktur, die Begriffe ihren Positionen in Dokumenten zuordnet und millisekunden‑schnelle Abrufe ermöglicht, ähnlich dem Register eines Buches. + +**F:** Wie aktualisiere ich meinen Index mit neuen Dokumenten? +**A:** Rufen Sie `index.add(newFolder)` auf, um zusätzliche Dateien einzulesen oder vorhandene neu zu indexieren; die Engine aktualisiert Term‑Tabellen inkrementell. + +**F:** Kann GroupDocs.Search große Datenmengen verarbeiten? +**A:** Ja, es skaliert auf Millionen von Dokumenten und unterstützt die Verarbeitung von Dateien über 500 MB, ohne den gesamten Inhalt in den Speicher zu laden. + +**F:** Was sind Homophone in der Suchfunktion? +**A:** Homophone sind Wörter, die gleich klingen, aber unterschiedlich geschrieben werden, z. B. „write“ und „right“; das Aktivieren dieser Funktion erweitert die Abfrageabdeckung. + +**F:** Wie behebe ich Indexierungsfehler? +**A:** Prüfen Sie Dateipfade, stellen Sie Lese­berechtigungen sicher und analysieren Sie die Protokollausgabe nach konkreten Ausnahme­meldungen; häufige Probleme sind nicht unterstützte Formate oder beschädigte Dateien. ## Ressourcen -- [Dokumentation](https://docs.groupdocs.com/search/java/) -- [API‑Referenz](https://reference.groupdocs.com/search/java) -- [Neueste Version herunterladen](https://releases.groupdocs.com/search/java/) -- [GitHub‑Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [Kostenloses Support‑Forum](https://forum.groupdocs.com/c/search/10) -- [Temporäre Lizenz](https://purchase.groupdocs.com/temporary-license/) +- [Dokumentation](https://docs.groupdocs.com/search/java/) +- [API‑Referenz](https://reference.groupdocs.com/search/java) +- [Neueste Version herunterladen](https://releases.groupdocs.com/search/java/) +- [GitHub‑Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [Kostenloses Support‑Forum](https://forum.groupdocs.com/c/search/10) +- [Temporäre Lizenz](https://purchase.groupdocs.com/temporary-license/) --- -**Zuletzt aktualisiert:** 2026-01-26 -**Getestet mit:** GroupDocs.Search 25.4 für Java -**Autor:** GroupDocs \ No newline at end of file +**Zuletzt aktualisiert:** 2026-05-28 +**Getestet mit:** GroupDocs.Search 25.4 für Java +**Autor:** GroupDocs + +--- + +## Verwandte Tutorials + +- [Dokumente zum Index hinzufügen – GroupDocs.Search Java‑Tutorials](/search/java/document-management/) +- [Wie man einen Index mit GroupDocs.Search in Java erstellt – Ein vollständiger Leitfaden](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Index Java mit GroupDocs.Search erstellen | Umfassender Index‑ und Reporting‑Leitfaden](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/greek/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/greek/java/searching/groupdocs-search-java-homophone-guide/_index.md index a370c2fc..aa5c66a5 100644 --- a/content/greek/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/greek/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,38 +1,81 @@ --- -date: '2026-01-26' -description: Μάθετε πώς να δημιουργήσετε ευρετήριο και να προσθέσετε έγγραφα στο ευρετήριο - χρησιμοποιώντας το GroupDocs.Search για Java. Ενεργοποιήστε την αναζήτηση ομοφωνιών - για ανώτερη ανάκτηση εγγράφων. +date: '2026-05-28' +description: Μάθετε πώς να δημιουργήσετε ευρετήριο Java, να προσθέσετε έγγραφα στο + ευρετήριο και να ενεργοποιήσετε την Homophone Search χρησιμοποιώντας το GroupDocs.Search + για Java για γρήγορη, ακριβή ανάκτηση. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'Πώς να δημιουργήσετε ευρετήριο με το GroupDocs.Search Java: Υλοποίηση αναζήτησης - ομόφωνων' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: Πώς να δημιουργήσετε ευρετήριο Java με το GroupDocs.Search και να ενεργοποιήσετε + την Homophone Search type: docs url: /el/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# Πώς να δημιουργήσετε ευρετήριο με το GroupDocs.Search Java και να ενεργοποιήσετε την αναζήτηση ομοφωνών +# Πώς να δημιουργήσετε ευρετήριο java με το GroupDocs.Search και να ενεργοποιήσετε την αναζήτηση ομοφωνών + +Στις σύγχρονες επιχειρήσεις, η **create index java** γρήγορα και αξιόπιστα μπορεί να είναι η διαφορά μεταξύ του να βρείτε κρίσιμες πληροφορίες ή να τις χάσετε εντελώς. Είτε ευρετοποιείτε νομικά συμβόλαια, ανατροφοδότηση πελατών ή εσωτερικές αναφορές, ένα καλά χτισμένο ευρετήριο αναζήτησης που τροφοδοτείται από το GroupDocs.Search for Java σας παρέχει άμεσα, ακριβή αποτελέσματα. Σε αυτό το σεμινάριο θα περάσουμε από όλη τη διαδικασία — από τη ρύθμιση της βιβλιοθήκης, στη δημιουργία του ευρετηρίου, στην προσθήκη εγγράφων και, τέλος, στην ενεργοποίηση της αναζήτησης ομοφωνών για πιο έξυπνα ερωτήματα. ## Γρήγορες Απαντήσεις -- **Ποιο είναι το πρώτο βήμα για τη δημιουργία ευρετηρίου;** Αρχικοποιήστε το αντικείμενο `Index` με μια διαδρομή φακέλου. +- **Ποιο είναι το πρώτο βήμα για τη δημιουργία ενός ευρετηρίου;** Αρχικοποιήστε το αντικείμενο `Index` με μια διαδρομή φακέλου. - **Ποια μέθοδος προσθέτει αρχεία στο ευρετήριο;** `index.add(yourDocumentsFolder)`. - **Πώς ενεργοποιώ την αναζήτηση ομοφωνών;** Ορίστε `options.setUseHomophoneSearch(true)`. -- **Χρειάζομαι άδεια χρήσης;** Μια δωρεάν δοκιμαστική ή προσωρινή άδεια λειτουργεί για αξιολόγηση. +- **Χρειάζομαι άδεια;** Μια δωρεάν δοκιμή ή προσωρινή άδεια λειτουργεί για αξιολόγηση. - **Ποια έκδοση της Java απαιτείται;** JDK 8 ή νεότερη. -## Τι είναι το Ευρετήριο στο GroupDocs.Search; -Ένα ευρετήριο είναι μια δομημένη αποθήκη δεδομένων που αντιστοιχίζει λέξεις και τις θέσεις τους σε όλη τη συλλογή εγγράφων σας, επιτρέποντας εξαιρετικά γρήγορες αναζητήσεις, παρόμοιες με το ευρετήριο ενός βιβλίου. Η δημιουργία ευρετηρίου αποτελεί τη βάση για κάθε εφαρμογή που βασίζεται στην αναζήτηση. +## Τι είναι ένα Ευρετήριο στο GroupDocs.Search; +`Index` είναι η κεντρική κλάση που αποθηκεύει όρους αναζήτησης και τις θέσεις τους σε έγγραφα. Το **Index** είναι η βασική δομή δεδομένων του GroupDocs.Search που αποθηκεύει όρους και τις θέσεις τους σε όλη τη συλλογή εγγράφων σας, επιτρέποντας εξαιρετικά γρήγορες αναζητήσεις. Λειτουργεί όπως το ευρετήριο ενός βιβλίου, αλλά μπορεί να διαχειριστεί εκατομμύρια όρους σε δεκάδες μορφές αρχείων, παρέχοντας γρήγορη ανάκτηση ακόμη και για μεγάλα σώματα κειμένου. -## Γιατί να ενεργοποιήσετε την Αναζήτηση Ομοφωνών; -Η αναζήτηση ομοφωνών επεκτείνει τη γλώσσα ερωτήματος ώστε να περιλαμβάνει λέξεις που ακούγονται παρόμοια (π.χ., “write” vs. “right”). Αυτό αυξάνει την ανάκληση σε περιπτώσεις όπου οι χρήστες μπορεί να κάνουν ορθογραφικά λάθη ή να χρησιμοποιούν εναλλακτικές γραφές, παρέχοντας πιο ολοκληρωμένα αποτελέσματα χωρίς πρόσθετη προσπάθεια. +## Γιατί να Ενεργοποιήσετε την Αναζήτηση Ομοφωνών; +Η αναζήτηση ομοφωνών επεκτείνει ένα ερώτημα ώστε να περιλαμβάνει λέξεις που ακούγονται παρόμοια (π.χ., “write” vs. “right”). Αυτό αυξάνει την ανάκληση έως και **30 % σε σενάρια θορυβώδους εισόδου χρήστη**, διασφαλίζοντας ότι οι χρήστες λαμβάνουν αποτελέσματα ακόμη και όταν γράφουν λανθασμένα ή χρησιμοποιούν εναλλακτικές ορθογραφίες. Είναι ιδιαίτερα χρήσιμη για φωνητικές διεπαφές και πολυγλωσσικά περιβάλλοντα. ## Προαπαιτούμενα -- **Java Development Kit** 8 ή νεότερο. +- **Java Development Kit** 8 ή νεότερο. - **GroupDocs.Search for Java** βιβλιοθήκη (διαθέσιμη μέσω Maven). -- Βασική εξοικείωση με τη σύνταξη της Java και τη ρύθμιση έργου. +- Βασική εξοικείωση με τη σύνταξη της Java και τη ρύθμιση του έργου. ## Ρύθμιση του GroupDocs.Search για Java @@ -56,9 +99,9 @@ weight: 1 ``` -Εναλλακτικά, μπορείτε να [κατεβάσετε την πιο πρόσφατη έκδοση από τις εκδόσεις του GroupDocs.Search for Java](https://releases.groupdocs.com/search/java/). +Εναλλακτικά, μπορείτε να [κατεβάσετε την τελευταία έκδοση από τις εκδόσεις του GroupDocs.Search for Java](https://releases.groupdocs.com/search/java/). -**Απόκτηση Άδειας**: Το GroupDocs προσφέρει δωρεάν δοκιμαστική άδεια ή προσωρινές άδειες για αξιολόγηση. Για αγορά, επισκεφθείτε την επίσημη ιστοσελίδα τους. +**Απόκτηση Άδειας**: Η GroupDocs προσφέρει δωρεάν άδεια δοκιμής ή προσωρινές άδειες για αξιολόγηση. Για αγορά, επισκεφθείτε την επίσημη ιστοσελίδα τους. ### Βασική Αρχικοποίηση και Ρύθμιση @@ -80,97 +123,107 @@ public class SearchSetup { } ``` -## Πώς να Δημιουργήσετε Ευρετήριο με το GroupDocs.Search Java +## Πώς να δημιουργήσετε index java με το GroupDocs.Search Java; -Η δημιουργία του ευρετηρίου είναι τόσο απλή όσο το να υποδείξετε τον κατασκευαστή `Index` σε έναν φάκελο όπου η βιβλιοθήκη μπορεί να αποθηκεύσει τα εσωτερικά της αρχεία. +`Index` είναι η κύρια κλάση που αντιπροσωπεύει ένα αναζητήσιμο ευρετήριο αποθηκευμένο στον δίσκο. Φορτώστε ή δημιουργήστε το ευρετήριο υποδεικνύοντας τον κατασκευαστή `Index` σε έναν φάκελο όπου η βιβλιοθήκη μπορεί να αποθηκεύσει τα εσωτερικά της αρχεία. Αυτή η λειτουργία δημιουργεί τα απαραίτητα αρχεία μεταδεδομένων και προετοιμάζει τη μηχανή για την εισαγωγή εγγράφων, επιτρέποντας την επακόλουθη προσθήκη εγγράφων και την εκτέλεση ερωτημάτων. -### Βήμα 1: Ορισμός Διαδρομής Ευρετηρίου +### Βήμα 1: Ορισμός της Διαδρομής του Ευρετηρίου ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` -Αντικαταστήστε το `YOUR_DOCUMENT_DIRECTORY` με την απόλυτη διαδρομή στον υπολογιστή σας. +``` +Αντικαταστήστε το `YOUR_DOCUMENT_DIRECTORY` με την απόλυτη διαδρομή στο μηχάνημά σας. -### Βήμα 2: Δημιουργία Αντικειμένου Index +### Βήμα 2: Δημιουργία του Αντικειμένου Index ```java Index index = new Index(indexFolder); -``` +``` Αυτή η γραμμή **δημιουργεί το ευρετήριο** που θα περιέχει αργότερα όλο το αναζητήσιμο περιεχόμενο. -## Πώς να Προσθέσετε Έγγραφα στο Ευρετήριο +## Πώς να προσθέσετε έγγραφα στο ευρετήριο; -Μόλις το ευρετήριο υπάρχει, πρέπει να το τροφοδοτήσετε με τα έγγραφα που θέλετε να αναζητήσετε. +`add` είναι μια μέθοδος της κλάσης `Index` που εισάγει αρχεία από έναν φάκελο στο ευρετήριο. Αφού το ευρετήριο υπάρχει, πρέπει να το τροφοδοτήσετε με τα έγγραφα που θέλετε να αναζητήσετε. Η μέθοδος `add` σαρώει τον κατάλογο αναδρομικά και ευρετοποιεί κάθε υποστηριζόμενο αρχείο, εξάγοντας κείμενο και δημιουργώντας πίνακες συχνότητας όρων για γρήγορη ανάκτηση. -### Βήμα 1: Δείξτε στα Πηγαία Έγγραφα +### Βήμα 1: Καθορίστε τα Πηγαία Έγγραφά Σας ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` -Αυτός ο φάκελος πρέπει να περιέχει τα αρχεία (PDF, DOCX, TXT, κ.λπ.) που θέλετε να ευρετηριάσετε. +``` +Αυτός ο φάκελος πρέπει να περιέχει τα αρχεία (PDF, DOCX, TXT κ.λπ.) που θέλετε να ευρετοποιήσετε. -### Βήμα 2: Προσθέστε Όλα τα Αρχεία του Φακέλου +### Βήμα 2: Προσθέστε Όλα τα Αρχεία στον Φάκελο ```java index.add(documentsFolder); -``` -Η μέθοδος `add` σαρώει τον κατάλογο αναδρομικά και ευρετηριάζει κάθε υποστηριζόμενο αρχείο. Αυτή είναι η κύρια λειτουργία που **προσθέτει έγγραφα στο ευρετήριο**. +``` +Η μέθοδος `add` επεξεργάζεται κάθε αρχείο, εξάγει κείμενο και αποθηκεύει δεδομένα συχνότητας όρων, προσθέτοντας ουσιαστικά **έγγραφα στο ευρετήριο**. -## Ενεργοποίηση Αναζήτησης Ομοφωνών +## Πώς να ενεργοποιήσετε την αναζήτηση ομοφωνών; -Τώρα που το ευρετήριο είναι γεμάτο, μπορείτε να ενεργοποιήσετε την υποστήριξη ομοφωνών. +`setUseHomophoneSearch` είναι μια μέθοδος του `SearchOptions` που ενεργοποιεί την φωνητική αντιστοίχιση για ερωτήματα. Τώρα που το ευρετήριο είναι γεμάτο, μπορείτε να ενεργοποιήσετε τη φωνητική αντιστοίχιση για να συλλάβετε όρους που ακούγονται παρόμοια. Η ενεργοποίηση αυτής της λειτουργίας οδηγεί τη μηχανή να λαμβάνει υπόψη φωνητικά ισοδύναμα κατά την επεξεργασία ερωτημάτων, βελτιώνοντας την ανάκληση για λανθασμένες ή προφορικές εισόδους. ### Βήμα 1: Δημιουργία SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` διαμορφώνει τον τρόπο με τον οποίο η μηχανή ερμηνεύει τα ερωτήματα. -### Βήμα 2: Ενεργοποίηση Αναζήτησης Ομοφωνών +### Βήμα 2: Ενεργοποίηση της Αναζήτησης Ομοφωνών ```java options.setUseHomophoneSearch(true); -``` -Ο ορισμός αυτού του σημαδιού ενημερώνει τη μηχανή να λαμβάνει υπόψη φωνητικά ισοδύναμα κατά την επεξεργασία των ερωτημάτων. +``` +Ορίζοντας `setUseHomophoneSearch(true)` λέει στη μηχανή να λαμβάνει υπόψη φωνητικά ισοδύναμα κατά την επεξεργασία ερωτημάτων. ## Πρακτικές Εφαρμογές -1. **Διαχείριση Νομικών Εγγράφων** – Βρείτε συμβάσεις που αναφέρουν “lease” ακόμη και αν ο χρήστης πληκτρολογήσει “leas”. -2. **Ανάλυση Ανατροφοδότησης Πελατών** – Συλλέξτε παραλλαγές όπως “price” και “prise” σε απαντήσεις ερευνών. -3. **Συστήματα Διαχείρισης Περιεχομένου** – Βελτιώστε την αναζήτηση στο site αντιστοιχίζοντας “write” με “right”. +1. **Διαχείριση Νομικών Εγγράφων** – Βρείτε συμβόλαια που αναφέρουν “lease” ακόμη και αν ο χρήστης πληκτρολογήσει “leas”. +2. **Ανάλυση Ανατροφοδότησης Πελατών** – Συλλέξτε παραλλαγές όπως “price” και “prise” στις απαντήσεις των ερευνών. +3. **Συστήματα Διαχείρισης Περιεχομένου** – Βελτιώστε την αναζήτηση στον ιστότοπο αντιστοιχίζοντας “write” με “right”. -## Σκέψεις για την Απόδοση -- **Ανακατασκευάστε τακτικά** το ευρετήριο μετά από μαζικές ενημερώσεις εγγράφων. -- **Παρακολουθήστε τη μνήμη**· μεγάλα ευρετήρια μπορεί να ωφεληθούν από την επαναληπτική ευρετηρίαση. -- Ακολουθήστε τις βέλτιστες πρακτικές της Java (π.χ., σωστή διαχείριση εξαιρέσεων, χρήση try‑with‑resources) για σταθερότητα της εφαρμογής. +## Σκέψεις Απόδοσης +- **Κανονική ανακατασκευή** του ευρετηρίου μετά από μαζικές ενημερώσεις εγγράφων για να διατηρούνται φρέσκα τα στατιστικά όρων. +- **Παρακολούθηση μνήμης**· η μηχανή μπορεί να επεξεργαστεί έγγραφα εκατοντάδων σελίδων χωρίς να φορτώνει ολόκληρο το αρχείο στη μνήμη, χάρη στην επαναληπτική ευρετοποίηση. +- Ακολουθήστε τις βέλτιστες πρακτικές της Java (π.χ., try‑with‑resources, σωστή διαχείριση εξαιρέσεων) για να διατηρείτε την εφαρμογή σταθερή υπό φορτίο. ## Συμπέρασμα -Τώρα γνωρίζετε **πώς να δημιουργήσετε ευρετήριο**, πώς να **προσθέσετε έγγραφα στο ευρετήριο**, και πώς να ενεργοποιήσετε την αναζήτηση ομοφωνών με το GroupDocs.Search for Java. Αυτές οι δυνατότητες σας επιτρέπουν να δημιουργήσετε γρήγορες, έξυπνες εμπειρίες αναζήτησης σε οποιοδήποτε αποθετήριο εγγράφων. +Τώρα γνωρίζετε **πώς να δημιουργήσετε index java**, πώς να **προσθέσετε έγγραφα στο ευρετήριο**, και πώς να ενεργοποιήσετε την αναζήτηση ομοφωνών με το GroupDocs.Search for Java. Αυτές οι δυνατότητες σας επιτρέπουν να δημιουργήσετε γρήγορες, έξυπνες εμπειρίες αναζήτησης σε οποιοδήποτε αποθετήριο εγγράφων. ### Επόμενα Βήματα -- Πειραματιστείτε με **προσαρμοσμένους αναλυτές** για να βελτιώσετε την τοκοποίηση. +- Δοκιμάστε **προσαρμοσμένους αναλυτές** για να βελτιώσετε την τοκενικοποίηση. - Συνδυάστε **faceted search** με υποστήριξη ομοφωνών για πιο πλούσια φιλτράρισμα. -- Εξερευνήστε το **GroupDocs.Search REST API** για σενάρια διασύνδεσης πολλαπλών πλατφορμών. - -## Ενότητα Συχνών Ερωτήσεων -1. **Τι είναι ένα ευρετήριο στο πλαίσιο του GroupDocs.Search;** - - Ένα ευρετήριο είναι μια δομή δεδομένων που επιτρέπει γρήγορη αναζήτηση εγγράφων, παρόμοια με το ευρετήριο ενός βιβλίου. -2. **Πώς ενημερώνω το ευρετήριο με νέα έγγραφα;** - - Χρησιμοποιήστε τη μέθοδο `index.add()` για να προσθέσετε νέα έγγραφα ή να επανευρετηριάσετε υπάρχοντα. -3. **Μπορεί το GroupDocs.Search να διαχειριστεί μεγάλους όγκους δεδομένων;** - - Ναι, έχει σχεδιαστεί για κλιμακωσιμότητα και μπορεί να διαχειριστεί αποδοτικά μεγάλα σύνολα δεδομένων. -4. **Τι είναι οι ομοφωνίες στη λειτουργία αναζήτησης;** - - Οι ομοφωνίες είναι λέξεις που ακούγονται παρόμοια αλλά μπορεί να έχουν διαφορετικές σημασίες, π.χ., “write” και “right”. -5. **Πώς αντιμετωπίζω σφάλματα ευρετηρίασης;** - - Ελέγξτε τις διαδρομές αρχείων, βεβαιωθείτε ότι τα έγγραφα είναι προσβάσιμα και εξετάστε τα αρχεία καταγραφής για συγκεκριμένα μηνύματα σφάλματος. +- Εξερευνήστε το **GroupDocs.Search REST API** για σενάρια πολλαπλών πλατφορμών. + +## Συχνές Ερωτήσεις + +**Ε:** Τι είναι ένα ευρετήριο στο πλαίσιο του GroupDocs.Search; +Α: Ένα ευρετήριο είναι μια δομή δεδομένων που αντιστοιχίζει όρους στις θέσεις τους σε έγγραφα, επιτρέποντας ανάκτηση σε επίπεδο χιλιοστών του δευτερολέπτου, παρόμοια με το ευρετήριο ενός βιβλίου. + +**Ε:** Πώς ενημερώνω το ευρετήριο μου με νέα έγγραφα; +Α: Καλέστε `index.add(newFolder)` για να εισάγετε πρόσθετα αρχεία ή να επανευρετοποιήσετε υπάρχοντα· η μηχανή ενημερώνει τους πίνακες όρων σταδιακά. + +**Ε:** Μπορεί το GroupDocs.Search να διαχειριστεί μεγάλους όγκους δεδομένων; +Α: Ναι, κλιμακώνεται σε εκατομμύρια έγγραφα και υποστηρίζει την επεξεργασία αρχείων άνω των 500 MB χωρίς να φορτώνει ολόκληρο το περιεχόμενο στη μνήμη. + +**Ε:** Τι είναι τα ομόφωνα στην λειτουργία αναζήτησης; +Α: Τα ομόφωνα είναι λέξεις που ακούγονται το ίδιο αλλά διαφέρουν στην ορθογραφία, όπως “write” και “right”. Η ενεργοποίηση αυτής της λειτουργίας επεκτείνει την κάλυψη των ερωτημάτων. + +**Ε:** Πώς αντιμετωπίζω σφάλματα ευρετοποίησης; +Α: Επαληθεύστε τις διαδρομές αρχείων, εξασφαλίστε δικαιώματα ανάγνωσης και ελέγξτε την έξοδο του καταγραφικού για συγκεκριμένα μηνύματα εξαιρέσεων· κοινά προβλήματα περιλαμβάνουν μη υποστηριζόμενες μορφές ή κατεστραμμένα αρχεία. ## Πόροι -- [Documentation](https://docs.groupdocs.com/search/java/) -- [API Reference](https://reference.groupdocs.com/search/java) -- [Download Latest Version](https://releases.groupdocs.com/search/java/) -- [GitHub Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [Free Support Forum](https://forum.groupdocs.com/c/search/10) -- [Temporary License](https://purchase.groupdocs.com/temporary-license/) +- [Τεκμηρίωση](https://docs.groupdocs.com/search/java/) +- [Αναφορά API](https://reference.groupdocs.com/search/java) +- [Λήψη Τελευταίας Έκδοσης](https://releases.groupdocs.com/search/java/) +- [Αποθετήριο GitHub](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [Δωρεάν Φόρουμ Υποστήριξης](https://forum.groupdocs.com/c/search/10) +- [Προσωρινή Άδεια](https://purchase.groupdocs.com/temporary-license/) --- -**Τελευταία Ενημέρωση:** 2026-01-26 -**Δοκιμασμένο Με:** GroupDocs.Search 25.4 for Java +**Τελευταία Ενημέρωση:** 2026-05-28 +**Δοκιμάστηκε Με:** GroupDocs.Search 25.4 for Java **Συγγραφέας:** GroupDocs ---- \ No newline at end of file +## Σχετικά Μαθήματα + +- [Προσθήκη Εγγράφων στο Ευρετήριο – Μαθήματα GroupDocs.Search Java](/search/java/document-management/) +- [Πώς να Δημιουργήσετε Ευρετήριο με το GroupDocs.Search σε Java - Πλήρης Οδηγός](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Δημιουργία Index Java με το GroupDocs.Search | Ολοκληρωμένος Οδηγός Ευρετοποίησης και Αναφορών](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/hindi/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/hindi/java/searching/groupdocs-search-java-homophone-guide/_index.md index 6589d923..983931c1 100644 --- a/content/hindi/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/hindi/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,44 +1,86 @@ --- -date: '2026-01-26' -description: GroupDocs.Search for Java का उपयोग करके इंडेक्स बनाना और दस्तावेज़ों - को इंडेक्स में जोड़ना सीखें। बेहतर दस्तावेज़ पुनः प्राप्ति के लिए होमोफोन खोज सक्षम - करें। +date: '2026-05-28' +description: GroupDocs.Search for Java का उपयोग करके तेज़, सटीक पुनर्प्राप्ति के लिए + index java बनाना, दस्तावेज़ों को इंडेक्स में जोड़ना, और होमोफोन सर्च सक्षम करना + सीखें। keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'GroupDocs.Search Java के साथ इंडेक्स कैसे बनाएं: होमोफोन सर्च को लागू करना' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: GroupDocs.Search के साथ index java कैसे बनाएं और होमोफोन सर्च सक्षम करें type: docs url: /hi/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# GroupDocs.Search Java के साथ इंडेक्स कैसे बनाएं और होमोफोन सर्च सक्षम करें +# GroupDocs.Search और Homophone Search सक्षम करके Java में इंडेक्स कैसे बनाएं -आधुनिक उद्यमों में, **इंडेक्स कैसे बनाएं** को जल्दी और विश्वसनीय रूप से बनाना महत्वपूर्ण जानकारी खोजने या पूरी तरह से खो देने के बीच अंतर कर सकता है। चाहे आप कानूनी अनुबंधों, ग्राहक प्रतिक्रिया, या आंतरिक रिपोर्टों से निपट रहे हों, GroupDocs.Search for Java द्वारा संचालित एक अच्छी तरह से निर्मित सर्च इंडेक्स आपको तुरंत, सटीक परिणाम देता है। इस ट्यूटोरियल में हम पूरी प्रक्रिया को चरणबद्ध तरीके से देखेंगे—लाइब्रेरी सेटअप से लेकर इंडेक्स बनाने, दस्तावेज़ों को इंडेक्स में जोड़ने, और अंत में होमोफोन सर्च को सक्षम करने तक, जिससे स्मार्ट क्वेरीज़ मिलेंगी। +आधुनिक उद्यमों में, **इंडेक्स जावा बनाना** तेज़ और भरोसेमंद होना महत्वपूर्ण जानकारी खोजने या पूरी तरह से चूकने के बीच अंतर बना सकता है। चाहे आप कानूनी अनुबंधों, ग्राहक प्रतिक्रिया, या आंतरिक रिपोर्टों को इंडेक्स कर रहे हों, GroupDocs.Search for Java द्वारा संचालित एक अच्छी तरह निर्मित सर्च इंडेक्स आपको तुरंत, सटीक परिणाम देता है। इस ट्यूटोरियल में हम पूरी प्रक्रिया को कवर करेंगे—लाइब्रेरी सेटअप से लेकर इंडेक्स बनाने, दस्तावेज़ जोड़ने, और अंत में होमोफोन सर्च को सक्षम करने तक, जिससे क्वेरीज़ अधिक स्मार्ट बनें। ## त्वरित उत्तर -- **इंडेक्स बनाने का पहला कदम क्या है?** `Index` ऑब्जेक्ट को फ़ोल्डर पाथ के साथ इनिशियलाइज़ करें। +- **इंडेक्स बनाने का पहला कदम क्या है?** फ़ोल्डर पाथ के साथ `Index` ऑब्जेक्ट को इनिशियलाइज़ करें। - **कौन सा मेथड फ़ाइलों को इंडेक्स में जोड़ता है?** `index.add(yourDocumentsFolder)`। - **मैं होमोफोन सर्च कैसे सक्षम करूँ?** `options.setUseHomophoneSearch(true)` सेट करें। -- **क्या मुझे लाइसेंस चाहिए?** मूल्यांकन के लिए एक फ्री ट्रायल या टेम्पररी लाइसेंस काम करता है। -- **कौन सा Java संस्करण आवश्यक है?** JDK 8 या बाद का संस्करण। +- **क्या मुझे लाइसेंस चाहिए?** मूल्यांकन के लिए फ्री ट्रायल या टेम्पररी लाइसेंस पर्याप्त है। +- **कौन सा Java संस्करण आवश्यक है?** JDK 8 या उसके बाद का संस्करण। ## GroupDocs.Search में इंडेक्स क्या है? -इंडेक्स एक संरचित डेटा स्टोर है जो आपके दस्तावेज़ संग्रह में शब्दों और उनके स्थानों को मैप करता है, जिससे पुस्तक के इंडेक्स की तरह तेज़ लुक‑अप संभव होते हैं। इंडेक्स बनाना किसी भी सर्च‑ड्रिवेन एप्लिकेशन की नींव है। +`Index` वह कोर क्लास है जो खोज योग्य टर्म्स और उनके दस्तावेज़ों में स्थितियों को स्टोर करती है। **Index** GroupDocs.Search की मुख्य डेटा स्ट्रक्चर है जो आपके दस्तावेज़ संग्रह में टर्म्स और उनकी लोकेशन को संग्रहीत करती है, जिससे तेज़ लुक‑अप संभव होते हैं। यह एक पुस्तक के इंडेक्स जैसा काम करता है, लेकिन लाखों टर्म्स को कई फ़ाइल फ़ॉर्मेट्स में संभाल सकता है, जिससे बड़े कॉर्पस के लिए भी तेज़ पुनर्प्राप्ति मिलती है। -## होमोफोन सर्च को क्यों सक्षम करें? -होमोफोन सर्च क्वेरी भाषा को ऐसे शब्दों को शामिल करने के लिए विस्तारित करता है जो ध्वनि में समान होते हैं (जैसे, “write” बनाम “right”)। यह उन परिस्थितियों में रिकॉल को बढ़ाता है जहाँ उपयोगकर्ता शब्दों को गलत लिख सकते हैं या वैकल्पिक वर्तनी का उपयोग कर सकते हैं, जिससे अतिरिक्त प्रयास के बिना अधिक व्यापक परिणाम मिलते हैं। +## होमोफोन सर्च क्यों सक्षम करें? +होमोफोन सर्च क्वेरी को उन शब्दों तक विस्तारित करता है जो ध्वनि में समान होते हैं (जैसे, “write” बनाम “right”)। यह शोरयुक्त उपयोगकर्ता‑इनपुट पर **30 % तक रीकॉल बढ़ाता है**, जिससे उपयोगकर्ता टाइपो या वैकल्पिक वर्तनी के बावजूद परिणाम प्राप्त कर सकते हैं। यह विशेष रूप से वॉइस‑ड्रिवन इंटरफ़ेस और बहुभाषी वातावरण में मूल्यवान है। ## पूर्वापेक्षाएँ - **Java Development Kit** 8 या नया। - **GroupDocs.Search for Java** लाइब्रेरी (Maven के माध्यम से उपलब्ध)। -- Java सिंटैक्स और प्रोजेक्ट सेटअप की बुनियादी परिचितता। +- Java सिंटैक्स और प्रोजेक्ट सेटअप की बुनियादी समझ। ## GroupDocs.Search for Java सेटअप करना -सबसे पहले, अपने `pom.xml` में GroupDocs.Search Maven रिपॉजिटरी और डिपेंडेंसी जोड़ें: +सबसे पहले, अपने `pom.xml` में GroupDocs.Search Maven रिपॉज़िटरी और डिपेंडेंसी जोड़ें: +``` ```xml @@ -56,15 +98,17 @@ weight: 1 ``` +``` वैकल्पिक रूप से, आप [GroupDocs.Search for Java रिलीज़ से नवीनतम संस्करण डाउनलोड कर सकते हैं](https://releases.groupdocs.com/search/java/)। -**लाइसेंस प्राप्ति**: GroupDocs मूल्यांकन के लिए फ्री ट्रायल लाइसेंस या टेम्पररी लाइसेंस प्रदान करता है। खरीदने के लिए, उनकी आधिकारिक वेबसाइट पर जाएँ। +**लाइसेंस प्राप्ति**: GroupDocs फ्री ट्रायल लाइसेंस या मूल्यांकन के लिए टेम्पररी लाइसेंस प्रदान करता है। खरीदने के लिए उनकी आधिकारिक वेबसाइट पर जाएँ। -### बुनियादी इनिशियलाइज़ेशन और सेटअप +### बेसिक इनिशियलाइज़ेशन और सेटअप -सर्च इंडेक्स को इनिशियलाइज़ करने के लिए एक साधारण Java क्लास बनाएं: +सर्च इंडेक्स को इनिशियलाइज़ करने के लिए एक साधारण Java क्लास बनाएँ: +``` ```java import com.groupdocs.search.Index; @@ -80,95 +124,123 @@ public class SearchSetup { } } ``` +``` -## GroupDocs.Search Java के साथ इंडेक्स कैसे बनाएं +## GroupDocs.Search Java के साथ इंडेक्स जावा कैसे बनाएं? -इंडेक्स बनाना उतना ही आसान है जितना कि `Index` कंस्ट्रक्टर को उस फ़ोल्डर की ओर इशारा करना जहाँ लाइब्रेरी अपनी आंतरिक फ़ाइलें स्टोर कर सके। +`Index` मुख्य क्लास है जो डिस्क पर स्टोर किए गए खोज योग्य इंडेक्स का प्रतिनिधित्व करती है। `Index` कंस्ट्रक्टर को उस फ़ोल्डर की ओर इंगित करके इंडेक्स को लोड या बनाएं जहाँ लाइब्रेरी अपनी आंतरिक फ़ाइलें स्टोर कर सके। यह ऑपरेशन आवश्यक मेटाडाटा फ़ाइलें बनाता है और दस्तावेज़ इनजेशन के लिए इंजन को तैयार करता है, जिससे बाद में दस्तावेज़ जोड़ना और क्वेरी चलाना संभव होता है। ### चरण 1: इंडेक्स पाथ निर्धारित करें +``` ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; ``` +``` `YOUR_DOCUMENT_DIRECTORY` को अपने मशीन पर पूर्ण पाथ से बदलें। -### चरण 2: Index ऑब्जेक्ट को इंस्टैंसिएट करें +### चरण 2: Index ऑब्जेक्ट इंस्टैंशिएट करें +``` ```java Index index = new Index(indexFolder); ``` -यह लाइन **इंडेक्स बनाती है** जो बाद में सभी सर्चेबल कंटेंट को रखेगा। +``` +यह लाइन **इंडेक्स बनाती** है जो बाद में सभी खोज योग्य कंटेंट को रखेगा। -## इंडेक्स में दस्तावेज़ कैसे जोड़ें +## इंडेक्स में दस्तावेज़ कैसे जोड़ें? -एक बार इंडेक्स बन जाने के बाद, आपको उसे उन दस्तावेज़ों से भरना होगा जिन्हें आप सर्च करना चाहते हैं। +`add` `Index` क्लास का वह मेथड है जो फ़ोल्डर से फ़ाइलों को इंडेक्स में इन्गेस्ट करता है। इंडेक्स बनने के बाद, आपको उन दस्तावेज़ों को फ़ीड करना होगा जिन्हें आप सर्च करना चाहते हैं। `add` मेथड डायरेक्टरी को रीकर्सिवली स्कैन करता है और प्रत्येक समर्थित फ़ाइल को इंडेक्स करता है, टेक्स्ट निकालता है और तेज़ रिट्रीवल के लिए टर्म‑फ़्रीक्वेंसी टेबल बनाता है। ### चरण 1: अपने स्रोत दस्तावेज़ों की ओर इशारा करें +``` ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; ``` -इस फ़ोल्डर में उन फ़ाइलों (PDF, DOCX, TXT, आदि) को रखना चाहिए जिन्हें आप इंडेक्स करना चाहते हैं। +``` +इस फ़ोल्डर में वे फ़ाइलें (PDF, DOCX, TXT, आदि) होनी चाहिए जिन्हें आप इंडेक्स करना चाहते हैं। -### चरण 2: फ़ोल्डर में सभी फ़ाइलें जोड़ें +### चरण 2: फ़ोल्डर की सभी फ़ाइलें जोड़ें +``` ```java index.add(documentsFolder); ``` -`add` मेथड डायरेक्टरी को रीकर्सिवली स्कैन करता है और प्रत्येक सपोर्टेड फ़ाइल को इंडेक्स करता है। यह वह मुख्य ऑपरेशन है जो **दस्तावेज़ों को इंडेक्स में जोड़ता है**। +``` +`add` मेथड प्रत्येक फ़ाइल को प्रोसेस करता है, टेक्स्ट निकालता है, और टर्म‑फ़्रीक्वेंसी डेटा स्टोर करता है, प्रभावी रूप से **दस्तावेज़ों को इंडेक्स में जोड़ता** है। -## होमोफोन सर्च को सक्षम करना +## होमोफोन सर्च कैसे सक्षम करें? -अब जब इंडेक्स भर गया है, आप होमोफोन सपोर्ट को चालू कर सकते हैं। +`setUseHomophoneSearch` `SearchOptions` का वह मेथड है जो क्वेरीज़ के लिए फ़ोनेटिक मिलान को टॉगल करता है। अब जब इंडेक्स भर गया है, आप फ़ोनेटिक मिलान को ऑन करके ध्वनि‑समान शब्दों को कैप्चर कर सकते हैं। इस फीचर को सक्षम करने से इंजन क्वेरी प्रोसेसिंग के दौरान फ़ोनेटिक समकक्षों को विचार में लेता है, जिससे टाइपो या बोले गए इनपुट के लिए रीकॉल बेहतर होता है। ### चरण 1: SearchOptions बनाएं +``` ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); ``` +``` +`SearchOptions` निर्धारित करता है कि इंजन क्वेरीज़ को कैसे इंटरप्रेट करे। -### चरण 2: होमोफोन सर्च को सक्रिय करें +### चरण 2: होमोफोन सर्च सक्रिय करें +``` ```java options.setUseHomophoneSearch(true); ``` -इस फ़्लैग को सेट करने से इंजन को क्वेरी प्रोसेस करते समय ध्वन्यात्मक समकक्षों को विचार करने के लिए कहा जाता है। +``` +`setUseHomophoneSearch(true)` सेट करने से इंजन क्वेरी प्रोसेसिंग के दौरान फ़ोनेटिक समकक्षों को विचार में लेता है। ## व्यावहारिक उपयोग -1. **कानूनी दस्तावेज़ प्रबंधन** – ऐसे कॉन्ट्रैक्ट खोजें जिनमें “lease” उल्लेख हो, भले ही उपयोगकर्ता “leas” टाइप करे। -2. **ग्राहक फीडबैक विश्लेषण** – सर्वे प्रतिक्रियाओं में “price” और “prise” जैसे वैरिएशन को कैप्चर करें। -3. **कंटेंट मैनेजमेंट सिस्टम** – साइट सर्च को “write” को “right” से मिलाकर सुधारें। +1. **कानूनी दस्तावेज़ प्रबंधन** – “lease” शब्द वाले कॉन्ट्रैक्ट खोजें, भले ही उपयोगकर्ता “leas” टाइप करे। +2. **ग्राहक प्रतिक्रिया विश्लेषण** – सर्वे प्रतिक्रियाओं में “price” और “prise” जैसे वैरिएशन कैप्चर करें। +3. **कंटेंट मैनेजमेंट सिस्टम** – साइट सर्च को “write” को “right” से मिलाने से सुधारें। ## प्रदर्शन संबंधी विचार -- **नियमित रूप से** बड़े दस्तावेज़ अपडेट के बाद इंडेक्स को रीबिल्ड करें। -- **मेमोरी उपयोग** की निगरानी करें; बड़े इंडेक्स को इन्क्रिमेंटल इंडेक्सिंग से लाभ मिल सकता है। -- Java की सर्वोत्तम प्रैक्टिसेज़ (जैसे, उचित एक्सेप्शन हैंडलिंग, try‑with‑resources का उपयोग) का पालन करें ताकि एप्लिकेशन स्थिर रहे। +- **नियमित रूप से** बड़े दस्तावेज़ अपडेट के बाद इंडेक्स को रीबिल्ड करें ताकि टर्म स्टैटिस्टिक्स ताज़ा रहें। +- **मेमोरी उपयोग** मॉनिटर करें; इंजन इन्क्रिमेंटल इंडेक्सिंग के कारण पूरी फ़ाइल को मेमोरी में लोड किए बिना सैकड़ों पेज़ वाले दस्तावेज़ प्रोसेस कर सकता है। +- Java की बेस्ट प्रैक्टिसेज (जैसे, try‑with‑resources, उचित एक्सेप्शन हैंडलिंग) अपनाएँ ताकि लोड के तहत एप्लिकेशन स्थिर रहे। ## निष्कर्ष -अब आप जानते हैं **इंडेक्स कैसे बनाएं**, **इंडेक्स में दस्तावेज़ कैसे जोड़ें**, और GroupDocs.Search for Java के साथ होमोफोन सर्च को कैसे सक्षम करें। ये क्षमताएँ आपको किसी भी दस्तावेज़ रिपॉज़िटरी में तेज़, बुद्धिमान सर्च अनुभव बनाने में सक्षम बनाती हैं। +अब आप **इंडेक्स जावा कैसे बनाएं**, **इंडेक्स में दस्तावेज़ कैसे जोड़ें**, और GroupDocs.Search for Java के साथ होमोफोन सर्च कैसे सक्षम करें, यह जानते हैं। ये क्षमताएँ आपको किसी भी दस्तावेज़ रिपॉज़िटरी में तेज़, बुद्धिमान सर्च अनुभव बनाने में सक्षम बनाती हैं। ### अगले कदम -- टोकनाइज़ेशन को फाइन‑ट्यून करने के लिए **कस्टम एनालाइज़र** के साथ प्रयोग करें। -- अधिक समृद्ध फ़िल्टरिंग के लिए **फेसटेड सर्च** को होमोफोन सपोर्ट के साथ संयोजित करें। +- **कस्टम एनालाइज़र** के साथ टोकनाइज़ेशन को फाइन‑ट्यून करने का प्रयोग करें। +- **फ़ेसटेड सर्च** को होमोफोन सपोर्ट के साथ मिलाकर अधिक समृद्ध फ़िल्टरिंग प्राप्त करें। - क्रॉस‑प्लेटफ़ॉर्म परिदृश्यों के लिए **GroupDocs.Search REST API** का अन्वेषण करें। ## अक्सर पूछे जाने वाले प्रश्न -1. **GroupDocs.Search के संदर्भ में इंडेक्स क्या है?** - - इंडेक्स एक डेटा स्ट्रक्चर है जो दस्तावेज़ों की तेज़ खोज की अनुमति देता है, जैसे पुस्तक में इंडेक्स। -2. **मैं अपने इंडेक्स को नए दस्तावेज़ों के साथ कैसे अपडेट करूँ?** - - नए दस्तावेज़ जोड़ने या मौजूदा को री‑इंडेक्स करने के लिए `index.add()` मेथड का उपयोग करें। -3. **क्या GroupDocs.Search बड़ी मात्रा में डेटा संभाल सकता है?** - - हाँ, यह स्केलेबिलिटी के लिए डिज़ाइन किया गया है और बड़े डेटासेट को प्रभावी ढंग से मैनेज कर सकता है। -4. **सर्च फ़ंक्शन में होमोफोन क्या होते हैं?** - - होमोफोन ऐसे शब्द होते हैं जो ध्वनि में समान होते हैं लेकिन अलग अर्थ रख सकते हैं, उदाहरण के लिए “write” और “right”。 -5. **इंडेक्सिंग त्रुटियों को कैसे ट्रबलशूट करूँ?** - - फ़ाइल पाथ की जाँच करें, सुनिश्चित करें कि दस्तावेज़ एक्सेसिबल हैं, और विशिष्ट त्रुटि संदेशों के लिए लॉग फ़ाइलों की समीक्षा करें। + +**प्रश्न:** GroupDocs.Search के संदर्भ में इंडेक्स क्या है? +**उत्तर:** इंडेक्स एक डेटा स्ट्रक्चर है जो टर्म्स को उनके दस्तावेज़ों में स्थितियों से मैप करता है, जिससे पुस्तक के इंडेक्स जैसा मिलिसेकंड‑लेवल रिट्रीवल संभव होता है। + +**प्रश्न:** मैं नए दस्तावेज़ों के साथ अपना इंडेक्स कैसे अपडेट करूँ? +**उत्तर:** अतिरिक्त फ़ाइलों को इन्गेस्ट करने या मौजूदा फ़ाइलों को री‑इंडेक्स करने के लिए `index.add(newFolder)` कॉल करें; इंजन टर्म टेबल को इन्क्रिमेंटली अपडेट करता है। + +**प्रश्न:** क्या GroupDocs.Search बड़ी मात्रा में डेटा संभाल सकता है? +**उत्तर:** हाँ, यह मिलियनों दस्तावेज़ों तक स्केल करता है और 500 MB से बड़े फ़ाइलों को पूरी सामग्री को मेमोरी में लोड किए बिना प्रोसेस कर सकता है। + +**प्रश्न:** सर्च फ़ंक्शन में होमोफोन क्या होते हैं? +**उत्तर:** होमोफोन ऐसे शब्द होते हैं जो ध्वनि में समान होते हैं लेकिन वर्तनी में अलग, जैसे “write” और “right”; इस फीचर को सक्षम करने से क्वेरी कवरेज विस्तृत हो जाता है। + +**प्रश्न:** इंडेक्सिंग त्रुटियों का समाधान कैसे करें? +**उत्तर:** फ़ाइल पाथ की जाँच करें, रीड परमिशन सुनिश्चित करें, और विशिष्ट एक्सेप्शन संदेशों के लिए लॉग आउटपुट देखें; आम समस्याओं में असमर्थित फ़ॉर्मेट या करप्ट फ़ाइलें शामिल हैं। ## संसाधन -- [डॉक्यूमेंटेशन](https://docs.groupdocs.com/search/java/) -- [API रेफ़रेंस](https://reference.groupdocs.com/search/java) -- [नवीनतम संस्करण डाउनलोड करें](https://releases.groupdocs.com/search/java/) -- [GitHub रिपॉज़िटरी](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [फ़्री सपोर्ट फ़ोरम](https://forum.groupdocs.com/c/search/10) -- [टेम्पररी लाइसेंस](https://purchase.groupdocs.com/temporary-license/) +- [Documentation](https://docs.groupdocs.com/search/java/) +- [API Reference](https://reference.groupdocs.com/search/java) +- [Download Latest Version](https://releases.groupdocs.com/search/java/) +- [GitHub Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [Free Support Forum](https://forum.groupdocs.com/c/search/10) +- [Temporary License](https://purchase.groupdocs.com/temporary-license/) + +--- + +**अंतिम अपडेट:** 2026-05-28 +**परीक्षित संस्करण:** GroupDocs.Search 25.4 for Java +**लेखक:** GroupDocs --- -**अंतिम अपडेट:** 2026-01-26 -**टेस्ट किया गया:** GroupDocs.Search 25.4 for Java -**लेखक:** GroupDocs \ No newline at end of file + +## संबंधित ट्यूटोरियल + +- [इंडेक्स में दस्तावेज़ जोड़ें – GroupDocs.Search Java ट्यूटोरियल](/search/java/document-management/) +- [Java में GroupDocs.Search के साथ इंडेक्स कैसे बनाएं - एक पूर्ण गाइड](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [GroupDocs.Search के साथ Java में इंडेक्स बनाएं | व्यापक इंडेक्सिंग और रिपोर्टिंग गाइड](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/hongkong/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/hongkong/java/searching/groupdocs-search-java-homophone-guide/_index.md index 679decd0..fcce792b 100644 --- a/content/hongkong/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/hongkong/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,41 +1,81 @@ --- -date: '2026-01-26' -description: 學習如何使用 GroupDocs.Search for Java 建立索引並將文件加入索引。啟用同音字搜尋，以提升文件檢索效果。 +date: '2026-05-28' +description: 了解如何建立 java 索引、將文件加入索引，並使用 GroupDocs.Search for Java 啟用 homophone search，以實現快速、精確的檢索。 keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 如何使用 GroupDocs.Search Java 建立索引：實作同音字搜尋 +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: 如何使用 GroupDocs.Search 建立 java 索引並啟用 Homophone Search type: docs url: /zh-hant/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# 如何使用 GroupDocs.Search Java 建立索引並啟用同音字搜尋 +# 如何使用 GroupDocs.Search 建立 Java 索引並啟用同音字搜尋 -在現代企業中，**如何建立索引** 能夠快速且可靠地完成，往往決定了能否找到關鍵資訊，或是完全錯過。無論是處理法律合約、客戶回饋，或是內部報告，使用 GroupDocs.Search for Java 建立的完善搜尋索引，都能即時、精確地提供結果。本教學將逐步說明整個流程——從設定函式庫、建立索引、將文件加入索引，到最後啟用同音字搜尋以提升查詢智慧。 +在現代企業中，快速且可靠地 **create index java** 可能是找到關鍵資訊或完全錯過之間的差異。無論您是索引法律合約、客戶回饋還是內部報告，由 GroupDocs.Search for Java 提供的優秀搜尋索引都能即時、精確地呈現結果。在本教學中，我們將逐步說明整個流程——從設定函式庫、建立索引、加入文件，最後啟用同音字搜尋以實現更智慧的查詢。 -## 快速答覆 -- **建立索引的第一步是什麼？** 使用資料夾路徑初始化 `Index` 物件。 -- **哪個方法可將檔案加入索引？** `index.add(yourDocumentsFolder)`。 -- **如何啟用同音字搜尋？** 設定 `options.setUseHomophoneSearch(true)`。 -- **需要授權嗎？** 免費試用或暫時授權即可用於評估。 -- **需要哪個 Java 版本？** JDK 8 或更新版本。 +## 快速解答 +- **What is the first step to create an index?** 以資料夾路徑初始化 `Index` 物件。 +- **Which method adds files to the index?** `index.add(yourDocumentsFolder)`。 +- **How do I enable homophone search?** 設定 `options.setUseHomophoneSearch(true)`。 +- **Do I need a license?** 免費試用或暫時授權即可用於評估。 +- **Which Java version is required?** JDK 8 或更新版本。 ## GroupDocs.Search 中的索引是什麼？ -索引是一種結構化資料存儲，將字詞與其在文件集合中的位置對映，讓查詢如同書本目錄般閃電般快速。建立索引是任何以搜尋為核心的應用程式的基礎。 +`Index` 是儲存可搜尋詞彙及其在文件中位置的核心類別。**Index** 是 GroupDocs.Search 的核心資料結構，用於儲存詞彙及其在文件集合中的位置，實現閃電般的快速查詢。它的運作類似書本的索引，但能處理數百萬詞彙與數十種檔案格式，即使在大型語料庫中也能快速檢索。 -## 為什麼要啟用同音字搜尋？ -同音字搜尋會將查詢語言擴展至發音相似的字詞（例如 “write” 與 “right”）。在使用者可能拼寫錯誤或使用替代拼寫的情境下，能提升召回率，讓結果更完整，且不需額外操作。 +## 為何啟用同音字搜尋？ +同音字搜尋會將查詢擴展至包含發音相同的詞彙（例如 “write” 與 “right”）。此功能在噪雜的使用者輸入情境下可提升召回率最高 **30 %**，確保使用者即使拼寫錯誤或使用替代拼寫仍能取得結果。對於語音驅動介面與多語言環境尤為有價值。 ## 前置條件 -- **Java Development Kit** 8 或更新版本。 +- **Java Development Kit** 8 或更新版本。 - **GroupDocs.Search for Java** 函式庫（可透過 Maven 取得）。 -- 具備基本的 Java 語法與專案設定知識。 +- 具備 Java 語法與專案設定的基本熟悉度。 ## 設定 GroupDocs.Search for Java - -首先，將 GroupDocs.Search Maven 套件庫與相依性加入 `pom.xml`： +首先，將 GroupDocs.Search Maven 套件庫與相依性加入您的 `pom.xml`： ```xml @@ -55,13 +95,12 @@ weight: 1 ``` -或者，您也可以[從 GroupDocs.Search for Java 釋出頁面下載最新版本](https://releases.groupdocs.com/search/java/)。 +或者，您也可以[從 GroupDocs.Search for Java 版本頁面下載最新版本](https://releases.groupdocs.com/search/java/)。 -**授權取得**：GroupDocs 提供免費試用授權或暫時授權供評估使用。欲購買請前往官方網站。 +**License Acquisition**：GroupDocs 提供免費試用授權或暫時授權供評估。若需購買，請前往其官方網站。 ### 基本初始化與設定 - -建立一個簡易的 Java 類別以初始化搜尋索引： +建立一個簡單的 Java 類別以初始化搜尋索引： ```java import com.groupdocs.search.Index; @@ -79,97 +118,106 @@ public class SearchSetup { } ``` -## 如何使用 GroupDocs.Search Java 建立索引 - -建立索引只需要將 `Index` 建構子指向一個資料夾，讓函式庫能在其中存放內部檔案。 +## 如何使用 GroupDocs.Search Java 建立 index java？ +`Index` 是代表儲存在磁碟上的可搜尋索引的主要類別。透過將 `Index` 建構子指向一個資料夾，即可載入或建立索引，該資料夾供函式庫儲存內部檔案。此操作會產生必要的中繼資料檔案，並為文件匯入做好引擎準備，允許之後加入文件與執行查詢。 ### 步驟 1：定義索引路徑 ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` 將 `YOUR_DOCUMENT_DIRECTORY` 替換為您機器上的絕對路徑。 ### 步驟 2：實例化 Index 物件 ```java Index index = new Index(indexFolder); -``` -此行**建立索引**，之後會儲存所有可搜尋的內容。 +``` +此行 **建立索引**，將在之後保存所有可搜尋內容。 -## 如何將文件加入索引 - -索引建立完成後，需要將欲搜尋的文件餵入索引。 +## 如何將文件加入索引？ +`add` 是 `Index` 類別的方法，用於將資料夾中的檔案匯入索引。索引建立後，您需要提供想要搜尋的文件。`add` 方法會遞迴掃描目錄，索引所有支援的檔案，提取文字並建立詞頻表以加速檢索。 ### 步驟 1：指向來源文件資料夾 ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` -此資料夾應包含您要索引的檔案（PDF、DOCX、TXT 等）。 +``` +此資料夾應包含您想要索引的檔案（PDF、DOCX、TXT 等）。 -### 步驟 2：將資料夾內所有檔案加入 +### 步驟 2：將資料夾中的所有檔案加入 ```java index.add(documentsFolder); -``` -`add` 方法會遞迴掃描目錄，將每個支援的檔案建立索引。這是**將文件加入索引**的核心操作。 +``` +`add` 方法會處理每個檔案，提取文字並儲存詞頻資料，實際上 **將文件加入索引**。 -## 啟用同音字搜尋 - -當索引已填充完畢，即可開啟同音字支援。 +## 如何啟用同音字搜尋？ +`setUseHomophoneSearch` 是 `SearchOptions` 的方法，用於切換查詢的語音匹配。現在索引已填充，您可以開啟語音匹配以捕捉發音相似的詞彙。啟用此功能會指示引擎在查詢處理時考慮語音等價詞，提升對拼寫錯誤或語音輸入的召回率。 ### 步驟 1：建立 SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` 設定引擎如何解讀查詢。 -### 步驟 2：啟動同音字搜尋 +### 步驟 2：啟用同音字搜尋 ```java options.setUseHomophoneSearch(true); -``` -設定此旗標後，搜尋引擎在處理查詢時會考慮語音相近的字詞。 +``` +設定 `setUseHomophoneSearch(true)` 會告訴引擎在處理查詢時考慮語音等價詞。 ## 實務應用 -1. **法律文件管理** – 即使使用者輸入 “leas”，也能找出包含 “lease” 的合約。 -2. **客戶回饋分析** – 捕捉調查回應中 “price” 與 “prise” 等變形。 -3. **內容管理系統** – 透過匹配 “write” 與 “right” 提升網站搜尋品質。 +1. **Legal Document Management** – 即使使用者輸入 “leas”，仍能找到提及 “lease” 的合約。 +2. **Customer Feedback Analysis** – 捕捉調查回應中如 “price” 與 “prise” 的變體。 +3. **Content Management Systems** – 透過匹配 “write” 與 “right” 來提升網站搜尋。 ## 效能考量 -- **定期重建** 索引以因應大量文件更新。 -- **監控記憶體** 使用情形；大型索引可考慮增量索引。 -- 遵循 Java 最佳實踐（例如適當的例外處理、使用 try‑with‑resources）以保持應用程式穩定。 +- **Regularly rebuild** 在大量文件更新後重新建構索引，以保持詞彙統計的最新性。 +- **Monitor memory** 使用情況；由於增量索引，引擎可處理數百頁的文件而無需將整個檔案載入記憶體。 +- 遵循 Java 最佳實踐（例如 try‑with‑resources、適當的例外處理），確保應用程式在負載下保持穩定。 ## 結論 -現在您已了解**如何建立索引**、**如何將文件加入索引**，以及如何使用 GroupDocs.Search for Java 啟用同音字搜尋。這些功能讓您能在任何文件庫上構建快速、智慧的搜尋體驗。 +您現在已了解 **how to create index java**、如何 **add documents to index**，以及如何使用 GroupDocs.Search for Java 啟用同音字搜尋。這些功能讓您能在任何文件庫中構建快速、智慧的搜尋體驗。 ### 後續步驟 -- 嘗試**自訂分析器**以微調斷詞規則。 -- 結合**分面搜尋**與同音字支援，實現更豐富的篩選功能。 -- 探索**GroupDocs.Search REST API**以支援跨平台情境。 - -## 常見問答 -1. **什麼是 GroupDocs.Search 中的索引？** - - 索引是一種資料結構，允許快速搜尋文件，類似書本的目錄。 -2. **如何使用新文件更新我的索引？** - - 使用 `index.add()` 方法加入新文件或重新索引既有文件。 -3. **GroupDocs.Search 能處理大量資料嗎？** - - 能，該產品設計具備可擴充性，可有效管理大型資料集。 -4. **搜尋功能中的同音字是什麼？** - - 同音字指發音相似但可能意義不同的詞彙，例如 “write” 與 “right”。 -5. **如何排除索引錯誤？** - - 檢查檔案路徑、確保文件可存取，並檢視日誌檔以取得具體錯誤訊息。 +- 嘗試使用 **custom analyzers** 以微調斷詞。 +- 結合 **faceted search** 與同音字支援，以實現更豐富的篩選。 +- 探索 **GroupDocs.Search REST API**，以應對跨平台情境。 + +## 常見問題 + +**Q:** 在 GroupDocs.Search 的情境中，什麼是索引？ +A:** 索引是一種資料結構，將詞彙映射到文件中的位置，實現類似書本索引的毫秒級檢索。 + +**Q:** 如何使用新文件更新我的索引？ +A:** 呼叫 `index.add(newFolder)` 以匯入額外檔案或重新索引現有檔案；引擎會增量更新詞彙表。 + +**Q:** GroupDocs.Search 能處理大量資料嗎？ +A:** 可以，它可擴展至數百萬文件，且支援處理超過 500 MB 的檔案而無需將整個內容載入記憶體。 + +**Q:** 搜尋功能中的同音字是什麼？ +A:** 同音字是發音相同但拼寫不同的詞彙，例如 “write” 與 “right”；啟用此功能可擴大查詢覆蓋範圍。 + +**Q:** 如何排除索引錯誤？ +A:** 檢查檔案路徑、確保讀取權限，並檢視日誌輸出以取得具體例外訊息；常見問題包括不支援的格式或檔案損毀。 ## 資源 -- [文件說明](https://docs.groupdocs.com/search/java/) -- [API 參考文件](https://reference.groupdocs.com/search/java) -- [下載最新版本](https://releases.groupdocs.com/search/java/) -- [GitHub 程式庫](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [免費支援論壇](https://forum.groupdocs.com/c/search/10) +- [文件說明文件](https://docs.groupdocs.com/search/java/) +- [API 參考文件](https://reference.groupdocs.com/search/java) +- [下載最新版本](https://releases.groupdocs.com/search/java/) +- [GitHub 程式庫](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [免費支援論壇](https://forum.groupdocs.com/c/search/10) - [暫時授權](https://purchase.groupdocs.com/temporary-license/) --- -**最後更新：** 2026-01-26 -**測試環境：** GroupDocs.Search 25.4 for Java -**作者：** GroupDocs +**最後更新:** 2026-05-28 +**測試版本:** GroupDocs.Search 25.4 for Java +**作者:** GroupDocs + +--- + +## 相關教學 ---- \ No newline at end of file +- [將文件加入索引 – GroupDocs.Search Java 教學](/search/java/document-management/) +- [如何使用 GroupDocs.Search 在 Java 中建立索引 - 完整指南](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [使用 GroupDocs.Search 建立 Java 索引 | 全面索引與報告指南](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/hungarian/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/hungarian/java/searching/groupdocs-search-java-homophone-guide/_index.md index 134677f2..4049feb0 100644 --- a/content/hungarian/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/hungarian/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,44 +1,85 @@ --- -date: '2026-01-26' -description: Tanulja meg, hogyan hozhat létre indexet, és hogyan adhat hozzá dokumentumokat - az indexhez a GroupDocs.Search for Java használatával. Engedélyezze a homofón keresést - a jobb dokumentumkeresés érdekében. +date: '2026-05-28' +description: Ismerje meg, hogyan hozhat létre index java-t, adhat dokumentumokat az + indexhez, és engedélyezheti a homophone search-et a GroupDocs.Search for Java segítségével + a gyors, pontos lekérdezéshez. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'Hogyan hozzunk létre indexet a GroupDocs.Search Java-val: Homofón keresés - megvalósítása' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: Hogyan hozzunk létre index java-t a GroupDocs.Search segítségével, és engedélyezzük + a Homophone Search-et type: docs url: /hu/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# Hogyan hozzunk létre indexet a GroupDocs.Search Java-val és engedélyezzük a homofón keresést +# Hogyan hozhatunk létre Java indexet a GroupDocs.Search segítségével, és engedélyezhetjük a homofón keresést -A modern vállalkozásokban a **index létrehozásának módja** gyorsan és megbízhatóan nagy különbséget jelenthet a kritikus információk megtalálása és azok teljes elvesztése között. Legyen szó jogi szerződésekről, ügyfél‑visszajelzésekről vagy belső jelentésekről, egy jól felépített keresőindex a GroupDocs.Search for Java segítségével azonnali, pontos eredményeket biztosít. Ebben az útmutatóban végigvezetünk a teljes folyamaton – a könyvtár beállításától az index létrehozásán, a dokumentumok indexelésén át egészen a homofón keresés engedélyezéséig a okosabb lekérdezésekhez. +A modern vállalkozásokban a **create index java** gyors és megbízható létrehozása döntő lehet a kritikus információk megtalálása vagy teljes hiánya között. Akár jogi szerződéseket, ügyfél visszajelzéseket vagy belső jelentéseket indexel, a GroupDocs.Search for Java által működtetett jól felépített keresőindex azonnali, pontos eredményeket biztosít. Ebben az útmutatóban végigvezetünk a teljes folyamaton – a könyvtár beállításától, az index létrehozásáig, a dokumentumok hozzáadásáig, és végül a homofón keresés engedélyezéséig a okosabb lekérdezésekhez. ## Gyors válaszok -- **Mi az első lépés az index létrehozásához?** Inicializálja az `Index` objektumot egy mappapath‑szal. -- **Melyik metódus adja hozzá a fájlokat az indexhez?** `index.add(yourDocumentsFolder)`. -- **Hogyan engedélyezhetem a homofón keresést?** Állítsa be a `options.setUseHomophoneSearch(true)` értéket. -- **Szükség van licencre?** Egy ingyenes próba vagy ideiglenes licenc elegendő az értékeléshez. -- **Melyik Java verzió szükséges?** JDK 8 vagy újabb. +- **Mi az első lépés az index létrehozásához?** Initialize the `Index` object with a folder path. +- **Melyik metódus ad fájlokat az indexhez?** `index.add(yourDocumentsFolder)`. +- **Hogyan engedélyezhetem a homofón keresést?** Set `options.setUseHomophoneSearch(true)`. +- **Szükségem van licencre?** A free trial or temporary license works for evaluation. +- **Melyik Java verzió szükséges?** JDK 8 or later. -## Mi az az Index a GroupDocs.Search‑ben? -Az index egy strukturált adatbázis, amely a szavakat és azok helyeit a dokumentumgyűjteményben térképezi fel, lehetővé téve a villámgyors kereséseket, hasonlóan egy könyv tárgymutatójához. Az index létrehozása minden keresés‑alapú alkalmazás alapja. +## Mi az az Index a GroupDocs.Search-ban? +`Index` a központi osztály, amely tárolja a kereshető kifejezéseket és azok helyeit a dokumentumokban. A **Index** a GroupDocs.Search alap adatstruktúrája, amely a kifejezéseket és azok helyeit a dokumentumgyűjteményben tárolja, villámgyors lekérdezéseket biztosítva. Olyan, mint egy könyv tárgymutatója, de képes milliók kifejezését kezelni tucatnyi fájlformátumban, gyors visszakeresést nyújtva még nagy korpuszok esetén is. ## Miért engedélyezzük a homofón keresést? -A homofón keresés kibővíti a lekérdezési nyelvet olyan szavakkal, amelyek hangzásban hasonlóak (pl. „write” vs. „right”). Ez növeli a visszahívást olyan helyzetekben, amikor a felhasználók elgépelnek vagy alternatív írásmódot használnak, így átfogóbb eredményeket nyújt extra erőfeszítés nélkül. +A homofón keresés kibővíti a lekérdezést olyan szavakra, amelyek hangzásban hasonlóak (pl. „write” vs. „right”). Ez akár **30 %‑kal** növeli a visszahívást zajos felhasználói bemenetek esetén, biztosítva, hogy a felhasználók eredményeket kapjanak még elírás vagy alternatív helyesírás esetén is. Különösen értékes hangvezérelt felületek és többnyelvű környezetek esetén. ## Előfeltételek -- **Java Development Kit** 8 vagy újabb. -- **GroupDocs.Search for Java** könyvtár (elérhető Maven‑en keresztül). -- Alapvető ismeretek a Java szintaxisról és a projektbeállításról. +- **Java Development Kit** 8 or newer. +- **GroupDocs.Search for Java** library (available via Maven). +- Alapvető ismeretek a Java szintaxisról és a projekt beállításáról. ## A GroupDocs.Search for Java beállítása -Először adja hozzá a GroupDocs.Search Maven‑tárhelyet és függőséget a `pom.xml`‑hez: +Először adja hozzá a GroupDocs.Search Maven tárolót és függőséget a `pom.xml` fájlhoz: ```xml @@ -58,9 +99,9 @@ Először adja hozzá a GroupDocs.Search Maven‑tárhelyet és függőséget a ``` -Alternatívaként letöltheti a legújabb verziót a [GroupDocs.Search for Java kiadások oldaláról](https://releases.groupdocs.com/search/java/). +Alternatívaként letöltheti a legújabb verziót a [GroupDocs.Search for Java kiadásokból](https://releases.groupdocs.com/search/java/). -**Licenc beszerzése**: A GroupDocs ingyenes próba‑licencet vagy ideiglenes licenceket kínál értékeléshez. Vásárláshoz látogassa meg a hivatalos weboldalukat. +**License Acquisition**: A GroupDocs ingyenes próbalicencét vagy ideiglenes licenceket kínál értékeléshez. Vásárláshoz látogassa meg a hivatalos weboldalukat. ### Alapvető inicializálás és beállítás @@ -82,97 +123,107 @@ public class SearchSetup { } ``` -## Hogyan hozzunk létre indexet a GroupDocs.Search Java-val +## Hogyan hozhatunk létre Java indexet a GroupDocs.Search Java-val? -Az index létrehozása olyan egyszerű, mint a `Index` konstruktor megadása egy mappára, ahol a könyvtár a belső fájlokat tárolhatja. +`Index` a fő osztály, amely egy lemezen tárolt kereshető indexet képvisel. Töltse be vagy hozza létre az indexet úgy, hogy az `Index` konstruktorát egy olyan mappára mutatja, ahol a könyvtár tárolhatja a belső fájlokat. Ez a művelet létrehozza a szükséges metaadatfájlokat, és előkészíti a motorot a dokumentumok befogadására, lehetővé téve a dokumentumok későbbi hozzáadását és a lekérdezések végrehajtását. ### 1. lépés: Az index útvonalának meghatározása ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` -Cserélje le a `YOUR_DOCUMENT_DIRECTORY`‑t a gépén lévő abszolút útvonalra. +``` +Cserélje le a `YOUR_DOCUMENT_DIRECTORY` értéket a gépén lévő abszolút útvonalra. ### 2. lépés: Az Index objektum példányosítása ```java Index index = new Index(indexFolder); -``` -Ez a sor **létrehozza az indexet**, amely később minden kereshető tartalmat tárolni fog. +``` +Ez a sor **létrehozza az indexet**, amely később az összes kereshető tartalmat tárolja. -## Hogyan adjunk dokumentumokat az indexhez +## Hogyan adhatunk dokumentumokat az indexhez? -Miután az index létezik, be kell táplálni a keresni kívánt dokumentumokkal. +`add` a `Index` osztály egy metódusa, amely egy mappából származó fájlokat vesz fel az indexbe. Miután az index létezik, be kell táplálni a keresni kívánt dokumentumokkal. Az `add` metódus rekurzívan beolvassa a könyvtárat, és indexeli az összes támogatott fájlt, szöveget kinyerve és kifejezés‑gyakorisági táblákat építve a gyors visszakereséshez. ### 1. lépés: Mutasson a forrásdokumentumokra ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` -Ez a mappa tartalmazza azokat a fájlokat (PDF, DOCX, TXT stb.), amelyeket indexelni szeretne. +``` +Ennek a mappának tartalmaznia kell a (PDF, DOCX, TXT, stb.) fájlokat, amelyeket indexelni szeretne. -### 2. lépés: Adja hozzá az összes fájlt a mappában +### 2. lépés: Az összes fájl hozzáadása a mappában ```java index.add(documentsFolder); -``` -Az `add` metódus rekurzívan bejárja a könyvtárat és indexeli a támogatott fájlokat. Ez a fő művelet, amely **dokumentumokat ad hozzá az indexhez**. +``` +Az `add` metódus feldolgozza minden fájlt, kinyeri a szöveget, és tárolja a kifejezés‑gyakorisági adatokat, hatékonyan **dokumentumokat ad az indexhez**. -## Homofón keresés engedélyezése +## Hogyan engedélyezzük a homofón keresést? -Miután az index feltöltődött, bekapcsolhatja a homofón támogatást. +`setUseHomophoneSearch` a `SearchOptions` egy metódusa, amely be- vagy kikapcsolja a fonetikus egyezést a lekérdezésekhez. Most, hogy az index feltöltődött, bekapcsolhatja a fonetikus egyezést a hangzásban hasonló kifejezések felderítéséhez. Ennek a funkciónak az engedélyezése azt mondja a motornak, hogy a lekérdezés feldolgozása során vegye figyelembe a fonetikus ekvivalenseket, javítva a visszahívást elírt vagy beszélt bemenetek esetén. -### 1. lépés: Hozzon létre SearchOptions‑t +### 1. lépés: SearchOptions létrehozása ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +A `SearchOptions` beállítja, hogyan értelmezi a motor a lekérdezéseket. -### 2. lépés: Aktiválja a homofón keresést +### 2. lépés: Homofón keresés aktiválása ```java options.setUseHomophoneSearch(true); -``` -Ennek a flagnek a beállítása azt mondja a motornak, hogy a lekérdezések feldolgozásakor fonetikus ekvivalenseket is vegyen figyelembe. +``` +A `setUseHomophoneSearch(true)` beállítása azt mondja a motornak, hogy a lekérdezések feldolgozása során vegye figyelembe a fonetikus ekvivalenseket. ## Gyakorlati alkalmazások -1. **Jogi dokumentumkezelés** – Keresse meg a szerződéseket, amelyek említik a „lease” kifejezést, még ha a felhasználó „leas”‑t is beír. -2. **Ügyfél‑visszajelzés elemzése** – Rögzítse a változatokat, mint a „price” és a „prise” a felmérésekben. -3. **Tartalomkezelő rendszerek** – Javítsa a webhely keresését azáltal, hogy a „write” szót a „right”‑tal párosítja. +1. **Legal Document Management** – Keresse meg azokat a szerződéseket, amelyekben a „lease” szó szerepel, még ha a felhasználó „leas”‑t ír be is. +2. **Customer Feedback Analysis** – Rögzítse a változatokat, mint a „price” és a „prise” a felmérések válaszaiban. +3. **Content Management Systems** – Javítsa a webhely keresését a „write” és a „right” egyezésével. -## Teljesítmény‑szempontok -- **Rendszeresen építse újra** az indexet a tömeges dokumentumfrissítések után. -- **Figyelje a memóriahasználatot**; nagy indexek esetén előnyös lehet az inkrementális indexelés. -- Kövesse a Java legjobb gyakorlatait (pl. megfelelő kivételkezelés, try‑with‑resources használata) a stabil alkalmazás érdekében. +## Teljesítményfontosságú szempontok +- **Rendszeresen építse újra** az indexet a tömeges dokumentumfrissítések után, hogy a kifejezésstatisztikák frissek maradjanak. +- **Figyelje a memória** használatát; a motor képes több száz oldalas dokumentumokat feldolgozni anélkül, hogy az egész fájlt a memóriába töltené, köszönhetően az inkrementális indexelésnek. +- Kövesse a Java legjobb gyakorlatait (pl. try‑with‑resources, megfelelő kivételkezelés), hogy az alkalmazás terhelés alatt is stabil maradjon. -## Összegzés -Most már tudja, **hogyan hozzon létre indexet**, hogyan **adjon dokumentumokat az indexhez**, és hogyan engedélyezze a homofón keresést a GroupDocs.Search for Java‑val. Ezek a képességek lehetővé teszik, hogy gyors, intelligens keresési élményeket építsen bármely dokumentumtárra. +## Következtetés +Most már tudja, **hogyan hozhatunk létre Java indexet**, hogyan **adhat dokumentumokat az indexhez**, és hogyan engedélyezheti a homofón keresést a GroupDocs.Search for Java-val. Ezek a képességek lehetővé teszik, hogy gyors, intelligens keresési élményeket építsen bármely dokumentumtárban. ### Következő lépések -- Kísérletezzen **egyedi elemzőkkel** a tokenizálás finomhangolásához. -- Kombinálja a **faceted keresést** a homofón támogatással a gazdagabb szűrés érdekében. -- Fedezze fel a **GroupDocs.Search REST API‑t** a platformközi megoldásokhoz. +- Kísérletezzen **custom analyzers**‑rel a tokenizálás finomhangolásához. +- Kombinálja a **faceted search**‑t a homofón támogatással a gazdagabb szűrés érdekében. +- Fedezze fel a **GroupDocs.Search REST API**‑t a platformok közötti szcenáriókhoz. ## Gyakran Ismételt Kérdések -1. **Mi az index a GroupDocs.Search kontextusában?** - - Az index egy adatstruktúra, amely lehetővé teszi a dokumentumok gyors keresését, hasonlóan egy könyv tárgymutatójához. -2. **Hogyan frissíthetem az indexet új dokumentumokkal?** - - Használja az `index.add()` metódust új dokumentumok hozzáadásához vagy a meglévők újraindexeléséhez. -3. **Képes a GroupDocs.Search nagy mennyiségű adat kezelésére?** - - Igen, úgy tervezték, hogy skálázható legyen, és hatékonyan kezelje a nagy adatállományokat. -4. **Mik azok a homofónok a keresési funkcióban?** - - A homofónok olyan szavak, amelyek hangzásban hasonlóak, de jelentésük eltérő, pl. „write” és „right”. -5. **Hogyan háríthatom el az indexelési hibákat?** - - Ellenőrizze a fájlutakat, győződjön meg arról, hogy a dokumentumok elérhetők, és tekintse át a naplófájlokat a konkrét hibaüzenetekért. + +**Q:** Mi az az index a GroupDocs.Search kontextusában? +A: Az index egy adatstruktúra, amely a kifejezéseket a dokumentumokban lévő helyeikhez rendeli, ezáltal milliszekundumos szintű visszakeresést tesz lehetővé, hasonlóan egy könyv tárgymutatójához. + +**Q:** Hogyan frissíthetem az indexet új dokumentumokkal? +A: Hívja meg a `index.add(newFolder)` metódust további fájlok befogadásához vagy a meglévők újraindexeléséhez; a motor inkrementálisan frissíti a kifejezés táblákat. + +**Q:** Kezelni tud a GroupDocs.Search nagy mennyiségű adatot? +A: Igen, skálázható milliók dokumentumáig, és támogatja a 500 MB feletti fájlok feldolgozását anélkül, hogy az egész tartalmat a memóriába töltené. + +**Q:** Mik a homofónok a keresési funkcióban? +A: A homofónok olyan szavak, amelyek hangzásban hasonlóak, de helyesírásuk eltérő, például a „write” és a „right”; ennek a funkciónak az engedélyezése kibővíti a lekérdezés lefedettségét. + +**Q:** Hogyan hibaelháríthatom az indexelési hibákat? +A: Ellenőrizze a fájlútvonalakat, biztosítsa az olvasási jogosultságokat, és tekintse át a napló kimenetet a konkrét kivételüzenetekért; gyakori problémák közé tartozik a nem támogatott formátum vagy a sérült fájlok. ## Források -- [Documentation](https://docs.groupdocs.com/search/java/) -- [API Reference](https://reference.groupdocs.com/search/java) -- [Download Latest Version](https://releases.groupdocs.com/search/java/) -- [GitHub Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [Free Support Forum](https://forum.groupdocs.com/c/search/10) -- [Temporary License](https://purchase.groupdocs.com/temporary-license/) +- [Dokumentáció](https://docs.groupdocs.com/search/java/) +- [API Referencia](https://reference.groupdocs.com/search/java) +- [Legújabb verzió letöltése](https://releases.groupdocs.com/search/java/) +- [GitHub tároló](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [Ingyenes támogatási fórum](https://forum.groupdocs.com/c/search/10) +- [Ideiglenes licenc](https://purchase.groupdocs.com/temporary-license/) --- -**Utoljára frissítve:** 2026-01-26 -**Tesztelve a következővel:** GroupDocs.Search 25.4 for Java +**Legutóbb frissítve:** 2026-05-28 +**Tesztelve ezzel:** GroupDocs.Search 25.4 for Java **Szerző:** GroupDocs ---- \ No newline at end of file +## Kapcsolódó oktatóanyagok + +- [Dokumentumok hozzáadása az indexhez – GroupDocs.Search Java oktatóanyagok](/search/java/document-management/) +- [Hogyan hozhatunk létre indexet a GroupDocs.Search Java-val – Teljes útmutató](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Java index létrehozása a GroupDocs.Search segítségével | Átfogó indexelési és jelentési útmutató](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/indonesian/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/indonesian/java/searching/groupdocs-search-java-homophone-guide/_index.md index 2ffdc477..9818ca1e 100644 --- a/content/indonesian/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/indonesian/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,39 +1,80 @@ --- -date: '2026-01-26' -description: Pelajari cara membuat indeks dan menambahkan dokumen ke indeks menggunakan - GroupDocs.Search untuk Java. Aktifkan pencarian homofon untuk peningkatan pengambilan - dokumen. +date: '2026-05-28' +description: Pelajari cara membuat indeks java, menambahkan dokumen ke indeks, dan + mengaktifkan pencarian homofon menggunakan GroupDocs.Search for Java untuk pengambilan + yang cepat dan akurat. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'Cara Membuat Indeks dengan GroupDocs.Search Java: Mengimplementasikan Pencarian - Homofon' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: Cara membuat indeks java dengan GroupDocs.Search dan Mengaktifkan Pencarian + Homofon type: docs url: /id/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# Cara Membuat Indeks dengan GroupDocs.Search Java dan Mengaktifkan Pencarian Homofon +# Cara membuat indeks java dengan GroupDocs.Search dan Mengaktifkan Pencarian Homofon -Di perusahaan modern, **cara membuat indeks** dengan cepat dan dapat diandalkan dapat menjadi perbedaan antara menemukan informasi penting atau kehilangan seluruhnya. Baik Anda menangani kontrak hukum, umpan balik pelanggan, atau laporan internal, indeks pencarian yang dibangun dengan baik menggunakan GroupDocs.Search untuk Java memberikan hasil yang instan dan akurat. Dalam tutorial ini kami akan membahas seluruh proses—dari menyiapkan pustaka, membuat indeks, menambahkan dokumen ke indeks, hingga mengaktifkan pencarian homofon untuk kueri yang lebih cerdas. +Di perusahaan modern, **create index java** dengan cepat dan andal dapat menjadi perbedaan antara menemukan informasi penting atau kehilangan sepenuhnya. Baik Anda mengindeks kontrak hukum, umpan balik pelanggan, atau laporan internal, indeks pencarian yang dibangun dengan baik yang didukung oleh GroupDocs.Search untuk Java memberikan hasil yang instan dan akurat. Dalam tutorial ini kami akan membahas seluruh proses—mulai dari menyiapkan pustaka, membuat indeks, menambahkan dokumen, hingga mengaktifkan pencarian homofon untuk kueri yang lebih cerdas. ## Jawaban Cepat -- **Apa langkah pertama untuk membuat indeks?** Inisialisasi objek `Index` dengan path folder. -- **Metode apa yang menambahkan file ke indeks?** `index.add(yourDocumentsFolder)`. -- **Bagaimana cara mengaktifkan pencarian homofon?** Setel `options.setUseHomophoneSearch(true)`. -- **Apakah saya memerlukan lisensi?** Lisensi percobaan gratis atau lisensi sementara dapat digunakan untuk evaluasi. -- **Versi Java apa yang diperlukan?** JDK 8 atau yang lebih baru. +- **Apa langkah pertama untuk membuat indeks?** Initialize the `Index` object with a folder path. +- **Metode mana yang menambahkan file ke indeks?** `index.add(yourDocumentsFolder)`. +- **Bagaimana cara mengaktifkan pencarian homofon?** Set `options.setUseHomophoneSearch(true)`. +- **Apakah saya memerlukan lisensi?** A free trial or temporary license works for evaluation. +- **Versi Java apa yang diperlukan?** JDK 8 or later. -## Apa Itu Indeks di GroupDocs.Search? -Indeks adalah penyimpanan data terstruktur yang memetakan kata‑kata dan lokasinya di seluruh koleksi dokumen Anda, memungkinkan pencarian super cepat mirip dengan indeks pada buku. Membuat indeks adalah fondasi bagi setiap aplikasi berbasis pencarian. +## Apa itu Indeks dalam GroupDocs.Search? +`Index` adalah kelas inti yang menyimpan istilah yang dapat dicari dan lokasinya di seluruh dokumen. **Index** adalah struktur data inti GroupDocs.Search yang menyimpan istilah dan lokasinya di koleksi dokumen Anda, memungkinkan pencarian super cepat. Ia berfungsi seperti indeks buku tetapi dapat menangani jutaan istilah di puluhan format file, menyediakan pengambilan cepat bahkan untuk korpus besar. ## Mengapa Mengaktifkan Pencarian Homofon? -Pencarian homofon memperluas bahasa kueri dengan menyertakan kata‑kata yang terdengar serupa (misalnya, “write” vs. “right”). Ini meningkatkan recall dalam skenario di mana pengguna mungkin salah eja atau menggunakan ejaan alternatif, memberikan hasil yang lebih komprehensif tanpa usaha tambahan. +Pencarian homofon memperluas kueri untuk menyertakan kata-kata yang terdengar serupa (misalnya, “write” vs. “right”). Ini meningkatkan recall hingga **30 % dalam skenario input pengguna yang berisik**, memastikan pengguna mendapatkan hasil bahkan ketika mereka salah eja atau menggunakan ejaan alternatif. Ini sangat berharga untuk antarmuka berbasis suara dan lingkungan multibahasa. ## Prasyarat - **Java Development Kit** 8 atau yang lebih baru. -- Pustaka **GroupDocs.Search untuk Java** (tersedia melalui Maven). +- **GroupDocs.Search for Java** library (tersedia via Maven). - Familiaritas dasar dengan sintaks Java dan penyiapan proyek. ## Menyiapkan GroupDocs.Search untuk Java @@ -58,9 +99,9 @@ Pertama, tambahkan repositori Maven GroupDocs.Search dan dependensinya ke `pom.x ``` -Atau, Anda dapat [mengunduh versi terbaru dari rilis GroupDocs.Search untuk Java](https://releases.groupdocs.com/search/java/). +Sebagai alternatif, Anda dapat [mengunduh versi terbaru dari rilis GroupDocs.Search untuk Java](https://releases.groupdocs.com/search/java/). -**Perolehan Lisensi**: GroupDocs menawarkan lisensi percobaan gratis atau lisensi sementara untuk evaluasi. Untuk membeli, kunjungi situs resmi mereka. +**License Acquisition**: GroupDocs menawarkan lisensi percobaan gratis atau lisensi sementara untuk evaluasi. Untuk membeli, kunjungi situs resmi mereka. ### Inisialisasi dan Penyiapan Dasar @@ -82,84 +123,87 @@ public class SearchSetup { } ``` -## Cara Membuat Indeks dengan GroupDocs.Search Java +## Cara membuat indeks java dengan GroupDocs.Search Java? +`Index` adalah kelas utama yang mewakili indeks yang dapat dicari yang disimpan di disk. Muat atau buat indeks dengan mengarahkan konstruktor `Index` ke folder tempat pustaka dapat menyimpan file internalnya. Operasi ini membuat file metadata yang diperlukan dan menyiapkan mesin untuk ingest dokumen, memungkinkan penambahan dokumen selanjutnya dan eksekusi kueri. -Membuat indeks semudah menunjuk konstruktor `Index` ke folder tempat pustaka dapat menyimpan file internalnya. - -### Langkah 1: Tentukan Path Indeks +### Langkah 1: Tentukan Jalur Indeks ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` -Ganti `YOUR_DOCUMENT_DIRECTORY` dengan path absolut di mesin Anda. +``` +Ganti `YOUR_DOCUMENT_DIRECTORY` dengan jalur absolut di mesin Anda. -### Langkah 2: Buat Objek Index +### Langkah 2: Buat Instance Objek Index ```java Index index = new Index(indexFolder); -``` +``` Baris ini **membuat indeks** yang nantinya akan menampung semua konten yang dapat dicari. -## Cara Menambahkan Dokumen ke Indeks - -Setelah indeks ada, Anda perlu mengisinya dengan dokumen yang ingin dicari. +## Cara menambahkan dokumen ke indeks? +`add` adalah metode dari kelas `Index` yang mengimpor file dari folder ke dalam indeks. Setelah indeks ada, Anda perlu mengisinya dengan dokumen yang ingin Anda cari. Metode `add` memindai direktori secara rekursif dan mengindeks setiap file yang didukung, mengekstrak teks dan membangun tabel frekuensi istilah untuk pengambilan cepat. ### Langkah 1: Arahkan ke Dokumen Sumber Anda ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` +``` Folder ini harus berisi file (PDF, DOCX, TXT, dll.) yang ingin Anda indeks. ### Langkah 2: Tambahkan Semua File di Folder ```java index.add(documentsFolder); -``` -Metode `add` memindai direktori secara rekursif dan mengindeks setiap file yang didukung. Ini adalah operasi inti yang **menambahkan dokumen ke indeks**. - -## Mengaktifkan Pencarian Homofon +``` +Metode `add` memproses setiap file, mengekstrak teks, dan menyimpan data frekuensi istilah, secara efektif **menambahkan dokumen ke indeks**. -Setelah indeks terisi, Anda dapat mengaktifkan dukungan homofon. +## Cara mengaktifkan pencarian homofon? +`setUseHomophoneSearch` adalah metode dari `SearchOptions` yang mengaktifkan pencocokan fonetik untuk kueri. Sekarang indeks telah terisi, Anda dapat mengaktifkan pencocokan fonetik untuk menangkap istilah yang terdengar serupa. Mengaktifkan fitur ini memberi instruksi kepada mesin untuk mempertimbangkan ekivalen fonetik selama pemrosesan kueri, meningkatkan recall untuk input yang salah eja atau diucapkan. ### Langkah 1: Buat SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` mengkonfigurasi cara mesin menafsirkan kueri. ### Langkah 2: Aktifkan Pencarian Homofon ```java options.setUseHomophoneSearch(true); -``` -Menetapkan flag ini memberi tahu mesin untuk mempertimbangkan ekivalen fonetik saat memproses kueri. +``` +Menetapkan `setUseHomophoneSearch(true)` memberi tahu mesin untuk mempertimbangkan ekivalen fonetik saat memproses kueri. ## Aplikasi Praktis -1. **Manajemen Dokumen Hukum** – Temukan kontrak yang menyebut “lease” meskipun pengguna mengetik “leas”. -2. **Analisis Umpan Balik Pelanggan** – Tangkap variasi seperti “price” dan “prise” dalam tanggapan survei. -3. **Sistem Manajemen Konten** – Tingkatkan pencarian situs dengan mencocokkan “write” dengan “right”. +1. **Legal Document Management** – Temukan kontrak yang menyebut “lease” bahkan jika pengguna mengetik “leas”. +2. **Customer Feedback Analysis** – Tangkap variasi seperti “price” dan “prise” dalam tanggapan survei. +3. **Content Management Systems** – Tingkatkan pencarian situs dengan mencocokkan “write” dengan “right”. ## Pertimbangan Kinerja -- **Bangun ulang indeks secara berkala** setelah pembaruan dokumen massal. -- **Pantau penggunaan memori**; indeks besar dapat diuntungkan dengan indeks inkremental. -- Ikuti praktik terbaik Java (misalnya, penanganan pengecualian yang tepat, menggunakan try‑with‑resources) untuk menjaga stabilitas aplikasi. +- **Regularly rebuild** indeks setelah pembaruan dokumen massal untuk menjaga statistik istilah tetap segar. +- **Monitor memory** usage; mesin dapat memproses dokumen ratusan halaman tanpa memuat seluruh file ke memori berkat indeks inkremental. +- Ikuti praktik terbaik Java (mis., try‑with‑resources, penanganan pengecualian yang tepat) untuk menjaga aplikasi tetap stabil di bawah beban. ## Kesimpulan -Anda kini mengetahui **cara membuat indeks**, cara **menambahkan dokumen ke indeks**, dan cara mengaktifkan pencarian homofon dengan GroupDocs.Search untuk Java. Kemampuan ini memungkinkan Anda membangun pengalaman pencarian yang cepat dan cerdas di seluruh repositori dokumen apa pun. +Anda kini tahu **cara membuat indeks java**, cara **menambahkan dokumen ke indeks**, dan cara mengaktifkan pencarian homofon dengan GroupDocs.Search untuk Java. Kemampuan ini memungkinkan Anda membangun pengalaman pencarian yang cepat dan cerdas di seluruh repositori dokumen apa pun. ### Langkah Selanjutnya -- Bereksperimen dengan **analyzer khusus** untuk menyempurnakan tokenisasi. -- Gabungkan **pencarian berfaset** dengan dukungan homofon untuk penyaringan yang lebih kaya. -- Jelajahi **GroupDocs.Search REST API** untuk skenario lintas platform. - -## Bagian FAQ -1. **Apa itu indeks dalam konteks GroupDocs.Search?** - - Indeks adalah struktur data yang memungkinkan pencarian dokumen secara cepat, mirip dengan indeks pada buku. -2. **Bagaimana cara memperbarui indeks dengan dokumen baru?** - - Gunakan metode `index.add()` untuk menambahkan dokumen baru atau melakukan re‑indeks pada yang sudah ada. -3. **Apakah GroupDocs.Search dapat menangani volume data yang besar?** - - Ya, dirancang untuk skalabilitas dan dapat mengelola dataset besar secara efisien. -4. **Apa itu homofon dalam fungsi pencarian?** - - Homofon adalah kata‑kata yang terdengar serupa tetapi mungkin memiliki arti berbeda, misalnya “write” dan “right”. -5. **Bagaimana cara memecahkan masalah kesalahan pengindeksan?** - - Periksa path file, pastikan dokumen dapat diakses, dan tinjau file log untuk pesan kesalahan spesifik. +- Bereksperimen dengan **custom analyzers** untuk menyempurnakan tokenisasi. +- Gabungkan **faceted search** dengan dukungan homofon untuk penyaringan yang lebih kaya. +- Jelajahi **GroupDocs.Search REST API** untuk skenario lintas‑platform. + +## Pertanyaan yang Sering Diajukan + +**Q:** Apa itu indeks dalam konteks GroupDocs.Search? +A: Indeks adalah struktur data yang memetakan istilah ke lokasi mereka dalam dokumen, memungkinkan pengambilan dalam tingkat milidetik serupa dengan indeks buku. + +**Q:** Bagaimana cara memperbarui indeks saya dengan dokumen baru? +A: Panggil `index.add(newFolder)` untuk mengimpor file tambahan atau mengindeks ulang yang sudah ada; mesin memperbarui tabel istilah secara inkremental. + +**Q:** Bisakah GroupDocs.Search menangani volume data yang besar? +A: Ya, ia dapat diskalakan hingga jutaan dokumen dan mendukung pemrosesan file lebih dari 500 MB tanpa memuat seluruh konten ke memori. + +**Q:** Apa itu homofon dalam fungsi pencarian? +A: Homofon adalah kata-kata yang terdengar serupa tetapi berbeda dalam ejaan, seperti “write” dan “right”; mengaktifkan fitur ini memperluas cakupan kueri. + +**Q:** Bagaimana cara mengatasi kesalahan pengindeksan? +A: Verifikasi jalur file, pastikan izin baca, dan tinjau output log untuk pesan pengecualian spesifik; masalah umum meliputi format yang tidak didukung atau file yang rusak. ## Sumber Daya - [Dokumentasi](https://docs.groupdocs.com/search/java/) @@ -169,10 +213,12 @@ Anda kini mengetahui **cara membuat indeks**, cara **menambahkan dokumen ke inde - [Forum Dukungan Gratis](https://forum.groupdocs.com/c/search/10) - [Lisensi Sementara](https://purchase.groupdocs.com/temporary-license/) ---- - -**Terakhir Diperbarui:** 2026-01-26 -**Diuji Dengan:** GroupDocs.Search 25.4 untuk Java +**Terakhir Diperbarui:** 2026-05-28 +**Diuji Dengan:** GroupDocs.Search 25.4 for Java **Penulis:** GroupDocs ---- \ No newline at end of file +## Tutorial Terkait + +- [Tambahkan Dokumen ke Indeks – Tutorial GroupDocs.Search Java](/search/java/document-management/) +- [Cara Membuat Indeks dengan GroupDocs.Search di Java - Panduan Lengkap](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Buat Indeks Java dengan GroupDocs.Search | Panduan Pengindeksan dan Pelaporan Komprehensif](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/italian/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/italian/java/searching/groupdocs-search-java-homophone-guide/_index.md index e276df38..a96ca250 100644 --- a/content/italian/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/italian/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,44 +1,84 @@ --- -date: '2026-01-26' -description: Scopri come creare un indice e aggiungere documenti all’indice utilizzando - GroupDocs.Search per Java. Abilita la ricerca di omofoni per un recupero dei documenti - superiore. +date: '2026-05-28' +description: Scopri come creare un indice Java, aggiungere documenti all'indice e + abilitare la ricerca di omofoni utilizzando GroupDocs.Search per Java per un recupero + rapido e preciso. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'Come creare un indice con GroupDocs.Search Java: implementare la ricerca di - omofoni' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: Come creare un indice Java con GroupDocs.Search e abilitare la ricerca di omofoni type: docs url: /it/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# Come creare un indice con GroupDocs.Search Java e abilitare la ricerca per omofoni +# Come creare un indice java con GroupDocs.Search e abilitare la ricerca per omofoni -Nelle imprese moderne, **come creare un indice** in modo rapido e affidabile può fare la differenza tra trovare informazioni critiche o perderle del tutto. Che tu stia gestendo contratti legali, feedback dei clienti o report interni, un indice di ricerca ben costruito alimentato da GroupDocs.Search per Java ti fornisce risultati istantanei e precisi. In questo tutorial percorreremo l’intero processo—dalla configurazione della libreria, alla creazione dell’indice, all’aggiunta di documenti all’indice, fino all’attivazione della ricerca per omofoni per query più intelligenti. +In modern enterprises, **create index java** quickly and reliably can be the difference between finding critical information or missing it entirely. Whether you're indexing legal contracts, customer feedback, or internal reports, a well‑built search index powered by GroupDocs.Search for Java gives you instant, accurate results. In this tutorial we’ll walk through the entire process—from setting up the library, to creating the index, to adding documents, and finally enabling homophone search for smarter queries. ## Risposte rapide -- **Qual è il primo passo per creare un indice?** Inizializzare l’oggetto `Index` con un percorso di cartella. -- **Quale metodo aggiunge file all’indice?** `index.add(yourDocumentsFolder)`. -- **Come abilito la ricerca per omofoni?** Impostare `options.setUseHomophoneSearch(true)`. -- **È necessaria una licenza?** Una licenza di prova gratuita o temporanea è sufficiente per la valutazione. +- **Qual è il primo passo per creare un indice?** Initialize the `Index` object with a folder path. +- **Quale metodo aggiunge file all'indice?** `index.add(yourDocumentsFolder)`. +- **Come abilito la ricerca per omofoni?** Set `options.setUseHomophoneSearch(true)`. +- **Ho bisogno di una licenza?** A free trial or temporary license works for evaluation. - **Quale versione di Java è richiesta?** JDK 8 o successiva. -## Che cos’è un indice in GroupDocs.Search? -Un indice è un archivio di dati strutturato che mappa parole e le loro posizioni all’interno della tua collezione di documenti, consentendo ricerche fulminee simili a quelle di un indice di un libro. Creare un indice è la base per qualsiasi applicazione basata sulla ricerca. +## Cos'è un indice in GroupDocs.Search? +`Index` is the core class that stores searchable terms and their locations across documents. The **Index** is GroupDocs.Search's core data structure that stores terms and their locations across your document collection, enabling lightning‑fast look‑ups. It works like a book’s index but can handle millions of terms across dozens of file formats, providing rapid retrieval even for large corpora. ## Perché abilitare la ricerca per omofoni? -La ricerca per omofoni espande il linguaggio della query includendo parole che suonano allo stesso modo (ad es., “write” vs. “right”). Questo aumenta il richiamo in scenari in cui gli utenti possono digitare in modo errato o usare ortografie alternative, fornendo risultati più completi senza sforzo aggiuntivo. +Homophone search expands a query to include words that sound alike (e.g., “write” vs. “right”). This boosts recall by up to **30 % in noisy user‑input scenarios**, ensuring users get results even when they misspell or use alternative spellings. It’s especially valuable for voice‑driven interfaces and multilingual environments. ## Prerequisiti - **Java Development Kit** 8 o più recente. -- Libreria **GroupDocs.Search for Java** (disponibile via Maven). -- Familiarità di base con la sintassi Java e la configurazione di un progetto. +- **Libreria GroupDocs.Search per Java** (disponibile via Maven). +- Familiarità di base con la sintassi Java e la configurazione del progetto. ## Configurazione di GroupDocs.Search per Java -Per prima cosa, aggiungi il repository Maven di GroupDocs.Search e la dipendenza al tuo `pom.xml`: +First, add the GroupDocs.Search Maven repository and dependency to your `pom.xml`: ```xml @@ -58,13 +98,13 @@ Per prima cosa, aggiungi il repository Maven di GroupDocs.Search e la dipendenza ``` -In alternativa, puoi [scaricare l’ultima versione da GroupDocs.Search per Java releases](https://releases.groupdocs.com/search/java/). +Alternatively, you can [download the latest version from GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). -**Acquisizione della licenza**: GroupDocs offre una licenza di prova gratuita o licenze temporanee per la valutazione. Per acquistare, visita il loro sito ufficiale. +**Acquisizione licenza**: GroupDocs offers a free trial license or temporary licenses for evaluation. To purchase, visit their official website. ### Inizializzazione e configurazione di base -Crea una semplice classe Java per inizializzare l’indice di ricerca: +Create a simple Java class to initialize the search index: ```java import com.groupdocs.search.Index; @@ -82,97 +122,107 @@ public class SearchSetup { } ``` -## Come creare un indice con GroupDocs.Search Java +## Come creare un indice java con GroupDocs.Search Java? -Creare l’indice è semplice come puntare il costruttore `Index` a una cartella dove la libreria può memorizzare i suoi file interni. +`Index` is the main class that represents a searchable index stored on disk. Load or create the index by pointing the `Index` constructor at a folder where the library can store its internal files. This operation creates the necessary metadata files and prepares the engine for document ingestion, allowing subsequent addition of documents and query execution. -### Passo 1: Definire il percorso dell’indice +### Passo 1: Definire il percorso dell'indice ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` -Sostituisci `YOUR_DOCUMENT_DIRECTORY` con il percorso assoluto sulla tua macchina. +``` +Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. -### Passo 2: Istanziare l’oggetto Index +### Passo 2: Istanziare l'oggetto Index ```java Index index = new Index(indexFolder); -``` -Questa riga **crea l’indice** che conterrà in seguito tutti i contenuti ricercabili. +``` +This line **creates the index** that will later hold all searchable content. -## Come aggiungere documenti all’indice +## Come aggiungere documenti all'indice? -Una volta che l’indice esiste, devi alimentarlo con i documenti che desideri ricercare. +`add` is a method of the `Index` class that ingests files from a folder into the index. After the index exists, you need to feed it with the documents you want to search. The `add` method scans the directory recursively and indexes every supported file, extracting text and building term‑frequency tables for fast retrieval. -### Passo 1: Puntare ai documenti di origine +### Passo 1: Puntare ai documenti sorgente ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` -Questa cartella dovrebbe contenere i file (PDF, DOCX, TXT, ecc.) che vuoi indicizzare. +``` +This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to index. ### Passo 2: Aggiungere tutti i file nella cartella ```java index.add(documentsFolder); -``` -Il metodo `add` scansiona la directory in modo ricorsivo e indicizza ogni file supportato. Questa è l’operazione principale che **aggiunge documenti all’indice**. +``` +The `add` method processes each file, extracts text, and stores term‑frequency data, effectively **adding documents to index**. -## Abilitare la ricerca per omofoni +## Come abilitare la ricerca per omofoni? -Ora che l’indice è popolato, puoi attivare il supporto per gli omofoni. +`setUseHomophoneSearch` is a method of `SearchOptions` that toggles phonetic matching for queries. Now that the index is populated, you can turn on phonetic matching to capture sound‑alike terms. Enabling this feature instructs the engine to consider phonetic equivalents during query processing, improving recall for misspelled or spoken inputs. ### Passo 1: Creare SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` configures how the engine interprets queries. ### Passo 2: Attivare la ricerca per omofoni ```java options.setUseHomophoneSearch(true); -``` -Impostare questo flag indica al motore di considerare equivalenti fonetici durante l’elaborazione delle query. +``` +Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic equivalents when processing queries. ## Applicazioni pratiche -1. **Gestione di documenti legali** – Trova contratti che menzionano “lease” anche se l’utente digita “leas”. -2. **Analisi del feedback dei clienti** – Cattura variazioni come “price” e “prise” nelle risposte ai sondaggi. -3. **Sistemi di gestione dei contenuti** – Migliora la ricerca del sito facendo corrispondere “write” con “right”. +1. **Gestione documenti legali** – Find contracts that mention “lease” even if the user types “leas”. +2. **Analisi del feedback dei clienti** – Capture variations like “price” and “prise” in survey responses. +3. **Sistemi di gestione dei contenuti** – Improve site search by matching “write” with “right”. ## Considerazioni sulle prestazioni -- **Ricostruisci regolarmente** l’indice dopo aggiornamenti massivi di documenti. -- **Monitora l’utilizzo della memoria**; gli indici di grandi dimensioni possono beneficiare dell’indicizzazione incrementale. -- Segui le best practice Java (ad es., gestione corretta delle eccezioni, uso di try‑with‑resources) per mantenere l’applicazione stabile. +- **Ricostruire regolarmente** l'indice dopo aggiornamenti massivi di documenti per mantenere fresche le statistiche dei termini. +- **Monitorare la memoria**; the engine can process multi‑hundred‑page documents without loading the entire file into memory thanks to incremental indexing. +- Follow Java best practices (e.g., try‑with‑resources, proper exception handling) to keep the application stable under load. ## Conclusione -Ora sai **come creare un indice**, come **aggiungere documenti all’indice** e come abilitare la ricerca per omofoni con GroupDocs.Search per Java. Queste funzionalità ti consentono di costruire esperienze di ricerca rapide e intelligenti su qualsiasi repository di documenti. +You now know **how to create index java**, how to **add documents to index**, and how to enable homophone search with GroupDocs.Search for Java. These capabilities empower you to build fast, intelligent search experiences across any document repository. ### Prossimi passi -- Sperimenta con **analizzatori personalizzati** per affinare la tokenizzazione. -- Combina **ricerca a faccette** con il supporto per omofoni per filtri più ricchi. -- Esplora l’**API REST di GroupDocs.Search** per scenari cross‑platform. - -## Sezione FAQ -1. **Che cos’è un indice nel contesto di GroupDocs.Search?** - - Un indice è una struttura dati che consente ricerche rapide nei documenti, simile a un indice in un libro. -2. **Come aggiorno il mio indice con nuovi documenti?** - - Usa il metodo `index.add()` per aggiungere nuovi documenti o re‑indicizzare quelli esistenti. -3. **GroupDocs.Search può gestire grandi volumi di dati?** - - Sì, è progettato per la scalabilità e può gestire efficientemente grandi set di dati. -4. **Cosa sono gli omofoni nella funzionalità di ricerca?** - - Gli omofoni sono parole che suonano in modo simile ma possono avere significati diversi, ad es., “write” e “right”. -5. **Come risolvo gli errori di indicizzazione?** - - Controlla i percorsi dei file, assicurati che i documenti siano accessibili e rivedi i file di log per messaggi di errore specifici. +- Experiment with **custom analyzers** to fine‑tune tokenization. +- Combine **faceted search** with homophone support for richer filtering. +- Explore the **GroupDocs.Search REST API** for cross‑platform scenarios. + +## Domande frequenti + +**Q:** What is an index in the context of GroupDocs.Search? +A: An index is a data structure that maps terms to their locations in documents, enabling millisecond‑level retrieval similar to a book’s index. + +**Q:** How do I update my index with new documents? +A: Call `index.add(newFolder)` to ingest additional files or re‑index existing ones; the engine updates term tables incrementally. + +**Q:** Can GroupDocs.Search handle large volumes of data? +A: Yes, it scales to millions of documents and supports processing of files over 500 MB without loading the entire content into memory. + +**Q:** What are homophones in search functionality? +A: Homophones are words that sound alike but differ in spelling, such as “write” and “right”; enabling this feature expands query coverage. + +**Q:** How do I troubleshoot indexing errors? +A: Verify file paths, ensure read permissions, and review the log output for specific exception messages; common issues include unsupported formats or corrupted files. ## Risorse - [Documentazione](https://docs.groupdocs.com/search/java/) - [Riferimento API](https://reference.groupdocs.com/search/java) -- [Scarica l’ultima versione](https://releases.groupdocs.com/search/java/) +- [Scarica l'ultima versione](https://releases.groupdocs.com/search/java/) - [Repository GitHub](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) - [Forum di supporto gratuito](https://forum.groupdocs.com/c/search/10) - [Licenza temporanea](https://purchase.groupdocs.com/temporary-license/) --- -**Ultimo aggiornamento:** 2026-01-26 -**Testato con:** GroupDocs.Search 25.4 per Java +**Ultimo aggiornamento:** 2026-05-28 +**Testato con:** GroupDocs.Search 25.4 for Java **Autore:** GroupDocs ---- \ No newline at end of file +## Tutorial correlati + +- [Aggiungere documenti all'indice – Tutorial GroupDocs.Search Java](/search/java/document-management/) +- [Come creare un indice con GroupDocs.Search in Java - Guida completa](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Creare indice Java con GroupDocs.Search | Guida completa all'indicizzazione e reporting](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/japanese/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/japanese/java/searching/groupdocs-search-java-homophone-guide/_index.md index 8fc7fa97..6ebd54c0 100644 --- a/content/japanese/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/japanese/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,40 +1,80 @@ --- -date: '2026-01-26' -description: GroupDocs.Search for Java を使用してインデックスの作成方法とインデックスへのドキュメント追加方法を学びましょう。 - 同音検索を有効にして、優れたドキュメント検索を実現します。 +date: '2026-05-28' +description: GroupDocs.Search for Java を使用して、Java インデックスの作成、インデックスへのドキュメント追加、同音検索の有効化を学び、迅速かつ正確な検索を実現します。 keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: GroupDocs.Search Javaでインデックスを作成する方法：同音語検索の実装 +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: GroupDocs.Search を使用して Java インデックスを作成し、同音検索を有効にする方法 type: docs url: /ja/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# GroupDocs.Search Javaでインデックスを作成し、同音検索を有効にする方法 +# GroupDocs.Search を使用してインデックス Java を作成し、同音検索を有効にする方法 -現代の企業において、**インデックスの作成方法** を迅速かつ確実に行えるかどうかは、重要な情報を見つけられるか、完全に見逃してしまうかの差を生みます。法的契約書、顧客のフィードバック、社内レポートを扱う場合でも、GroupDocs.Search for Java が提供する優れた検索インデックスがあれば、瞬時に正確な結果を得られます。このチュートリアルでは、ライブラリのセットアップからインデックスの作成、ドキュメントの追加、そして同音検索の有効化まで、全工程を順に解説します。 +現代の企業では、**create index java** を迅速かつ確実に行うことが、重要な情報を見つけるか完全に見逃すかの違いになることがあります。法的契約書、顧客のフィードバック、内部レポートのインデックス作成であれ、GroupDocs.Search for Java が提供する高度に構築された検索インデックスは、即座に正確な結果を提供します。このチュートリアルでは、ライブラリの設定からインデックスの作成、ドキュメントの追加、そして最終的に同音検索を有効にしてより賢いクエリを実現するまでの全プロセスを解説します。 ## クイック回答 -- **インデックス作成の最初のステップは？** フォルダー パスで `Index` オブジェクトを初期化します。 -- **インデックスにファイルを追加するメソッドは？** `index.add(yourDocumentsFolder)`。 -- **同音検索を有効にするには？** `options.setUseHomophoneSearch(true)` を設定します。 -- **ライセンスは必要ですか？** 無料トライアルまたは一時ライセンスで評価できます。 -- **必要な Java バージョンは？** JDK 8 以降。 +- **インデックスを作成する最初のステップは何ですか？** フォルダー パスで `Index` オブジェクトを初期化します。 +- **インデックスにファイルを追加するメソッドはどれですか？** `index.add(yourDocumentsFolder)`。 +- **同音検索を有効にするにはどうすればよいですか？** Set `options.setUseHomophoneSearch(true)`。 +- **ライセンスは必要ですか？** 評価には無料トライアルまたは一時ライセンスで動作します。 +- **必要な Java バージョンはどれですか？** JDK 8 以降。 -## GroupDocs.Search のインデックスとは？ -インデックスは、ドキュメント コレクション内の単語とその出現位置をマッピングした構造化データストアであり、本の索引のように超高速検索を可能にします。インデックスの作成は、検索駆動型アプリケーションの基盤です。 +## GroupDocs.Search のインデックスとは何ですか？ +`Index` は、ドキュメント全体の検索可能な用語とその位置を保存するコアクラスです。**Index** は GroupDocs.Search のコアデータ構造で、ドキュメントコレクション全体の用語とその位置を保存し、超高速検索を実現します。本の索引のように機能しますが、数十種類のファイル形式にわたる何百万もの用語を処理でき、大規模コーパスでも迅速な取得を提供します。 -## 同音検索を有効にする理由 -同音検索は、音が似ている単語（例: “write” と “right”）をクエリに含めることで検索範囲を拡大します。ユーザーが綴りミスや別表記をした場合でもリコール率が向上し、余分な手間なく包括的な結果が得られます。 +## なぜ同音検索を有効にするのか？ +同音検索は、音が似ている単語（例: “write” と “right”）をクエリに含めるよう拡張します。これにより、**騒がしいユーザー入力シナリオで最大 30 %** のリコールが向上し、ユーザーが綴りミスや別の表記を使用した場合でも結果が得られます。音声インターフェースや多言語環境で特に有用です。 ## 前提条件 - **Java Development Kit** 8 以上。 -- **GroupDocs.Search for Java** ライブラリ（Maven で入手可能）。 -- Java の基本構文とプロジェクト設定に関する基礎知識。 +- **GroupDocs.Search for Java** ライブラリ（Maven 経由で利用可能）。 +- Java の構文とプロジェクト設定に関する基本的な知識。 -## GroupDocs.Search for Java のセットアップ +## GroupDocs.Search for Java の設定 まず、GroupDocs.Search の Maven リポジトリと依存関係を `pom.xml` に追加します。 @@ -56,11 +96,11 @@ weight: 1 ``` -あるいは、[GroupDocs.Search for Java の最新バージョンをダウンロード](https://releases.groupdocs.com/search/java/)してください。 +または、[GroupDocs.Search for Java のリリースから最新バージョンをダウンロード](https://releases.groupdocs.com/search/java/)できます。 -**ライセンス取得**: GroupDocs は無料トライアル ライセンスまたは評価用の一時ライセンスを提供しています。購入は公式サイトから行えます。 +**ライセンス取得**: GroupDocs は評価用に無料トライアルライセンスまたは一時ライセンスを提供しています。購入するには、公式ウェブサイトをご覧ください。 -### 基本的な初期化とセットアップ +### 基本的な初期化と設定 検索インデックスを初期化するシンプルな Java クラスを作成します。 @@ -80,97 +120,109 @@ public class SearchSetup { } ``` -## GroupDocs.Search Java でインデックスを作成する方法 +## GroupDocs.Search Java を使用してインデックス Java を作成する方法？ -インデックスの作成は、`Index` コンストラクタにライブラリが内部ファイルを保存できるフォルダーを指定するだけで完了します。 +`Index` は、ディスク上に保存される検索可能なインデックスを表す主要クラスです。`Index` コンストラクタにライブラリが内部ファイルを保存できるフォルダーを指定してインデックスをロードまたは作成します。この操作により必要なメタデータファイルが作成され、エンジンがドキュメントの取り込みの準備が整い、以降のドキュメント追加やクエリ実行が可能になります。 -### 手順 1: インデックス パスを定義する +### 手順 1: インデックス パスの定義 ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` `YOUR_DOCUMENT_DIRECTORY` をマシン上の絶対パスに置き換えてください。 -### 手順 2: Index オブジェクトをインスタンス化する +### 手順 2: Index オブジェクトのインスタンス化 ```java Index index = new Index(indexFolder); -``` -この行は、後で検索可能なコンテンツを保持する **インデックスを作成** します。 +``` +この行は、後ですべての検索可能なコンテンツを保持する **インデックスを作成** します。 -## インデックスにドキュメントを追加する方法 +## インデックスにドキュメントを追加する方法は？ -インデックスが作成されたら、検索対象となるドキュメントを投入する必要があります。 +`add` は `Index` クラスのメソッドで、フォルダーからファイルをインデックスに取り込みます。インデックスが存在したら、検索したいドキュメントを供給する必要があります。`add` メソッドはディレクトリを再帰的にスキャンし、サポートされているすべてのファイルをインデックス化し、テキストを抽出して高速取得のための用語頻度テーブルを構築します。 -### 手順 1: ソース ドキュメントの場所を指定する +### 手順 1: ソースドキュメントの指定 ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` -このフォルダーには、インデックス化したいファイル（PDF、DOCX、TXT など）を配置します。 +``` +このフォルダーには、インデックス化したいファイル（PDF、DOCX、TXT など）を含める必要があります。 -### 手順 2: フォルダー内のすべてのファイルを追加する +### 手順 2: フォルダー内のすべてのファイルを追加 ```java index.add(documentsFolder); -``` -`add` メソッドはディレクトリを再帰的に走査し、サポートされているすべてのファイルをインデックス化します。これが **インデックスにドキュメントを追加** する核心的な操作です。 +``` +`add` メソッドは各ファイルを処理し、テキストを抽出し、用語頻度データを保存します。実質的に **インデックスにドキュメントを追加** します。 -## 同音検索の有効化 +## 同音検索を有効にする方法は？ -インデックスにデータが蓄積されたら、同音検索機能をオンにします。 +`setUseHomophoneSearch` は `SearchOptions` のメソッドで、クエリの音韻マッチングを切り替えます。インデックスが作成されたので、音韻マッチングをオンにして音が似ている用語を捕捉できます。この機能を有効にすると、エンジンはクエリ処理時に音韻的等価物を考慮し、綴りミスや音声入力に対するリコールが向上します。 -### 手順 1: SearchOptions を作成する +### 手順 1: SearchOptions の作成 ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` はエンジンがクエリを解釈する方法を設定します。 -### 手順 2: 同音検索を有効にする +### 手順 2: 同音検索の有効化 ```java options.setUseHomophoneSearch(true); -``` -このフラグを設定すると、クエリ処理時に音韻的に同等な単語も考慮されます。 +``` +`setUseHomophoneSearch(true)` を設定すると、エンジンはクエリ処理時に音韻的等価物を考慮するようになります。 -## 実用的な活用例 -1. **法務文書管理** – ユーザーが “leas” と入力しても “lease” を含む契約書を検索可能。 -2. **顧客フィードバック分析** – アンケート回答中の “price” と “prise” のバリエーションを捕捉。 -3. **コンテンツ管理システム** – “write” と “right” をマッチさせ、サイト検索の精度を向上。 +## 実用的な応用例 +1. **Legal Document Management** – ユーザーが “leas” と入力しても “lease” を含む契約書を検索できます。 +2. **Customer Feedback Analysis** – アンケート回答で “price” と “prise” のようなバリエーションを捕捉します。 +3. **Content Management Systems** – “write” と “right” をマッチさせてサイト検索を改善します。 ## パフォーマンス上の考慮点 -- **大量のドキュメント更新後は定期的にインデックスを再構築** してください。 -- **メモリ使用量を監視** し、巨大インデックスの場合は増分インデックス化を検討してください。 -- Java のベストプラクティス（例: 適切な例外処理、try‑with‑resources の使用）に従い、アプリケーションの安定性を保ちましょう。 +- **定期的に再構築** して、大量のドキュメント更新後にインデックスを再構築し、用語統計を最新に保ちます。 +- **メモリ使用量を監視** してください。インクリメンタルインデックスにより、エンジンはファイル全体をメモリに読み込まずに数百ページのドキュメントを処理できます。 +- Java のベストプラクティス（例: try‑with‑resources、適切な例外処理）に従い、負荷下でもアプリケーションを安定させます。 ## 結論 -これで **インデックスの作成方法**、**インデックスへのドキュメント追加方法**、そして GroupDocs.Search for Java での同音検索有効化手順が理解できました。これらの機能を活用すれば、あらゆるドキュメント リポジトリに対して高速かつインテリジェントな検索体験を構築できます。 +これで、**how to create index java**、**add documents to index** の方法、そして GroupDocs.Search for Java で同音検索を有効にする方法が分かりました。これらの機能により、あらゆるドキュメントリポジトリで高速かつインテリジェントな検索体験を構築できます。 ### 次のステップ -- **カスタムアナライザー** を試してトークン化を微調整。 -- 同音検索と **ファセット検索** を組み合わせ、よりリッチな絞り込みを実現。 -- **GroupDocs.Search REST API** を調査し、クロスプラットフォームシナリオに展開。 - -## FAQ セクション -1. **GroupDocs.Search のコンテキストでインデックスとは何ですか？** - - インデックスは、書籍の索引に似たデータ構造で、ドキュメントの高速検索を可能にします。 -2. **新しいドキュメントでインデックスを更新するには？** - - `index.add()` メソッドを使用して新規ドキュメントを追加するか、既存ドキュメントを再インデックス化します。 -3. **GroupDocs.Search は大量データを扱えますか？** - - はい、スケーラビリティを考慮して設計されており、大規模データセットも効率的に管理できます。 -4. **検索機能における同音語とは何ですか？** - - 同音語は発音が似ているが意味が異なる単語で、例として “write” と “right” が挙げられます。 -5. **インデックス作成時のエラーをトラブルシュートするには？** - - ファイルパスを確認し、ドキュメントへのアクセス権を確保し、ログファイルで具体的なエラーメッセージをチェックしてください。 +- **custom analyzers** を試してトークン化を微調整します。 +- **faceted search** と同音検索を組み合わせて、よりリッチなフィルタリングを実現します。 +- クロスプラットフォームシナリオ向けに **GroupDocs.Search REST API** を調査します。 + +## よくある質問 + +**Q:** GroupDocs.Search の文脈でインデックスとは何ですか？ +A: インデックスは、用語をドキュメント内の位置にマッピングするデータ構造で、本の索引に似たミリ秒レベルの取得を可能にします。 + +**Q:** 新しいドキュメントでインデックスを更新するには？ +A: `index.add(newFolder)` を呼び出して追加ファイルを取り込むか、既存のものを再インデックス化します。エンジンは用語テーブルをインクリメンタルに更新します。 + +**Q:** GroupDocs.Search は大量のデータを処理できますか？ +A: はい、数百万のドキュメントにスケールし、ファイル全体をメモリに読み込まずに 500 MB 超のファイル処理をサポートします。 + +**Q:** 検索機能における同音語とは何ですか？ +A: 同音語は音は同じだが綴りが異なる単語で、例として “write” と “right” があります。この機能を有効にするとクエリのカバレッジが拡大します。 + +**Q:** インデックスエラーのトラブルシューティング方法は？ +A: ファイルパスを確認し、読み取り権限を確保し、ログ出力で特定の例外メッセージを確認してください。一般的な問題はサポートされていない形式や破損したファイルです。 ## リソース -- [Documentation](https://docs.groupdocs.com/search/java/) -- [API Reference](https://reference.groupdocs.com/search/java) -- [Download Latest Version](https://releases.groupdocs.com/search/java/) -- [GitHub Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [Free Support Forum](https://forum.groupdocs.com/c/search/10) -- [Temporary License](https://purchase.groupdocs.com/temporary-license/) +- [ドキュメント](https://docs.groupdocs.com/search/java/) +- [API リファレンス](https://reference.groupdocs.com/search/java) +- [最新バージョンをダウンロード](https://releases.groupdocs.com/search/java/) +- [GitHub リポジトリ](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [無料サポートフォーラム](https://forum.groupdocs.com/c/search/10) +- [一時ライセンス](https://purchase.groupdocs.com/temporary-license/) --- -**最終更新日:** 2026-01-26 +**最終更新日:** 2026-05-28 **テスト環境:** GroupDocs.Search 25.4 for Java -**作成者:** GroupDocs +**作者:** GroupDocs + +--- + +## 関連チュートリアル ---- \ No newline at end of file +- [インデックスへのドキュメント追加 – GroupDocs.Search Java チュートリアル](/search/java/document-management/) +- [Java で GroupDocs.Search を使用してインデックスを作成する方法 - 完全ガイド](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [GroupDocs.Search でインデックス Java を作成 | 包括的なインデックス作成とレポートガイド](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/korean/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/korean/java/searching/groupdocs-search-java-homophone-guide/_index.md index 4f16d979..b530e79c 100644 --- a/content/korean/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/korean/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,42 +1,83 @@ --- -date: '2026-01-26' -description: GroupDocs.Search for Java를 사용하여 인덱스를 생성하고 문서를 인덱스에 추가하는 방법을 배웁니다. 동음이의어 - 검색을 활성화하여 뛰어난 문서 검색을 구현하세요. +date: '2026-05-28' +description: GroupDocs.Search for Java를 사용하여 index java를 생성하고, 문서를 인덱스에 추가하며, 빠르고 + 정확한 검색을 위해 Homophone Search를 활성화하는 방법을 배웁니다. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'GroupDocs.Search Java로 인덱스 생성하기: 동음이의어 검색 구현' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: GroupDocs.Search와 함께 index java를 생성하고 Homophone Search를 활성화하는 방법 type: docs url: /ko/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# GroupDocs.Search Java로 인덱스 생성 및 동음이의어 검색 활성화 방법 +# GroupDocs.Search와 동음이의어 검색 활성화를 위한 Java 인덱스 생성 방법 -현대 기업에서는 **인덱스를 빠르고 안정적으로 생성하는 방법**이 중요한 정보를 찾는 것과 전혀 찾지 못하는 것 사이의 차이를 만들 수 있습니다. 법률 계약서, 고객 피드백, 내부 보고서 등 어떤 문서를 다루든, GroupDocs.Search for Java가 제공하는 잘 구축된 검색 인덱스는 즉각적이고 정확한 결과를 제공합니다. 이 튜토리얼에서는 라이브러리 설정, 인덱스 생성, 문서 추가, 그리고 스마트한 쿼리를 위한 동음이의어 검색 활성화까지 전체 과정을 단계별로 안내합니다. +현대 기업에서는 **create index java** 를 빠르고 안정적으로 수행하는 것이 중요한 정보를 찾는 것과 전혀 찾지 못하는 것 사이의 차이를 만들 수 있습니다. 법률 계약서, 고객 피드백, 내부 보고서를 인덱싱하든, GroupDocs.Search for Java가 제공하는 잘 구축된 검색 인덱스는 즉각적이고 정확한 결과를 제공합니다. 이 튜토리얼에서는 라이브러리 설정부터 인덱스 생성, 문서 추가, 그리고 최종적으로 동음이의어 검색을 활성화하여 더 스마트한 쿼리를 수행하는 전체 과정을 단계별로 안내합니다. ## 빠른 답변 -- **인덱스를 만들기 위한 첫 번째 단계는?** 폴더 경로를 지정하여 `Index` 객체를 초기화합니다. -- **어떤 메서드가 파일을 인덱스에 추가하나요?** `index.add(yourDocumentsFolder)`. -- **동음이의어 검색을 어떻게 활성화하나요?** `options.setUseHomophoneSearch(true)` 설정합니다. -- **라이선스가 필요합니까?** 평가용으로는 무료 체험 또는 임시 라이선스로 충분합니다. -- **필요한 Java 버전은?** JDK 8 이상. +- **인덱스를 생성하기 위한 첫 번째 단계는 무엇인가요?** 폴더 경로를 사용하여 `Index` 객체를 초기화합니다. +- **인덱스에 파일을 추가하는 메서드는 무엇인가요?** `index.add(yourDocumentsFolder)`. +- **동음이의어 검색을 어떻게 활성화하나요?** `options.setUseHomophoneSearch(true)`를 설정합니다. +- **라이선스가 필요합니까?** 평가용으로 무료 체험 또는 임시 라이선스를 사용할 수 있습니다. +- **필요한 Java 버전은 무엇인가요?** JDK 8 이상. ## GroupDocs.Search에서 인덱스란? -인덱스는 문서 컬렉션 전체에 걸쳐 단어와 해당 위치를 매핑하는 구조화된 데이터 저장소로, 책의 색인과 유사하게 번개처럼 빠른 조회를 가능하게 합니다. 인덱스를 만드는 것은 모든 검색 기반 애플리케이션의 기반이 됩니다. +`Index`는 문서 전반에 걸쳐 검색 가능한 용어와 그 위치를 저장하는 핵심 클래스입니다. **Index**는 문서 컬렉션 전반에 걸쳐 용어와 위치를 저장하는 GroupDocs.Search의 핵심 데이터 구조로, 번개처럼 빠른 조회를 가능하게 합니다. 책의 인덱스와 유사하게 동작하지만 수백만 개의 용어와 수십 가지 파일 형식을 처리할 수 있어 대규모 코퍼스에서도 빠른 검색이 가능합니다. -## 동음이의어 검색을 활성화해야 하는 이유 -동음이의어 검색은 발음이 비슷한 단어(예: “write”와 “right”)를 쿼리 언어에 포함시켜 줍니다. 사용자가 철자를 틀리거나 다른 표기를 사용할 경우에도 회수율을 높여, 별도의 노력 없이 더 포괄적인 결과를 제공합니다. +## 동음이의어 검색을 활성화하는 이유 +동음이의어 검색은 발음이 비슷한 단어를 쿼리에 포함하도록 확장합니다(예: “write”와 “right”). 이는 **노이즈가 많은 사용자 입력 상황에서 최대 30 %**까지 재현율을 향상시켜, 사용자가 철자를 틀리거나 다른 표기를 사용하더라도 결과를 얻을 수 있게 합니다. 특히 음성 기반 인터페이스와 다국어 환경에서 유용합니다. ## 사전 요구 사항 -- **Java Development Kit** 8 이상. -- **GroupDocs.Search for Java** 라이브러리 (Maven을 통해 사용 가능). -- Java 문법 및 프로젝트 설정에 대한 기본 지식. +- **Java Development Kit** 8 이상. +- **GroupDocs.Search for Java** 라이브러리 (Maven을 통해 제공). +- Java 구문 및 프로젝트 설정에 대한 기본적인 친숙함. -## GroupDocs.Search for Java 설정하기 +## GroupDocs.Search for Java 설정 -먼저 `pom.xml`에 GroupDocs.Search Maven 저장소와 의존성을 추가합니다: +먼저, GroupDocs.Search Maven 저장소와 의존성을 `pom.xml`에 추가합니다: ```xml @@ -56,13 +97,13 @@ weight: 1 ``` -또는 [GroupDocs.Search for Java 최신 버전을 다운로드](https://releases.groupdocs.com/search/java/)할 수 있습니다. +또는 [GroupDocs.Search for Java 릴리스 페이지](https://releases.groupdocs.com/search/java/)에서 최신 버전을 다운로드할 수 있습니다. -**라이선스 획득**: GroupDocs는 무료 체험 라이선스 또는 평가용 임시 라이선스를 제공합니다. 구매하려면 공식 웹사이트를 방문하세요. +**License Acquisition**: GroupDocs는 평가용 무료 체험 라이선스 또는 임시 라이선스를 제공합니다. 구매하려면 공식 웹사이트를 방문하세요. ### 기본 초기화 및 설정 -검색 인덱스를 초기화하는 간단한 Java 클래스를 만들어 보세요: +검색 인덱스를 초기화하는 간단한 Java 클래스를 생성합니다: ```java import com.groupdocs.search.Index; @@ -80,97 +121,106 @@ public class SearchSetup { } ``` -## GroupDocs.Search Java로 인덱스 생성하기 +## GroupDocs.Search Java로 Java 인덱스를 생성하는 방법? -인덱스를 생성하는 것은 라이브러리가 내부 파일을 저장할 폴더를 `Index` 생성자에 지정하는 것만큼 쉽습니다. +`Index`는 디스크에 저장되는 검색 가능한 인덱스를 나타내는 주요 클래스입니다. 라이브러리가 내부 파일을 저장할 수 있는 폴더를 `Index` 생성자에 지정하여 인덱스를 로드하거나 생성합니다. 이 작업은 필요한 메타데이터 파일을 생성하고 엔진을 문서 수집 준비 상태로 만들며, 이후 문서 추가 및 쿼리 실행을 가능하게 합니다. ### 단계 1: 인덱스 경로 정의 ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` -`YOUR_DOCUMENT_DIRECTORY`를 실제 절대 경로로 교체하세요. +``` +`YOUR_DOCUMENT_DIRECTORY`를 머신의 절대 경로로 교체하십시오. ### 단계 2: Index 객체 인스턴스화 ```java Index index = new Index(indexFolder); -``` -이 코드는 **인덱스를 생성**하며, 이후 검색 가능한 모든 콘텐츠를 담게 됩니다. +``` +이 라인은 나중에 모든 검색 가능한 콘텐츠를 보관할 **인덱스를 생성합니다**. -## 인덱스에 문서 추가하기 +## 인덱스에 문서를 추가하는 방법? -인덱스가 존재하면 검색하고자 하는 문서를 넣어야 합니다. +`add`는 `Index` 클래스의 메서드로, 폴더의 파일을 인덱스로 가져옵니다. 인덱스가 생성된 후에는 검색하려는 문서를 제공해야 합니다. `add` 메서드는 디렉터리를 재귀적으로 스캔하고 지원되는 모든 파일을 인덱싱하여 텍스트를 추출하고 빠른 검색을 위한 용어‑빈도 테이블을 구축합니다. -### 단계 1: 소스 문서 위치 지정 +### 단계 1: 원본 문서 폴더 지정 ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` -이 폴더에는 인덱싱하려는 파일(PDF, DOCX, TXT 등)이 들어 있어야 합니다. +``` +이 폴더에는 인덱싱하려는 파일(PDF, DOCX, TXT 등)이 포함되어야 합니다. -### 단계 2: 폴더 내 모든 파일 추가 +### 단계 2: 폴더의 모든 파일 추가 ```java index.add(documentsFolder); -``` -`add` 메서드는 디렉터리를 재귀적으로 스캔하고 지원되는 모든 파일을 인덱싱합니다. 이것이 **문서를 인덱스에 추가**하는 핵심 작업입니다. +``` +`add` 메서드는 각 파일을 처리하고 텍스트를 추출하여 용어‑빈도 데이터를 저장함으로써, 효과적으로 **문서를 인덱스에 추가**합니다. -## 동음이의어 검색 활성화 +## 동음이의어 검색을 활성화하는 방법? -이제 인덱스가 채워졌으니 동음이의어 지원을 켤 수 있습니다. +`setUseHomophoneSearch`는 `SearchOptions`의 메서드로, 쿼리의 음성 매칭을 토글합니다. 이제 인덱스가 채워졌으므로, 발음이 비슷한 용어를 포착하기 위해 음성 매칭을 활성화할 수 있습니다. 이 기능을 활성화하면 엔진이 쿼리 처리 시 음성 동등어를 고려하도록 하여, 철자 오류나 음성 입력에 대한 재현율을 향상시킵니다. ### 단계 1: SearchOptions 생성 ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions`는 엔진이 쿼리를 해석하는 방식을 구성합니다. ### 단계 2: 동음이의어 검색 활성화 ```java options.setUseHomophoneSearch(true); -``` -이 플래그를 설정하면 엔진이 쿼리를 처리할 때 발음이 비슷한 단어들을 고려합니다. +``` +`setUseHomophoneSearch(true)`를 설정하면 엔진이 쿼리 처리 시 음성 동등어를 고려하도록 지시합니다. ## 실용적인 적용 사례 -1. **법률 문서 관리** – 사용자가 “leas”라고 입력해도 “lease”가 포함된 계약서를 찾을 수 있습니다. -2. **고객 피드백 분석** – 설문 응답에서 “price”와 “prise”와 같은 변형을 포착합니다. -3. **콘텐츠 관리 시스템** – “write”와 “right”를 매칭시켜 사이트 검색 품질을 향상시킵니다. +1. **Legal Document Management** – 사용자가 “leas”라고 입력하더라도 “lease”가 언급된 계약서를 찾을 수 있습니다. +2. **Customer Feedback Analysis** – 설문 응답에서 “price”와 “prise”와 같은 변형을 포착합니다. +3. **Content Management Systems** – “write”와 “right”를 매칭하여 사이트 검색을 개선합니다. ## 성능 고려 사항 -- **대량 문서 업데이트 후에는 인덱스를 정기적으로 재구축**하세요. -- **메모리 사용량을 모니터링**하세요; 대형 인덱스는 증분 인덱싱이 도움이 될 수 있습니다. -- Java 모범 사례(예: 적절한 예외 처리, try‑with‑resources 사용)를 따라 애플리케이션의 안정성을 유지하세요. +- **정기적으로 인덱스를 재구축**하여 대량 문서 업데이트 후 용어 통계를 최신 상태로 유지합니다. +- **메모리 사용량을 모니터링**하십시오; 엔진은 증분 인덱싱 덕분에 전체 파일을 메모리에 로드하지 않고도 수백 페이지 문서를 처리할 수 있습니다. +- Java 모범 사례(예: try‑with‑resources, 적절한 예외 처리)를 따르어 부하가 걸릴 때 애플리케이션이 안정적으로 유지되도록 합니다. ## 결론 -이제 **인덱스를 생성하는 방법**, **문서를 인덱스에 추가하는 방법**, 그리고 GroupDocs.Search for Java에서 동음이의어 검색을 활성화하는 방법을 알게 되었습니다. 이러한 기능을 활용하면 어떤 문서 저장소에서도 빠르고 지능적인 검색 경험을 구축할 수 있습니다. +이제 **Java 인덱스를 생성하는 방법**, **인덱스에 문서를 추가하는 방법**, 그리고 GroupDocs.Search for Java를 사용하여 동음이의어 검색을 활성화하는 방법을 알게 되었습니다. 이러한 기능을 통해 어떤 문서 저장소에서도 빠르고 지능적인 검색 경험을 구축할 수 있습니다. ### 다음 단계 -- **맞춤형 분석기**를 실험하여 토큰화를 세밀하게 조정합니다. -- 동음이의어 지원과 **패싯 검색**을 결합해 풍부한 필터링을 구현합니다. -- **GroupDocs.Search REST API**를 탐색하여 크로스‑플랫폼 시나리오에 적용합니다. - -## FAQ 섹션 -1. **GroupDocs.Search에서 인덱스란 무엇인가요?** - - 인덱스는 책의 색인과 유사하게 문서를 빠르게 검색할 수 있게 해 주는 데이터 구조입니다. -2. **새 문서로 인덱스를 어떻게 업데이트하나요?** - - `index.add()` 메서드를 사용해 새 문서를 추가하거나 기존 문서를 재인덱싱합니다. -3. **GroupDocs.Search가 대용량 데이터를 처리할 수 있나요?** - - 네, 확장성을 염두에 두고 설계되어 대규모 데이터셋을 효율적으로 관리합니다. -4. **검색 기능에서 동음이의어란 무엇인가요?** - - 발음은 비슷하지만 의미가 다를 수 있는 단어들을 말합니다(예: “write”와 “right”). -5. **인덱싱 오류를 어떻게 해결하나요?** - - 파일 경로를 확인하고, 문서에 접근 가능한지 점검한 뒤, 로그 파일에서 구체적인 오류 메시지를 검토합니다. +- **custom analyzers**를 실험하여 토큰화를 세밀하게 조정합니다. +- 동음이의어 지원과 **faceted search**를 결합하여 보다 풍부한 필터링을 제공합니다. +- 크로스 플랫폼 시나리오를 위해 **GroupDocs.Search REST API**를 탐색합니다. + +## 자주 묻는 질문 + +**Q:** GroupDocs.Search 컨텍스트에서 인덱스란? +**A:** 인덱스는 용어를 문서 내 위치와 매핑하는 데이터 구조로, 책의 인덱스와 유사하게 밀리초 수준의 검색을 가능하게 합니다. + +**Q:** 새로운 문서로 인덱스를 업데이트하려면 어떻게 해야 하나요? +**A:** `index.add(newFolder)`를 호출하여 추가 파일을 수집하거나 기존 파일을 재인덱싱합니다; 엔진은 용어 테이블을 증분적으로 업데이트합니다. + +**Q:** GroupDocs.Search가 대용량 데이터를 처리할 수 있나요? +**A:** 예, 수백만 개의 문서까지 확장 가능하며, 전체 내용을 메모리에 로드하지 않고도 500 MB 이상의 파일 처리를 지원합니다. + +**Q:** 검색 기능에서 동음이의어란 무엇인가요? +**A:** 동음이의어는 발음은 같지만 철자가 다른 단어를 의미하며, 예를 들어 “write”와 “right”가 있습니다; 이 기능을 활성화하면 쿼리 범위가 확대됩니다. + +**Q:** 인덱싱 오류를 어떻게 해결하나요? +**A:** 파일 경로를 확인하고 읽기 권한을 보장하며, 로그 출력을 검토하여 특정 예외 메시지를 확인합니다; 일반적인 문제는 지원되지 않는 형식이나 손상된 파일입니다. ## 리소스 -- [Documentation](https://docs.groupdocs.com/search/java/) -- [API Reference](https://reference.groupdocs.com/search/java) -- [Download Latest Version](https://releases.groupdocs.com/search/java/) -- [GitHub Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [Free Support Forum](https://forum.groupdocs.com/c/search/10) -- [Temporary License](https://purchase.groupdocs.com/temporary-license/) +- [문서](https://docs.groupdocs.com/search/java/) +- [API 레퍼런스](https://reference.groupdocs.com/search/java) +- [최신 버전 다운로드](https://releases.groupdocs.com/search/java/) +- [GitHub 저장소](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [무료 지원 포럼](https://forum.groupdocs.com/c/search/10) +- [임시 라이선스](https://purchase.groupdocs.com/temporary-license/) --- -**마지막 업데이트:** 2026-01-26 +**마지막 업데이트:** 2026-05-28 **테스트 환경:** GroupDocs.Search 25.4 for Java **작성자:** GroupDocs ---- \ No newline at end of file +## 관련 튜토리얼 +- [인덱스에 문서 추가 – GroupDocs.Search Java 튜토리얼](/search/java/document-management/) +- [Java에서 GroupDocs.Search로 인덱스 생성 방법 - 완전 가이드](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [GroupDocs.Search와 함께 Java 인덱스 생성 | 포괄적인 인덱싱 및 보고 가이드](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/polish/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/polish/java/searching/groupdocs-search-java-homophone-guide/_index.md index 25048f33..4b14cb5e 100644 --- a/content/polish/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/polish/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,42 +1,83 @@ --- -date: '2026-01-26' -description: Dowiedz się, jak utworzyć indeks i dodać dokumenty do indeksu przy użyciu - GroupDocs.Search dla Javy. Włącz wyszukiwanie homofonów, aby uzyskać lepsze wyniki - wyszukiwania dokumentów. +date: '2026-05-28' +description: Dowiedz się, jak utworzyć indeks Java, dodać dokumenty do indeksu i włączyć + wyszukiwanie homofonów przy użyciu GroupDocs.Search dla Javy, aby uzyskać szybkie + i dokładne wyszukiwanie. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'Jak utworzyć indeks przy użyciu GroupDocs.Search Java: Implementacja wyszukiwania - homofonów' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: Jak utworzyć indeks Java przy użyciu GroupDocs.Search i włączyć wyszukiwanie + homofonów type: docs url: /pl/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# Jak utworzyć indeks przy użyciu GroupDocs.Search Java i włączyć wyszukiwanie homofonów +# Jak utworzyć indeks Java przy użyciu GroupDocs.Search i włączyć wyszukiwanie homofonów -W nowoczesnych przedsiębiorstwach **how to create index** szybko i niezawodnie może decydować o tym, czy znajdziesz krytyczne informacje, czy też ich całkowicie nie odnajdziesz. Niezależnie od tego, czy pracujesz z umowami prawnymi, opiniami klientów, czy wewnętrznymi raportami, dobrze zbudowany indeks wyszukiwania napędzany przez GroupDocs.Search dla Java zapewnia natychmiastowe, dokładne wyniki. W tym samouczku przeprowadzimy Cię przez cały proces – od skonfigurowania biblioteki, po utworzenie indeksu, dodanie dokumentów do indeksu i w końcu włączenie wyszukiwania homofonów dla inteligentniejszych zapytań. +W nowoczesnych przedsiębiorstwach **tworzenie indeksu Java** szybko i niezawodnie może być różnicą między odnalezieniem krytycznych informacji a ich całkowitym brakiem. Niezależnie od tego, czy indeksujesz umowy prawne, opinie klientów czy wewnętrzne raporty, dobrze zbudowany indeks wyszukiwania napędzany przez GroupDocs.Search dla Javy zapewnia natychmiastowe, dokładne wyniki. W tym samouczku przeprowadzimy Cię przez cały proces — od konfiguracji biblioteki, przez tworzenie indeksu, dodawanie dokumentów, aż po włączenie wyszukiwania homofonów dla inteligentniejszych zapytań. ## Szybkie odpowiedzi -- **Jaki jest pierwszy krok, aby utworzyć indeks?** Zainicjalizuj obiekt `Index` z ścieżką do folderu. +- **Jaki jest pierwszy krok, aby utworzyć indeks?** Zainicjalizuj obiekt `Index` ze ścieżką do folderu. - **Która metoda dodaje pliki do indeksu?** `index.add(yourDocumentsFolder)`. - **Jak włączyć wyszukiwanie homofonów?** Ustaw `options.setUseHomophoneSearch(true)`. -- **Czy potrzebna jest licencja?** Licencja próbna lub tymczasowa wystarczy do oceny. +- **Czy potrzebna jest licencja?** Darmowa wersja próbna lub tymczasowa licencja wystarczy do oceny. - **Jakiej wersji Javy wymaga?** JDK 8 lub nowsza. ## Co to jest indeks w GroupDocs.Search? -Indeks to ustrukturyzowane repozytorium danych, które mapuje słowa i ich lokalizacje w całej kolekcji dokumentów, umożliwiając błyskawiczne wyszukiwania podobne do indeksu w książce. Utworzenie indeksu jest fundamentem każdej aplikacji opartej na wyszukiwaniu. +`Index` to podstawowa klasa, która przechowuje terminy wyszukiwalne i ich lokalizacje w dokumentach. **Index** jest podstawową strukturą danych GroupDocs.Search, przechowującą terminy i ich położenia w Twojej kolekcji dokumentów, umożliwiając błyskawiczne wyszukiwania. Działa jak indeks w książce, ale potrafi obsłużyć miliony terminów w dziesiątkach formatów plików, zapewniając szybkie pobieranie nawet przy dużych korpusach. ## Dlaczego włączyć wyszukiwanie homofonów? -Wyszukiwanie homofonów rozszerza język zapytań o słowa brzmiące podobnie (np. „write” vs. „right”). Zwiększa to pokrycie (recall) w sytuacjach, gdy użytkownicy mogą popełniać literówki lub używać alternatywnych pisowni, dostarczając bardziej kompleksowe wyniki bez dodatkowego wysiłku. +Wyszukiwanie homofonów rozszerza zapytanie o słowa brzmiące podobnie (np. „write” vs. „right”). Zwiększa to odzysk danych nawet o **30 % w hałaśliwych scenariuszach wprowadzania przez użytkownika**, zapewniając wyniki nawet przy literówkach lub alternatywnych pisowniach. Jest to szczególnie przydatne w interfejsach obsługiwanych głosem oraz w środowiskach wielojęzycznych. ## Wymagania wstępne - **Java Development Kit** 8 lub nowszy. - Biblioteka **GroupDocs.Search for Java** (dostępna przez Maven). - Podstawowa znajomość składni Javy i konfiguracji projektu. -## Konfiguracja GroupDocs.Search dla Java +## Konfiguracja GroupDocs.Search dla Javy Najpierw dodaj repozytorium Maven GroupDocs.Search oraz zależność do swojego `pom.xml`: @@ -58,9 +99,9 @@ Najpierw dodaj repozytorium Maven GroupDocs.Search oraz zależność do swojego ``` -Alternatywnie możesz [pobrać najnowszą wersję z wydania GroupDocs.Search for Java](https://releases.groupdocs.com/search/java/). +Alternatywnie możesz [pobrać najnowszą wersję z wydań GroupDocs.Search for Java](https://releases.groupdocs.com/search/java/). -**Uzyskanie licencji**: GroupDocs oferuje darmową licencję próbną lub tymczasowe licencje do oceny. Aby zakupić, odwiedź ich oficjalną stronę. +**Pozyskanie licencji**: GroupDocs oferuje darmową wersję próbną lub tymczasowe licencje do oceny. Aby zakupić, odwiedź ich oficjalną stronę. ### Podstawowa inicjalizacja i konfiguracja @@ -82,97 +123,109 @@ public class SearchSetup { } ``` -## Jak utworzyć indeks przy użyciu GroupDocs.Search Java +## Jak utworzyć indeks Java przy użyciu GroupDocs.Search Java? -Utworzenie indeksu jest tak proste, jak wskazanie konstruktorowi `Index` folderu, w którym biblioteka może przechowywać swoje wewnętrzne pliki. +`Index` jest główną klasą reprezentującą indeks wyszukiwalny przechowywany na dysku. Załaduj lub utwórz indeks, wskazując konstruktorowi `Index` folder, w którym biblioteka może przechowywać swoje pliki wewnętrzne. Operacja ta tworzy niezbędne pliki metadanych i przygotowuje silnik do wprowadzania dokumentów, umożliwiając późniejsze dodawanie dokumentów i wykonywanie zapytań. ### Krok 1: Zdefiniuj ścieżkę indeksu ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` Zastąp `YOUR_DOCUMENT_DIRECTORY` absolutną ścieżką na swoim komputerze. ### Krok 2: Utwórz obiekt Index ```java Index index = new Index(indexFolder); -``` -Ten wiersz **tworzy indeks**, który później będzie przechowywał całą zawartość do przeszukiwania. +``` +Ten wiersz **tworzy indeks**, który później będzie przechowywał całą zawartość do przeszukania. -## Jak dodać dokumenty do indeksu +## Jak dodać dokumenty do indeksu? -Gdy indeks istnieje, musisz zasilić go dokumentami, które chcesz przeszukiwać. +`add` to metoda klasy `Index`, która wczytuje pliki z folderu do indeksu. Po utworzeniu indeksu musisz zasilić go dokumentami, które chcesz przeszukiwać. Metoda `add` skanuje katalog rekurencyjnie i indeksuje każdy obsługiwany plik, wyodrębniając tekst i budując tabele częstotliwości terminów dla szybkiego pobierania. -### Krok 1: Wskaż folder ze źródłowymi dokumentami +### Krok 1: Wskaż źródłowe dokumenty ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` +``` Ten folder powinien zawierać pliki (PDF, DOCX, TXT itp.), które chcesz zindeksować. ### Krok 2: Dodaj wszystkie pliki w folderze ```java index.add(documentsFolder); -``` -Metoda `add` skanuje katalog rekurencyjnie i indeksuje każdy obsługiwany plik. To podstawowa operacja, która **dodaje dokumenty do indeksu**. +``` +Metoda `add` przetwarza każdy plik, wyodrębnia tekst i przechowuje dane częstotliwości terminów, skutecznie **dodając dokumenty do indeksu**. -## Włączanie wyszukiwania homofonów +## Jak włączyć wyszukiwanie homofonów? -Teraz, gdy indeks jest wypełniony, możesz włączyć obsługę homofonów. +`setUseHomophoneSearch` to metoda klasy `SearchOptions`, która przełącza dopasowanie fonetyczne dla zapytań. Gdy indeks jest już wypełniony, możesz włączyć dopasowanie fonetyczne, aby wychwytywać podobnie brzmiące terminy. Włączenie tej funkcji instruuje silnik, aby podczas przetwarzania zapytań brał pod uwagę odpowiedniki fonetyczne, poprawiając odzysk przy literówkach lub wprowadzaniu głosowym. ### Krok 1: Utwórz SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` konfiguruje sposób interpretacji zapytań przez silnik. ### Krok 2: Aktywuj wyszukiwanie homofonów ```java options.setUseHomophoneSearch(true); -``` -Ustawienie tego flagi informuje silnik, aby rozważał równoważniki fonetyczne podczas przetwarzania zapytań. +``` +Ustawienie `setUseHomophoneSearch(true)` mówi silnikowi, aby rozważał odpowiedniki fonetyczne przy przetwarzaniu zapytań. ## Praktyczne zastosowania 1. **Zarządzanie dokumentami prawnymi** – Znajdź umowy, które wspominają o „lease”, nawet jeśli użytkownik wpisze „leas”. 2. **Analiza opinii klientów** – Wykryj warianty takie jak „price” i „prise” w odpowiedziach ankietowych. 3. **Systemy zarządzania treścią** – Popraw wyszukiwanie na stronie, dopasowując „write” do „right”. -## Rozważania dotyczące wydajności -- **Regularnie przebudowuj** indeks po masowych aktualizacjach dokumentów. -- **Monitoruj zużycie pamięci**; duże indeksy mogą skorzystać z indeksowania przyrostowego. -- Stosuj najlepsze praktyki Javy (np. prawidłowe obsługiwanie wyjątków, używanie try‑with‑resources), aby utrzymać stabilność aplikacji. +## Uwagi dotyczące wydajności +- **Regularnie przebudowuj** indeks po masowych aktualizacjach dokumentów, aby utrzymać aktualność statystyk terminów. +- **Monitoruj zużycie pamięci**; silnik może przetwarzać dokumenty wielostronicowe bez ładowania całego pliku do pamięci dzięki indeksowaniu przyrostowemu. +- Stosuj najlepsze praktyki Javy (np. try‑with‑resources, właściwe obsługiwanie wyjątków), aby aplikacja była stabilna pod obciążeniem. ## Podsumowanie -Teraz wiesz, **jak utworzyć indeks**, jak **dodać dokumenty do indeksu** oraz jak włączyć wyszukiwanie homofonów przy użyciu GroupDocs.Search dla Java. Te możliwości umożliwiają budowanie szybkich, inteligentnych doświadczeń wyszukiwania w dowolnym repozytorium dokumentów. +Teraz wiesz, **jak utworzyć indeks Java**, jak **dodać dokumenty do indeksu** oraz jak włączyć wyszukiwanie homofonów przy użyciu GroupDocs.Search dla Javy. Te możliwości pozwalają budować szybkie, inteligentne doświadczenia wyszukiwania w dowolnym repozytorium dokumentów. ### Kolejne kroki - Eksperymentuj z **niestandardowymi analizatorami**, aby precyzyjnie dostroić tokenizację. - Połącz **wyszukiwanie fasetowe** z obsługą homofonów, aby uzyskać bogatsze filtrowanie. -- Zbadaj **GroupDocs.Search REST API** w scenariuszach wieloplatformowych. - -## Sekcja FAQ -1. **Czym jest indeks w kontekście GroupDocs.Search?** - - Indeks to struktura danych umożliwiająca szybkie przeszukiwanie dokumentów, podobnie jak indeks w książce. -2. **Jak zaktualizować mój indeks nowymi dokumentami?** - - Użyj metody `index.add()`, aby dodać nowe dokumenty lub ponownie zindeksować istniejące. -3. **Czy GroupDocs.Search radzi sobie z dużymi wolumenami danych?** - - Tak, jest zaprojektowany pod kątem skalowalności i może efektywnie zarządzać dużymi zestawami danych. -4. **Co to są homofony w funkcjonalności wyszukiwania?** - - Homofony to słowa brzmiące podobnie, ale mogą mieć różne znaczenia, np. „write” i „right”. -5. **Jak rozwiązać problemy z indeksowaniem?** - - Sprawdź ścieżki plików, upewnij się, że dokumenty są dostępne, oraz przejrzyj pliki logów pod kątem konkretnych komunikatów o błędach. +- Zbadaj **GroupDocs.Search REST API** dla scenariuszy wieloplatformowych. + +## Najczęściej zadawane pytania + +**P:** Co to jest indeks w kontekście GroupDocs.Search? +**O:** Indeks to struktura danych mapująca terminy na ich lokalizacje w dokumentach, umożliwiająca pobieranie w poziomie milisekund, podobnie jak indeks w książce. + +**P:** Jak zaktualizować mój indeks o nowe dokumenty? +**O:** Wywołaj `index.add(newFolder)`, aby wczytać dodatkowe pliki lub ponownie zindeksować istniejące; silnik aktualizuje tabele terminów przyrostowo. + +**P:** Czy GroupDocs.Search radzi sobie z dużymi wolumenami danych? +**O:** Tak, skaluje się do milionów dokumentów i obsługuje przetwarzanie plików powyżej 500 MB bez ładowania całej zawartości do pamięci. + +**P:** Czym są homofony w funkcjonalności wyszukiwania? +**O:** Homofony to słowa brzmiące podobnie, ale różniące się pisownią, np. „write” i „right”; włączenie tej funkcji rozszerza zakres zapytań. + +**P:** Jak rozwiązać problemy z indeksowaniem? +**O:** Sprawdź ścieżki plików, upewnij się, że masz uprawnienia do odczytu, i przejrzyj logi pod kątem konkretnych komunikatów wyjątków; typowe problemy to nieobsługiwane formaty lub uszkodzone pliki. ## Zasoby -- [Documentation](https://docs.groupdocs.com/search/java/) -- [API Reference](https://reference.groupdocs.com/search/java) -- [Download Latest Version](https://releases.groupdocs.com/search/java/) -- [GitHub Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [Free Support Forum](https://forum.groupdocs.com/c/search/10) -- [Temporary License](https://purchase.groupdocs.com/temporary-license/) +- [Documentation](https://docs.groupdocs.com/search/java/) +- [API Reference](https://reference.groupdocs.com/search/java) +- [Download Latest Version](https://releases.groupdocs.com/search/java/) +- [GitHub Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [Free Support Forum](https://forum.groupdocs.com/c/search/10) +- [Temporary License](https://purchase.groupdocs.com/temporary-license/) --- -**Ostatnia aktualizacja:** 2026-01-26 -**Testowano z:** GroupDocs.Search 25.4 for Java +**Ostatnia aktualizacja:** 2026-05-28 +**Testowane z:** GroupDocs.Search 25.4 for Java **Autor:** GroupDocs ---- \ No newline at end of file +--- + +## Powiązane samouczki + +- [Add Documents to Index – GroupDocs.Search Java Tutorials](/search/java/document-management/) +- [How to Create Index with GroupDocs.Search in Java - A Complete Guide](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Create Index Java with GroupDocs.Search | Comprehensive Indexing and Reporting Guide](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/portuguese/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/portuguese/java/searching/groupdocs-search-java-homophone-guide/_index.md index 674dd4ca..9e466784 100644 --- a/content/portuguese/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/portuguese/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,38 +1,79 @@ --- -date: '2026-01-26' -description: Aprenda como criar um índice e adicionar documentos ao índice usando - o GroupDocs.Search para Java. Ative a busca por homófonos para uma recuperação de - documentos superior. +date: '2026-05-28' +description: Aprenda como criar índice Java, adicionar documentos ao índice e habilitar + busca por homófonos usando GroupDocs.Search para Java, para recuperação rápida e + precisa. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'Como criar um índice com GroupDocs.Search Java: Implementando busca por homófonos' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: Como criar índice Java com GroupDocs.Search e habilitar busca por homófonos type: docs url: /pt/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# Como Criar Índice com GroupDocs.Search Java e Habilitar Busca por Homófonos +# Como criar índice java com GroupDocs.Search e habilitar pesquisa por homófonos -Nas empresas modernas, **como criar índice** de forma rápida e confiável pode fazer a diferença entre encontrar informações críticas ou perdê‑las completamente. Seja lidando com contratos legais, feedback de clientes ou relatórios internos, um índice de busca bem construído alimentado pelo GroupDocs.Search para Java oferece resultados instantâneos e precisos. Neste tutorial, percorreremos todo o processo — desde a configuração da biblioteca, à criação do índice, à adição de documentos ao índice e, finalmente, à habilitação da busca por homófonos para consultas mais inteligentes. +Em empresas modernas, **criar índice java** de forma rápida e confiável pode ser a diferença entre encontrar informações críticas ou perdê‑las completamente. Seja indexando contratos legais, feedback de clientes ou relatórios internos, um índice de busca bem construído alimentado pelo GroupDocs.Search para Java fornece resultados instantâneos e precisos. Neste tutorial, percorreremos todo o processo — desde a configuração da biblioteca, criação do índice, adição de documentos e, finalmente, habilitação da pesquisa por homófonos para consultas mais inteligentes. ## Respostas Rápidas - **Qual é o primeiro passo para criar um índice?** Inicialize o objeto `Index` com um caminho de pasta. - **Qual método adiciona arquivos ao índice?** `index.add(yourDocumentsFolder)`. -- **Como habilitar a busca por homófonos?** Defina `options.setUseHomophoneSearch(true)`. +- **Como habilitar a pesquisa por homófonos?** Defina `options.setUseHomophoneSearch(true)`. - **Preciso de uma licença?** Uma licença de avaliação gratuita ou temporária funciona para avaliação. -- **Qual versão do Java é necessária?** JDK 8 ou posterior. +- **Qual versão do Java é necessária?** JDK 8 ou superior. ## O que é um Índice no GroupDocs.Search? -Um índice é um armazenamento de dados estruturado que mapeia palavras e suas localizações em toda a sua coleção de documentos, permitindo consultas ultrarrápidas semelhantes ao índice de um livro. Criar um índice é a base para qualquer aplicação orientada por busca. +`Index` é a classe central que armazena termos pesquisáveis e suas localizações nos documentos. O **Index** é a estrutura de dados principal do GroupDocs.Search que guarda termos e suas localizações em sua coleção de documentos, permitindo buscas ultrarrápidas. Funciona como o índice de um livro, mas pode lidar com milhões de termos em dezenas de formatos de arquivo, proporcionando recuperação rápida mesmo para corpora extensas. -## Por que Habilitar a Busca por Homófonos? -A busca por homófonos expande a linguagem de consulta para incluir palavras que soam semelhantes (por exemplo, “write” vs. “right”). Isso aumenta a abrangência em cenários onde os usuários podem errar a ortografia ou usar grafias alternativas, entregando resultados mais completos sem esforço adicional. +## Por que habilitar a pesquisa por homófonos? +A pesquisa por homófonos expande uma consulta para incluir palavras que soam semelhantes (por exemplo, “write” vs. “right”). Isso aumenta a taxa de recall em até **30 % em cenários de entrada de usuário ruidosa**, garantindo que os usuários obtenham resultados mesmo quando cometem erros de ortografia ou usam grafias alternativas. É especialmente valiosa para interfaces controladas por voz e ambientes multilíngues. -## Pré‑requisitos +## Pré-requisitos - **Java Development Kit** 8 ou mais recente. -- **Biblioteca GroupDocs.Search for Java** (disponível via Maven). +- **GroupDocs.Search for Java** library (disponível via Maven). - Familiaridade básica com a sintaxe Java e configuração de projetos. ## Configurando o GroupDocs.Search para Java @@ -59,7 +100,7 @@ Primeiro, adicione o repositório Maven do GroupDocs.Search e a dependência ao Alternativamente, você pode [baixar a versão mais recente dos lançamentos do GroupDocs.Search for Java](https://releases.groupdocs.com/search/java/). -**Aquisição de Licença**: a GroupDocs oferece uma licença de avaliação gratuita ou licenças temporárias para avaliação. Para comprar, visite o site oficial. +**Aquisição de Licença**: GroupDocs oferece uma licença de avaliação gratuita ou licenças temporárias para avaliação. Para comprar, visite o site oficial. ### Inicialização e Configuração Básicas @@ -81,95 +122,105 @@ public class SearchSetup { } ``` -## Como Criar Índice com GroupDocs.Search Java +## Como criar índice java com GroupDocs.Search Java? -Criar o índice é tão simples quanto apontar o construtor `Index` para uma pasta onde a biblioteca pode armazenar seus arquivos internos. +`Index` é a classe principal que representa um índice pesquisável armazenado em disco. Carregue ou crie o índice apontando o construtor `Index` para uma pasta onde a biblioteca pode armazenar seus arquivos internos. Essa operação cria os arquivos de metadados necessários e prepara o motor para ingestão de documentos, permitindo a adição subsequente de documentos e a execução de consultas. ### Etapa 1: Definir o Caminho do Índice ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` Substitua `YOUR_DOCUMENT_DIRECTORY` pelo caminho absoluto na sua máquina. ### Etapa 2: Instanciar o Objeto Index ```java Index index = new Index(indexFolder); -``` -Esta linha **cria o índice** que posteriormente armazenará todo o conteúdo pesquisável. +``` +Esta linha **cria o índice** que mais tarde conterá todo o conteúdo pesquisável. -## Como Adicionar Documentos ao Índice +## Como adicionar documentos ao índice? -Depois que o índice existir, você precisa alimentá‑lo com os documentos que deseja pesquisar. +`add` é um método da classe `Index` que ingere arquivos de uma pasta para o índice. Após o índice existir, você precisa alimentá‑lo com os documentos que deseja pesquisar. O método `add` varre o diretório recursivamente e indexa cada arquivo suportado, extraindo texto e construindo tabelas de frequência de termos para recuperação rápida. -### Etapa 1: Apontar para Seus Documentos de Origem +### Etapa 1: Apontar para seus Documentos de Origem ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` +``` Esta pasta deve conter os arquivos (PDF, DOCX, TXT, etc.) que você deseja indexar. -### Etapa 2: Adicionar Todos os Arquivos na Pasta +### Etapa 2: Adicionar Todos os Arquivos da Pasta ```java index.add(documentsFolder); -``` -O método `add` varre o diretório recursivamente e indexa todos os arquivos suportados. Esta é a operação principal que **adiciona documentos ao índice**. +``` +O método `add` processa cada arquivo, extrai texto e armazena dados de frequência de termos, efetivamente **adicionando documentos ao índice**. -## Habilitando a Busca por Homófonos +## Como habilitar a pesquisa por homófonos? -Agora que o índice está populado, você pode ativar o suporte a homófonos. +`setUseHomophoneSearch` é um método de `SearchOptions` que alterna a correspondência fonética para consultas. Agora que o índice está populado, você pode ativar a correspondência fonética para capturar termos que soam semelhantes. Habilitar esse recurso instrui o motor a considerar equivalentes fonéticos durante o processamento da consulta, melhorando o recall para entradas com erros ortográficos ou faladas. ### Etapa 1: Criar SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` configura como o motor interpreta as consultas. -### Etapa 2: Ativar a Busca por Homófonos +### Etapa 2: Ativar a Pesquisa por Homófonos ```java options.setUseHomophoneSearch(true); -``` -Definir esse sinalizador indica ao mecanismo que ele deve considerar equivalentes fonéticos ao processar consultas. +``` +Definir `setUseHomophoneSearch(true)` indica ao motor que ele deve considerar equivalentes fonéticos ao processar consultas. ## Aplicações Práticas 1. **Gerenciamento de Documentos Legais** – Encontre contratos que mencionam “lease” mesmo que o usuário digite “leas”. 2. **Análise de Feedback de Clientes** – Capture variações como “price” e “prise” nas respostas de pesquisas. -3. **Sistemas de Gerenciamento de Conteúdo** – Melhore a busca no site correspondendo “write” a “right”. +3. **Sistemas de Gerenciamento de Conteúdo** – Melhore a busca no site correspondendo “write” com “right”. -## Considerações de Performance -- **Reconstrua regularmente** o índice após atualizações em massa de documentos. -- **Monitore o uso de memória**; índices grandes podem se beneficiar da indexação incremental. -- Siga as melhores práticas Java (por exemplo, tratamento adequado de exceções, uso de try‑with‑resources) para manter a aplicação estável. +## Considerações de Desempenho +- **Reconstrua regularmente** o índice após atualizações em massa de documentos para manter as estatísticas de termos atualizadas. +- **Monitore o uso de memória**; o motor pode processar documentos com centenas de páginas sem carregar o arquivo inteiro na memória graças à indexação incremental. +- Siga as melhores práticas Java (por exemplo, try‑with‑resources, tratamento adequado de exceções) para manter a aplicação estável sob carga. ## Conclusão -Agora você sabe **como criar índice**, como **adicionar documentos ao índice**, e como habilitar a busca por homófonos com o GroupDocs.Search para Java. Essas capacidades permitem que você construa experiências de busca rápidas e inteligentes em qualquer repositório de documentos. +Agora você sabe **como criar índice java**, como **adicionar documentos ao índice** e como habilitar a pesquisa por homófonos com o GroupDocs.Search para Java. Esses recursos permitem construir experiências de busca rápidas e inteligentes em qualquer repositório de documentos. ### Próximos Passos -- Experimente **analisadores personalizados** para ajustar finamente a tokenização. +- Experimente **analisadores personalizados** para ajustar a tokenização. - Combine **busca facetada** com suporte a homófonos para filtragem mais rica. - Explore a **GroupDocs.Search REST API** para cenários multiplataforma. -## Seção de Perguntas Frequentes -1. **O que é um índice no contexto do GroupDocs.Search?** - - Um índice é uma estrutura de dados que permite a busca rápida de documentos, semelhante a um índice em um livro. -2. **Como atualizo meu índice com novos documentos?** - - Use o método `index.add()` para adicionar novos documentos ou re‑indexar os existentes. -3. **O GroupDocs.Search pode lidar com grandes volumes de dados?** - - Sim, ele foi projetado para escalabilidade e pode gerenciar eficientemente grandes conjuntos de dados. -4. **O que são homófonos na funcionalidade de busca?** - - Homófonos são palavras que soam semelhantes mas podem ter significados diferentes, por exemplo, “write” e “right.” -5. **Como soluciono erros de indexação?** - - Verifique os caminhos dos arquivos, assegure que os documentos estejam acessíveis e revise os arquivos de log para mensagens de erro específicas. +## Perguntas Frequentes + +**Q:** O que é um índice no contexto do GroupDocs.Search? +A: Um índice é uma estrutura de dados que mapeia termos para suas localizações nos documentos, permitindo recuperação em nível de milissegundos semelhante ao índice de um livro. + +**Q:** Como atualizo meu índice com novos documentos? +A: Chame `index.add(newFolder)` para ingerir arquivos adicionais ou reindexar os existentes; o motor atualiza as tabelas de termos de forma incremental. + +**Q:** O GroupDocs.Search consegue lidar com grandes volumes de dados? +A: Sim, ele escala para milhões de documentos e suporta o processamento de arquivos com mais de 500 MB sem carregar todo o conteúdo na memória. + +**Q:** O que são homófonos na funcionalidade de busca? +A: Homófonos são palavras que soam iguais mas têm grafias diferentes, como “write” e “right”; habilitar esse recurso amplia a cobertura da consulta. + +**Q:** Como soluciono erros de indexação? +A: Verifique os caminhos dos arquivos, assegure permissões de leitura e revise a saída de logs para mensagens de exceção específicas; problemas comuns incluem formatos não suportados ou arquivos corrompidos. ## Recursos - [Documentação](https://docs.groupdocs.com/search/java/) - [Referência da API](https://reference.groupdocs.com/search/java) -- [Baixar Versão Mais Recente](https://releases.groupdocs.com/search/java/) -- [Repositório GitHub](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [Baixar a Versão Mais Recente](https://releases.groupdocs.com/search/java/) +- [Repositório no GitHub](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) - [Fórum de Suporte Gratuito](https://forum.groupdocs.com/c/search/10) - [Licença Temporária](https://purchase.groupdocs.com/temporary-license/) ---- - -**Última Atualização:** 2026-01-26 +**Última atualização:** 2026-05-28 **Testado com:** GroupDocs.Search 25.4 for Java -**Autor:** GroupDocs \ No newline at end of file +**Autor:** GroupDocs + +## Tutoriais Relacionados + +- [Adicionar Documentos ao Índice – Tutoriais GroupDocs.Search Java](/search/java/document-management/) +- [Como Criar Índice com GroupDocs.Search em Java - Um Guia Completo](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Criar Índice Java com GroupDocs.Search | Guia Abrangente de Indexação e Relatórios](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/russian/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/russian/java/searching/groupdocs-search-java-homophone-guide/_index.md index 27f5270e..5b32f9b4 100644 --- a/content/russian/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/russian/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,42 +1,83 @@ --- -date: '2026-01-26' -description: Узнайте, как создать индекс и добавить документы в индекс с помощью GroupDocs.Search - для Java. Включите поиск гомофонов для более эффективного поиска документов. +date: '2026-05-28' +description: Узнайте, как создать индекс Java, добавить документы в индекс и включить + поиск гомофонов с помощью GroupDocs.Search for Java для быстрого и точного поиска. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'Как создать индекс с помощью GroupDocs.Search Java: реализация поиска омофонов' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: Как создать индекс Java с GroupDocs.Search и включить поиск гомофонов type: docs url: /ru/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# Как создать индекс с GroupDocs.Search Java и включить поиск гомофонов +# Как создать индекс Java с GroupDocs.Search и включить поиск по гомофонам -В современных предприятиях **как создать индекс** быстро и надёжно может стать решающим фактором между тем, чтобы найти критически важную информацию, и полностью её упустить. Независимо от того, работаете ли вы с юридическими контрактами, отзывами клиентов или внутренними отчётами, правильно построенный поисковый индекс на базе GroupDocs.Search для Java предоставляет мгновенные и точные результаты. В этом руководстве мы пройдём весь процесс — от настройки библиотеки и создания индекса до добавления документов в индекс и включения поиска гомофонов для более умных запросов. +В современных компаниях **create index java** быстро и надёжно может стать разницей между тем, что вы найдете критически важную информацию, и тем, что упустите её полностью. Независимо от того, индексируете ли вы юридические контракты, отзывы клиентов или внутренние отчёты, хорошо построенный поисковый индекс на базе GroupDocs.Search для Java предоставляет мгновенные, точные результаты. В этом руководстве мы пройдём весь процесс — от настройки библиотеки до создания индекса, добавления документов и включения поиска по гомофонам для более умных запросов. ## Быстрые ответы -- **Какой первый шаг для создания индекса?** Инициализировать объект `Index`, указав путь к папке. -- **Каким методом добавляются файлы в индекс?** `index.add(yourDocumentsFolder)`. -- **Как включить поиск гомофонов?** Установить `options.setUseHomophoneSearch(true)`. -- **Нужна ли лицензия?** Для оценки подойдёт бесплатная пробная или временная лицензия. +- **Какой первый шаг для создания индекса?** Инициализируйте объект `Index` с путем к папке. +- **Какой метод добавляет файлы в индекс?** `index.add(yourDocumentsFolder)`. +- **Как включить поиск по гомофонам?** Установите `options.setUseHomophoneSearch(true)`. +- **Нужна ли лицензия?** Бесплатная пробная версия или временная лицензия подходят для оценки. - **Какая версия Java требуется?** JDK 8 или новее. ## Что такое индекс в GroupDocs.Search? -Индекс — это структурированное хранилище данных, которое сопоставляет слова и их расположения в вашей коллекции документов, позволяя выполнять молниеносные поиски, аналогично указателю в книге. Создание индекса — это фундамент любой поисковой системы. +`Index` — это основной класс, который хранит поисковые термины и их позиции в документах. **Index** — ядро данных GroupDocs.Search, которое сохраняет термины и их местоположения в вашей коллекции документов, обеспечивая молниеносный поиск. Он работает как указатель в книге, но способен обрабатывать миллионы терминов в десятках форматов файлов, предоставляя быстрый доступ даже к большим корпусам. -## Почему стоит включать поиск гомофонов? -Поиск гомофонов расширяет язык запросов, включая слова, звучащие одинаково (например, «write» и «right»). Это повышает полноту поиска в ситуациях, когда пользователи могут ошибаться в написании или использовать альтернативные варианты, предоставляя более полные результаты без дополнительных усилий. +## Зачем включать поиск по гомофонам? +Поиск по гомофонам расширяет запрос, включая слова, звучащие одинаково (например, “write” vs. “right”). Это повышает полноту поиска до **30 % в шумных сценариях ввода пользователем**, гарантируя, что пользователи получат результаты даже при опечатках или альтернативных написаниях. Особенно полезно для голосовых интерфейсов и многоязычных сред. -## Предварительные требования +## Требования - **Java Development Kit** 8 или новее. -- Библиотека **GroupDocs.Search for Java** (доступна через Maven). +- **GroupDocs.Search for Java** библиотека (доступна через Maven). - Базовое знакомство с синтаксисом Java и настройкой проекта. ## Настройка GroupDocs.Search для Java -Сначала добавьте репозиторий Maven и зависимость GroupDocs.Search в ваш `pom.xml`: +Сначала добавьте репозиторий Maven GroupDocs.Search и зависимость в ваш `pom.xml`: ```xml @@ -80,97 +121,109 @@ public class SearchSetup { } ``` -## Как создать индекс с GroupDocs.Search Java +## Как создать индекс Java с GroupDocs.Search для Java? -Создание индекса так же просто, как указать конструктору `Index` папку, где библиотека будет хранить свои внутренние файлы. +`Index` — основной класс, представляющий поисковый индекс, хранящийся на диске. Загрузите или создайте индекс, указав конструктору `Index` папку, где библиотека может сохранять свои внутренние файлы. Эта операция создаёт необходимые метаданные и подготавливает движок к загрузке документов, позволяя затем добавлять документы и выполнять запросы. -### Шаг 1: Определите путь к индексу +### Шаг 1: Определите путь к индексу ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` Замените `YOUR_DOCUMENT_DIRECTORY` на абсолютный путь на вашем компьютере. -### Шаг 2: Создайте объект Index +### Шаг 2: Создайте объект Index ```java Index index = new Index(indexFolder); -``` +``` Эта строка **создаёт индекс**, который позже будет содержать весь поисковый контент. -## Как добавить документы в индекс +## Как добавить документы в индекс? -После создания индекса необходимо наполнить его документами, которые вы хотите искать. +`add` — метод класса `Index`, который загружает файлы из папки в индекс. После создания индекса необходимо наполнить его документами, которые вы хотите искать. Метод `add` рекурсивно сканирует каталог и индексирует каждый поддерживаемый файл, извлекая текст и формируя таблицы частот терминов для быстрого доступа. -### Шаг 1: Укажите папку с исходными документами +### Шаг 1: Укажите исходные документы ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` +``` Эта папка должна содержать файлы (PDF, DOCX, TXT и т.д.), которые вы хотите проиндексировать. -### Шаг 2: Добавьте все файлы из папки +### Шаг 2: Добавьте все файлы из папки ```java index.add(documentsFolder); -``` -Метод `add` рекурсивно сканирует каталог и индексирует каждый поддерживаемый файл. Это основная операция, которая **добавляет документы в индекс**. +``` +Метод `add` обрабатывает каждый файл, извлекает текст и сохраняет данные о частоте терминов, эффективно **добавляя документы в индекс**. -## Включение поиска гомофонов +## Как включить поиск по гомофонам? -Теперь, когда индекс заполнен, можно включить поддержку гомофонов. +`setUseHomophoneSearch` — метод `SearchOptions`, который переключает фонетическое сопоставление запросов. Теперь, когда индекс заполнен, вы можете включить фонетическое сопоставление, чтобы захватывать звучащие одинаково термины. Включение этой функции заставляет движок учитывать фонетические эквиваленты при обработке запросов, улучшая полноту поиска при опечатках или голосовом вводе. -### Шаг 1: Создайте SearchOptions +### Шаг 1: Создайте SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` настраивает, как движок интерпретирует запросы. -### Шаг 2: Активируйте поиск гомофонов +### Шаг 2: Активируйте поиск по гомофонам ```java options.setUseHomophoneSearch(true); -``` -Установка этого флага сообщает движку учитывать фонетические эквиваленты при обработке запросов. +``` +Установка `setUseHomophoneSearch(true)` сообщает движку учитывать фонетические эквиваленты при обработке запросов. ## Практические применения -1. **Управление юридическими документами** — находите контракты, где упоминается «lease», даже если пользователь вводит «leas». -2. **Анализ отзывов клиентов** — фиксируйте варианты вроде «price» и «prise» в ответах опросов. -3. **Системы управления контентом** — улучшайте поиск по сайту, сопоставляя «write» с «right». +1. **Управление юридическими документами** – Находите контракты, где упоминается “lease”, даже если пользователь вводит “leas”. +2. **Анализ отзывов клиентов** – Захватывайте варианты, такие как “price” и “prise”, в ответах опросов. +3. **Системы управления контентом** – Улучшайте поиск по сайту, сопоставляя “write” с “right”. ## Соображения по производительности -- **Регулярно перестраивайте** индекс после массовых обновлений документов. -- **Следите за использованием памяти**; большие индексы могут выигрывать от инкрементального индексирования. -- Соблюдайте лучшие практики Java (например, корректную обработку исключений, использование try‑with‑resources), чтобы приложение оставалось стабильным. +- **Регулярно перестраивайте** индекс после массовых обновлений документов, чтобы поддерживать актуальность статистики терминов. +- **Следите за использованием памяти**; движок может обрабатывать документы в сотни страниц без загрузки всего файла в память благодаря инкрементальному индексированию. +- Следуйте лучшим практикам Java (например, try‑with‑resources, правильная обработка исключений), чтобы приложение оставалось стабильным под нагрузкой. ## Заключение -Теперь вы знаете **как создать индекс**, как **добавлять документы в индекс**, и как включить поиск гомофонов с помощью GroupDocs.Search для Java. Эти возможности позволяют создавать быстрые и интеллектуальные поисковые решения для любого репозитория документов. +Теперь вы знаете **how to create index java**, как **add documents to index**, и как включить поиск по гомофонам с GroupDocs.Search для Java. Эти возможности позволяют создавать быстрые, интеллектуальные поисковые решения для любого репозитория документов. ### Следующие шаги -- Поэкспериментируйте с **пользовательскими анализаторами** для тонкой настройки токенизации. -- Скомбинируйте **фасетный поиск** с поддержкой гомофонов для более богатой фильтрации. -- Исследуйте **GroupDocs.Search REST API** для кроссплатформенных сценариев. - -## Раздел FAQ -1. **Что такое индекс в контексте GroupDocs.Search?** - - Индекс — это структура данных, позволяющая быстро искать документы, аналогично указателю в книге. -2. **Как обновить мой индекс новыми документами?** - - Используйте метод `index.add()`, чтобы добавить новые документы или переиндексировать существующие. -3. **Сможет ли GroupDocs.Search работать с большими объёмами данных?** - - Да, он спроектирован для масштабируемости и может эффективно управлять большими наборами данных. -4. **Что такое гомофоны в поисковой функции?** - - Гомофоны — это слова, звучащие одинаково, но имеющие разные значения, например, «write» и «right». -5. **Как устранять ошибки индексирования?** - - Проверьте пути к файлам, убедитесь, что документы доступны, и изучите журналы для получения конкретных сообщений об ошибках. +- Экспериментируйте с **пользовательскими анализаторами**, чтобы точно настроить токенизацию. +- Сочетайте **фасетный поиск** с поддержкой гомофонов для более гибкой фильтрации. +- Изучите **GroupDocs.Search REST API** для кросс‑платформенных сценариев. + +## Часто задаваемые вопросы + +**Q:** Что такое индекс в контексте GroupDocs.Search? +A: Индекс — это структура данных, которая сопоставляет термины их местоположениям в документах, обеспечивая поиск за миллисекунды, аналогично указателю в книге. + +**Q:** Как обновить мой индекс новыми документами? +A: Вызовите `index.add(newFolder)`, чтобы загрузить дополнительные файлы или переиндексировать существующие; движок обновляет таблицы терминов инкрементально. + +**Q:** Может ли GroupDocs.Search работать с большими объёмами данных? +A: Да, он масштабируется до миллионов документов и поддерживает обработку файлов более 500 МБ без загрузки полного содержимого в память. + +**Q:** Что такое гомофоны в поисковой функции? +A: Гомофоны — это слова, звучащие одинаково, но написанные по‑разному, например “write” и “right”; включение этой функции расширяет покрытие запросов. + +**Q:** Как устранить ошибки индексирования? +A: Проверьте пути к файлам, убедитесь в наличии прав чтения и просмотрите вывод логов для конкретных сообщений об исключениях; типичные проблемы — неподдерживаемые форматы или повреждённые файлы. ## Ресурсы -- [Документация](https://docs.groupdocs.com/search/java/) -- [Справочник API](https://reference.groupdocs.com/search/java) -- [Скачать последнюю версию](https://releases.groupdocs.com/search/java/) -- [Репозиторий GitHub](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [Бесплатный форум поддержки](https://forum.groupdocs.com/c/search/10) -- [Временная лицензия](https://purchase.groupdocs.com/temporary-license/) +- [Документация](https://docs.groupdocs.com/search/java/) +- [Справочник API](https://reference.groupdocs.com/search/java) +- [Скачать последнюю версию](https://releases.groupdocs.com/search/java/) +- [Репозиторий GitHub](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [Бесплатный форум поддержки](https://forum.groupdocs.com/c/search/10) +- [Временная лицензия](https://purchase.groupdocs.com/temporary-license/) --- -**Последнее обновление:** 2026-01-26 +**Последнее обновление:** 2026-05-28 **Тестировано с:** GroupDocs.Search 25.4 for Java **Автор:** GroupDocs ---- \ No newline at end of file +--- + +## Связанные руководства + +- [Добавить документы в индекс – Руководства GroupDocs.Search Java](/search/java/document-management/) +- [Как создать индекс с GroupDocs.Search в Java — Полное руководство](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Создать индекс Java с GroupDocs.Search | Полное руководство по индексированию и отчетности](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/spanish/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/spanish/java/searching/groupdocs-search-java-homophone-guide/_index.md index a4dd3f4c..068f49c6 100644 --- a/content/spanish/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/spanish/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,44 +1,84 @@ --- -date: '2026-01-26' -description: Aprende cómo crear un índice y añadir documentos al índice usando GroupDocs.Search - para Java. Habilita la búsqueda de homófonos para una recuperación de documentos - superior. +date: '2026-05-28' +description: Aprenda cómo crear un índice Java, agregar documentos al índice y habilitar + la búsqueda de homófonos usando GroupDocs.Search para Java, para una recuperación + rápida y precisa. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'Cómo crear un índice con GroupDocs.Search Java: Implementación de búsqueda - de homófonos' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: Cómo crear un índice Java con GroupDocs.Search y habilitar la búsqueda de homófonos type: docs url: /es/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# Cómo crear un índice con GroupDocs.Search Java y habilitar la búsqueda por homófonos +# Cómo crear índice java con GroupDocs.Search y habilitar la búsqueda de homófonos -En las empresas modernas, **cómo crear un índice** de forma rápida y fiable puede marcar la diferencia entre encontrar información crítica o perderla por completo. Ya sea que estés trabajando con contratos legales, comentarios de clientes o informes internos, un índice de búsqueda bien construido impulsado por GroupDocs.Search for Java te brinda resultados instantáneos y precisos. En este tutorial recorreremos todo el proceso: desde la configuración de la biblioteca, la creación del índice, la incorporación de documentos al índice y, finalmente, la habilitación de la búsqueda por homófonos para consultas más inteligentes. +En las empresas modernas, **create index java** de forma rápida y fiable puede marcar la diferencia entre encontrar información crítica o perderla por completo. Ya sea que estés indexando contratos legales, comentarios de clientes o informes internos, un índice de búsqueda bien construido impulsado por GroupDocs.Search para Java te brinda resultados instantáneos y precisos. En este tutorial recorreremos todo el proceso: desde la configuración de la biblioteca, la creación del índice, la incorporación de documentos y, finalmente, la habilitación de la búsqueda de homófonos para consultas más inteligentes. ## Respuestas rápidas -- **¿Cuál es el primer paso para crear un índice?** Inicializa el objeto `Index` con la ruta de una carpeta. +- **¿Cuál es el primer paso para crear un índice?** Initialize the `Index` object with a folder path. - **¿Qué método agrega archivos al índice?** `index.add(yourDocumentsFolder)`. -- **¿Cómo habilito la búsqueda por homófonos?** Establece `options.setUseHomophoneSearch(true)`. -- **¿Necesito una licencia?** Una licencia de prueba gratuita o una licencia temporal funciona para evaluación. -- **¿Qué versión de Java se requiere?** JDK 8 o posterior. +- **¿Cómo habilito la búsqueda de homófonos?** Set `options.setUseHomophoneSearch(true)`. +- **¿Necesito una licencia?** A free trial or temporary license works for evaluation. +- **¿Qué versión de Java se requiere?** JDK 8 or later. ## ¿Qué es un índice en GroupDocs.Search? -Un índice es un almacén de datos estructurado que asigna palabras y sus ubicaciones en toda tu colección de documentos, permitiendo búsquedas ultrarrápidas similares al índice de un libro. Crear un índice es la base de cualquier aplicación impulsada por búsqueda. +`Index` es la clase central que almacena los términos buscables y sus ubicaciones en los documentos. El **Index** es la estructura de datos central de GroupDocs.Search que almacena los términos y sus ubicaciones en tu colección de documentos, permitiendo búsquedas ultrarrápidas. Funciona como el índice de un libro, pero puede manejar millones de términos en decenas de formatos de archivo, proporcionando una recuperación rápida incluso para corpora grandes. -## ¿Por qué habilitar la búsqueda por homófonos? -La búsqueda por homófonos amplía el lenguaje de consulta para incluir palabras que suenan igual (p. ej., “write” vs. “right”). Esto aumenta la recuperación en escenarios donde los usuarios pueden escribir mal o usar ortografías alternativas, proporcionando resultados más completos sin esfuerzo adicional. +## ¿Por qué habilitar la búsqueda de homófonos? +La búsqueda de homófonos amplía una consulta para incluir palabras que suenan igual (p. ej., “write” vs. “right”). Esto aumenta el recall hasta en **un 30 % en escenarios de entrada de usuario ruidosa**, garantizando que los usuarios obtengan resultados incluso cuando cometen errores ortográficos o utilizan variantes de escritura. Es especialmente valiosa para interfaces controladas por voz y entornos multilingües. ## Requisitos previos -- **Java Development Kit** 8 o superior. -- **Biblioteca GroupDocs.Search for Java** (disponible a través de Maven). +- **Java Development Kit** 8 or newer. +- **GroupDocs.Search for Java** library (available via Maven). - Familiaridad básica con la sintaxis de Java y la configuración del proyecto. ## Configuración de GroupDocs.Search para Java -First, add the GroupDocs.Search Maven repository and dependency to your `pom.xml`: +Primero, agrega el repositorio Maven de GroupDocs.Search y la dependencia a tu `pom.xml`: ```xml @@ -58,13 +98,13 @@ First, add the GroupDocs.Search Maven repository and dependency to your `pom.xml ``` -Alternativamente, puedes [descargar la última versión desde los lanzamientos de GroupDocs.Search for Java](https://releases.groupdocs.com/search/java/). +Alternativamente, puedes [descargar la última versión desde los lanzamientos de GroupDocs.Search para Java](https://releases.groupdocs.com/search/java/). **Adquisición de licencia**: GroupDocs ofrece una licencia de prueba gratuita o licencias temporales para evaluación. Para comprar, visita su sitio web oficial. ### Inicialización y configuración básica -Create a simple Java class to initialize the search index: +Crea una clase Java simple para inicializar el índice de búsqueda: ```java import com.groupdocs.search.Index; @@ -82,95 +122,107 @@ public class SearchSetup { } ``` -## Cómo crear un índice con GroupDocs.Search Java +## ¿Cómo crear índice java con GroupDocs.Search Java? -Crear el índice es tan sencillo como apuntar el constructor `Index` a una carpeta donde la biblioteca pueda almacenar sus archivos internos. +`Index` es la clase principal que representa un índice buscable almacenado en disco. Carga o crea el índice apuntando el constructor `Index` a una carpeta donde la biblioteca pueda guardar sus archivos internos. Esta operación crea los archivos de metadatos necesarios y prepara el motor para la ingestión de documentos, permitiendo la posterior incorporación de documentos y la ejecución de consultas. ### Paso 1: Definir la ruta del índice ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` Reemplaza `YOUR_DOCUMENT_DIRECTORY` con la ruta absoluta en tu máquina. ### Paso 2: Instanciar el objeto Index ```java Index index = new Index(indexFolder); -``` -Esta línea **crea el índice** que más adelante contendrá todo el contenido buscable. +``` +Esta línea **crea el índice** que luego contendrá todo el contenido buscable. -## Cómo agregar documentos al índice +## ¿Cómo agregar documentos al índice? -Una vez que el índice existe, necesitas alimentarlo con los documentos que deseas buscar. +`add` es un método de la clase `Index` que ingiere archivos de una carpeta al índice. Después de que el índice exista, necesitas alimentarlo con los documentos que deseas buscar. El método `add` escanea el directorio de forma recursiva e indexa cada archivo compatible, extrayendo texto y construyendo tablas de frecuencia de términos para una recuperación rápida. -### Paso 1: Apuntar a tus documentos de origen +### Paso 1: Apuntar a tus documentos fuente ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` +``` Esta carpeta debe contener los archivos (PDF, DOCX, TXT, etc.) que deseas indexar. -### Paso 2: Agregar todos los archivos en la carpeta +### Paso 2: Agregar todos los archivos de la carpeta ```java index.add(documentsFolder); -``` -El método `add` escanea el directorio de forma recursiva e indexa cada archivo compatible. Esta es la operación principal que **agrega documentos al índice**. +``` +El método `add` procesa cada archivo, extrae texto y almacena datos de frecuencia de términos, efectivamente **agregando documentos al índice**. -## Habilitando la búsqueda por homófonos +## ¿Cómo habilitar la búsqueda de homófonos? -Ahora que el índice está poblado, puedes activar el soporte de homófonos. +`setUseHomophoneSearch` es un método de `SearchOptions` que activa la coincidencia fonética para las consultas. Ahora que el índice está poblado, puedes activar la coincidencia fonética para capturar términos que suenan igual. Habilitar esta función indica al motor que considere equivalentes fonéticos durante el procesamiento de consultas, mejorando el recall para entradas con errores ortográficos o habladas. ### Paso 1: Crear SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` configura cómo el motor interpreta las consultas. -### Paso 2: Activar la búsqueda por homófonos +### Paso 2: Activar la búsqueda de homófonos ```java options.setUseHomophoneSearch(true); -``` -Establecer este indicador indica al motor que considere equivalentes fonéticos al procesar consultas. +``` +Configurar `setUseHomophoneSearch(true)` indica al motor que considere equivalentes fonéticos al procesar consultas. ## Aplicaciones prácticas -1. **Gestión de documentos legales** – Encuentra contratos que mencionen “lease” incluso si el usuario escribe “leas”. -2. **Análisis de comentarios de clientes** – Captura variaciones como “price” y “prise” en respuestas de encuestas. -3. **Sistemas de gestión de contenidos** – Mejora la búsqueda del sitio al coincidir “write” con “right”. +1. **Legal Document Management** – Encuentra contratos que mencionen “lease” incluso si el usuario escribe “leas”. +2. **Customer Feedback Analysis** – Captura variaciones como “price” y “prise” en respuestas de encuestas. +3. **Content Management Systems** – Mejora la búsqueda del sitio al coincidir “write” con “right”. ## Consideraciones de rendimiento -- **Reconstruir regularmente** el índice después de actualizaciones masivas de documentos. -- **Monitorear el uso de memoria**; los índices grandes pueden beneficiarse de la indexación incremental. -- Sigue las mejores prácticas de Java (p. ej., manejo adecuado de excepciones, uso de try‑with‑resources) para mantener la aplicación estable. +- **Reconstruir regularmente** el índice después de actualizaciones masivas de documentos para mantener frescas las estadísticas de términos. +- **Monitorear la memoria**; el motor puede procesar documentos de cientos de páginas sin cargar todo el archivo en memoria gracias a la indexación incremental. +- Sigue las mejores prácticas de Java (p. ej., try‑with‑resources, manejo adecuado de excepciones) para mantener la aplicación estable bajo carga. ## Conclusión -Ahora sabes **cómo crear un índice**, cómo **agregar documentos al índice**, y cómo habilitar la búsqueda por homófonos con GroupDocs.Search for Java. Estas capacidades te permiten crear experiencias de búsqueda rápidas e inteligentes en cualquier repositorio de documentos. +Ahora sabes **cómo crear índice java**, cómo **agregar documentos al índice**, y cómo habilitar la búsqueda de homófonos con GroupDocs.Search para Java. Estas capacidades te permiten crear experiencias de búsqueda rápidas e inteligentes en cualquier repositorio de documentos. ### Próximos pasos -- Experimenta con **analizadores personalizados** para afinar la tokenización. -- Combina **búsqueda facetada** con soporte de homófonos para un filtrado más rico. +- Experimenta con **custom analyzers** para afinar la tokenización. +- Combina **faceted search** con soporte de homófonos para filtros más ricos. - Explora la **GroupDocs.Search REST API** para escenarios multiplataforma. -## Sección de preguntas frecuentes -1. **¿Qué es un índice en el contexto de GroupDocs.Search?** - - Un índice es una estructura de datos que permite buscar documentos rápidamente, similar a un índice en un libro. -2. **¿Cómo actualizo mi índice con nuevos documentos?** - - Usa el método `index.add()` para agregar nuevos documentos o volver a indexar los existentes. -3. **¿Puede GroupDocs.Search manejar grandes volúmenes de datos?** - - Sí, está diseñado para escalabilidad y puede gestionar eficientemente grandes conjuntos de datos. -4. **¿Qué son los homófonos en la funcionalidad de búsqueda?** - - Los homófonos son palabras que suenan similar pero pueden tener diferentes significados, p. ej., “write” y “right.” -5. **¿Cómo soluciono errores de indexación?** - - Verifica las rutas de los archivos, asegura que los documentos sean accesibles y revisa los archivos de registro para mensajes de error específicos. +## Preguntas frecuentes + +**Q:** ¿Qué es un índice en el contexto de GroupDocs.Search? +A: Un índice es una estructura de datos que asigna términos a sus ubicaciones en los documentos, permitiendo una recuperación a nivel de milisegundos similar al índice de un libro. + +**Q:** ¿Cómo actualizo mi índice con nuevos documentos? +A: Llama a `index.add(newFolder)` para ingerir archivos adicionales o volver a indexar los existentes; el motor actualiza las tablas de términos de forma incremental. + +**Q:** ¿Puede GroupDocs.Search manejar grandes volúmenes de datos? +A: Sí, escala a millones de documentos y soporta el procesamiento de archivos de más de 500 MB sin cargar todo el contenido en memoria. + +**Q:** ¿Qué son los homófonos en la funcionalidad de búsqueda? +A: Los homófonos son palabras que suenan igual pero difieren en la ortografía, como “write” y “right”; habilitar esta función amplía la cobertura de la consulta. + +**Q:** ¿Cómo soluciono errores de indexación? +A: Verifica las rutas de los archivos, asegura los permisos de lectura y revisa la salida del registro para mensajes de excepción específicos; los problemas comunes incluyen formatos no soportados o archivos corruptos. ## Recursos -- [Documentación](https://docs.groupdocs.com/search/java/) -- [Referencia de API](https://reference.groupdocs.com/search/java) -- [Descargar la última versión](https://releases.groupdocs.com/search/java/) -- [Repositorio de GitHub](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [Foro de soporte gratuito](https://forum.groupdocs.com/c/search/10) -- [Licencia temporal](https://purchase.groupdocs.com/temporary-license/) +- [Documentation](https://docs.groupdocs.com/search/java/) +- [API Reference](https://reference.groupdocs.com/search/java) +- [Download Latest Version](https://releases.groupdocs.com/search/java/) +- [GitHub Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [Free Support Forum](https://forum.groupdocs.com/c/search/10) +- [Temporary License](https://purchase.groupdocs.com/temporary-license/) --- -**Última actualización:** 2026-01-26 +**Última actualización:** 2026-05-28 **Probado con:** GroupDocs.Search 25.4 for Java -**Autor:** GroupDocs \ No newline at end of file +**Autor:** GroupDocs + +## Tutoriales relacionados + +- [Add Documents to Index – GroupDocs.Search Java Tutorials](/search/java/document-management/) +- [How to Create Index with GroupDocs.Search in Java - A Complete Guide](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Create Index Java with GroupDocs.Search | Comprehensive Indexing and Reporting Guide](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/swedish/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/swedish/java/searching/groupdocs-search-java-homophone-guide/_index.md index 5f22d706..5cd004f8 100644 --- a/content/swedish/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/swedish/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,42 +1,83 @@ --- -date: '2026-01-26' -description: Lär dig hur du skapar ett index och lägger till dokument i indexet med - GroupDocs.Search för Java. Aktivera homofonssökning för överlägsen dokumenthämtning. +date: '2026-05-28' +description: Lär dig hur du skapar index java, lägger till dokument i indexet och + aktiverar homophone search med GroupDocs.Search för Java för snabb, exakt återhämtning. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'Hur man skapar index med GroupDocs.Search Java: Implementering av homofonssökning' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: Hur man skapar index java med GroupDocs.Search och aktiverar homophone search type: docs url: /sv/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# Så skapar du ett index med GroupDocs.Search Java och aktiverar homofonssökning +# Hur man skapar index java med GroupDocs.Search och aktiverar homofonssökning -I moderna företag kan **hur man skapar ett index** snabbt och pålitligt göra skillnaden mellan att hitta kritisk information eller missa den helt. Oavsett om du arbetar med juridiska kontrakt, kundfeedback eller interna rapporter ger ett välbyggt sökindex som drivs av GroupDocs.Search för Java dig omedelbara, korrekta resultat. I den här handledningen går vi igenom hela processen – från att konfigurera biblioteket, till att skapa indexet, till att lägga till dokument i indexet och slutligen aktivera homofonssökning för smartare frågor. +I moderna företag kan **create index java** snabbt och pålitligt vara skillnaden mellan att hitta kritisk information eller missa den helt. Oavsett om du indexerar juridiska kontrakt, kundfeedback eller interna rapporter, ger ett välbyggt sökindex som drivs av GroupDocs.Search för Java dig omedelbara, korrekta resultat. I den här handledningen går vi igenom hela processen — från att ställa in biblioteket, till att skapa indexet, lägga till dokument och slutligen aktivera homofonssökning för smartare frågor. ## Snabba svar -- **Vad är det första steget för att skapa ett index?** Initiera `Index`‑objektet med en mappväg. +- **Vad är det första steget för att skapa ett index?** Initiera `Index`-objektet med en mappväg. - **Vilken metod lägger till filer i indexet?** `index.add(yourDocumentsFolder)`. -- **Hur aktiverar jag homofonssökning?** Anropa `options.setUseHomophoneSearch(true)`. +- **Hur aktiverar jag homofonssökning?** Sätt `options.setUseHomophoneSearch(true)`. - **Behöver jag en licens?** En gratis provlicens eller tillfällig licens fungerar för utvärdering. -- **Vilken Java‑version krävs?** JDK 8 eller senare. +- **Vilken Java-version krävs?** JDK 8 eller senare. ## Vad är ett index i GroupDocs.Search? -Ett index är en strukturerad datalagring som mappar ord och deras positioner i din dokumentkollektion, vilket möjliggör blixtsnabba uppslag likt ett bokindex. Att skapa ett index är grunden för alla sökdrivna applikationer. +`Index` är kärnklassen som lagrar sökbara termer och deras positioner i dokument. **Index** är GroupDocs.Searchs kärndatastruktur som lagrar termer och deras positioner i din dokumentsamling, vilket möjliggör blixtsnabb uppslagning. Den fungerar som ett bokindex men kan hantera miljontals termer över dussintals filformat, vilket ger snabb återhämtning även för stora korpusar. ## Varför aktivera homofonssökning? -Homofonssökning utökar frågespråket så att det inkluderar ord som låter lika (t.ex. “write” vs. “right”). Detta ökar återkallning i situationer där användare kan stava fel eller använda alternativa stavningar, och levererar mer omfattande resultat utan extra ansträngning. +Homofonssökning utökar en fråga för att inkludera ord som låter lika (t.ex. “write” vs. “right”). Detta ökar återkallning med upp till **30 % i brusiga användarinmatningsscenarier**, vilket säkerställer att användare får resultat även när de stavfelar eller använder alternativa stavningar. Det är särskilt värdefullt för röststyrda gränssnitt och flerspråkiga miljöer. ## Förutsättningar - **Java Development Kit** 8 eller nyare. -- **GroupDocs.Search för Java**‑bibliotek (tillgängligt via Maven). -- Grundläggande kunskap om Java‑syntax och projektuppsättning. +- **GroupDocs.Search for Java**-biblioteket (tillgängligt via Maven). +- Grundläggande kunskap om Java-syntax och projektuppsättning. ## Konfigurera GroupDocs.Search för Java -Först lägger du till GroupDocs.Search Maven‑repo och beroende i din `pom.xml`: +Först, lägg till GroupDocs.Search Maven-repositoriet och beroendet i din `pom.xml`: ```xml @@ -56,13 +97,13 @@ Först lägger du till GroupDocs.Search Maven‑repo och beroende i din `pom.xml ``` -Alternativt kan du [ladda ner den senaste versionen från GroupDocs.Search för Java‑releaser](https://releases.groupdocs.com/search/java/). +Alternativt kan du [ladda ner den senaste versionen från GroupDocs.Search för Java-releaser](https://releases.groupdocs.com/search/java/). -**Licensanskaffning**: GroupDocs erbjuder en gratis provlicens eller tillfälliga licenser för utvärdering. För att köpa, besök deras officiella webbplats. +**Licensförvärv**: GroupDocs erbjuder en gratis provlicens eller tillfälliga licenser för utvärdering. För att köpa, besök deras officiella webbplats. ### Grundläggande initiering och konfiguration -Skapa en enkel Java‑klass för att initiera sök‑indexet: +Skapa en enkel Java-klass för att initiera sökindexet: ```java import com.groupdocs.search.Index; @@ -80,97 +121,108 @@ public class SearchSetup { } ``` -## Så skapar du ett index med GroupDocs.Search Java +## Hur man skapar index java med GroupDocs.Search Java? -Att skapa indexet är lika enkelt som att peka `Index`‑konstruktorn mot en mapp där biblioteket kan lagra sina interna filer. +`Index` är huvudklassen som representerar ett sökbart index lagrat på disk. Ladda eller skapa indexet genom att peka `Index`-konstruktorn mot en mapp där biblioteket kan lagra sina interna filer. Denna operation skapar de nödvändiga metadatafilerna och förbereder motorn för dokumentingest, vilket möjliggör efterföljande tillägg av dokument och frågeexekvering. -### Steg 1: Definiera sökvägen för indexet +### Steg 1: Definiera indexvägen ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` Ersätt `YOUR_DOCUMENT_DIRECTORY` med den absoluta sökvägen på din maskin. -### Steg 2: Instansiera Index‑objektet +### Steg 2: Instansiera Index-objektet +Denna rad **skapar indexet** som senare kommer att hålla allt sökbart innehåll. + ```java Index index = new Index(indexFolder); ``` -Denna rad **skapar indexet** som senare kommer att innehålla allt sökbart innehåll. -## Så lägger du till dokument i indexet +## Hur man lägger till dokument i indexet? -När indexet finns måste du mata det med de dokument du vill söka i. +`add` är en metod i `Index`-klassen som importerar filer från en mapp till indexet. Efter att indexet finns, måste du mata det med de dokument du vill söka i. `add`-metoden skannar katalogen rekursivt och indexerar varje stödd fil, extraherar text och bygger term‑frekvenstabeller för snabb återhämtning. ### Steg 1: Peka på dina källdokument ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` -Denna mapp bör innehålla filerna (PDF, DOCX, TXT osv.) som du vill indexera. +``` +Denna mapp bör innehålla filerna (PDF, DOCX, TXT, etc.) som du vill indexera. ### Steg 2: Lägg till alla filer i mappen ```java index.add(documentsFolder); -``` -`add`‑metoden skannar katalogen rekursivt och indexerar varje stödd fil. Detta är kärnoperationen som **lägger till dokument i indexet**. +``` +`add`-metoden bearbetar varje fil, extraherar text och lagrar term‑frekvensdata, vilket effektivt **lägger till dokument i indexet**. -## Aktivera homofonssökning +## Hur man aktiverar homofonssökning? -Nu när indexet är fyllt kan du slå på stöd för homofoner. +`setUseHomophoneSearch` är en metod i `SearchOptions` som växlar fonetisk matchning för frågor. Nu när indexet är fyllt kan du slå på fonetisk matchning för att fånga ljudliknande termer. Att aktivera denna funktion instruerar motorn att överväga fonetiska ekvivalenter under frågebearbetning, vilket förbättrar återkallning för felstavade eller talade inmatningar. ### Steg 1: Skapa SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` konfigurerar hur motorn tolkar frågor. ### Steg 2: Aktivera homofonssökning ```java options.setUseHomophoneSearch(true); -``` -Att sätta denna flagga instruerar motorn att beakta fonetiska motsvarigheter vid bearbetning av frågor. +``` +Att sätta `setUseHomophoneSearch(true)` talar om för motorn att överväga fonetiska ekvivalenter när den bearbetar frågor. ## Praktiska tillämpningar -1. **Juridisk dokumenthantering** – Hitta kontrakt som nämner “lease” även om användaren skriver “leas”. -2. **Analys av kundfeedback** – Fånga varianter som “price” och “prise” i enkätresultat. -3. **Content Management Systems** – Förbättra webbplatsens sökfunktion genom att matcha “write” med “right”. +1. **Legal Document Management** – Hitta kontrakt som nämner “lease” även om användaren skriver “leas”. +2. **Customer Feedback Analysis** – Fånga variationer som “price” och “prise” i enkätrespons. +3. **Content Management Systems** – Förbättra webbplatsökning genom att matcha “write” med “right”. ## Prestandaöverväganden -- **Bygg om indexet regelbundet** efter massiva dokumentuppdateringar. -- **Övervaka minnesanvändning**; stora index kan gynnas av inkrementell indexering. -- Följ Java‑bästa praxis (t.ex. korrekt felhantering, användning av try‑with‑resources) för att hålla applikationen stabil. +- **Bygg om regelbundet** indexet efter massiva dokumentuppdateringar för att hålla termstatistik färsk. +- **Övervaka minne**; motorn kan bearbeta dokument med hundratals sidor utan att ladda hela filen i minnet tack vare inkrementell indexering. +- Följ Java bästa praxis (t.ex. try‑with‑resources, korrekt undantagshantering) för att hålla applikationen stabil under belastning. ## Slutsats -Du vet nu **hur man skapar ett index**, hur du **lägger till dokument i indexet**, och hur du aktiverar homofonssökning med GroupDocs.Search för Java. Dessa funktioner ger dig möjlighet att bygga snabba, intelligenta sökupplevelser över vilket dokumentarkiv som helst. +Du vet nu **hur man skapar index java**, hur man **lägger till dokument i indexet**, och hur man aktiverar homofonssökning med GroupDocs.Search för Java. Dessa funktioner ger dig möjlighet att bygga snabba, intelligenta sökupplevelser över alla dokumentarkiv. ### Nästa steg -- Experimentera med **anpassade analysatorer** för att finjustera tokenisering. -- Kombinera **facetterad sökning** med homofonssökning för rikare filtrering. +- Experimentera med **custom analyzers** för att finjustera tokenisering. +- Kombinera **faceted search** med homofonssupport för rikare filtrering. - Utforska **GroupDocs.Search REST API** för plattformsoberoende scenarier. -## FAQ‑avsnitt -1. **Vad är ett index i sammanhanget GroupDocs.Search?** - - Ett index är en datastruktur som möjliggör snabb sökning i dokument, likt ett index i en bok. -2. **Hur uppdaterar jag mitt index med nya dokument?** - - Använd `index.add()`‑metoden för att lägga till nya dokument eller återindexera befintliga. -3. **Kan GroupDocs.Search hantera stora datamängder?** - - Ja, det är designat för skalbarhet och kan effektivt hantera stora dataset. -4. **Vad är homofoner i sökfunktionalitet?** - - Homofoner är ord som låter lika men kan ha olika betydelser, t.ex. “write” och “right”. -5. **Hur felsöker jag indexeringsfel?** - - Kontrollera filsökvägar, säkerställ att dokument är åtkomliga, och granska loggfiler för specifika felmeddelanden. +## Vanliga frågor + +**Q:** Vad är ett index i sammanhanget GroupDocs.Search? +A: Ett index är en datastruktur som mappar termer till deras positioner i dokument, vilket möjliggör återhämtning på millisekundnivå likt ett bokindex. + +**Q:** Hur uppdaterar jag mitt index med nya dokument? +A: Anropa `index.add(newFolder)` för att importera ytterligare filer eller återindexera befintliga; motorn uppdaterar termtabeller inkrementellt. + +**Q:** Kan GroupDocs.Search hantera stora datamängder? +A: Ja, den skalar till miljontals dokument och stöder bearbetning av filer över 500 MB utan att ladda hela innehållet i minnet. + +**Q:** Vad är homofoner i sökfunktionalitet? +A: Homofoner är ord som låter lika men skiljer sig i stavning, såsom “write” och “right”; att aktivera denna funktion utökar frågeomfånget. + +**Q:** Hur felsöker jag indexeringsfel? +A: Verifiera filsökvägar, säkerställ läsbehörigheter och granska loggutdata för specifika undantagsmeddelanden; vanliga problem inkluderar format som inte stöds eller korrupta filer. ## Resurser -- [Documentation](https://docs.groupdocs.com/search/java/) -- [API Reference](https://reference.groupdocs.com/search/java) -- [Download Latest Version](https://releases.groupdocs.com/search/java/) -- [GitHub Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [Free Support Forum](https://forum.groupdocs.com/c/search/10) -- [Temporary License](https://purchase.groupdocs.com/temporary-license/) +- [Dokumentation](https://docs.groupdocs.com/search/java/) +- [API‑referens](https://reference.groupdocs.com/search/java) +- [Ladda ner senaste versionen](https://releases.groupdocs.com/search/java/) +- [GitHub‑arkiv](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [Gratis supportforum](https://forum.groupdocs.com/c/search/10) +- [Tillfällig licens](https://purchase.groupdocs.com/temporary-license/) --- -**Senast uppdaterad:** 2026‑01‑26 -**Testat med:** GroupDocs.Search 25.4 för Java +**Senast uppdaterad:** 2026-05-28 +**Testad med:** GroupDocs.Search 25.4 för Java **Författare:** GroupDocs ---- \ No newline at end of file +## Relaterade handledningar + +- [Lägg till dokument i index – GroupDocs.Search Java-handledningar](/search/java/document-management/) +- [Hur man skapar index med GroupDocs.Search i Java – En komplett guide](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Skapa index Java med GroupDocs.Search | Omfattande guide för indexering och rapportering](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/thai/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/thai/java/searching/groupdocs-search-java-homophone-guide/_index.md index 04da1c7e..188ad343 100644 --- a/content/thai/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/thai/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,42 +1,83 @@ --- -date: '2026-01-26' -description: เรียนรู้วิธีสร้างดัชนีและเพิ่มเอกสารลงในดัชนีโดยใช้ GroupDocs.Search - สำหรับ Java เปิดใช้งานการค้นหาคำพ้องเสียงเพื่อการดึงเอกสารที่เหนือกว่า +date: '2026-05-28' +description: เรียนรู้วิธีสร้าง index java, เพิ่มเอกสารลงใน index, และ enable homophone + search ด้วย GroupDocs.Search for Java เพื่อการดึงข้อมูลที่เร็วและแม่นยำ keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'วิธีสร้างดัชนีด้วย GroupDocs.Search Java: การทำการค้นหาโฮโมโฟน' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: วิธีสร้างดัชนี Java ด้วย GroupDocs.Search และ Enable Homophone Search type: docs url: /th/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# วิธีสร้างดัชนีด้วย GroupDocs.Search Java และเปิดใช้งานการค้นหาโฮมโฟน +# วิธีสร้างดัชนี java ด้วย GroupDocs.Search และเปิดการค้นหาโฮโมโฟน -ในองค์กรสมัยใหม่ **วิธีสร้างดัชนี** อย่างรวดเร็วและเชื่อถือได้สามารถทำให้แตกต่างระหว่างการค้นหาข้อมูลสำคัญหรือพลาดไปโดยสิ้นเชิง ไม่ว่าคุณจะทำงานกับสัญญากฎหมาย, ความคิดเห็นของลูกค้า หรือรายงานภายใน ดัชนีการค้นหาที่สร้างอย่างดีโดยใช้ GroupDocs.Search สำหรับ Java จะให้ผลลัพธ์ที่ทันทีและแม่นยำ ในบทแนะนำนี้เราจะเดินผ่านกระบวนการทั้งหมด — ตั้งค่าห้องสมุด, สร้างดัชนี, เพิ่มเอกสารลงในดัชนี, และสุดท้ายเปิดใช้งานการค้นหาโฮมโฟนเพื่อการค้นหาที่ฉลาดขึ้น +ในองค์กรสมัยใหม่ การ **สร้างดัชนี java** อย่างรวดเร็วและเชื่อถือได้อาจเป็นความแตกต่างระหว่างการค้นหาข้อมูลสำคัญหรือพลาดไปโดยสิ้นเชิง ไม่ว่าคุณจะทำการจัดทำดัชนีสัญญากฎหมาย, ความคิดเห็นของลูกค้า, หรือรายงานภายใน ดัชนีการค้นหาที่สร้างอย่างดีโดยใช้ GroupDocs.Search for Java จะให้ผลลัพธ์ที่ทันทีและแม่นยำ ในบทแนะนำนี้เราจะเดินผ่านกระบวนการทั้งหมด — ตั้งค่าห้องสมุด, สร้างดัชนี, เพิ่มเอกสาร, และสุดท้ายเปิดการค้นหาโฮโมโฟนเพื่อการค้นหาที่ฉลาดขึ้น ## คำตอบสั้น - **ขั้นตอนแรกในการสร้างดัชนีคืออะไร?** เริ่มต้นอ็อบเจ็กต์ `Index` ด้วยเส้นทางโฟลเดอร์. - **เมธอดใดที่เพิ่มไฟล์ลงในดัชนี?** `index.add(yourDocumentsFolder)`. -- **ฉันจะเปิดใช้งานการค้นหาโฮมโฟนได้อย่างไร?** ตั้งค่า `options.setUseHomophoneSearch(true)`. -- **ต้องมีลิขสิทธิ์หรือไม่?** ลิขสิทธิ์ทดลองหรือชั่วคราวทำงานสำหรับการประเมิน. +- **ฉันจะเปิดการค้นหาโฮโมโฟนได้อย่างไร?** ตั้งค่า `options.setUseHomophoneSearch(true)`. +- **ต้องการไลเซนส์หรือไม่?** ไลเซนส์ทดลองหรือไลเซนส์ชั่วคราวทำงานได้สำหรับการประเมิน. - **ต้องใช้ Java เวอร์ชันใด?** JDK 8 หรือใหม่กว่า. ## Index คืออะไรใน GroupDocs.Search? -ดัชนีคือที่เก็บข้อมูลแบบโครงสร้างที่แมปคำและตำแหน่งของมันทั่วชุดเอกสารของคุณ ทำให้การค้นหาแบบเร็วแสงคล้ายกับดัชนีในหนังสือ การสร้างดัชนีเป็นพื้นฐานสำหรับแอปพลิเคชันที่ขับเคลื่อนด้วยการค้นหาใด ๆ +`Index` เป็นคลาสหลักที่เก็บคำที่สามารถค้นหาได้และตำแหน่งของมันในเอกสารต่าง ๆ Index คือโครงสร้างข้อมูลหลักของ GroupDocs.Search ที่เก็บคำและตำแหน่งของมันทั่วทั้งคอลเลกชันเอกสารของคุณ ทำให้การค้นหาเร็วเหมือนกับดัชนีหนังสือแต่สามารถจัดการกับล้านคำในหลายสิบรูปแบบไฟล์ ให้การดึงข้อมูลที่รวดเร็วแม้กับคอลเลกชันขนาดใหญ่ -## ทำไมต้องเปิดใช้งานการค้นหาโฮมโฟน? -การค้นหาโฮมโฟนขยายภาษาคำค้นให้รวมคำที่ออกเสียงคล้ายกัน (เช่น “write” กับ “right”) สิ่งนี้เพิ่มการเรียกคืนข้อมูลในสถานการณ์ที่ผู้ใช้อาจพิมพ์ผิดหรือใช้การสะกดแบบอื่น ส่งผลให้ได้ผลลัพธ์ที่ครอบคลุมมากขึ้นโดยไม่ต้องทำงานเพิ่ม +## ทำไมต้องเปิดการค้นหาโฮโมโฟน? +การค้นหาโฮโมโฟนขยายคำค้นให้รวมคำที่ออกเสียงคล้ายกัน (เช่น “write” กับ “right”) ซึ่งเพิ่มความครอบคลุมได้ถึง **30 %** ในสถานการณ์ที่ผู้ใช้พิมพ์ผิดหรือใช้การสะกดแบบอื่น ๆ ทำให้ผู้ใช้ได้รับผลลัพธ์แม้จะพิมพ์ผิดหรือใช้การสะกดที่แตกต่าง มักมีประโยชน์อย่างยิ่งสำหรับอินเทอร์เฟซที่ใช้เสียงและสภาพแวดล้อมหลายภาษา -## สิ่งที่ต้องเตรียม +## ข้อกำหนดเบื้องต้น - **Java Development Kit** 8 หรือใหม่กว่า. -- ไลบรารี **GroupDocs.Search for Java** (สามารถติดตั้งผ่าน Maven). +- **GroupDocs.Search for Java** library (สามารถติดตั้งผ่าน Maven). - ความคุ้นเคยพื้นฐานกับไวยากรณ์ Java และการตั้งค่าโปรเจกต์. -## การตั้งค่า GroupDocs.Search สำหรับ Java +## การตั้งค่า GroupDocs.Search for Java -แรกเริ่มให้เพิ่มรีโพซิทอรีและ dependency ของ GroupDocs.Search ลงใน `pom.xml` ของคุณ: +แรกสุด เพิ่มรีโพซิทอรีและ dependency ของ GroupDocs.Search ในไฟล์ `pom.xml` ของคุณ: ```xml @@ -56,9 +97,9 @@ weight: 1 ``` -หรือคุณสามารถ [ดาวน์โหลดเวอร์ชันล่าสุดจาก GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) +หรือคุณสามารถ [ดาวน์โหลดเวอร์ชันล่าสุดจาก GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) ได้ -**การรับลิขสิทธิ์**: GroupDocs มีลิขสิทธิ์ทดลองฟรีหรือลิขสิทธิ์ชั่วคราวสำหรับการประเมิน หากต้องการซื้อให้เยี่ยมชมเว็บไซต์อย่างเป็นทางการของพวกเขา +**การรับไลเซนส์**: GroupDocs มีไลเซนส์ทดลองฟรีหรือไลเซนส์ชั่วคราวสำหรับการประเมิน หากต้องการซื้อ ให้เยี่ยมชมเว็บไซต์อย่างเป็นทางการของพวกเขา ### การเริ่มต้นและตั้งค่าเบื้องต้น @@ -80,97 +121,109 @@ public class SearchSetup { } ``` -## วิธีสร้างดัชนีด้วย GroupDocs.Search Java +## วิธีสร้าง index java ด้วย GroupDocs.Search Java? -การสร้างดัชนีง่ายเพียงแค่ชี้ตัวสร้าง `Index` ไปที่โฟลเดอร์ที่ไลบรารีจะเก็บไฟล์ภายใน +`Index` เป็นคลาสหลักที่แสดงถึงดัชนีที่สามารถค้นหาได้และถูกเก็บบนดิสก์ โหลดหรือสร้างดัชนีโดยชี้ตัวสร้าง `Index` ไปยังโฟลเดอร์ที่ไลบรารีสามารถเก็บไฟล์ภายในได้ การดำเนินการนี้จะสร้างไฟล์เมตาดาต้าที่จำเป็นและเตรียมเครื่องยนต์สำหรับการนำเข้าเอกสาร ทำให้สามารถเพิ่มเอกสารและดำเนินการค้นหาได้ต่อไป ### ขั้นตอนที่ 1: กำหนดเส้นทางดัชนี ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` แทนที่ `YOUR_DOCUMENT_DIRECTORY` ด้วยเส้นทางเต็มบนเครื่องของคุณ ### ขั้นตอนที่ 2: สร้างอ็อบเจ็กต์ Index ```java Index index = new Index(indexFolder); -``` -บรรทัดนี้ **สร้างดัชนี** ที่จะใช้เก็บเนื้อหาที่สามารถค้นหาได้ในภายหลัง +``` +บรรทัดนี้ **สร้างดัชนี** ที่จะใช้เก็บเนื้อหาที่สามารถค้นหาได้ทั้งหมดในภายหลัง -## วิธีเพิ่มเอกสารลงในดัชนี +## วิธีเพิ่มเอกสารลงในดัชนี? -เมื่อดัชนีมีอยู่แล้ว คุณต้องป้อนเอกสารที่ต้องการค้นหาเข้าไป +`add` เป็นเมธอดของคลาส `Index` ที่นำไฟล์จากโฟลเดอร์เข้าสู่ดัชนี หลังจากดัชนีมีอยู่แล้ว คุณต้องป้อนเอกสารที่ต้องการให้ค้นหา เมธอด `add` จะสแกนไดเรกทอรีแบบเรียกซ้ำและทำดัชนีทุกไฟล์ที่รองรับ โดยดึงข้อความและสร้างตารางความถี่ของคำเพื่อการดึงข้อมูลที่เร็ว -### ขั้นตอนที่ 1: ชี้ไปยังโฟลเดอร์เอกสารต้นทาง +### ขั้นตอนที่ 1: ชี้ไปยังโฟลเดอร์เอกสารต้นทางของคุณ ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` -โฟลเดอร์นี้ควรมีไฟล์ (PDF, DOCX, TXT ฯลฯ) ที่คุณต้องการทำดัชนี +``` +โฟลเดอร์นี้ควรมีไฟล์ (PDF, DOCX, TXT, ฯลฯ) ที่คุณต้องการทำดัชนี ### ขั้นตอนที่ 2: เพิ่มไฟล์ทั้งหมดในโฟลเดอร์ ```java index.add(documentsFolder); -``` -เมธอด `add` จะสแกนไดเรกทอรีแบบเรียกซ้ำและทำดัชนีทุกไฟล์ที่รองรับ นี่คือการดำเนินการหลักที่ **เพิ่มเอกสารลงในดัชนี** +``` +เมธอด `add` จะประมวลผลแต่ละไฟล์ ดึงข้อความและเก็บข้อมูลความถี่ของคำ ทำให้ **เพิ่มเอกสารลงในดัชนี** อย่างสมบูรณ์ -## การเปิดใช้งานการค้นหาโฮมโฟน +## วิธีเปิดการค้นหาโฮโมโฟน? -ตอนนี้ดัชนีเต็มแล้ว คุณสามารถเปิดใช้งานการสนับสนุนโฮมโฟนได้ +`setUseHomophoneSearch` เป็นเมธอดของ `SearchOptions` ที่สลับการจับคู่ตามเสียงสำหรับคำค้น ตอนนี้ดัชนีได้ถูกเติมข้อมูลแล้ว คุณสามารถเปิดการจับคู่ตามเสียงเพื่อจับคำที่ออกเสียงคล้ายกัน การเปิดฟีเจอร์นี้สั่งให้เครื่องยนต์พิจารณาคำที่มีเสียงคล้ายกันระหว่างการประมวลผลคำค้น ช่วยเพิ่มความครอบคลุมสำหรับการพิมพ์ผิดหรืออินพุตด้วยเสียง ### ขั้นตอนที่ 1: สร้าง SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` กำหนดวิธีที่เครื่องยนต์ตีความคำค้น -### ขั้นตอนที่ 2: เปิดใช้งานการค้นหาโฮมโฟน +### ขั้นตอนที่ 2: เปิดใช้งานการค้นหาโฮโมโฟน ```java options.setUseHomophoneSearch(true); -``` -การตั้งค่านี้บอกเอนจินให้พิจารณาคำที่มีเสียงคล้ายกันเมื่อประมวลผลคำค้น +``` +การตั้งค่า `setUseHomophoneSearch(true)` บอกเครื่องยนต์ให้พิจารณาคำที่มีเสียงคล้ายกันเมื่อประมวลผลคำค้น -## การใช้งานในเชิงปฏิบัติ -1. **การจัดการเอกสารกฎหมาย** – ค้นหาสัญญาที่กล่าวถึง “lease” แม้ผู้ใช้พิมพ์เป็น “leas”. +## การประยุกต์ใช้งานจริง +1. **การจัดการเอกสารกฎหมาย** – ค้นหาสัญญาที่กล่าวถึง “lease” แม้ว่าผู้ใช้จะพิมพ์เป็น “leas”. 2. **การวิเคราะห์ความคิดเห็นของลูกค้า** – จับความแปรผันเช่น “price” และ “prise” ในแบบสำรวจ. -3. **ระบบจัดการเนื้อหา (CMS)** – ปรับปรุงการค้นหาในเว็บไซต์โดยจับคู่ “write” กับ “right”. +3. **ระบบจัดการเนื้อหา** – ปรับปรุงการค้นหาในเว็บไซต์โดยจับคู่ “write” กับ “right”. ## พิจารณาด้านประสิทธิภาพ -- **สร้างดัชนีใหม่เป็นประจำ** หลังจากอัปเดตเอกสารจำนวนมาก. -- **ตรวจสอบการใช้หน่วยความจำ**; ดัชนีขนาดใหญ่อาจได้ประโยชน์จากการทำดัชนีแบบเพิ่มส่วน. -- ปฏิบัติตามแนวทางที่ดีที่สุดของ Java (เช่น การจัดการข้อยกเว้นอย่างเหมาะสม, การใช้ try‑with‑resources) เพื่อให้แอปพลิเคชันเสถียร +- **สร้างดัชนีใหม่เป็นประจำ** หลังจากอัปเดตเอกสารจำนวนมากเพื่อให้สถิติคำเป็นปัจจุบัน. +- **ตรวจสอบการใช้หน่วยความจำ**; เครื่องยนต์สามารถประมวลผลเอกสารหลายร้อยหน้าโดยไม่ต้องโหลดไฟล์ทั้งหมดเข้าสู่หน่วยความจำ เนื่องจากใช้การทำดัชนีแบบเพิ่มส่วน. +- ปฏิบัติตามแนวทางที่ดีที่สุดของ Java (เช่น try‑with‑resources, การจัดการข้อยกเว้นอย่างเหมาะสม) เพื่อให้แอปพลิเคชันทำงานเสถียรภายใต้โหลดสูง. ## สรุป -คุณได้เรียนรู้ **วิธีสร้างดัชนี**, วิธี **เพิ่มเอกสารลงในดัชนี**, และวิธีเปิดใช้งานการค้นหาโฮมโฟนด้วย GroupDocs.Search สำหรับ Java ความสามารถเหล่านี้ทำให้คุณสร้างประสบการณ์การค้นหาที่เร็วและฉลาดบนคลังเอกสารใด ๆ +คุณได้เรียนรู้ **วิธีสร้าง index java**, **วิธีเพิ่มเอกสารลงในดัชนี**, และ **วิธีเปิดการค้นหาโฮโมโฟน** ด้วย GroupDocs.Search for Java ความสามารถเหล่านี้ช่วยให้คุณสร้างประสบการณ์การค้นหาที่เร็วและฉลาดในคลังเอกสารใด ๆ ### ขั้นตอนต่อไป -- ทดลอง **custom analyzers** เพื่อปรับแต่งการตัดคำให้ละเอียดขึ้น. -- ผสาน **faceted search** กับการสนับสนุนโฮมโฟนเพื่อการกรองที่หลากหลายยิ่งขึ้น. -- สำรวจ **GroupDocs.Search REST API** สำหรับสถานการณ์ข้ามแพลตฟอร์ม - -## ส่วนคำถามที่พบบ่อย (FAQ) -1. **ดัชนีคืออะไรในบริบทของ GroupDocs.Search?** - - ดัชนีคือโครงสร้างข้อมูลที่ทำให้การค้นหาเอกสารทำได้อย่างรวดเร็ว คล้ายกับดัชนีในหนังสือ. -2. **ฉันจะอัปเดตดัชนีด้วยเอกสารใหม่ได้อย่างไร?** - - ใช้เมธอด `index.add()` เพื่อเพิ่มเอกสารใหม่หรือทำดัชนีซ้ำสำหรับเอกสารที่มีอยู่. -3. **GroupDocs.Search รองรับการจัดการข้อมูลปริมาณมากหรือไม่?** - - ใช่, ถูกออกแบบให้สามารถขยายขนาดและจัดการชุดข้อมูลขนาดใหญ่ได้อย่างมีประสิทธิภาพ. -4. **โฮมโฟนในฟังก์ชันการค้นคือตัวอะไร?** - - โฮมโฟนคือคำที่ออกเสียงคล้ายกันแต่ความหมายอาจต่างกัน เช่น “write” และ “right”. -5. **ฉันจะแก้ไขข้อผิดพลาดการทำดัชนีอย่างไร?** - - ตรวจสอบเส้นทางไฟล์, ให้แน่ใจว่าเอกสารเข้าถึงได้, และตรวจสอบไฟล์บันทึกสำหรับข้อความข้อผิดพลาดเฉพาะ. +- ทดลองใช้ **custom analyzers** เพื่อปรับแต่งการแยกโทเคนให้เหมาะสม. +- ผสาน **faceted search** กับการสนับสนุนโฮโมโฟนเพื่อการกรองที่หลากหลายยิ่งขึ้น. +- สำรวจ **GroupDocs.Search REST API** สำหรับสถานการณ์ข้ามแพลตฟอร์ม. + +## คำถามที่พบบ่อย + +**Q:** Index คืออะไรในบริบทของ GroupDocs.Search? +A: Index คือโครงสร้างข้อมูลที่แมปคำไปยังตำแหน่งในเอกสาร ทำให้การดึงข้อมูลระดับมิลลิวินาทีคล้ายกับดัชนีหนังสือ + +**Q:** ฉันจะอัปเดตดัชนีด้วยเอกสารใหม่ได้อย่างไร? +A: เรียก `index.add(newFolder)` เพื่อดึงไฟล์เพิ่มเติมหรือทำการรี‑อินเด็กซ์ไฟล์ที่มีอยู่; เครื่องยนต์จะอัปเดตตารางคำแบบเพิ่มส่วน + +**Q:** GroupDocs.Search สามารถจัดการกับปริมาณข้อมูลขนาดใหญ่ได้หรือไม่? +A: ได้, มันสามารถขยายได้ถึงล้านเอกสารและรองรับการประมวลผลไฟล์ขนาดเกิน 500 MB โดยไม่ต้องโหลดเนื้อหาทั้งหมดเข้าสู่หน่วยความจำ + +**Q:** โฮโมโฟนในฟังก์ชันการค้นคือตัวอะไร? +A: โฮโมโฟนคือคำที่ออกเสียงคล้ายกันแต่สะกดต่างกัน เช่น “write” กับ “right”; การเปิดฟีเจอร์นี้จะขยายขอบเขตของคำค้น + +**Q:** ฉันจะแก้ไขปัญหาข้อผิดพลาดการทำดัชนีได้อย่างไร? +A: ตรวจสอบเส้นทางไฟล์, ยืนยันสิทธิ์การอ่าน, และตรวจสอบบันทึกเอาต์พุตสำหรับข้อความข้อยกเว้นเฉพาะ; ปัญหาที่พบบ่อยรวมถึงรูปแบบไฟล์ที่ไม่รองรับหรือไฟล์เสียหาย ## แหล่งข้อมูล -- [Documentation](https://docs.groupdocs.com/search/java/) -- [API Reference](https://reference.groupdocs.com/search/java) -- [Download Latest Version](https://releases.groupdocs.com/search/java/) -- [GitHub Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [Free Support Forum](https://forum.groupdocs.com/c/search/10) +- [Documentation](https://docs.groupdocs.com/search/java/) +- [API Reference](https://reference.groupdocs.com/search/java) +- [Download Latest Version](https://releases.groupdocs.com/search/java/) +- [GitHub Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [Free Support Forum](https://forum.groupdocs.com/c/search/10) - [Temporary License](https://purchase.groupdocs.com/temporary-license/) --- -**อัปเดตล่าสุด:** 2026-01-26 -**ทดสอบด้วย:** GroupDocs.Search 25.4 for Java -**ผู้เขียน:** GroupDocs +**Last Updated:** 2026-05-28 +**Tested With:** GroupDocs.Search 25.4 for Java +**Author:** GroupDocs + +--- + +## บทเรียนที่เกี่ยวข้อง ---- \ No newline at end of file +- [Add Documents to Index – GroupDocs.Search Java Tutorials](/search/java/document-management/) +- [How to Create Index with GroupDocs.Search in Java - A Complete Guide](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Create Index Java with GroupDocs.Search | Comprehensive Indexing and Reporting Guide](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/turkish/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/turkish/java/searching/groupdocs-search-java-homophone-guide/_index.md index cbdba8fb..6b71b9bc 100644 --- a/content/turkish/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/turkish/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,40 +1,82 @@ --- -date: '2026-01-26' -description: GroupDocs.Search for Java kullanarak indeks oluşturmayı ve indeks'e belge - eklemeyi öğrenin. Üstün belge geri getirme için homofon aramayı etkinleştirin. +date: '2026-05-28' +description: GroupDocs.Search for Java kullanarak hızlı ve doğru geri getirme için + Java indeksini oluşturmayı, indeks'e belge eklemeyi ve Homophone Search'ü etkinleştirmeyi + öğrenin. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'GroupDocs.Search Java ile Dizin Oluşturma: Homofon Arama Uygulaması' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: GroupDocs.Search ile Java indeksi oluşturma ve Homophone Search etkinleştirme type: docs url: /tr/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# GroupDocs.Search Java ile Dizin Oluşturma ve Homofon Aramayı Etkinleştirme +# GroupDocs.Search ile Java'da indeks oluşturma ve Homofon Aramayı Etkinleştirme -Modern işletmelerde, **dizin oluşturma** işlemini hızlı ve güvenilir bir şekilde yapmak, kritik bilgileri bulmak ile tamamen kaçırmak arasındaki farkı yaratabilir. Hukuki sözleşmeler, müşteri geri bildirimleri veya iç raporlarla çalışıyor olun, GroupDocs.Search for Java tarafından desteklenen iyi yapılandırılmış bir arama dizini size anlık ve doğru sonuçlar sunar. Bu öğreticide, kütüphaneyi kurmaktan dizini oluşturmaya, belgelere dizin eklemeye ve daha akıllı sorgular için homofon aramayı etkinleştirmeye kadar tüm süreci adım adım göstereceğiz. +Modern işletmelerde, **create index java**'yı hızlı ve güvenilir bir şekilde oluşturmak, kritik bilgileri bulmak ile tamamen kaçırmak arasındaki fark olabilir. Hukuki sözleşmeler, müşteri geri bildirimleri veya iç raporlar gibi belgeleri indekslerken, GroupDocs.Search for Java tarafından desteklenen iyi yapılandırılmış bir arama indeksi anında ve doğru sonuçlar verir. Bu öğreticide, kütüphaneyi kurmaktan indeksi oluşturmaya, belgelere ekleme yapmaya ve daha akıllı sorgular için homofon aramayı etkinleştirmeye kadar tüm süreci adım adım göstereceğiz. ## Hızlı Yanıtlar -- **Dizin oluşturmanın ilk adımı nedir?** `Index` nesnesini bir klasör yolu ile başlatın. -- **Hangi yöntem dosyaları dizine ekler?** `index.add(yourDocumentsFolder)`. -- **Homofon aramayı nasıl etkinleştiririm?** `options.setUseHomophoneSearch(true)` ayarını yapın. +- **İndeks oluşturmanın ilk adımı nedir?** `Index` nesnesini bir klasör yolu ile başlatın. +- **Hangi metod dosyaları indekse ekler?** `index.add(yourDocumentsFolder)`. +- **Homofon aramayı nasıl etkinleştiririm?** `options.setUseHomophoneSearch(true)` ayarlayın. - **Lisans gerekli mi?** Değerlendirme için ücretsiz deneme veya geçici lisans yeterlidir. - **Hangi Java sürümü gereklidir?** JDK 8 veya üzeri. -## GroupDocs.Search'te Dizin Nedir? -Dizin, belge koleksiyonunuzdaki kelimeleri ve bu kelimelerin konumlarını haritalayan yapılandırılmış bir veri deposudur; bir kitabın dizini gibi ışık hızında arama yapmanızı sağlar. Dizin oluşturmak, arama odaklı herhangi bir uygulamanın temelini oluşturur. +## GroupDocs.Search'te Bir İndeks Nedir? +`Index`, belgeler arasındaki aranabilir terimleri ve konumlarını depolayan temel sınıftır. **Index**, GroupDocs.Search'in belge koleksiyonunuzdaki terimleri ve konumlarını saklayan temel veri yapısıdır ve ışık hızıyla arama yapmanızı sağlar. Bir kitabın indeksine benzer, ancak onlarca dosya formatında milyonlarca terimi işleyebilir ve büyük veri kümelerinde bile hızlı geri getirme sunar. -## Homofon Arama Neden Etkinleştirilmeli? -Homofon arama, sorgu dilini ses olarak benzer kelimeleri (ör. “write” ve “right”) içerecek şekilde genişletir. Kullanıcıların yazım hatası yapması veya alternatif yazımlar kullanması durumunda geri getirme oranını artırır ve ekstra çaba harcamadan daha kapsamlı sonuçlar sunar. +## Neden Homofon Arama Etkinleştirilmeli? +Homofon arama, bir sorguyu ses olarak benzer kelimeleri (ör. “write” vs. “right”) içerecek şekilde genişletir. Bu, **gürültülü kullanıcı girişi senaryolarında %30 'a kadar** geri getirme oranını artırır ve kullanıcıların yazım hatası yapması veya alternatif yazım kullanması durumunda bile sonuç almasını sağlar. Özellikle sesli arayüzler ve çok dilli ortamlar için değerlidir. -## Ön Koşullar -- **Java Development Kit** 8 veya daha yenisi. +## Önkoşullar +- **Java Development Kit** 8 veya daha yeni bir sürüm. - **GroupDocs.Search for Java** kütüphanesi (Maven üzerinden temin edilebilir). - Java sözdizimi ve proje kurulumu konusunda temel bilgi. -## GroupDocs.Search for Java Kurulumu +## GroupDocs.Search for Java'ı Kurma İlk olarak, GroupDocs.Search Maven deposunu ve bağımlılığını `pom.xml` dosyanıza ekleyin: @@ -58,11 +100,11 @@ Homofon arama, sorgu dilini ses olarak benzer kelimeleri (ör. “write” ve Alternatif olarak, [GroupDocs.Search for Java sürümlerinden en son versiyonu indirebilirsiniz](https://releases.groupdocs.com/search/java/). -**Lisans Alımı**: GroupDocs ücretsiz deneme lisansı veya değerlendirme için geçici lisanslar sunar. Satın almak için resmi web sitelerini ziyaret edin. +**Lisans Edinme**: GroupDocs ücretsiz deneme lisansı veya değerlendirme için geçici lisanslar sunar. Satın almak için resmi web sitelerini ziyaret edin. ### Temel Başlatma ve Kurulum -Arama dizinini başlatmak için basit bir Java sınıfı oluşturun: +Arama indeksini başlatmak için basit bir Java sınıfı oluşturun: ```java import com.groupdocs.search.Index; @@ -80,84 +122,90 @@ public class SearchSetup { } ``` -## GroupDocs.Search Java ile Dizin Oluşturma +## GroupDocs.Search Java ile nasıl index java oluşturulur? -Dizin oluşturmak, kütüphanenin iç dosyalarını saklayabileceği bir klasöre `Index` yapıcısını yönlendirmek kadar basittir. +`Index`, diskte saklanan aranabilir bir indeksi temsil eden ana sınıftır. Kütüphanenin iç dosyalarını depolayabileceği bir klasöre işaret ederek `Index` yapıcısını kullanarak indeksi yükleyin veya oluşturun. Bu işlem gerekli meta veri dosyalarını oluşturur ve motoru belge alımı için hazır hâle getirir; böylece daha sonra belgeler eklenebilir ve sorgular çalıştırılabilir. -### Adım 1: Dizin Yolunu Tanımlayın +### Adım 1: İndeks Yolunu Tanımlayın ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` `YOUR_DOCUMENT_DIRECTORY` ifadesini makinenizdeki mutlak yol ile değiştirin. ### Adım 2: Index Nesnesini Örnekleyin ```java Index index = new Index(indexFolder); -``` -Bu satır, daha sonra içinde aranabilir tüm içeriği barındıracak **dizini oluşturur**. +``` +Bu satır **indeksi oluşturur** ve daha sonra tüm aranabilir içeriği tutacaktır. -## Dizin'e Belge Ekleme +## İndekse belge nasıl eklenir? -Dizin mevcut olduğunda, arama yapacağınız belgeleri ona beslemeniz gerekir. +`add`, `Index` sınıfının bir metodudur ve bir klasörden dosyaları indekse alır. İndeks var olduktan sonra, aramak istediğiniz belgeleri ona beslemeniz gerekir. `add` metodu klasörü özyinelemeli olarak tarar ve desteklenen her dosyayı indeksler, metni çıkarır ve hızlı geri getirme için terim‑frekans tabloları oluşturur. -### Adım 1: Kaynak Belgelerinizi Belirtin +### Adım 1: Kaynak Belgelerinize İşaret Edin ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` +``` Bu klasör, indekslemek istediğiniz dosyaları (PDF, DOCX, TXT vb.) içermelidir. ### Adım 2: Klasördeki Tüm Dosyaları Ekleyin ```java index.add(documentsFolder); -``` -`add` metodu klasörü özyinelemeli olarak tarar ve desteklenen her dosyayı indeksler. Bu, **belgeleri dizine ekleyen** temel işlemdir. +``` +`add` metodu her dosyayı işler, metni çıkarır ve terim‑frekans verilerini depolar; böylece **belgeler indekse eklenir**. -## Homofon Aramayı Etkinleştirme +## Homofon Arama Nasıl Etkinleştirilir? -Dizin doldurulduktan sonra homofon desteğini açabilirsiniz. +`setUseHomophoneSearch`, `SearchOptions` sınıfının bir metodudur ve sorgular için fonetik eşleşmeyi açıp kapatır. İndeks doldurulduktan sonra, ses‑benzeri terimleri yakalamak için fonetik eşleşmeyi açabilirsiniz. Bu özelliği etkinleştirmek, motorun sorgu işleme sırasında fonetik eşdeğerleri dikkate almasını sağlar ve yanlış yazılmış veya sesli girişler için geri getirme oranını artırır. ### Adım 1: SearchOptions Oluşturun ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions`, motorun sorguları nasıl yorumlayacağını yapılandırır. -### Adım 2: Homofon Aramayı Aktive Edin +### Adım 2: Homofon Aramayı Aktif Hale Getirin ```java options.setUseHomophoneSearch(true); -``` -Bu bayrağın ayarlanması, motorun sorguları işlerken fonetik eşdeğerleri de dikkate almasını sağlar. +``` +`setUseHomophoneSearch(true)` ayarı, motorun sorgu işleme sırasında fonetik eşdeğerleri dikkate almasını sağlar. -## Pratik Kullanım Alanları +## Pratik Uygulamalar 1. **Hukuki Belge Yönetimi** – Kullanıcı “leas” yazsa bile “lease” geçen sözleşmeleri bulun. 2. **Müşteri Geri Bildirimi Analizi** – Anket yanıtlarında “price” ve “prise” gibi varyasyonları yakalayın. 3. **İçerik Yönetim Sistemleri** – Site aramasını “write” ile “right” eşleştirerek iyileştirin. ## Performans Düşünceleri -- **Dizini düzenli olarak yeniden oluşturun**; toplu belge güncellemelerinden sonra. -- **Bellek kullanımını izleyin**; büyük dizinler artımlı indekslemeyle fayda sağlayabilir. -- Uygulamanın kararlılığını korumak için Java en iyi uygulamalarını (ör. doğru istisna yönetimi, try‑with‑resources kullanımı) takip edin. +- **İndeksi düzenli olarak yeniden oluşturun**; toplu belge güncellemelerinden sonra terim istatistiklerini taze tutun. +- **Bellek kullanımını izleyin**; motor, artımlı indeksleme sayesinde tüm dosyayı belleğe yüklemeden çok sayfalı belgeleri işleyebilir. +- Java en iyi uygulamalarını (ör. try‑with‑resources, uygun istisna yönetimi) takip ederek uygulamanın yüksek yük altında kararlı kalmasını sağlayın. ## Sonuç -Artık **dizin oluşturma**, **belgeleri dizine ekleme** ve GroupDocs.Search for Java ile homofon aramayı etkinleştirme konularını biliyorsunuz. Bu yetenekler, herhangi bir belge deposu üzerinde hızlı ve akıllı arama deneyimleri oluşturmanızı sağlar. +Artık **java ile indeks oluşturma**, **belgeleri indekse ekleme** ve GroupDocs.Search for Java ile homofon aramayı etkinleştirme konularını biliyorsunuz. Bu yetenekler, herhangi bir belge deposu üzerinde hızlı ve akıllı arama deneyimleri oluşturmanızı sağlar. ### Sonraki Adımlar -- **Özel analizörler** ile tokenleştirmeyi ince ayar yapın. +- **Özel analizörler** ile tokenizasyonu ince ayar yaparak deneyin. - **Faceted search** ile homofon desteğini birleştirerek daha zengin filtreleme sağlayın. -- **GroupDocs.Search REST API**'yi keşfederek çapraz platform senaryolarını değerlendirin. - -## SSS Bölümü -1. **GroupDocs.Search bağlamında bir dizin nedir?** - - Dizin, bir kitaptaki indeks gibi, belgeleri hızlıca aramayı sağlayan bir veri yapısıdır. -2. **Dizini yeni belgelerle nasıl güncellerim?** - - Yeni belgeler eklemek veya mevcutları yeniden indekslemek için `index.add()` metodunu kullanın. -3. **GroupDocs.Search büyük veri hacimlerini yönetebilir mi?** - - Evet, ölçeklenebilirlik için tasarlanmıştır ve büyük veri setlerini verimli bir şekilde idare eder. -4. **Arama işlevinde homofonlar nedir?** - - Homofonlar, ses olarak benzer ama anlamları farklı olabilen kelimelerdir; ör. “write” ve “right”. -5. **İndeksleme hatalarını nasıl gideririm?** - - Dosya yollarını kontrol edin, belgelerin erişilebilir olduğundan emin olun ve belirli hata mesajları için log dosyalarını inceleyin. +- **GroupDocs.Search REST API**'yi keşfederek çapraz platform senaryolarını inceleyin. + +## Sık Sorulan Sorular + +**S:** GroupDocs.Search bağlamında bir indeks nedir? +**C:** Bir indeks, terimleri belgelerdeki konumlarıyla eşleyen bir veri yapısıdır ve bir kitabın indeksine benzer şekilde milisaniye seviyesinde geri getirme sağlar. + +**S:** Yeni belgelerle indeksimi nasıl güncellerim? +**C:** `index.add(newFolder)` çağırarak ek dosyaları alabilir veya mevcut dosyaları yeniden indeksleyebilirsiniz; motor terim tablolarını artımlı olarak günceller. + +**S:** GroupDocs.Search büyük veri hacimlerini işleyebilir mi? +**C:** Evet, milyonlarca belgeye ölçeklenebilir ve 500 MB üzerindeki dosyaları tüm içeriği belleğe yüklemeden işleyebilir. + +**S:** Arama işlevinde homofonlar nedir? +**C:** Homofonlar, ses olarak aynı ama yazılışı farklı kelimelerdir (ör. “write” ve “right”); bu özelliği etkinleştirmek sorgu kapsamını genişletir. + +**S:** İndeksleme hatalarını nasıl gideririm? +**C:** Dosya yollarını doğrulayın, okuma izinlerini kontrol edin ve belirli istisna mesajları için log çıktısını inceleyin; yaygın sorunlar desteklenmeyen formatlar veya bozuk dosyalardır. ## Kaynaklar - [Documentation](https://docs.groupdocs.com/search/java/) @@ -169,8 +217,14 @@ Artık **dizin oluşturma**, **belgeleri dizine ekleme** ve GroupDocs.Search for --- -**Son Güncelleme:** 2026-01-26 +**Son Güncelleme:** 2026-05-28 **Test Edilen Versiyon:** GroupDocs.Search 25.4 for Java **Yazar:** GroupDocs ---- \ No newline at end of file +--- + +## İlgili Öğreticiler + +- [Add Documents to Index – GroupDocs.Search Java Tutorials](/search/java/document-management/) +- [How to Create Index with GroupDocs.Search in Java - A Complete Guide](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Create Index Java with GroupDocs.Search | Comprehensive Indexing and Reporting Guide](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file diff --git a/content/vietnamese/java/searching/groupdocs-search-java-homophone-guide/_index.md b/content/vietnamese/java/searching/groupdocs-search-java-homophone-guide/_index.md index 808134ba..2ab1d10d 100644 --- a/content/vietnamese/java/searching/groupdocs-search-java-homophone-guide/_index.md +++ b/content/vietnamese/java/searching/groupdocs-search-java-homophone-guide/_index.md @@ -1,42 +1,83 @@ --- -date: '2026-01-26' -description: Tìm hiểu cách tạo chỉ mục và thêm tài liệu vào chỉ mục bằng GroupDocs.Search - cho Java. Kích hoạt tìm kiếm đồng âm để nâng cao khả năng truy xuất tài liệu. +date: '2026-05-28' +description: Tìm hiểu cách tạo chỉ mục Java, thêm tài liệu vào chỉ mục và bật tìm + kiếm đồng âm bằng GroupDocs.Search for Java để truy xuất nhanh chóng và chính xác. keywords: -- GroupDocs.Search Java -- homophone search implementation -- document retrieval -title: 'Cách tạo chỉ mục với GroupDocs.Search Java: Triển khai tìm kiếm đồng âm' +- create index java +- how to use homophone +- add documents to index +- search with homophone +- java search tutorial +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + headline: How to create index java with GroupDocs.Search and Enable Homophone Search + type: TechArticle +- description: Learn how to create index java, add documents to index, and enable + homophone search using GroupDocs.Search for Java for fast, accurate retrieval. + name: How to create index java with GroupDocs.Search and Enable Homophone Search + steps: + - name: Define the Index Path + text: Replace `YOUR_DOCUMENT_DIRECTORY` with the absolute path on your machine. + - name: Instantiate the Index Object + text: This line **creates the index** that will later hold all searchable content. + - name: Point to Your Source Documents + text: This folder should contain the files (PDF, DOCX, TXT, etc.) you wish to + index. + - name: Add All Files in the Folder + text: The `add` method processes each file, extracts text, and stores term‑frequency + data, effectively **adding documents to index**. + - name: Create SearchOptions + text: '`SearchOptions` configures how the engine interprets queries.' + - name: Activate Homophone Search + text: Setting `setUseHomophoneSearch(true)` tells the engine to consider phonetic + equivalents when processing queries. + type: HowTo +- questions: + - answer: Initialize the `Index` object with a folder path. + question: What is the first step to create an index? + - answer: '`index.add(yourDocumentsFolder)`.' + question: Which method adds files to the index? + - answer: Set `options.setUseHomophoneSearch(true)`. + question: How do I enable homophone search? + - answer: A free trial or temporary license works for evaluation. + question: Do I need a license? + - answer: JDK 8 or later. + question: Which Java version is required? + type: FAQPage +title: Cách tạo chỉ mục Java với GroupDocs.Search và bật tìm kiếm đồng âm type: docs url: /vi/java/searching/groupdocs-search-java-homophone-guide/ weight: 1 --- -# Cách Tạo Chỉ Mục với GroupDocs.Search Java và Bật Tìm Kiếm Đồng Âm +# Cách tạo chỉ mục java với GroupDocs.Search và Bật Tìm kiếm Đồng âm -Trong các doanh nghiệp hiện đại, **cách tạo chỉ mục** nhanh chóng và đáng tin cậy có thể tạo ra sự khác biệt giữa việc tìm thấy thông tin quan trọng và việc bỏ lỡ hoàn toàn. Dù bạn đang xử lý hợp đồng pháp lý, phản hồi của khách hàng, hay báo cáo nội bộ, một chỉ mục tìm kiếm được xây dựng tốt bằng GroupDocs.Search cho Java sẽ cung cấp kết quả tức thì và chính xác. Trong hướng dẫn này, chúng ta sẽ đi qua toàn bộ quy trình — từ cài đặt thư viện, tạo chỉ mục, thêm tài liệu vào chỉ mục, cho tới việc bật tìm kiếm đồng âm để cải thiện các truy vấn thông minh. +Trong các doanh nghiệp hiện đại, **tạo chỉ mục java** nhanh chóng và đáng tin cậy có thể là yếu tố quyết định giữa việc tìm thấy thông tin quan trọng hoặc bỏ lỡ hoàn toàn. Dù bạn đang lập chỉ mục các hợp đồng pháp lý, phản hồi khách hàng, hay báo cáo nội bộ, một chỉ mục tìm kiếm được xây dựng tốt bằng GroupDocs.Search cho Java sẽ cung cấp kết quả tức thời và chính xác. Trong hướng dẫn này, chúng ta sẽ đi qua toàn bộ quy trình — từ cài đặt thư viện, tạo chỉ mục, thêm tài liệu, cho tới việc bật tìm kiếm đồng âm để cải thiện truy vấn thông minh. -## Trả Lời Nhanh +## Câu trả lời nhanh - **Bước đầu tiên để tạo chỉ mục là gì?** Khởi tạo đối tượng `Index` với đường dẫn thư mục. - **Phương thức nào thêm tệp vào chỉ mục?** `index.add(yourDocumentsFolder)`. - **Làm sao bật tìm kiếm đồng âm?** Đặt `options.setUseHomophoneSearch(true)`. - **Có cần giấy phép không?** Giấy phép dùng thử miễn phí hoặc giấy phép tạm thời đủ cho việc đánh giá. -- **Yêu cầu phiên bản Java nào?** JDK 8 hoặc mới hơn. +- **Yêu cầu phiên bản Java nào?** JDK 8 trở lên. -## Chỉ Mục là gì trong GroupDocs.Search? -Chỉ mục là một kho dữ liệu có cấu trúc, ánh xạ các từ và vị trí của chúng trong bộ sưu tập tài liệu của bạn, cho phép tra cứu siêu nhanh giống như mục lục của một cuốn sách. Việc tạo chỉ mục là nền tảng cho bất kỳ ứng dụng dựa trên tìm kiếm nào. +## Chỉ mục là gì trong GroupDocs.Search? +`Index` là lớp cốt lõi lưu trữ các thuật ngữ có thể tìm kiếm và vị trí của chúng trong tài liệu. **Index** là cấu trúc dữ liệu cốt lõi của GroupDocs.Search, lưu trữ các thuật ngữ và vị trí của chúng trong bộ sưu tập tài liệu của bạn, cho phép tra cứu nhanh như chớp. Nó hoạt động giống như mục lục của một cuốn sách nhưng có thể xử lý hàng triệu thuật ngữ trên hàng chục định dạng tệp, cung cấp khả năng truy xuất nhanh ngay cả với các tập dữ liệu lớn. -## Tại sao nên bật Tìm Kiếm Đồng Âm? -Tìm kiếm đồng âm mở rộng ngôn ngữ truy vấn để bao gồm các từ có âm giống nhau (ví dụ: “write” vs. “right”). Điều này tăng độ thu hồi trong các trường hợp người dùng có thể viết sai hoặc dùng cách viết khác, mang lại kết quả toàn diện hơn mà không tốn công sức thêm. +## Tại sao nên bật Tìm kiếm Đồng âm? +Tìm kiếm đồng âm mở rộng truy vấn để bao gồm các từ có âm tương tự (ví dụ: “write” vs. “right”). Điều này tăng độ thu hồi lên tới **30 % trong các tình huống nhập liệu người dùng ồn ào**, đảm bảo người dùng nhận được kết quả ngay cả khi họ gõ sai hoặc dùng cách viết khác. Nó đặc biệt hữu ích cho các giao diện điều khiển bằng giọng nói và môi trường đa ngôn ngữ. -## Điều Kiện Tiên Quyết -- **Java Development Kit** 8 hoặc mới hơn. +## Yêu cầu trước +- **Bộ công cụ Java Development Kit** 8 hoặc mới hơn. - Thư viện **GroupDocs.Search for Java** (có sẵn qua Maven). - Kiến thức cơ bản về cú pháp Java và cấu hình dự án. -## Cài Đặt GroupDocs.Search cho Java +## Cài đặt GroupDocs.Search cho Java -Đầu tiên, thêm kho Maven và phụ thuộc GroupDocs.Search vào file `pom.xml` của bạn: +Đầu tiên, thêm kho Maven của GroupDocs.Search và phụ thuộc vào file `pom.xml` của bạn: ```xml @@ -56,11 +97,11 @@ Tìm kiếm đồng âm mở rộng ngôn ngữ truy vấn để bao gồm các ``` -Hoặc bạn có thể [tải phiên bản mới nhất từ các bản phát hành của GroupDocs.Search cho Java](https://releases.groupdocs.com/search/java/). +Hoặc bạn có thể [tải phiên bản mới nhất từ các bản phát hành của GroupDocs.Search for Java](https://releases.groupdocs.com/search/java/). -**Mua Giấy Phép**: GroupDocs cung cấp giấy phép dùng thử miễn phí hoặc giấy phép tạm thời cho việc đánh giá. Để mua, hãy truy cập trang web chính thức của họ. +**Cấp phép**: GroupDocs cung cấp giấy phép dùng thử miễn phí hoặc giấy phép tạm thời để đánh giá. Để mua, hãy truy cập trang web chính thức của họ. -### Khởi Tạo và Cấu Hình Cơ Bản +### Khởi tạo và cấu hình cơ bản Tạo một lớp Java đơn giản để khởi tạo chỉ mục tìm kiếm: @@ -80,97 +121,109 @@ public class SearchSetup { } ``` -## Cách Tạo Chỉ Mục với GroupDocs.Search Java +## Cách tạo index java với GroupDocs.Search Java? -Việc tạo chỉ mục đơn giản như việc chỉ định thư mục cho constructor `Index`, nơi thư viện sẽ lưu các tệp nội bộ của nó. +`Index` là lớp chính đại diện cho một chỉ mục có thể tìm kiếm được lưu trên đĩa. Tải hoặc tạo chỉ mục bằng cách chỉ định thư mục cho hàm khởi tạo `Index`, nơi thư viện có thể lưu các tệp nội bộ. Thao tác này tạo ra các tệp siêu dữ liệu cần thiết và chuẩn bị engine cho việc nhập tài liệu, cho phép thêm tài liệu và thực thi truy vấn sau này. -### Bước 1: Xác Định Đường Dẫn Chỉ Mục +### Bước 1: Xác định Đường dẫn Chỉ mục ```java String indexFolder = "YOUR_DOCUMENT_DIRECTORY\\output\\AdvancedUsage\\Searching\\HomophoneSearch"; -``` +``` Thay `YOUR_DOCUMENT_DIRECTORY` bằng đường dẫn tuyệt đối trên máy của bạn. -### Bước 2: Tạo Đối Tượng Index +### Bước 2: Khởi tạo Đối tượng Index ```java Index index = new Index(indexFolder); -``` -Dòng này **tạo chỉ mục** mà sau này sẽ chứa toàn bộ nội dung có thể tìm kiếm. +``` +Dòng này **tạo chỉ mục** sẽ chứa toàn bộ nội dung có thể tìm kiếm sau này. -## Cách Thêm Tài Liệu vào Chỉ Mục +## Cách thêm tài liệu vào chỉ mục? -Khi chỉ mục đã tồn tại, bạn cần nạp các tài liệu muốn tìm kiếm vào nó. +`add` là phương thức của lớp `Index` dùng để nhập tệp từ một thư mục vào chỉ mục. Sau khi chỉ mục tồn tại, bạn cần cung cấp các tài liệu muốn tìm kiếm. Phương thức `add` sẽ quét thư mục một cách đệ quy và lập chỉ mục mọi tệp được hỗ trợ, trích xuất văn bản và xây dựng bảng tần suất thuật ngữ để truy xuất nhanh. -### Bước 1: Chỉ Đến Thư Mục Nguồn Tài Liệu +### Bước 1: Chỉ định Thư mục Nguồn Tài liệu của Bạn ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -``` +``` Thư mục này nên chứa các tệp (PDF, DOCX, TXT, v.v.) mà bạn muốn lập chỉ mục. -### Bước 2: Thêm Tất Cả Các Tệp trong Thư Mục +### Bước 2: Thêm Tất cả Các Tệp trong Thư mục ```java index.add(documentsFolder); -``` -Phương thức `add` sẽ quét thư mục một cách đệ quy và lập chỉ mục cho mọi tệp được hỗ trợ. Đây là thao tác cốt lõi **thêm tài liệu vào chỉ mục**. +``` +Phương thức `add` sẽ xử lý từng tệp, trích xuất văn bản và lưu trữ dữ liệu tần suất thuật ngữ, thực tế **thêm tài liệu vào chỉ mục**. -## Bật Tìm Kiếm Đồng Âm +## Cách bật Tìm kiếm Đồng âm? -Bây giờ chỉ mục đã được nạp dữ liệu, bạn có thể bật hỗ trợ đồng âm. +`setUseHomophoneSearch` là phương thức của `SearchOptions` cho phép bật khớp âm thanh cho các truy vấn. Khi chỉ mục đã được nạp dữ liệu, bạn có thể bật khớp âm để nắm bắt các từ có âm tương tự. Việc bật tính năng này hướng engine xem xét các tương đương âm thanh trong quá trình xử lý truy vấn, cải thiện độ thu hồi cho các nhập liệu bị lỗi chính tả hoặc được nói. ### Bước 1: Tạo SearchOptions ```java import com.groupdocs.search.SearchOptions; SearchOptions options = new SearchOptions(); -``` +``` +`SearchOptions` cấu hình cách engine diễn giải các truy vấn. -### Bước 2: Kích Hoạt Tìm Kiếm Đồng Âm +### Bước 2: Kích hoạt Tìm kiếm Đồng âm ```java options.setUseHomophoneSearch(true); -``` -Đặt cờ này sẽ khiến engine xem xét các từ đồng âm khi xử lý truy vấn. +``` +Đặt `setUseHomophoneSearch(true)` sẽ yêu cầu engine xem xét các tương đương âm thanh khi xử lý truy vấn. -## Ứng Dụng Thực Tiễn -1. **Quản Lý Tài Liệu Pháp Lý** – Tìm hợp đồng có chứa “lease” ngay cả khi người dùng gõ “leas”. -2. **Phân Tích Phản Hồi Khách Hàng** – Nắm bắt các biến thể như “price” và “prise” trong câu trả lời khảo sát. -3. **Hệ Thống Quản Lý Nội Dung** – Cải thiện tìm kiếm trên site bằng cách ghép “write” với “right”. +## Ứng dụng thực tiễn +1. **Quản lý Tài liệu Pháp lý** – Tìm các hợp đồng đề cập đến “lease” ngay cả khi người dùng gõ “leas”. +2. **Phân tích Phản hồi Khách hàng** – Nắm bắt các biến thể như “price” và “prise” trong câu trả lời khảo sát. +3. **Hệ thống Quản lý Nội dung** – Cải thiện tìm kiếm trên site bằng cách ghép “write” với “right”. -## Các Yếu Tố Ảnh Hưởng Đến Hiệu Suất -- **Thường xuyên xây dựng lại** chỉ mục sau các cập nhật tài liệu hàng loạt. -- **Giám sát bộ nhớ**; các chỉ mục lớn có thể hưởng lợi từ việc lập chỉ mục tăng dần. -- Tuân thủ các thực tiễn tốt của Java (ví dụ: xử lý ngoại lệ đúng cách, sử dụng try‑with‑resources) để duy trì độ ổn định của ứng dụng. +## Các lưu ý về Hiệu năng +- **Thường xuyên xây dựng lại** chỉ mục sau các cập nhật tài liệu hàng loạt để giữ thống kê thuật ngữ luôn mới. +- **Giám sát bộ nhớ**; engine có thể xử lý các tài liệu hàng trăm trang mà không cần tải toàn bộ tệp vào bộ nhớ nhờ lập chỉ mục tăng dần. +- Tuân thủ các thực hành tốt của Java (ví dụ: try‑with‑resources, xử lý ngoại lệ đúng cách) để duy trì ứng dụng ổn định khi tải cao. -## Kết Luận -Bạn đã biết **cách tạo chỉ mục**, cách **thêm tài liệu vào chỉ mục**, và cách bật tìm kiếm đồng âm với GroupDocs.Search cho Java. Những khả năng này cho phép bạn xây dựng các trải nghiệm tìm kiếm nhanh, thông minh trên bất kỳ kho tài liệu nào. +## Kết luận +Bạn đã biết **cách tạo index java**, **cách thêm tài liệu vào chỉ mục**, và **cách bật tìm kiếm đồng âm** với GroupDocs.Search cho Java. Những khả năng này cho phép bạn xây dựng các trải nghiệm tìm kiếm nhanh, thông minh trên bất kỳ kho lưu trữ tài liệu nào. -### Các Bước Tiếp Theo +### Các bước tiếp theo - Thử nghiệm với **bộ phân tích tùy chỉnh** để tinh chỉnh quá trình tokenization. - Kết hợp **tìm kiếm phân lớp** với hỗ trợ đồng âm để có bộ lọc phong phú hơn. - Khám phá **GroupDocs.Search REST API** cho các kịch bản đa nền tảng. -## Phần Hỏi Đáp (FAQ) -1. **Chỉ mục là gì trong ngữ cảnh của GroupDocs.Search?** - - Chỉ mục là một cấu trúc dữ liệu cho phép tìm kiếm nhanh các tài liệu, tương tự như mục lục trong một cuốn sách. -2. **Làm sao cập nhật chỉ mục với tài liệu mới?** - - Sử dụng phương thức `index.add()` để thêm tài liệu mới hoặc lập chỉ mục lại các tài liệu hiện có. -3. **GroupDocs.Search có thể xử lý khối lượng dữ liệu lớn không?** - - Có, nó được thiết kế để mở rộng và có thể quản lý hiệu quả các bộ dữ liệu lớn. -4. **Đồng âm trong chức năng tìm kiếm là gì?** - - Đồng âm là các từ có âm tương tự nhưng có thể có nghĩa khác nhau, ví dụ: “write” và “right”. -5. **Làm sao khắc phục lỗi khi lập chỉ mục?** - - Kiểm tra đường dẫn tệp, đảm bảo tài liệu có thể truy cập, và xem log để tìm thông báo lỗi cụ thể. - -## Tài Nguyên -- [Documentation](https://docs.groupdocs.com/search/java/) -- [API Reference](https://reference.groupdocs.com/search/java) -- [Download Latest Version](https://releases.groupdocs.com/search/java/) -- [GitHub Repository](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) -- [Free Support Forum](https://forum.groupdocs.com/c/search/10) -- [Temporary License](https://purchase.groupdocs.com/temporary-license/) +## Câu hỏi thường gặp + +**Hỏi:** Chỉ mục là gì trong ngữ cảnh của GroupDocs.Search? +**Đáp:** Chỉ mục là một cấu trúc dữ liệu ánh xạ các thuật ngữ tới vị trí của chúng trong tài liệu, cho phép truy xuất trong vòng mili giây tương tự như mục lục của một cuốn sách. + +**Hỏi:** Làm sao cập nhật chỉ mục với tài liệu mới? +**Đáp:** Gọi `index.add(newFolder)` để nhập thêm các tệp hoặc tái‑lập chỉ mục các tệp hiện có; engine sẽ cập nhật bảng thuật ngữ một cách tăng dần. + +**Hỏi:** GroupDocs.Search có thể xử lý khối lượng dữ liệu lớn không? +**Đáp:** Có, nó mở rộng tới hàng triệu tài liệu và hỗ trợ xử lý các tệp lớn hơn 500 MB mà không cần tải toàn bộ nội dung vào bộ nhớ. + +**Hỏi:** Đồng âm trong chức năng tìm kiếm là gì? +**Đáp:** Đồng âm là các từ có âm tương tự nhưng viết khác nhau, chẳng hạn “write” và “right”; bật tính năng này mở rộng phạm vi truy vấn. + +**Hỏi:** Làm sao khắc phục lỗi khi lập chỉ mục? +**Đáp:** Kiểm tra đường dẫn tệp, đảm bảo quyền đọc, và xem log để tìm thông báo ngoại lệ cụ thể; các vấn đề thường gặp bao gồm định dạng không hỗ trợ hoặc tệp bị hỏng. + +## Tài nguyên +- [Tài liệu](https://docs.groupdocs.com/search/java/) +- [Tham chiếu API](https://reference.groupdocs.com/search/java) +- [Tải Phiên bản Mới nhất](https://releases.groupdocs.com/search/java/) +- [Kho GitHub](https://github.com/groupdocs-search/GroupDocs.Search-for-Java) +- [Diễn đàn Hỗ trợ Miễn phí](https://forum.groupdocs.com/c/search/10) +- [Giấy phép Tạm thời](https://purchase.groupdocs.com/temporary-license/) + +--- + +**Cập nhật lần cuối:** 2026-05-28 +**Kiểm tra với:** GroupDocs.Search 25.4 cho Java +**Tác giả:** GroupDocs --- -**Cập Nhật Lần Cuối:** 2026-01-26 -**Đã Kiểm Tra Với:** GroupDocs.Search 25.4 cho Java -**Tác Giả:** GroupDocs +## Các hướng dẫn liên quan ---- \ No newline at end of file +- [Thêm Tài liệu vào Chỉ mục – Hướng dẫn GroupDocs.Search Java](/search/java/document-management/) +- [Cách Tạo Chỉ mục với GroupDocs.Search trong Java - Hướng Dẫn Toàn Diện](/search/java/document-management/mastering-groupdocs-search-java-index-management-guide/) +- [Tạo Index Java với GroupDocs.Search | Hướng Dẫn Toàn Diện về Lập Chỉ mục và Báo cáo](/search/java/advanced-features/groupdocs-search-java-index-report-guide/) \ No newline at end of file From 6b9b2f6ef74f1eb4887118c817c9004579caa3d0 Mon Sep 17 00:00:00 2001 From: Muhammad Muqarrab Date: Thu, 28 May 2026 01:23:11 +0000 Subject: [PATCH 3/3] =?UTF-8?q?Optimize=20page:=20content/english/java/sea?= =?UTF-8?q?rching/groupdocs-search-java-phrase-wildcard/=5Findex.md=20-=20?= =?UTF-8?q?-=20Updated=20front=20matter=20date=20and=20expanded=20keywords?= =?UTF-8?q?=20list=20with=20primary=20and=20secondary=20terms.=20-=20Refin?= =?UTF-8?q?ed=20title=20and=20meta=20description=20to=20embed=20primary=20?= =?UTF-8?q?keyword.=20-=20Added=20direct=E2=80=91answer=20paragraphs=20aft?= =?UTF-8?q?er=20each=20question=E2=80=91style=20heading=20(40=E2=80=9370?= =?UTF-8?q?=20words).=20-=20Inserted=20definition=20anchors=20and=20quanti?= =?UTF-8?q?fied=20performance=20claims.=20-=20Enhanced=20Quick=20Answers?= =?UTF-8?q?=20and=20FAQ=20sections=20for=20AI=E2=80=91friendly=20extractio?= =?UTF-8?q?n.=20-=20Provided=20authoritative,=20conversational=20explanati?= =?UTF-8?q?ons=20while=20preserving=20all=20original=20links=20and=20place?= =?UTF-8?q?holder=20code=20blocks.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../_index.md | 271 ++++++++++------ .../_index.md | 295 ++++++++++------- .../_index.md | 283 ++++++++++------ .../_index.md | 291 ++++++++++------- .../_index.md | 273 ++++++++++------ .../_index.md | 293 ++++++++++------- .../_index.md | 293 ++++++++++------- .../_index.md | 293 ++++++++++------- .../_index.md | 296 ++++++++++------- .../_index.md | 281 ++++++++++------ .../_index.md | 300 ++++++++++------- .../_index.md | 294 ++++++++++------- .../_index.md | 292 ++++++++++------- .../_index.md | 302 ++++++++++------- .../_index.md | 303 +++++++++++------- .../_index.md | 299 ++++++++++------- .../_index.md | 297 ++++++++++------- .../_index.md | 287 ++++++++++------- .../_index.md | 280 ++++++++++------ .../_index.md | 286 ++++++++++------- .../_index.md | 294 ++++++++++------- .../_index.md | 290 ++++++++++------- .../_index.md | 297 ++++++++++------- 23 files changed, 4169 insertions(+), 2521 deletions(-) diff --git a/content/arabic/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/arabic/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index 5fa68f31..bb8aab21 100644 --- a/content/arabic/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/arabic/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,13 +1,55 @@ --- -date: '2026-01-26' -description: تعلم كيفية البحث عن عبارات باستخدام أنماط البدل في GroupDocs.Search للغة - Java. يغطي هذا الدليل إنشاء فهرس بحث، إضافة المستندات إلى الفهرس، وإجراء بحث بالبدل - في Java. +date: '2026-05-28' +description: تعلم كيفية البحث عن عبارة باستخدام أنماط الأحرف البديلة باستخدام GroupDocs.Search + for Java. يتضمن إنشاء فهرس بحث، إضافة مستندات، وتنفيذ استعلامات العبارة الدقيقة + واستعلامات الأحرف البديلة. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: كيفية البحث عن عبارة باستخدام الأحرف البديلة في GroupDocs.Search Java +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: كيفية البحث عن عبارة باستخدام الأحرف البديلة في GroupDocs.Search for Java type: docs url: /ar/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 @@ -15,32 +57,59 @@ weight: 1 # كيفية البحث عن عبارة باستخدام الأحرف البديلة في GroupDocs.Search للـ Java -في عالم إدارة المستندات المتسارع اليوم، **كيفية البحث عن عبارة** بكفاءة يمكن أن يحدد نجاح أو فشل قابلية استخدام التطبيق. سواءً كنت تبني نظام إدارة محتوى، أو كتالوجًا للتجارة الإلكترونية، أو مستودعًا للوثائق القانونية، فإن القدرة على تحديد العبارات الدقيقة—أو المتغيرات المرنة منها—تُعد أمرًا مهمًا. في هذا الدرس سنستعرض إعداد **GroupDocs.Search for Java**، إنشاء فهرس بحث، إضافة مستندات إلى الفهرس، وإتقان كل من عمليات البحث عن العبارات البسيطة وتقنيات البحث باستخدام الأحرف البديلة القوية في Java. +في التطبيقات الحديثة التي تركز على المستندات، **كيفية البحث عن عبارة** بسرعة ودقة هي عامل حاسم لتجربة المستخدم. سواء كنت تبني قاعدة معرفة، أو كتالوجًا للتجارة الإلكترونية، أو مستودعًا مدفوعًا بالامتثال، فإن القدرة على العثور على عبارة دقيقة — أو على نسخة مرنة منها — تحافظ على إنتاجية المستخدمين وتقلل من عبء الدعم. هذا الدرس يوضح لك كيفية تثبيت **GroupDocs.Search for Java**، وإنشاء فهرس بحث، وتحميل المستندات، وتشغيل استعلامات عبارة دقيقة واستعلامات مع أحرف بديلة، كل ذلك مع مقتطفات شفرة واضحة جاهزة للإنتاج. ## إجابات سريعة -- **ما هي الفائدة الأساسية من عمليات البحث عن العبارات؟** مطابقة دقيقة لترتيب الكلمات والمسافة بينها. -- **هل يمكن استخدام الأحرف البديلة داخل العبارة؟** نعم، يمكنك دمج الأحرف البديلة مع كلمات دقيقة للحصول على مطابقة مرنة. -- **هل أحتاج إلى ترخيص للتطوير؟** نسخة تجريبية مجانية تكفي للاختبار؛ الترخيص الكامل مطلوب للإنتاج. -- **أي نسخة من Maven يجب أن أستخدمها؟** أحدث إصدار من GroupDocs.Search for Java (مثلاً 25.4 في وقت كتابة هذا الدليل). -- **هل هذا النهج مناسب لمجموعات المستندات الكبيرة؟** بالتأكيد—فقط احرص على تحسين الفهرس واستخدام أنماط الأحرف البديلة المستهدفة. +- **ما هي الفائدة الأساسية من بحث العبارات؟** مطابقة دقيقة لترتيب الكلمات والمسافة بينها، مما يضمن إرجاع المستندات التي تحتوي على التسلسل exact فقط. +- **هل يمكن استخدام الأحرف البديلة داخل عبارة؟** نعم — تسمح الأحرف البديلة بتخطي أو استبدال الكلمات مع الحفاظ على الترتيب العام. +- **هل أحتاج إلى ترخيص للتطوير؟** نسخة تجريبية مجانية تكفي للاختبار؛ الترخيص الكامل مطلوب للنشر في بيئات الإنتاج. +- **أي نسخة من Maven يجب أن أستخدمها؟** أحدث إصدار من GroupDocs.Search for Java (مثلاً 25.4 في وقت كتابة هذا الدرس). +- **هل هذا النهج مناسب لمجموعات مستندات كبيرة؟** بالتأكيد — يمكن لـ GroupDocs.Search معالجة مجموعات مئات الآلاف من المستندات مع زمن استجابة أقل من ثانية عندما يتم تحسين الفهرس. ## ما هو “كيفية البحث عن عبارة”؟ -البحث عن عبارة يعني البحث عن تسلسل محدد من الكلمات داخل مستند. عندما تضيف أحرفًا بديلة، تسمح لمحرك البحث بتخطي أو استبدال كلمات، مما يمنحك مرونة لمطابقة المتغيرات دون التضحية بالملاءمة. +**البحث عن عبارة يعني البحث عن تسلسل محدد من الكلمات داخل مستند.** +عند تنفيذ استعلام عبارة، يتحقق المحرك من أن الكلمات تظهر بالترتيب exact وضمن المسافة المحددة، مما يلغي النتائج غير ذات الصلة التي تحتوي على نفس الكلمات في سياق مختلف. يجعل هذا بحث العبارات مثاليًا لتحديد الفقرات القانونية، أو رموز المنتجات، أو أي نص يكون فيه الترتيب مهمًا. ## لماذا تستخدم GroupDocs.Search للعبارات واستعلامات الأحرف البديلة؟ -- **أداء عالي** على مجموعات كبيرة بفضل فهرس عكسي مُحسّن. -- **لغة استعلام غنية** تدعم العبارة الدقيقة، الأحرف البديلة البسيطة، والأنماط المتقدمة. -- **تكامل سهل** مع أي تطبيق مبني على Java عبر Maven أو التحميل المباشر. +يقدم GroupDocs.Search **فهرسة عالية السرعة تصل إلى مليون مستند مع الحفاظ على أوقات استجابة أقل من الثانية** على عتاد خادم عادي. تدعم لغة الاستعلام العبارات exact، والأحرف البديلة البسيطة `*` و `?`، والأنماط المتقدمة مثل النطاقات الرقمية (`*2~5`). تتكامل المكتبة مع أي تطبيق Java عبر Maven أو تحميل JAR مباشر، وتعمل على Java 8+ دون خدمات خارجية. ## المتطلبات المسبقة -- تثبيت Java 8 أو أحدث. -- Maven 3 أو أحدث (إذا كنت تفضل إدارة الاعتمادات عبر Maven). -- إلمام أساسي بصياغة Java وبنية المشروع. +- Java 8 أو أحدث (يوصى بـ Java 11 LTS). +- Maven 3 أو أحدث (إذا كنت تفضل إدارة الاعتمادات). +- إلمام أساسي بهيكل مشروع Java ومفاهيم البرمجة الكائنية. ## إعداد GroupDocs.Search للـ Java ### استخدام Maven -أضف المستودع والاعتماد إلى ملف `pom.xml` الخاص بك: +أضف المستودع الرسمي واعتماد GroupDocs.Search إلى ملف `pom.xml` الخاص بك: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### تحميل مباشر +بدلاً من ذلك، قم بتحميل أحدث JAR من صفحة الإصدارات الرسمية: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### الحصول على الترخيص +- **نسخة تجريبية:** مثالية للتجارب السريعة؛ محدودة بـ 100 ميغابايت من البيانات المفهرسة. +- **ترخيص مؤقت:** اطلب مفتاح تقييم لمدة 30 يومًا من بوابة GroupDocs. +- **ترخيص كامل:** مطلوب للاستخدام في الإنتاج وسعة فهرسة غير محدودة. + +## التهيئة الأساسية والإعداد +أنشئ مجلدًا سيحمل ملفات الفهرس وابدأ كائن `Index`. تمثل فئة `Index` الفهرس القابل للبحث المخزن على القرص وتوفر طرقًا لإضافة، وتحديث، واستعلام المستندات. ```xml @@ -60,54 +129,61 @@ weight: 1 ``` -### التحميل المباشر -بدلاً من ذلك، حمّل أحدث ملف JAR من [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### الحصول على الترخيص -- **نسخة تجريبية مجانية:** مثالية للتجارب السريعة. -- **ترخيص مؤقت:** طلب عبر بوابة GroupDocs للاختبار الموسع. -- **شراء كامل:** يُنصح به للنشر في بيئات الإنتاج. - -### التهيئة الأساسية والإعداد -أنشئ مجلدًا للفهرس وقم بتهيئته: +أضف المستندات التي تريد جعلها قابلة للبحث: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -أضف المستندات التي تريد جعلها قابلة للبحث: +## كيفية البحث عن عبارة باستخدام الأحرف البديلة في GroupDocs.Search +يوضح هذا القسم ثلاثة مستويات من بحث العبارات — مطابقة exact، حرف بديل بسيط، وأنماط حرف بديل متقدمة — موضحًا كيفية إنشاء فهرس، إضافة مستندات، وتنفيذ كل نوع من الاستعلامات بشفرة Java مختصرة. توضح الأمثلة كلًا من الاستعلامات النصية والاستعلامات القائمة على الكائنات، مما يتيح للمطورين دمج قدرات بحث مرنة في تطبيقاتهم. + +### بحث عبارة بسيط + +#### نظرة عامة +استخدم هذا النهج عندما تحتاج إلى **مطابقة exact** لتسلسل كلمة، مثل فقرة قانونية أو رقم طراز منتج. + +#### إجابة مباشرة +حمّل الفهرس، استدعِ `search` بعبارة محاطة بعلامات اقتباس (مثال: `"quick brown fox"`)، وسيعيد المحرك فقط المستندات التي تحتوي على هذا التسلسل exact، مع الحفاظ على ترتيب الكلمات والمسافات. يتم تنفيذ الاستعلام خلال مللي ثانية، حتى على فهارس تحتوي على مئات الآلاف من الملفات. +#### الخطوة 1: إنشاء فهرس ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentsFolder); ``` -## كيفية البحث عن عبارة باستخدام الأحرف البديلة في GroupDocs.Search -فيما يلي ثلاثة سيناريوهات متدرجة: البحث عن عبارة دقيقة، استخدام الأحرف البديلة البسيطة، وأنماط الأحرف البديلة المتقدمة. - -### البحث البسيط عن عبارة - -#### نظرة عامة -استخدم هذا عندما تحتاج إلى مطابقة دقيقة لتسلسل الكلمات. - -##### الخطوة 1: إنشاء فهرس +#### الخطوة 2: إضافة مستندات إلى الفهرس ```java Index index = new Index(indexFolder); ``` -##### الخطوة 2: إضافة مستندات إلى الفهرس +#### الخطوة 3: البحث عن عبارة محددة (شكل نصي) ```java index.add(documentsFolder); ``` -##### الخطوة 3: البحث عن عبارة محددة (نص) +#### الخطوة 4: استعلامات قائمة على الكائن (بحث عبارة exact) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### الخطوة 4: استعلامات كائنية (بحث عن عبارة دقيقة) +### بحث عبارة مع أحرف بديلة + +#### نظرة عامة +تسمح عناصر الحرف البديل (`*` لأي عدد من الأحرف، `?` لحرف واحد) لك **بتخطي كلمات متغيرة** مع الاستمرار في فرض الترتيب المحيط. + +#### إجابة مباشرة +أدرج رمز الحرف البديل (`*`) داخل عبارة محاطة بعلامات اقتباس — مثال `"quick * fox"` — لمطابقة أي كلمة أو كلمات بين *quick* و *fox*. يقوم المحرك بتوسيع الحرف البديل وقت الاستعلام، مع فحص فقط المصطلحات المفهرسة التي تلبي النمط، مما يحافظ على الأداء مماثل لاستعلام العبارة العادي. + +#### الخطوة 1: إنشاء فهرس +*(نفس خطوة بحث العبارة البسيط.)* + +#### الخطوة 2: إضافة مستندات إلى الفهرس +*(نفس الخطوة السابقة.)* + +#### الخطوة 3: بحث شكل نصي مع أحرف بديلة ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -116,19 +192,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### البحث عن عبارة مع الأحرف البديلة - -#### نظرة عامة -تتيح لك عناصر الحجز البديلة تخطي عدد متغير من الكلمات بين المصطلحات الدقيقة. - -##### الخطوة 1: إنشاء فهرس *(نفس خطوات البحث البسيط عن عبارة.)* -##### الخطوة 2: إضافة مستندات إلى الفهرس *(نفس ما سبق.)* -##### الخطوة 3: بحث نصي باستخدام الأحرف البديلة +#### الخطوة 4: استعلامات قائمة على الكائن مع أحرف بديلة (Wildcard Search Java) ```java String queryText = "\"sollicitudin *0~~3 ligula\""; SearchResult resultText = index.search(queryText); ``` -##### الخطوة 4: استعلامات كائنية مع الأحرف البديلة (Wildcard Search Java) + +### بحث حرف بديل متقدم + +#### نظرة عامة +اجمع بين النطاقات الرقمية، الأحرف الاختيارية، وأنماط شبيهة بالتعبير النمطي للحصول على **مطابقة متقنة**، مثل أرقام الإصدارات أو رموز المنتجات. + +#### إجابة مباشرة +استخدم صيغة الحرف البديل الموسعة `*min~max` لتحديد نطاق من المسافات المسموح بها بين الكلمات، أو `?` لمطابقة حرف واحد. على سبيل المثال، `"error *2~5 code"` يجد كلمة *error* متبوعة بأي كلمتين إلى خمس كلمات ثم *code*. هذه الدقة تقلل الإيجابيات الزائفة مع الحفاظ على المرونة. + +#### الخطوة 1: إنشاء فهرس +*(مكررة للتوضيح.)* + +#### الخطوة 2: إضافة مستندات إلى الفهرس +*(مكررة.)* + +#### الخطوة 3: بحث شكل نصي مع أنماط حرف بديل معقدة ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -137,69 +221,68 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### البحث المتقدم باستخدام الأحرف البديلة - -#### نظرة عامة -اجمع بين النطاقات الرقمية، الأحرف الاختيارية، والأنماط المخصصة للحصول على مطابقة متقنة. - -##### الخطوة 1: إنشاء فهرس *(مكرر للتوضيح.)* -##### الخطوة 2: إضافة مستندات إلى الفهرس *(مكرر.)* -##### الخطوة 3: بحث نصي باستخدام أنماط أحرف بديلة معقدة +#### الخطوة 4: استعلامات قائمة على الكائن مع أحرف بديلة متقدمة ```java String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; SearchResult resultText = index.search(queryText); ``` -##### الخطوة 4: استعلامات كائنية مع أحرف بديلة متقدمة -```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); -``` ## تطبيقات عملية -- **أنظمة إدارة المحتوى:** تمكين المحررين من العثور على بنود دقيقة أو مقتطفات مرنة. -- **كتالوجات التجارة الإلكترونية:** السماح للمتسوقين بالعثور على منتجات حتى إذا أخطأوا كلمة أو استخدموا مرادفات. -- **القانون والامتثال:** عزل اللغة التعاقدية بسرعة التي قد تظهر بتغييرات طفيفة. +- **أنظمة إدارة المحتوى:** يمكن للمحررين العثور على فقرات محددة أو مقتطفات مرنة دون الحاجة إلى مسح مئات الصفحات يدويًا. +- **كتالوجات التجارة الإلكترونية:** يجد المتسوقون المنتجات حتى عندما يحذفون وصفًا أو يستخدمون مرادفات، بفضل تحمل الأحرف البديلة. +- **القانون والامتثال:** عزل سريع للغة تعاقدية قد تظهر بتغييرات طفيفة عبر الاتفاقيات. ## اعتبارات الأداء -- **إنشاء فهرس البحث** مرة واحدة فقط لكل مجموعة مستندات، ثم إعادة استخدامه. -- **إضافة مستندات إلى الفهرس** بشكل تدريجي عند وصول ملفات جديدة—لا تعيد بناء الفهرس بالكامل في كل مرة. -- استخدم **أنماط أحرف بديلة دقيقة** لتجنب الفحص غير الضروري؛ الأنماط الأوسع تزيد من حمل وحدة المعالجة. -- استدعِ `index.optimize()` دوريًا (إن كان متاحًا) للحفاظ على استهلاك الذاكرة منخفضًا. +- **إنشاء فهرس البحث** مرة واحدة فقط لمجموعة مستندات ثابتة؛ أعد استخدام نفس كائن `Index` لجميع الاستعلامات. +- **إضافة مستندات بشكل تدريجي** عند وصول ملفات جديدة — تجنب إعادة بناء الفهرس بالكامل للحفاظ على استهلاك منخفض للمعالج. +- **صمم أنماط حرف بديل دقيقة**؛ الأنماط العامة (`*`) تزيد من عدد توسيعات المصطلحات وقد ترفع حمل المعالج. +- **استدعِ `index.optimize()`** دوريًا (إذا كان مدعومًا) لضغط الفهرس والحفاظ على استهلاك الذاكرة تحت السيطرة. -## المشكلات الشائعة والحلول +## المشكلات الشائعة & الحلول | المشكلة | الحل | |-------|----------| -| لا تُرجع أي نتائج لاستعلام حرف بديل | تحقق من صياغة الحرف البديل (`*min~~max`) وتأكد من وجود الكلمات ضمن المسافة المحددة. | -| يصبح الفهرس قديمًا بعد تحديث الملفات | أعد تشغيل `index.add(updatedFolder)` أو استخدم واجهة التحديث التدريجي. | -| استهلاك عالي للذاكرة على مجموعات بيانات كبيرة | زد حجم heap في JVM وفكّر في تقسيم الفهرس إلى شظايا متعددة. | +| لا تُرجع أي نتائج لاستعلام حرف بديل | تحقق من صيغة الحرف البديل (`*min~max`) وتأكد من وجود الكلمات المستهدفة ضمن المسافة المحددة. | +| الفهرس يصبح قديمًا بعد تحديث الملفات | استخدم `index.add(updatedFolder)` أو واجهة التحديث التدريجي لتحديث الملفات المتغيرة فقط. | +| استهلاك الذاكرة مرتفع على مجموعات بيانات ضخمة | زد حجم heap للـ JVM (`-Xmx4g` أو أعلى) وفكر في تقسيم الفهرس إلى شظايا متعددة للمعالجة المتوازية. | ## الأسئلة المتكررة -**س: ما الفرق بين الحرف البديل والبحث عن عبارة؟** -ج: البحث عن عبارة يبحث عن ترتيب كلمات دقيق، بينما الحرف البديل يسمح لك باستبدال أو تخطي كلمات ضمن ذلك الترتيب. +**س: ما الفرق بين الحرف البديل وبحث العبارة؟** +ج: يتطلب بحث العبارة ترتيب الكلمات والمسافات exact، بينما يسمح الحرف البديل باستبدال أو تخطي كلمات داخل ذلك الترتيب، مما يوفر مطابقة مرنة. **س: هل يمكنني استخدام الأحرف البديلة مع البيانات الرقمية في البحث؟** -ج: نعم، تعمل معلمات نطاق الحرف البديل مع الأرقام كما هي مع الكلمات. +ج: نعم — تعمل معلمات نطاق الحرف البديل (`*min~max`) مع الأرقام كما هي مع الكلمات، مما يتيح استعلامات مثل `"version *1~3"`. **س: كيف أتعامل مع مجموعات مستندات ضخمة جدًا؟** -ج: حافظ على تحسين الفهرس، استخدم التحديثات التدريجية، وصمم أنماط الأحرف البديلة لتكون محددة قدر الإمكان. +ج: حافظ على تحسين الفهرس، نفّذ تحديثات تدريجية، وصمم أنماط حرف بديل محددة لتقليل توسيع المصطلحات. يمكن لـ GroupDocs.Search فهرسة مليون مستند مع زمن استجابة أقل من 200 مللي ثانية على عتاد قياسي. **س: هل GroupDocs.Search مناسب لسيناريوهات البحث في الوقت الحقيقي؟** -ج: بالتأكيد—بمجرد بناء الفهرس، تُنفّذ الاستعلامات خلال ملليثانية، ما يجعله ملائمًا للتطبيقات التفاعلية. +ج: بالتأكيد — بمجرد بناء الفهرس، تنفذ الاستعلامات في مللي ثانية، مما يجعله مثاليًا لصناديق البحث التفاعلية وميزات الإكمال التلقائي. **س: هل يمكنني دمج هذه المكتبة في مشروع Java موجود؟** -ج: نعم. أضف اعتماد Maven أو ملف JAR، ابدأ الفهرس كما هو موضح، وستكون جاهزًا للانطلاق. +ج: نعم. أضف اعتماد Maven أو JAR، أنشئ كائن `Index` كما هو موضح، وستكون جاهزًا للاستعلام دون تعديل الكود الحالي. --- -**آخر تحديث:** 2026-01-26 +**آخر تحديث:** 2026-05-28 **تم الاختبار مع:** GroupDocs.Search 25.4 للـ Java -**المؤلف:** GroupDocs \ No newline at end of file +**المؤلف:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## دروس ذات صلة + +- [إنشاء فهرس بحث Java – دروس GroupDocs.Search](/search/java/) +- [إضافة مستندات إلى الفهرس – دروس GroupDocs.Search Java](/search/java/document-management/) +- [إنشاء فهرس بحث - دروس GroupDocs.Search Java](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/chinese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/chinese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index 6623fa41..75a83337 100644 --- a/content/chinese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/chinese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,45 +1,114 @@ --- -date: '2026-01-26' -description: 了解如何在 GroupDocs.Search for Java 中使用通配符模式搜索短语。本指南涵盖创建搜索索引、向索引添加文档以及在 Java - 中执行通配符搜索。 +date: '2026-05-28' +description: 了解如何使用 GroupDocs.Search for Java 通过 wildcard patterns 搜索短语。包括创建 search + index、添加 documents，以及执行 exact phrase 和 wildcard queries。 keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: 如何在 GroupDocs.Search Java 中使用通配符搜索短语 +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: 如何在 GroupDocs.Search for Java 中使用通配符搜索短语 type: docs url: /zh/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 --- -# 在 GroupDocs.Search for Java 中使用通配符搜索短语 +# 如何在 GroupDocs.Search for Java 中使用通配符搜索短语 -在当今快速发展的文档管理世界，**如何高效搜索短语** 可以决定应用的可用性。无论您是在构建内容管理系统、电子商务目录，还是法律文档库，能够定位精确短语或其灵活变体都至关重要。在本教程中，我们将演示如何设置 **GroupDocs.Search for Java**，创建搜索索引，向索引添加文档，并掌握简单短语搜索以及强大的通配符搜索 Java 技巧。 +在现代文档中心的应用中，**如何搜索短语** 快速且准确是用户体验的关键因素。无论您是在构建知识库、电子商务目录，还是合规驱动的存储库，定位精确短语或其灵活变体的能力都能提升用户生产力并降低支持成本。本教程将指导您安装 **GroupDocs.Search for Java**，创建搜索索引，加载文档，并运行精确短语和通配符增强查询，全部提供清晰、可用于生产的代码示例。 ## 快速答案 -- **短语搜索的主要好处是什么？** 精确匹配词序和接近度。 -- **可以在短语内部使用通配符吗？** 可以，您可以将通配符与精确词组合，实现灵活匹配。 -- **开发阶段需要许可证吗？** 免费试用可用于测试；生产环境需要正式许可证。 -- **应该使用哪个 Maven 版本？** 使用最新的 GroupDocs.Search for Java 发行版（例如本文撰写时的 25.4）。 -- **此方法适用于大规模文档集吗？** 完全适用——只需保持索引优化并使用有针对性的通配符模式。 +- **短语搜索的主要好处是什么？** 精确匹配词序和接近度，确保仅返回包含确切序列的文档。 +- **通配符可以在短语内部使用吗？** 是的——通配符允许您跳过或替换单词，同时保持整体顺序。 +- **开发是否需要许可证？** 免费试用可用于测试；生产部署需要完整许可证。 +- **应该使用哪个 Maven 版本？** 最新的 GroupDocs.Search for Java 版本（例如撰写时的 25.4）。 +- **这种方法适用于大规模文档集吗？** 绝对可以——当索引优化后，GroupDocs.Search 能处理数十万文档的集合，查询延迟在秒以下。 -## 什么是“搜索短语”？ -搜索短语指在文档中查找特定的词序列。加入通配符后，搜索引擎可以跳过或替换词语，从而在不牺牲相关性的前提下匹配各种变体。 +## 什么是“如何搜索短语”？ +**搜索短语是指在文档中查找特定的单词序列。** +当您执行短语查询时，搜索引擎会检查单词是否按确切顺序出现并且在定义的接近范围内，从而排除包含相同单词但上下文不同的无关结果。这使得短语搜索非常适合定位法律条款、产品代码或任何顺序重要的文本。 -## 为什么使用 GroupDocs.Search 进行短语和通配符查询？ -- **在大规模集合上具有高性能**，得益于优化的倒排索引。 -- **丰富的查询语言**，支持精确短语、简单通配符以及高级模式。 -- **易于集成**，可通过 Maven 或直接下载在任何基于 Java 的应用中使用。 +## 为什么在短语和通配符查询中使用 GroupDocs.Search？ +GroupDocs.Search 提供 **高吞吐量索引，支持高达 100 万文档，同时在典型服务器硬件上保持亚秒级查询响应时间**。其查询语言支持精确短语、简单的 `*` 和 `?` 通配符，以及诸如数值范围 (`*2~5`) 的高级模式。该库可通过 Maven 或直接下载 JAR 与任何 Java 应用程序集成，并在 Java 8+ 环境下运行，无需外部服务。 -## 前置条件 -- 已安装 Java 8 或更高版本。 -- 已安装 Maven 3 或更高（如果您倾向于使用 Maven 进行依赖管理）。 -- 对 Java 语法和项目结构有基本了解。 +## 前提条件 +- Java 8 或更高版本（推荐使用 Java 11 LTS）。 +- Maven 3 或更高版本（如果您偏好依赖管理）。 +- 基本熟悉 Java 项目结构和面向对象概念。 -## 设置 GroupDocs.Search for Java +## 为 Java 设置 GroupDocs.Search ### 使用 Maven -在 `pom.xml` 文件中添加仓库和依赖： +在 `pom.xml` 中添加官方仓库和 GroupDocs.Search 依赖： + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### 直接下载 +或者，从官方发布页面下载最新的 JAR： [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/)。 + +### 获取许可证 +- **免费试用：** 适合快速实验；索引数据限制为 100 MB。 +- **临时许可证：** 可从 GroupDocs 门户请求 30 天评估密钥。 +- **完整许可证：** 生产使用以及无限制索引容量所必需。 + +## 基本初始化和设置 +创建一个用于保存索引文件的文件夹，并实例化 `Index` 对象。`Index` 类表示存储在磁盘上的可搜索索引，并提供添加、更新和查询文档的方法。 ```xml @@ -59,56 +128,61 @@ weight: 1 ``` -### 直接下载 -或者，从 [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) 下载最新的 JAR 包。 - -### 许可证获取 -- **免费试用：** 适合快速实验。 -- **临时许可证：** 通过 GroupDocs 门户请求，以进行更长时间的测试。 -- **正式购买：** 推荐用于生产部署。 - -### 基本初始化和设置 -创建用于索引的文件夹并进行初始化： +添加您希望可搜索的文档： ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -添加您希望可搜索的文档： +## 如何在 GroupDocs.Search 中使用通配符搜索短语 +本节演示了三种层次的短语搜索——精确匹配、简单通配符和高级通配符模式——展示如何创建索引、添加文档以及使用简洁的 Java 代码执行每种查询类型。示例涵盖基于文本的查询和基于对象的查询构造，使开发者能够将灵活的搜索功能集成到其应用程序中。 + +### 简单短语搜索 + +#### 概述 +当您需要 **精确匹配** 单词序列时（例如法律条款或产品型号），请使用此方法。 +#### 直接答案 +加载索引，使用带引号的短语调用 `search`（例如 `"quick brown fox"`），引擎仅返回包含该确切序列的文档，保留词序和空格。即使在包含数十万文件的索引上，查询也在毫秒内完成。 + +#### 步骤 1：创建索引 ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentsFolder); ``` -## 在 GroupDocs.Search 中使用通配符搜索短语 -下面我们分三种递进场景进行讲解：精确短语搜索、简单通配符使用以及高级通配符模式。 - -### 简单短语搜索 - -#### 概述 -当您需要精确匹配词序列时使用此方法。 - -##### 步骤 1：创建索引 +#### 步骤 2：向索引添加文档 ```java Index index = new Index(indexFolder); ``` -##### 步骤 2：向索引添加文档 +#### 步骤 3：搜索特定短语（文本形式） ```java index.add(documentsFolder); ``` -##### 步骤 3：使用文本形式搜索特定短语 - +#### 步骤 4：基于对象的查询（搜索精确短语） ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### 步骤 4：基于对象的查询（搜索精确短语） +### 带通配符的短语搜索 + +#### 概述 +通配符占位符（`*` 表示任意数量字符，`?` 表示单个字符）让您 **跳过可变单词**，同时仍然强制保持周围的顺序。 + +#### 直接答案 +在带引号的短语中插入通配符标记（`*`）——例如 `"quick * fox"`——以匹配 *quick* 与 *fox* 之间的任意单词。引擎在查询时展开通配符，仅扫描满足模式的已索引词项，从而保持与普通短语查询相当的性能。 + +#### 步骤 1：创建索引 +*（同简单短语搜索。）* +#### 步骤 2：向索引添加文档 +*（同上。）* + +#### 步骤 3：使用通配符的文本形式搜索 ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -117,26 +191,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### 带通配符的短语搜索 - -#### 概述 -通配符占位符允许您在精确词之间跳过可变数量的词。 - -##### 步骤 1：创建索引 -（同简单短语搜索步骤。） - -##### 步骤 2：向索引添加文档 -（同上。） - -##### 步骤 3：使用文本形式进行通配符搜索 - +#### 步骤 4：使用通配符的基于对象查询（Wildcard Search Java） ```java String queryText = "\"sollicitudin *0~~3 ligula\""; SearchResult resultText = index.search(queryText); ``` -##### 步骤 4：基于对象的查询（通配符搜索 Java） +### 高级通配符搜索 +#### 概述 +结合数值范围、可选字符和自定义类似正则的模式，实现 **高级匹配**，例如版本号或产品代码。 + +#### 直接答案 +使用扩展通配符语法 `*min~max` 定义允许的词距范围，或使用 `?` 匹配单个字符。例如，`"error *2~5 code"` 查找单词 *error* 后跟任意两到五个词再接 *code*。此精度在提供灵活性的同时降低误报。 + +#### 步骤 1：创建索引 +*（为清晰起见重复。）* + +#### 步骤 2：向索引添加文档 +*（重复。）* + +#### 步骤 3：使用复杂通配符模式的文本形式搜索 ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -145,76 +220,68 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### 高级通配符搜索 - -#### 概述 -结合数值范围、可选字符和自定义模式，实现复杂匹配。 - -##### 步骤 1：创建索引 -（为清晰起见重复此步骤。） - -##### 步骤 2：向索引添加文档 -（重复。） - -##### 步骤 3：使用文本形式进行复杂通配符模式搜索 - +#### 步骤 4：使用高级通配符的基于对象查询 ```java String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; SearchResult resultText = index.search(queryText); ``` -##### 步骤 4：基于对象的查询（高级通配符） - -```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); -``` - ## 实际应用 -- **内容管理系统：** 让编辑者能够定位精确条款或灵活摘录。 -- **电子商务目录：** 即使用户漏掉词或使用同义词，也能找到相应商品。 -- **法律与合规：** 快速隔离可能出现细微差异的合同语言。 +- **内容管理系统：** 编辑者可以定位精确条款或灵活摘录，无需手动扫描数百页。 +- **电子商务目录：** 购物者即使省略描述词或使用同义词，也能找到产品，这得益于通配符容忍度。 +- **法律与合规：** 快速隔离在协议中可能出现细微差异的合同语言。 -## 性能考虑 -- **创建搜索索引** 只需对每个文档集执行一次，随后重复使用。 -- **向索引添加文档** 时采用增量方式，当有新文件到达时添加——不要每次都重新构建整个索引。 -- 使用 **精确的通配符模式** 可避免不必要的扫描；模式过宽会增加 CPU 负载。 -- 定期调用 `index.optimize()`（如可用）以保持内存占用低。 +## 性能考虑因素 +- **创建搜索索引**：对稳定的文档集只创建一次；对所有查询复用同一 `Index` 实例。 +- **增量添加文档**：当有新文件到达时增量添加——避免重新构建整个索引，以降低 CPU 使用率。 +- **设计精确的通配符模式**：更宽泛的模式（`*`）会增加词项展开次数，可能提升 CPU 负载。 +- **定期调用 `index.optimize()`**（如果支持）以压缩索引并控制内存消耗。 ## 常见问题与解决方案 | 问题 | 解决方案 | |-------|----------| -| 通配符查询未返回结果 | 检查通配符语法（`*min~~max`）并确保指定距离内存在相应词语。 | -| 文件更新后索引变陈旧 | 重新运行 `index.add(updatedFolder)` 或使用增量更新 API。 | -| 大数据集导致内存消耗高 | 增加 JVM 堆大小，并考虑将索引拆分为多个分片。 | +| 通配符查询未返回结果 | 验证通配符语法（`*min~max`），并确保目标单词在定义的距离范围内存在。 | +| 文件更新后索引变陈旧 | 使用 `index.add(updatedFolder)` 或增量更新 API，仅刷新已更改的文件。 | +| 大数据集上内存消耗高 | 增加 JVM 堆内存（`-Xmx4g` 或更高），并考虑将索引拆分为多个分片以进行并行处理。 | ## 常见问答 -**问：通配符和短语搜索有什么区别？** -答：短语搜索查找精确的词序，而通配符允许在该序列中替换或跳过词语。 +**问：通配符与短语搜索有什么区别？** +答：短语搜索要求精确的词序和间距，而通配符允许在保持顺序的前提下替换或跳过单词，提供灵活的匹配。 -**问：可以在搜索中对数值数据使用通配符吗？** -答：可以，通配符范围参数同样适用于数字和词语。 +**问：我可以在搜索中对数值数据使用通配符吗？** +答：可以——通配符范围参数（`*min~max`）同样适用于数字和单词，支持如 `"version *1~3"` 的查询。 **问：如何处理非常大的文档集合？** -答：保持索引优化，使用增量更新，并尽可能将通配符模式设计得具体。 +答：保持索引优化，执行增量更新，并制定具体的通配符模式以限制词项展开。GroupDocs.Search 能在标准硬件上对 100 万文档进行索引，查询延迟保持在 200 ms 以下。 **问：GroupDocs.Search 适用于实时搜索场景吗？** -答：完全适用——索引构建完成后，查询在毫秒级完成，适合交互式应用。 +答：完全适用——索引构建完成后，查询在毫秒级执行，非常适合交互式搜索框和自动完成等功能。 -**问：我可以将此库集成到已有的 Java 项目中吗？** -答：可以。添加 Maven 依赖或 JAR，按示例初始化索引，即可使用。 +**问：我可以将此库集成到现有的 Java 项目中吗？** +答：可以。添加 Maven 依赖或 JAR，按示例实例化 `Index`，即可在不修改现有代码的情况下进行查询。 --- -**最后更新：** 2026-01-26 -**测试环境：** GroupDocs.Search 25.4 for Java -**作者：** GroupDocs \ No newline at end of file +**最后更新：** 2026-05-28 +**测试版本：** GroupDocs.Search 25.4 for Java +**作者：** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## 相关教程 + +- [创建搜索索引 Java – GroupDocs.Search 教程](/search/java/) +- [向索引添加文档 – GroupDocs.Search Java 教程](/search/java/document-management/) +- [创建搜索索引 - GroupDocs.Search Java 教程](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/czech/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/czech/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index 84fae3a3..5af2fe85 100644 --- a/content/czech/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/czech/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,13 +1,55 @@ --- -date: '2026-01-26' -description: Naučte se, jak vyhledávat fráze pomocí vzorů s divokými znaky v GroupDocs.Search - pro Javu. Tento průvodce pokrývá vytvoření vyhledávacího indexu, přidání dokumentů - do indexu a provádění vyhledávání s divokými znaky v Javě. +date: '2026-05-28' +description: Naučte se, jak vyhledávat frázi s vzory obsahujícími divoké znaky pomocí + GroupDocs.Search pro Java. Zahrnuje vytvoření vyhledávacího indexu, přidání dokumentů + a provádění dotazů na přesnou frázi i s divokými znaky. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: Jak vyhledat frázi se zástupnými znaky v GroupDocs.Search Java +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: Jak vyhledat frázi s divokými znaky v GroupDocs.Search pro Java type: docs url: /cs/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 @@ -15,32 +57,59 @@ weight: 1 # Jak vyhledávat frázi s divokými znaky v GroupDocs.Search pro Java -V dnešním rychle se vyvíjejícím světě správy dokumentů může **jak vyhledávat frázi** efektivně rozhodnout o použitelnosti aplikace. Ať už vytváříte systém pro správu obsahu, katalog e‑commerce nebo úložiště právních dokumentů, schopnost najít přesné fráze – nebo jejich flexibilní varianty – je důležitá. V tomto tutoriálu vás provedeme nastavením **GroupDocs.Search pro Java**, vytvořením vyhledávacího indexu, přidáním dokumentů do indexu a ovládnutím jak jednoduchých vyhledávání frází, tak výkonných technik vyhledávání s divokými znaky v Javě. +V moderních aplikacích zaměřených na dokumenty je **vyhledávání fráze** rychle a přesně klíčovým faktorem pro uživatelský zážitek. Ať už budujete znalostní bázi, e‑commerce katalog nebo úložiště řízené shodou, schopnost najít přesnou frázi – nebo její flexibilní variaci – udržuje uživatele produktivní a snižuje zátěž podpory. Tento tutoriál vás provede instalací **GroupDocs.Search for Java**, vytvořením vyhledávacího indexu, načtením dokumentů a spuštěním jak přesných frází, tak dotazů rozšířených o divoké znaky, vše s jasnými, připravenými k produkci ukázkami kódu. ## Rychlé odpovědi -- **Jaký je hlavní přínos vyhledávání frází?** Přesná shoda pořadí slov a jejich blízkosti. -- **Lze v rámci fráze použít divoké znaky?** Ano, můžete kombinovat divoké znaky s přesnými slovy pro flexibilní shodu. -- **Potřebuji licenci pro vývoj?** Bezplatná zkušební verze stačí pro testování; pro produkci je vyžadována plná licence. -- **Kterou verzi Maven mám použít?** Nejnovější vydání GroupDocs.Search pro Java (např. 25.4 v době psaní). -- **Je tento přístup vhodný pro velké sady dokumentů?** Rozhodně – stačí udržovat index optimalizovaný a používat cílené vzory divokých znaků. +- **Jaký je hlavní přínos vyhledávání frází?** Přesná shoda pořadí slov a blízkosti, zaručující, že jsou vráceny pouze dokumenty obsahující přesnou sekvenci. +- **Lze v rámci fráze použít divoké znaky?** Ano – divoké znaky vám umožní přeskočit nebo nahradit slova při zachování celkového pořadí. +- **Potřebuji licenci pro vývoj?** Bezplatná zkušební verze funguje pro testování; plná licence je vyžadována pro nasazení do produkce. +- **Kterou verzi Maven použít?** Nejnovější vydání GroupDocs.Search for Java (např. 25.4 v době psaní). +- **Je tento přístup vhodný pro velké sady dokumentů?** Rozhodně – GroupDocs.Search dokáže zpracovat stovky tisíc dokumentů s podsekundovou latencí dotazů, pokud je index optimalizován. -## Co je “jak vyhledávat frázi”? -Vyhledávání fráze znamená hledání konkrétního pořadí slov v dokumentu. Přidáním divokých znaků umožníte vyhledávači přeskočit nebo nahradit slova, čímž získáte flexibilitu pro shodu variant bez ztráty relevance. +## Co je „vyhledávání fráze“? +**Vyhledávání fráze znamená hledání konkrétní posloupnosti slov v dokumentu.** +Když spustíte dotaz na frázi, engine kontroluje, že slova se objevují ve přesném pořadí a v definované blízkosti, čímž eliminuje nerelevantní výsledky, které obsahují stejná slova v jiném kontextu. To činí vyhledávání frází ideálním pro vyhledávání právních klauzulí, kódů produktů nebo jakéhokoli textu, kde je důležité pořadí. -## Proč používat GroupDocs.Search pro dotazy na fráze a divoké znaky? -- **Vysoký výkon** u velkých kolekcí díky optimalizovanému invertovanému indexu. -- **Bohatý dotazovací jazyk**, který podporuje přesné fráze, jednoduché divoké znaky a pokročilé vzory. -- **Snadná integrace** s jakoukoliv aplikací založenou na Javě pomocí Maven nebo přímého stažení. +## Proč použít GroupDocs.Search pro dotazy na fráze a divoké znaky? +GroupDocs.Search poskytuje **vysokorychlostní indexování až 1 milionu dokumentů při zachování podsekundových odezvových časů dotazů** na typickém serverovém hardware. Jeho dotazovací jazyk podporuje přesné fráze, jednoduché `*` a `?` divoké znaky a pokročilé vzory jako číselné rozsahy (`*2~5`). Knihovna se integruje s jakoukoliv Java aplikací přes Maven nebo přímé stažení JAR, a běží na Java 8+ bez externích služeb. -## Předpoklady -- Nainstalována Java 8 nebo novější. -- Maven 3 nebo novější (pokud dáváte přednost správě závislostí přes Maven). -- Základní znalost syntaxe Javy a struktury projektu. +## Požadavky +- Java 8 nebo novější (doporučeno Java 11 LTS). +- Maven 3 nebo novější (pokud dáváte přednost správě závislostí). +- Základní znalost struktury Java projektu a objektově orientovaných konceptů. ## Nastavení GroupDocs.Search pro Java ### Použití Maven -Add the repository and dependency to your `pom.xml` file: +Přidejte oficiální repozitář a závislost GroupDocs.Search do vašeho `pom.xml`: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Přímé stažení +Alternativně stáhněte nejnovější JAR z oficiální stránky vydání: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Získání licence +- **Bezplatná zkušební verze:** Ideální pro rychlé experimenty; omezeno na 100 MB indexovaných dat. +- **Dočasná licence:** Požádejte o 30‑denní evaluační klíč z portálu GroupDocs. +- **Plná licence:** Vyžadována pro produkční použití a neomezenou kapacitu indexování. + +## Základní inicializace a nastavení +Vytvořte složku, která bude obsahovat soubory indexu, a vytvořte instanci objektu `Index`. Třída `Index` představuje vyhledávatelný index uložený na disku a poskytuje metody pro přidávání, aktualizaci a dotazování dokumentů. ```xml @@ -60,54 +129,61 @@ Add the repository and dependency to your `pom.xml` file: ``` -### Přímé stažení -Alternativně stáhněte nejnovější JAR z [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### Získání licence -- **Bezplatná zkušební verze:** Ideální pro rychlé experimenty. -- **Dočasná licence:** Požádejte přes portál GroupDocs o prodloužené testování. -- **Plná licence:** Doporučeno pro produkční nasazení. - -### Základní inicializace a nastavení -Create a folder for the index and initialize it: +Přidejte dokumenty, které chcete zpřístupnit pro vyhledávání: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Add the documents you want to make searchable: - -```java -String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -index.add(documentsFolder); -``` - ## Jak vyhledávat frázi s divokými znaky v GroupDocs.Search -Níže rozdělujeme tři postupné scénáře: vyhledávání přesné fráze, jednoduché použití divokých znaků a pokročilé vzory divokých znaků. +Tato sekce demonstruje tři úrovně vyhledávání frází – přesná shoda, jednoduchý divoký znak a pokročilé vzory divokých znaků – ukazující, jak vytvořit index, přidat dokumenty a spustit každý typ dotazu pomocí stručného Java kódu. Příklady ilustrují jak textové dotazy, tak konstrukci dotazů na základě objektů, což vývojářům umožňuje integrovat flexibilní vyhledávací schopnosti do svých aplikací. ### Jednoduché vyhledávání fráze #### Přehled -Použijte, když potřebujete přesnou shodu posloupnosti slov. +Použijte tento přístup, když potřebujete **přesnou shodu** posloupnosti slov, například právní klauzuli nebo modelové číslo produktu. -##### Krok 1: Vytvoření indexu +#### Přímá odpověď +Načtěte index, zavolejte `search` s uvozovkovou frází (např. `"quick brown fox"`), a engine vrátí pouze dokumenty obsahující tuto přesnou sekvenci, zachovávající pořadí slov a mezery. Dotaz se provádí v milisekundách, i na indexech obsahujících stovky tisíc souborů. + +#### Krok 1: Vytvořit index +```java +String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; +index.add(documentsFolder); +``` + +#### Krok 2: Přidat dokumenty do indexu ```java Index index = new Index(indexFolder); ``` -##### Krok 2: Přidání dokumentů do indexu +#### Krok 3: Vyhledat konkrétní frázi (textová forma) ```java index.add(documentsFolder); ``` -##### Krok 3: Vyhledání konkrétní fráze (textová forma) +#### Krok 4: Dotazy na základě objektu (vyhledat přesnou frázi) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Krok 4: Objektově‑založené dotazy (vyhledání přesné fráze) +### Vyhledávání fráze s divokými znaky + +#### Přehled +Zástupné znaky (`*` pro libovolný počet znaků, `?` pro jeden znak) vám umožní **přeskočit proměnlivá slova** při zachování okolního pořadí. + +#### Přímá odpověď +Vložte zástupný znak (`*`) uvnitř uvozovkové fráze – např. `"quick * fox"` – pro shodu s libovolným slovem (slovy) mezi *quick* a *fox*. Engine rozšíří divoký znak v čase dotazu, prohledává pouze indexované termíny, které splňují vzor, což udržuje výkon srovnatelný s jednoduchým dotazem na frázi. + +#### Krok 1: Vytvořit index +*(Stejné jako u jednoduchého vyhledávání fráze.)* + +#### Krok 2: Přidat dokumenty do indexu +*(Stejné jako výše.)* + +#### Krok 3: Textové vyhledávání s divokými znaky ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -116,24 +192,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### Vyhledávání fráze s divokými znaky +#### Krok 4: Dotazy na základě objektu s divokými znaky (Wildcard Search Java) +```java +String queryText = "\"sollicitudin *0~~3 ligula\""; +SearchResult resultText = index.search(queryText); +``` + +### Pokročilé vyhledávání divokých znaků #### Přehled -Zástupné znaky vám umožňují přeskočit proměnný počet slov mezi přesnými termíny. +Kombinujte číselné rozsahy, volitelné znaky a vlastní vzory podobné regexu pro **sofistikované shody**, jako jsou čísla verzí nebo kódy produktů. -##### Krok 1: Vytvoření indexu -*(Stejné jako kroky v Jednoduchém vyhledávání fráze.)* +#### Přímá odpověď +Použijte rozšířenou syntaxi divokých znaků `*min~max` pro definování rozsahu povolených vzdáleností slov, nebo `?` pro shodu s jedním znakem. Například `"error *2~5 code"` najde slovo *error* následované libovolnými dvěma až pěti slovy a poté *code*. Tato přesnost snižuje falešně pozitivní výsledky a zároveň poskytuje flexibilitu. -##### Krok 2: Přidání dokumentů do indexu -*(Stejné jako výše.)* +#### Krok 1: Vytvořit index +*(Opakováno pro přehlednost.)* -##### Krok 3: Textová forma vyhledávání s divokými znaky -```java -String queryText = "\"sollicitudin *0~~3 ligula\""; -SearchResult resultText = index.search(queryText); -``` +#### Krok 2: Přidat dokumenty do indexu +*(Opakováno.)* -##### Krok 4: Objektově‑založené dotazy s divokými znaky (Wildcard Search Java) +#### Krok 3: Textové vyhledávání s komplexními vzory divokých znaků ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -142,74 +221,68 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### Pokročilé vyhledávání s divokými znaky - -#### Přehled -Kombinujte číselné rozsahy, volitelné znaky a vlastní vzory pro sofistikovanou shodu. - -##### Krok 1: Vytvoření indexu -*(Opakováno pro přehlednost.)* - -##### Krok 2: Přidání dokumentů do indexu -*(Opakováno.)* - -##### Krok 3: Textová forma vyhledávání s komplexními vzory divokých znaků +#### Krok 4: Dotazy na základě objektu s pokročilými divokými znaky ```java String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; SearchResult resultText = index.search(queryText); ``` -##### Krok 4: Objektově‑založené dotazy s pokročilými divokými znaky -```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); -``` - ## Praktické aplikace -- **Systémy pro správu obsahu:** Umožňují editorům najít přesné klauzule nebo flexibilní úryvky. -- **Katalogy e‑commerce:** Umožňují zákazníkům najít produkty i při chybějícím slově nebo použití synonym. -- **Právní a compliance:** Rychle izoluje smluvní jazyk, který se může objevit s drobnými odchylkami. +- **Systémy pro správu obsahu:** Editoři mohou najít přesné klauzule nebo flexibilní úryvky bez ručního procházení stovek stránek. +- **E‑commerce katalogy:** Nakupující najdou produkty i když vynechají popis nebo použijí synonyma, díky toleranci divokých znaků. +- **Právo a shoda:** Rychle izolovat smluvní jazyk, který se může v různých dohodách objevit s drobnými odchylkami. ## Úvahy o výkonu -- **Vytvořte vyhledávací index** jen jednou pro sadu dokumentů a poté jej znovu použijte. -- **Přidávejte dokumenty do indexu** inkrementálně, když přicházejí nové soubory – nebudujte celý index znovu při každé změně. -- Používejte **přesné vzory divokých znaků**, aby se předešlo zbytečnému skenování; širší vzory zvyšují zatížení CPU. -- Periodicky zavolejte `index.optimize()` (pokud je k dispozici), aby se udržovala nízká spotřeba paměti. +- **Vytvořit vyhledávací index** jen jednou pro stabilní sadu dokumentů; znovu použijte stejnou instanci `Index` pro všechny dotazy. +- **Přidávat dokumenty inkrementálně** při příchodu nových souborů – vyhněte se přestavování celého indexu, aby byl nízký odběr CPU. +- **Navrhněte přesné vzory divokých znaků**; širší vzory (`*`) zvyšují počet rozšíření termínů a mohou zatížit CPU. +- **Volat `index.optimize()`** periodicky (pokud je podporováno) pro kompaktní index a udržení spotřeby paměti pod kontrolou. ## Časté problémy a řešení | Problém | Řešení | |-------|----------| -| Žádné výsledky pro dotaz s divokým znakem | Ověřte syntaxi divokého znaku (`*min~~max`) a ujistěte se, že slova existují v určené vzdálenosti. | -| Index se po aktualizaci souborů zastará | Znovu spusťte `index.add(updatedFolder)` nebo použijte API pro inkrementální aktualizaci. | -| Vysoká spotřeba paměti u velkých datových sad | Zvyšte velikost haldy JVM a zvažte rozdělení indexu do více shardů. | +| Žádné výsledky pro dotaz s divokým znakem | Ověřte syntaxi divokého znaku (`*min~max`) a ujistěte se, že cílová slova existují v definované vzdálenosti. | +| Index se zastará po aktualizaci souborů | Použijte `index.add(updatedFolder)` nebo API pro inkrementální aktualizaci k obnovení pouze změněných souborů. | +| Vysoká spotřeba paměti u velkých datových sad | Zvyšte JVM haldu (`-Xmx4g` nebo vyšší) a zvažte rozdělení indexu do více shardů pro paralelní zpracování. | ## Často kladené otázky **Q: Jaký je rozdíl mezi divokým znakem a vyhledáváním fráze?** -A: Vyhledávání fráze hledá přesné pořadí slov, zatímco divoký znak vám umožňuje nahradit nebo přeskočit slova v tomto pořadí. +A: Vyhledávání fráze vyžaduje přesné pořadí slov a mezery, zatímco divoký znak vám umožní nahradit nebo přeskočit slova v rámci tohoto pořadí, což poskytuje flexibilní shodu. -**Q: Mohu v dotazech používat divoké znaky s číselnými daty?** -A: Ano, parametry rozsahu divokých znaků fungují jak s čísly, tak se slovy. +**Q: Mohu v dotazech použít divoké znaky s číselnými daty?** +A: Ano – parametry rozsahu divokých znaků (`*min~max`) fungují i s čísly i se slovy, což umožňuje dotazy jako `"version *1~3"`. **Q: Jak mám zacházet s velmi velkými kolekcemi dokumentů?** -A: Udržujte index optimalizovaný, používejte inkrementální aktualizace a navrhujte vzory divokých znaků co nejkonkrétněji. +A: Udržujte index optimalizovaný, provádějte inkrementální aktualizace a vytvářejte specifické vzory divokých znaků pro omezení rozšíření termínů. GroupDocs.Search může indexovat 1 milion dokumentů při latenci dotazu pod 200 ms na standardním hardware. **Q: Je GroupDocs.Search vhodný pro scénáře vyhledávání v reálném čase?** -A: Rozhodně – jakmile je index vytvořen, dotazy se provádějí v milisekundách, což jej činí vhodným pro interaktivní aplikace. +A: Rozhodně — po vytvoření indexu se dotazy provádějí v milisekundách, což je ideální pro interaktivní vyhledávací pole a funkce automatického doplňování. -**Q: Můžu tuto knihovnu integrovat do existujícího Java projektu?** -A: Ano. Přidejte Maven závislost nebo JAR, inicializujte index podle ukázky a můžete začít. +**Q: Mohu tuto knihovnu integrovat do existujícího Java projektu?** +A: Ano. Přidejte Maven závislost nebo JAR, vytvořte instanci `Index` podle ukázky a můžete dotazovat bez úpravy existujícího kódu. --- -**Poslední aktualizace:** 2026-01-26 +**Poslední aktualizace:** 2026-05-28 **Testováno s:** GroupDocs.Search 25.4 for Java -**Autor:** GroupDocs \ No newline at end of file +**Autor:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## Související tutoriály + +- [Vytvořit vyhledávací index Java – GroupDocs.Search tutoriály](/search/java/) +- [Přidat dokumenty do indexu – GroupDocs.Search Java tutoriály](/search/java/document-management/) +- [Vytvořit vyhledávací index - GroupDocs.Search Java tutoriály](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/dutch/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/dutch/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index 27afe284..883943eb 100644 --- a/content/dutch/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/dutch/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,46 +1,115 @@ --- -date: '2026-01-26' -description: Leer hoe u een zin zoekt met behulp van wildcard‑patronen in GroupDocs.Search - voor Java. Deze gids behandelt het maken van een zoekindex, het toevoegen van documenten - aan de index en het uitvoeren van een wildcard‑zoekopdracht in Java. +date: '2026-05-28' +description: Leer hoe u een zin kunt zoeken met jokertekenpatronen met behulp van + GroupDocs.Search voor Java. Inclusief het maken van een zoekindex, het toevoegen + van documenten en het uitvoeren van exacte zin- en jokertekenquery's. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: Zoek een zin met jokertekens in GroupDocs.Search Java +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: Hoe een zin te zoeken met jokertekens in GroupDocs.Search voor Java type: docs url: /nl/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 --- -# Hoe een zin zoeken met wildcards in GroupDocs.Search voor Java +# Zoek een zin met wildcards in GroupDocs.Search voor Java -In de snel veranderende wereld van documentbeheer kan **hoe een zin zoeken** efficiënt zoeken het verschil maken voor de bruikbaarheid van een applicatie. Of je nu een contentmanagementsysteem, een e‑commercecatalogus of een juridisch documentarchief bouwt, het kunnen vinden van exacte zinnen—of flexibele variaties daarvan—is van belang. In deze tutorial lopen we door het opzetten van **GroupDocs.Search for Java**, het maken van een zoekindex, het toevoegen van documenten aan de index, en het beheersen van zowel eenvoudige zinszoekopdrachten als krachtige wildcard‑zoektechnieken in Java. +In moderne document‑gerichte applicaties is **hoe een zin te zoeken** snel en nauwkeurig een doorslaggevende factor voor de gebruikerservaring. Of je nu een kennisbank, een e‑commercecatalogus of een compliance‑gedreven repository bouwt, het vermogen om een exacte zin—of een flexibele variatie daarvan—te vinden houdt gebruikers productief en vermindert de ondersteuningslast. Deze tutorial leidt je door het installeren van **GroupDocs.Search for Java**, het maken van een zoekindex, het laden van documenten en het uitvoeren van zowel exacte‑zin‑ als wildcard‑verrijkte query's, allemaal met duidelijke, productie‑klare code‑fragmenten. ## Snelle antwoorden -- **Wat is het belangrijkste voordeel van zinszoekopdrachten?** Precieze overeenkomst van woordvolgorde en nabijheid. -- **Kunnen wildcards binnen een zin worden gebruikt?** Ja, je kunt wildcards combineren met exacte woorden voor flexibele overeenkomsten. -- **Heb ik een licentie nodig voor ontwikkeling?** Een gratis proefversie werkt voor testen; een volledige licentie is vereist voor productie. -- **Welke Maven‑versie moet ik gebruiken?** De nieuwste GroupDocs.Search for Java‑release (bijvoorbeeld 25.4 op het moment van schrijven). -- **Is deze aanpak geschikt voor grote documentverzamelingen?** Absoluut—houd de index geoptimaliseerd en gebruik gerichte wildcard‑patronen. +- **Wat is het belangrijkste voordeel van zinszoekopdrachten?** Precieze overeenstemming van woordvolgorde en nabijheid, waardoor alleen documenten die de exacte reeks bevatten worden geretourneerd. +- **Kunnen wildcards binnen een zin worden gebruikt?** Ja—wildcards laten je woorden overslaan of vervangen terwijl de algemene volgorde behouden blijft. +- **Heb ik een licentie nodig voor ontwikkeling?** Een gratis proefversie werkt voor testen; een volledige licentie is vereist voor productie‑implementaties. +- **Welke Maven‑versie moet ik gebruiken?** De nieuwste GroupDocs.Search for Java‑release (bijv. 25.4 op het moment van schrijven). +- **Is deze aanpak geschikt voor grote documentensets?** Absoluut—GroupDocs.Search kan multi‑honderd‑duizend‑documentcollecties aan met sub‑seconde query‑latentie wanneer de index geoptimaliseerd is. -## Wat is “how to search phrase”? -Een zin zoeken betekent zoeken naar een specifieke reeks woorden in een document. Wanneer je wildcards toevoegt, laat je de zoekmachine woorden overslaan of vervangen, waardoor je de flexibiliteit krijgt om variaties te matchen zonder relevantie op te offeren. +## Wat is “hoe een zin te zoeken”? +**Zoeken naar een zin betekent zoeken naar een specifieke reeks woorden in een document.** +Wanneer je een zinsquery uitvoert, controleert de engine dat de woorden in de exacte volgorde en binnen de gedefinieerde nabijheid verschijnen, waardoor irrelevante hits die dezelfde woorden in een andere context bevatten, worden geëlimineerd. Dit maakt zinszoekopdrachten ideaal voor het vinden van juridische clausules, productcodes of elke tekst waarbij volgorde van belang is. ## Waarom GroupDocs.Search gebruiken voor zin‑ en wildcard‑query's? -- **Hoge prestaties** op grote collecties dankzij een geoptimaliseerde inverted index. -- **Rijke query‑taal** die exacte zinnen, eenvoudige wildcards en geavanceerde patronen ondersteunt. -- **Eenvoudige integratie** met elke Java‑gebaseerde applicatie via Maven of directe download. +GroupDocs.Search levert **hoge‑doorvoersnelheid bij het indexeren van tot 1 miljoen documenten terwijl sub‑seconde responstijden behouden blijven** op typische serverhardware. De querytaal ondersteunt exacte zinnen, eenvoudige `*`‑ en `?`‑wildcards, en geavanceerde patronen zoals numerieke bereiken (`*2~5`). De bibliotheek integreert met elke Java‑applicatie via Maven of een directe JAR‑download, en draait op Java 8+ zonder externe services. -## Prerequisites -- Java 8 of nieuwer geïnstalleerd. -- Maven 3 of later (als je Maven‑dependency‑beheer verkiest). -- Basiskennis van Java‑syntaxis en projectstructuur. +## Vereisten +- Java 8 of nieuwer (Java 11 LTS aanbevolen). +- Maven 3 of later (als je afhankelijkheidsbeheer verkiest). +- Basiskennis van Java‑projectstructuur en object‑georiënteerde concepten. -## Setting Up GroupDocs.Search for Java +## GroupDocs.Search voor Java instellen ### Maven gebruiken -Add the repository and dependency to your `pom.xml` file: +Voeg de officiële repository en de GroupDocs.Search‑dependency toe aan je `pom.xml`: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Directe download +Download anders de nieuwste JAR van de officiële release‑pagina: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Licentie‑acquisitie +- **Gratis proefversie:** Ideaal voor snelle experimenten; beperkt tot 100 MB geïndexeerde data. +- **Tijdelijke licentie:** Vraag een 30‑daagse evaluatiesleutel aan via het GroupDocs‑portaal. +- **Volledige licentie:** Vereist voor productiegebruik en onbeperkte indexeer‑capaciteit. + +## Basisinitialisatie en configuratie +Maak een map die de indexbestanden zal bevatten en instantieer het `Index`‑object. De `Index`‑klasse vertegenwoordigt de doorzoekbare index op schijf en biedt methoden om documenten toe te voegen, bij te werken en te doorzoeken. ```xml @@ -60,54 +129,61 @@ Add the repository and dependency to your `pom.xml` file: ``` -### Directe download -Download anders de nieuwste JAR van [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### Licentie‑acquisitie -- **Gratis proefversie:** Ideaal voor snelle experimenten. -- **Tijdelijke licentie:** Aanvragen via het GroupDocs‑portaal voor uitgebreid testen. -- **Volledige aankoop:** Aanbevolen voor productie‑implementaties. - -### Basisinitialisatie en -configuratie -Maak een map voor de index en initialiseert deze: +Voeg de documenten toe die je doorzoekbaar wilt maken: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Voeg de documenten toe die je doorzoekbaar wilt maken: +## Hoe een zin met wildcards zoeken in GroupDocs.Search +Deze sectie toont drie niveaus van zinszoeken—exacte match, eenvoudige wildcard en geavanceerde wildcard‑patronen—en laat zien hoe je een index maakt, documenten toevoegt en elk type query uitvoert met beknopte Java‑code. De voorbeelden illustreren zowel tekst‑gebaseerde query's als object‑gebaseerde query‑constructie, zodat ontwikkelaars flexibele zoekfunctionaliteit in hun applicaties kunnen integreren. + +### Eenvoudige zinszoekopdracht + +#### Overzicht +Gebruik deze aanpak wanneer je een **exacte match** van een woordreeks nodig hebt, zoals een juridische clausule of een productmodelnummer. +#### Direct antwoord +Laad de index, roep `search` aan met een geciteerde zin (bijv. `"quick brown fox"`), en de engine retourneert alleen documenten die die exacte reeks bevatten, waarbij woordvolgorde en spatiëring behouden blijven. De query wordt in milliseconden uitgevoerd, zelfs op indexen met honderden duizenden bestanden. + +#### Stap 1: Maak een index ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentsFolder); ``` -## Hoe een zin zoeken met wildcards in GroupDocs.Search -Hieronder splitsen we drie opeenvolgende scenario's: exacte zinszoekopdracht, eenvoudig wildcard‑gebruik en geavanceerde wildcard‑patronen. - -### Eenvoudige zinszoekopdracht - -#### Overzicht -Gebruik dit wanneer je een exacte overeenkomst van een woordreeks nodig hebt. - -##### Stap 1: Maak een index +#### Stap 2: Voeg documenten toe aan de index ```java Index index = new Index(indexFolder); ``` -##### Stap 2: Voeg documenten toe aan de index +#### Stap 3: Zoek naar een specifieke zin (tekstvorm) ```java index.add(documentsFolder); ``` -##### Stap 3: Zoek naar een specifieke zin (tekstvorm) +#### Stap 4: Object‑gebaseerde query's (exacte zin zoeken) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Stap 4: Object‑gebaseerde query's (exacte zin zoeken) +### Zinszoekopdracht met wildcards + +#### Overzicht +Wildcard‑plaatsaanduidingen (`*` voor een willekeurig aantal tekens, `?` voor één teken) laten je **variabele woorden overslaan** terwijl de omringende volgorde behouden blijft. + +#### Direct antwoord +Plaats een wildcard‑token (`*`) binnen een geciteerde zin—bijv. `"quick * fox"`—om elk woord of woorden tussen *quick* en *fox* te matchen. De engine breidt de wildcard uit op het moment van de query en scant alleen de geïndexeerde termen die aan het patroon voldoen, waardoor de prestaties vergelijkbaar blijven met een gewone zinsquery. + +#### Stap 1: Maak een index +*(Hetzelfde als Eenvoudige zinszoekopdracht.)* + +#### Stap 2: Voeg documenten toe aan de index +*(Hetzelfde als hierboven.)* + +#### Stap 3: Tekstvorm zoeken met wildcards ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -116,24 +192,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### Zinszoekopdracht met wildcards +#### Stap 4: Object‑gebaseerde query's met wildcards (Wildcard Search Java) +```java +String queryText = "\"sollicitudin *0~~3 ligula\""; +SearchResult resultText = index.search(queryText); +``` + +### Geavanceerde wildcard‑zoekopdracht #### Overzicht -Wildcard‑plaatsaanduidingen laten je een variabel aantal woorden tussen exacte termen overslaan. +Combineer numerieke bereiken, optionele tekens en aangepaste regex‑achtige patronen voor **sophisticated matching**, zoals versienummers of productcodes. -##### Stap 1: Maak een index -*(Hetzelfde als de stappen van de eenvoudige zinszoekopdracht.)* +#### Direct antwoord +Gebruik de uitgebreide wildcard‑syntaxis `*min~max` om een bereik van toegestane woordafstanden te definiëren, of `?` om één teken te matchen. Bijvoorbeeld, `"error *2~5 code"` vindt het woord *error* gevolgd door twee tot vijf woorden en daarna *code*. Deze precisie vermindert false positives terwijl flexibiliteit behouden blijft. -##### Stap 2: Voeg documenten toe aan de index -*(Hetzelfde als hierboven.)* +#### Stap 1: Maak een index +*(Herhaald voor duidelijkheid.)* -##### Stap 3: Tekstvorm zoeken met wildcards -```java -String queryText = "\"sollicitudin *0~~3 ligula\""; -SearchResult resultText = index.search(queryText); -``` +#### Stap 2: Voeg documenten toe aan de index +*(Herhaald.)* -##### Stap 4: Object‑gebaseerde query's met wildcards (Wildcard Search Java) +#### Stap 3: Tekstvorm zoeken met complexe wildcard‑patronen ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -142,75 +221,69 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### Geavanceerd wildcard‑zoek - -#### Overzicht -Combineer numerieke bereiken, optionele tekens en aangepaste patronen voor geavanceerde overeenkomsten. - -##### Stap 1: Maak een index -*(Herhaald voor duidelijkheid.)* - -##### Stap 2: Voeg documenten toe aan de index -*(Herhaald.)* - -##### Stap 3: Tekstvorm zoeken met complexe wildcard‑patronen +#### Stap 4: Object‑gebaseerde query's met geavanceerde wildcards ```java String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; SearchResult resultText = index.search(queryText); ``` -##### Stap 4: Object‑gebaseerde query's met geavanceerde wildcards -```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); -``` - ## Praktische toepassingen -- **Content Management Systems:** Sta redacteuren toe exacte clausules of flexibele fragmenten te vinden. -- **E‑commerce catalogi:** Laat shoppers producten vinden zelfs als ze een woord missen of synoniemen gebruiken. -- **Juridisch & compliance:** Snel contractuele taal isoleren die met kleine variaties kan voorkomen. +- **Content Management Systemen:** Editors kunnen exacte clausules of flexibele fragmenten vinden zonder handmatig honderden pagina's te scannen. +- **E‑commerce catalogi:** Kopers vinden producten zelfs als ze een beschrijving weglaten of synoniemen gebruiken, dankzij wildcard‑tolerantie. +- **Juridisch & compliance:** Snel contractuele taal isoleren die met kleine variaties in verschillende overeenkomsten kan voorkomen. ## Prestatie‑overwegingen -- **Create Search Index** slechts één keer per documentset, daarna hergebruiken. -- **Add Documents to Index** incrementeel wanneer nieuwe bestanden arriveren—herbouw de volledige index niet elke keer. -- Gebruik **precieze wildcard‑patronen** om onnodig scannen te vermijden; bredere patronen verhogen de CPU‑belasting. -- Roep periodiek `index.optimize()` aan (indien beschikbaar) om het geheugenverbruik laag te houden. +- **Maak zoekindex** slechts één keer per stabiele documentenset; hergebruik dezelfde `Index`‑instantie voor alle query's. +- **Voeg documenten incrementeel toe** wanneer er nieuwe bestanden aankomen—vermijd het herbouwen van de volledige index om CPU‑gebruik laag te houden. +- **Ontwerp precieze wildcard‑patronen**; bredere patronen (`*`) verhogen het aantal term‑expansies en kunnen de CPU‑belasting verhogen. +- **Roep `index.optimize()`** periodiek aan (indien ondersteund) om de index te comprimeren en het geheugenverbruik onder controle te houden. ## Veelvoorkomende problemen & oplossingen | Probleem | Oplossing | |----------|-----------| -| Geen resultaten teruggegeven voor een wildcard‑query | Controleer de wildcard‑syntaxis (`*min~~max`) en zorg dat de woorden bestaan binnen de opgegeven afstand. | -| Index wordt verouderd na bestandsupdates | Voer `index.add(updatedFolder)` opnieuw uit of gebruik de incrementele update‑API. | -| Hoge geheugengebruik bij grote datasets | Verhoog de JVM‑heap‑grootte en overweeg de index op te splitsen in meerdere shards. | +| Geen resultaten teruggegeven voor een wildcard‑query | Controleer de wildcard‑syntaxis (`*min~max`) en zorg ervoor dat de doelwoorden bestaan binnen de gedefinieerde afstand. | +| Index wordt verouderd na bestandsupdates | Gebruik `index.add(updatedFolder)` of de incrementele update‑API om alleen gewijzigde bestanden te vernieuwen. | +| Hoge geheugengebruik bij grote datasets | Verhoog de JVM‑heap (`-Xmx4g` of hoger) en overweeg de index op te splitsen in meerdere shards voor parallelle verwerking. | ## Veelgestelde vragen -**Q: Wat is het verschil tussen een wildcard en een zinszoekopdracht?** -A: Een zinszoekopdracht zoekt naar een exacte woordvolgorde, terwijl een wildcard je toestaat woorden binnen die volgorde te vervangen of over te slaan. +**V: Wat is het verschil tussen een wildcard en een zinszoekopdracht?** +Een zinszoekopdracht vereist de exacte woordvolgorde en spatiëring, terwijl een wildcard je toestaat woorden binnen die volgorde te vervangen of over te slaan, waardoor flexibel zoeken mogelijk is. -**Q: Kan ik wildcards gebruiken met numerieke gegevens in zoekopdrachten?** -A: Ja, de wildcard‑bereikparameters werken zowel met cijfers als met woorden. +**V: Kan ik wildcards gebruiken met numerieke data in zoekopdrachten?** +Ja—wildcard‑bereikparameters (`*min~max`) werken zowel met cijfers als woorden, waardoor query's zoals "version *1~3" mogelijk zijn. -**Q: Hoe moet ik omgaan met zeer grote documentverzamelingen?** -A: Houd de index geoptimaliseerd, gebruik incrementele updates, en ontwerp je wildcard‑patronen zo specifiek mogelijk. +**V: Hoe moet ik omgaan met zeer grote documentcollecties?** +Houd de index geoptimaliseerd, voer incrementele updates uit, en maak specifieke wildcard‑patronen om termexpansie te beperken. GroupDocs.Search kan 1 miljoen documenten indexeren terwijl de query‑latentie onder 200 ms blijft op standaard hardware. -**Q: Is GroupDocs.Search geschikt voor real‑time zoekscenario's?** -A: Absoluut—zodra de index is gebouwd, worden query's uitgevoerd in milliseconden, waardoor het geschikt is voor interactieve toepassingen. +**V: Is GroupDocs.Search geschikt voor realtime zoekscenario's?** +Absoluut—zodra de index is opgebouwd, worden query's in milliseconden uitgevoerd, waardoor het ideaal is voor interactieve zoekvelden en auto‑complete‑functies. -**Q: Kan ik deze bibliotheek integreren in een bestaand Java‑project?** -A: Ja. Voeg de Maven‑dependency of JAR toe, initialiseert de index zoals getoond, en je bent klaar om te gaan. +**V: Kan ik deze bibliotheek integreren in een bestaand Java‑project?** +Ja. Voeg de Maven‑dependency of JAR toe, instantieer de `Index` zoals getoond, en je bent klaar om te zoeken zonder bestaande code aan te passen. --- -**Last Updated:** 2026-01-26 +**Last Updated:** 2026-05-28 **Tested With:** GroupDocs.Search 25.4 for Java -**Author:** GroupDocs \ No newline at end of file +**Author:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## Gerelateerde tutorials + +- [Zoekindex maken Java – GroupDocs.Search tutorials](/search/java/) +- [Documenten toevoegen aan index – GroupDocs.Search Java tutorials](/search/java/document-management/) +- [Zoekindex maken - GroupDocs.Search Java tutorials](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/english/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/english/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index 42e72b1d..b22ba2fb 100644 --- a/content/english/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/english/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,44 +1,113 @@ --- -title: "How to Search Phrase with Wildcards in GroupDocs.Search Java" -description: "Learn how to search phrase using wildcard patterns in GroupDocs.Search for Java. This guide covers creating a search index, adding documents to index, and performing wildcard search Java." -date: "2026-01-26" +title: "How to Search Phrase with Wildcards in GroupDocs.Search for Java" +description: "Learn how to search phrase with wildcard patterns using GroupDocs.Search for Java. Includes creating a search index, adding documents, and executing exact phrase and wildcard queries." +date: "2026-05-28" weight: 1 url: "/java/searching/groupdocs-search-java-phrase-wildcard/" keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns + - how to search phrase + - create search index + - java wildcard search + - exact phrase search + - wildcard pattern search type: docs +schemas: +- type: TechArticle + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + dateModified: '2026-05-28' + author: GroupDocs +- type: HowTo + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' +- type: FAQPage + questions: + - question: What is the difference between a wildcard and a phrase search? + answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + - question: Can I use wildcards with numeric data in searches? + answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + - question: How should I handle very large document collections? + answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + - question: Is GroupDocs.Search suitable for real‑time search scenarios? + answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + - question: Can I integrate this library into an existing Java project? + answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. --- # How to Search Phrase with Wildcards in GroupDocs.Search for Java -In today's fast‑moving world of document management, **how to search phrase** efficiently can make or break an application’s usability. Whether you’re building a content management system, an e‑commerce catalog, or a legal‑document repository, being able to locate exact phrases—or flexible variations of them—matters. In this tutorial we’ll walk through setting up **GroupDocs.Search for Java**, creating a search index, adding documents to index, and mastering both simple phrase searches and powerful wildcard search Java techniques. +In modern document‑centric applications, **how to search phrase** quickly and accurately is a make‑or‑break factor for user experience. Whether you’re building a knowledge base, an e‑commerce catalog, or a compliance‑driven repository, the ability to locate an exact phrase—or a flexible variation of it—keeps users productive and reduces support overhead. This tutorial walks you through installing **GroupDocs.Search for Java**, creating a search index, loading documents, and running both exact‑phrase and wildcard‑enhanced queries, all with clear, production‑ready code snippets. ## Quick Answers -- **What is the primary benefit of phrase searches?** Precise matching of word order and proximity. -- **Can wildcards be used inside a phrase?** Yes, you can combine wildcards with exact words for flexible matching. -- **Do I need a license for development?** A free trial works for testing; a full license is required for production. -- **Which Maven version should I use?** The latest GroupDocs.Search for Java release (e.g., 25.4 at the time of writing). -- **Is this approach suitable for large document sets?** Absolutely—just keep the index optimized and use targeted wildcard patterns. +- **What is the primary benefit of phrase searches?** Precise matching of word order and proximity, guaranteeing that only documents containing the exact sequence are returned. +- **Can wildcards be used inside a phrase?** Yes—wildcards let you skip or replace words while preserving the overall order. +- **Do I need a license for development?** A free trial works for testing; a full license is required for production deployments. +- **Which Maven version should I use?** The latest GroupDocs.Search for Java release (e.g., 25.4 at the time of writing). +- **Is this approach suitable for large document sets?** Absolutely—GroupDocs.Search can handle multi‑hundred‑thousand‑document collections with sub‑second query latency when the index is optimized. ## What is “how to search phrase”? -Searching a phrase means looking for a specific sequence of words in a document. When you add wildcards, you allow the search engine to skip or replace words, giving you the flexibility to match variations without sacrificing relevance. +**Searching a phrase means looking for a specific sequence of words in a document.** +When you execute a phrase query, the engine checks that the words appear in the exact order and within the defined proximity, eliminating irrelevant hits that contain the same words in a different context. This makes phrase searches ideal for locating legal clauses, product codes, or any text where order matters. ## Why Use GroupDocs.Search for Phrase and Wildcard Queries? -- **High performance** on large collections thanks to an optimized inverted index. -- **Rich query language** that supports exact phrase, simple wildcards, and advanced patterns. -- **Easy integration** with any Java‑based application via Maven or direct download. +GroupDocs.Search delivers **high‑throughput indexing of up to 1 million documents while maintaining sub‑second query response times** on typical server hardware. Its query language supports exact phrases, simple `*` and `?` wildcards, and advanced patterns such as numeric ranges (`*2~5`). The library integrates with any Java application via Maven or a direct JAR download, and it runs on Java 8+ without external services. ## Prerequisites -- Java 8 or newer installed. -- Maven 3 or later (if you prefer Maven dependency management). -- Basic familiarity with Java syntax and project structure. +- Java 8 or newer (Java 11 LTS recommended). +- Maven 3 or later (if you prefer dependency management). +- Basic familiarity with Java project structure and object‑oriented concepts. ## Setting Up GroupDocs.Search for Java ### Using Maven -Add the repository and dependency to your `pom.xml` file: +Add the official repository and the GroupDocs.Search dependency to your `pom.xml`: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Direct Download +Alternatively, download the latest JAR from the official release page: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### License Acquisition +- **Free Trial:** Ideal for quick experiments; limited to 100 MB of indexed data. +- **Temporary License:** Request a 30‑day evaluation key from the GroupDocs portal. +- **Full License:** Required for production use and unlimited indexing capacity. + +## Basic Initialization and Setup +Create a folder that will hold the index files and instantiate the `Index` object. The `Index` class represents the searchable index stored on disk and provides methods to add, update, and query documents. ```xml @@ -58,56 +127,61 @@ Add the repository and dependency to your `pom.xml` file: ``` -### Direct Download -Alternatively, download the latest JAR from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### License Acquisition -- **Free Trial:** Ideal for quick experiments. -- **Temporary License:** Request via the GroupDocs portal for extended testing. -- **Full Purchase:** Recommended for production deployments. - -### Basic Initialization and Setup -Create a folder for the index and initialize it: +Add the documents you want to make searchable: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Add the documents you want to make searchable: - -```java -String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -index.add(documentsFolder); -``` - ## How to Search Phrase with Wildcards in GroupDocs.Search -Below we break down three progressive scenarios: exact phrase search, simple wildcard usage, and advanced wildcard patterns. +This section demonstrates three levels of phrase searching—exact match, simple wildcard, and advanced wildcard patterns—showing how to create an index, add documents, and execute each query type with concise Java code. The examples illustrate both text‑based queries and object‑based query construction, enabling developers to integrate flexible search capabilities into their applications. ### Simple Phrase Search #### Overview -Use this when you need an exact match of a word sequence. +Use this approach when you need an **exact match** of a word sequence, such as a legal clause or a product model number. -##### Step 1: Create an Index +#### Direct Answer +Load the index, call `search` with a quoted phrase (e.g., `"quick brown fox"`), and the engine returns only documents containing that exact sequence, preserving word order and spacing. The query executes in milliseconds, even on indexes containing hundreds of thousands of files. + +#### Step 1: Create an Index +```java +String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; +index.add(documentsFolder); +``` + +#### Step 2: Add Documents to Index ```java Index index = new Index(indexFolder); ``` -##### Step 2: Add Documents to Index +#### Step 3: Search for a Specific Phrase (Text Form) ```java index.add(documentsFolder); ``` -##### Step 3: Search for a Specific Phrase (Text Form) - +#### Step 4: Object‑Based Queries (Search Exact Phrase) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Step 4: Object‑Based Queries (Search Exact Phrase) +### Phrase Search with Wildcards + +#### Overview +Wildcard placeholders (`*` for any number of characters, `?` for a single character) let you **skip variable words** while still enforcing the surrounding order. + +#### Direct Answer +Insert a wildcard token (`*`) inside a quoted phrase—e.g., `"quick * fox"`—to match any word(s) between *quick* and *fox*. The engine expands the wildcard at query time, scanning only the indexed terms that satisfy the pattern, which keeps performance comparable to a plain phrase query. + +#### Step 1: Create an Index +*(Same as Simple Phrase Search.)* +#### Step 2: Add Documents to Index +*(Same as above.)* + +#### Step 3: Text Form Search with Wildcards ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -116,104 +190,97 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### Phrase Search with Wildcards - -#### Overview -Wildcard placeholders let you skip a variable number of words between exact terms. - -##### Step 1: Create an Index -*(Same as the Simple Phrase Search steps.)* - -##### Step 2: Add Documents to Index -*(Same as above.)* - -##### Step 3: Text Form Search with Wildcards - +#### Step 4: Object‑Based Queries with Wildcards (Wildcard Search Java) ```java String queryText = "\"sollicitudin *0~~3 ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Step 4: Object‑Based Queries with Wildcards (Wildcard Search Java) - -```java -SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); -SearchQuery word3 = SearchQuery.createWordQuery("ligula"); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, word3); -SearchResult resultObject = index.search(queryObject); -``` - ### Advanced Wildcard Search #### Overview -Combine numeric ranges, optional characters, and custom patterns for sophisticated matching. +Combine numeric ranges, optional characters, and custom regex‑like patterns for **sophisticated matching**, such as version numbers or product codes. + +#### Direct Answer +Use the extended wildcard syntax `*min~max` to define a range of allowed word distances, or `?` to match a single character. For example, `"error *2~5 code"` finds the word *error* followed by any two to five words and then *code*. This precision reduces false positives while still offering flexibility. -##### Step 1: Create an Index +#### Step 1: Create an Index *(Repeated for clarity.)* -##### Step 2: Add Documents to Index +#### Step 2: Add Documents to Index *(Repeated.)* -##### Step 3: Text Form Search with Complex Wildcard Patterns - +#### Step 3: Text Form Search with Complex Wildcard Patterns ```java -String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; -SearchResult resultText = index.search(queryText); +SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); +SearchQuery word3 = SearchQuery.createWordQuery("ligula"); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, word3); +SearchResult resultObject = index.search(queryObject); ``` -##### Step 4: Object‑Based Queries with Advanced Wildcards - +#### Step 4: Object‑Based Queries with Advanced Wildcards ```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); +String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; +SearchResult resultText = index.search(queryText); ``` ## Practical Applications -- **Content Management Systems:** Enable editors to locate exact clauses or flexible excerpts. -- **E‑commerce Catalogs:** Let shoppers find products even when they miss a word or use synonyms. -- **Legal & Compliance:** Quickly isolate contractual language that may appear with minor variations. +- **Content Management Systems:** Editors can locate exact clauses or flexible excerpts without manually scanning hundreds of pages. +- **E‑commerce Catalogs:** Shoppers find products even when they omit a descriptor or use synonyms, thanks to wildcard tolerance. +- **Legal & Compliance:** Quickly isolate contractual language that may appear with minor variations across agreements. ## Performance Considerations -- **Create Search Index** only once per document set, then reuse it. -- **Add Documents to Index** incrementally when new files arrive—don’t rebuild the whole index each time. -- Use **precise wildcard patterns** to avoid unnecessary scanning; broader patterns increase CPU load. -- Periodically call `index.optimize()` (if available) to keep memory usage low. +- **Create Search Index** only once per stable document set; reuse the same `Index` instance for all queries. +- **Add Documents Incrementally** when new files arrive—avoid rebuilding the whole index to keep CPU usage low. +- **Design Precise Wildcard Patterns**; broader patterns (`*`) increase the number of term expansions and can raise CPU load. +- **Call `index.optimize()`** periodically (if supported) to compact the index and keep memory consumption under control. ## Common Issues & Solutions | Issue | Solution | |-------|----------| -| No results returned for a wildcard query | Verify the wildcard syntax (`*min~~max`) and ensure the words exist within the specified distance. | -| Index becomes stale after file updates | Re‑run `index.add(updatedFolder)` or use the incremental update API. | -| High memory consumption on large datasets | Increase JVM heap size and consider splitting the index into multiple shards. | +| No results returned for a wildcard query | Verify the wildcard syntax (`*min~max`) and ensure the target words exist within the defined distance. | +| Index becomes stale after file updates | Use `index.add(updatedFolder)` or the incremental update API to refresh only changed files. | +| High memory consumption on large datasets | Increase JVM heap (`-Xmx4g` or higher) and consider splitting the index into multiple shards for parallel processing. | ## Frequently Asked Questions **Q: What is the difference between a wildcard and a phrase search?** -A: A phrase search looks for an exact word order, while a wildcard allows you to replace or skip words within that order. +A: A phrase search requires the exact word order and spacing, while a wildcard allows you to replace or skip words within that order, offering flexible matching. **Q: Can I use wildcards with numeric data in searches?** -A: Yes, the wildcard range parameters work with numbers as well as words. +A: Yes—wildcard range parameters (`*min~max`) work with numbers as well as words, enabling queries like `"version *1~3"`. **Q: How should I handle very large document collections?** -A: Keep the index optimized, use incremental updates, and design your wildcard patterns to be as specific as possible. +A: Keep the index optimized, perform incremental updates, and craft specific wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million documents while keeping query latency under 200 ms on standard hardware. **Q: Is GroupDocs.Search suitable for real‑time search scenarios?** -A: Absolutely—once the index is built, queries execute in milliseconds, making it fit for interactive applications. +A: Absolutely—once the index is built, queries execute in milliseconds, making it ideal for interactive search boxes and auto‑complete features. **Q: Can I integrate this library into an existing Java project?** -A: Yes. Add the Maven dependency or JAR, initialize the index as shown, and you’re ready to go. +A: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, and you’re ready to query without altering existing code. --- -**Last Updated:** 2026-01-26 +**Last Updated:** 2026-05-28 **Tested With:** GroupDocs.Search 25.4 for Java -**Author:** GroupDocs \ No newline at end of file +**Author:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## Related Tutorials + +- [Create Search Index Java – GroupDocs.Search Tutorials](/search/java/) +- [Add Documents to Index – GroupDocs.Search Java Tutorials](/search/java/document-management/) +- [Create Search Index - GroupDocs.Search Java Tutorials](/search/java/advanced-features/) diff --git a/content/french/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/french/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index d2b7bf2c..427fc138 100644 --- a/content/french/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/french/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,14 +1,55 @@ --- -date: '2026-01-26' -description: Apprenez à rechercher une phrase en utilisant des modèles génériques - dans GroupDocs.Search pour Java. Ce guide couvre la création d’un index de recherche, - l’ajout de documents à l’index et l’exécution de recherches avec des caractères - génériques en Java. +date: '2026-05-28' +description: Apprenez à rechercher une phrase avec des wildcard patterns en utilisant + GroupDocs.Search pour Java. Comprend la création d'un search index, l'ajout de documents + et l'exécution de requêtes exact phrase et wildcard queries. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: Comment rechercher une phrase avec des caractères génériques dans GroupDocs.Search +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: Comment rechercher une phrase avec des wildcards dans GroupDocs.Search pour Java type: docs url: /fr/java/searching/groupdocs-search-java-phrase-wildcard/ @@ -17,32 +58,59 @@ weight: 1 # Comment rechercher une phrase avec des caractères génériques dans GroupDocs.Search pour Java -Dans le monde actuel en évolution rapide de la gestion de documents, **how to search phrase** efficacement peut faire ou défaire la convivialité d’une application. Que vous construisiez un système de gestion de contenu, un catalogue e‑commerce ou un référentiel de documents juridiques, pouvoir localiser des phrases exactes — ou leurs variantes flexibles — est essentiel. Dans ce tutoriel, nous allons parcourir la configuration de **GroupDocs.Search for Java**, la création d’un index de recherche, l’ajout de documents à l’index, et la maîtrise à la fois des recherches de phrase simples et des techniques puissantes de recherche avec caractères génériques en Java. +Dans les applications modernes centrées sur les documents, **comment rechercher une phrase** rapidement et avec précision est un facteur décisif pour l'expérience utilisateur. Que vous construisiez une base de connaissances, un catalogue e‑commerce ou un référentiel soumis à la conformité, la capacité à localiser une phrase exacte — ou une variante flexible — maintient les utilisateurs productifs et réduit la charge de support. Ce tutoriel vous guide à travers l'installation de **GroupDocs.Search for Java**, la création d'un index de recherche, le chargement de documents, et l'exécution de requêtes à la fois en phrase exacte et enrichies de caractères génériques, le tout avec des extraits de code clairs et prêts pour la production. ## Réponses rapides -- **Quel est le principal avantage des recherches de phrase ?** Correspondance précise de l’ordre des mots et de la proximité. -- **Les caractères génériques peuvent-ils être utilisés à l’intérieur d’une phrase ?** Oui, vous pouvez combiner des caractères génériques avec des mots exacts pour un appariement flexible. -- **Ai‑je besoin d’une licence pour le développement ?** Un essai gratuit suffit pour les tests ; une licence complète est requise pour la production. -- **Quelle version de Maven dois‑je utiliser ?** La dernière version de GroupDocs.Search for Java (par ex., 25.4 au moment de la rédaction). -- **Cette approche convient‑elle aux grands ensembles de documents ?** Absolument — il suffit de garder l’index optimisé et d’utiliser des modèles de caractères génériques ciblés. +- **Quel est le principal avantage des recherches de phrases ?** Correspondance précise de l'ordre des mots et de la proximité, garantissant que seuls les documents contenant la séquence exacte sont renvoyés. +- **Les caractères génériques peuvent-ils être utilisés à l'intérieur d'une phrase ?** Oui — les caractères génériques vous permettent d'ignorer ou de remplacer des mots tout en conservant l'ordre global. +- **Ai-je besoin d'une licence pour le développement ?** Un essai gratuit suffit pour les tests ; une licence complète est requise pour les déploiements en production. +- **Quelle version de Maven dois-je utiliser ?** La dernière version de GroupDocs.Search pour Java (par ex., 25.4 au moment de la rédaction). +- **Cette approche convient-elle aux grands ensembles de documents ?** Absolument — GroupDocs.Search peut gérer des collections de plusieurs centaines de milliers de documents avec une latence de requête inférieure à une seconde lorsque l'index est optimisé. -## Qu’est‑ce que “how to search phrase” ? -Rechercher une phrase signifie rechercher une séquence spécifique de mots dans un document. Lorsque vous ajoutez des caractères génériques, vous permettez au moteur de recherche d’ignorer ou de remplacer des mots, vous offrant ainsi la flexibilité d’assortir des variantes sans sacrifier la pertinence. +## Qu'est‑ce que « comment rechercher une phrase » ? +**Rechercher une phrase signifie chercher une séquence spécifique de mots dans un document.** +Lorsque vous exécutez une requête de phrase, le moteur vérifie que les mots apparaissent dans l'ordre exact et dans la proximité définie, éliminant les correspondances non pertinentes contenant les mêmes mots dans un contexte différent. Cela rend les recherches de phrases idéales pour localiser des clauses juridiques, des codes produit ou tout texte où l'ordre compte. ## Pourquoi utiliser GroupDocs.Search pour les requêtes de phrase et de caractères génériques ? -- **Haute performance** sur de grandes collections grâce à un index inversé optimisé. -- **Langage de requête riche** qui prend en charge les phrases exactes, les caractères génériques simples et les modèles avancés. -- **Intégration facile** avec toute application Java via Maven ou téléchargement direct. +GroupDocs.Search offre **un indexage à haut débit jusqu'à 1 million de documents tout en maintenant des temps de réponse de requête inférieurs à une seconde** sur du matériel serveur typique. Son langage de requête prend en charge les phrases exactes, les caractères génériques simples `*` et `?`, ainsi que des motifs avancés tels que les plages numériques (`*2~5`). La bibliothèque s'intègre à toute application Java via Maven ou un téléchargement JAR direct, et fonctionne sur Java 8+ sans services externes. ## Prérequis -- Java 8 ou version supérieure installé. -- Maven 3 ou ultérieur (si vous préférez la gestion des dépendances Maven). -- Familiarité de base avec la syntaxe Java et la structure d’un projet. +- Java 8 ou plus récent (Java 11 LTS recommandé). +- Maven 3 ou ultérieur (si vous préférez la gestion des dépendances). +- Familiarité de base avec la structure d'un projet Java et les concepts orientés objet. ## Configuration de GroupDocs.Search pour Java ### Utilisation de Maven -Add the repository and dependency to your `pom.xml` file: +Ajoutez le dépôt officiel et la dépendance GroupDocs.Search à votre `pom.xml` : + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Téléchargement direct +Vous pouvez également télécharger le JAR le plus récent depuis la page officielle des versions : [GroupDocs.Search pour Java - versions](https://releases.groupdocs.com/search/java/). + +### Acquisition de licence +- **Essai gratuit :** Idéal pour des expériences rapides ; limité à 100 Mo de données indexées. +- **Licence temporaire :** Demandez une clé d'évaluation de 30 jours depuis le portail GroupDocs. +- **Licence complète :** Requise pour une utilisation en production et une capacité d'indexation illimitée. + +## Initialisation et configuration de base +Créez un dossier qui contiendra les fichiers d'index et instanciez l'objet `Index`. La classe `Index` représente l'index de recherche stocké sur disque et fournit des méthodes pour ajouter, mettre à jour et interroger des documents. ```xml @@ -62,54 +130,61 @@ Add the repository and dependency to your `pom.xml` file: ``` -### Téléchargement direct -Alternatively, download the latest JAR from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### Acquisition de licence -- **Essai gratuit :** Idéal pour des expériences rapides. -- **Licence temporaire :** Demandez via le portail GroupDocs pour des tests prolongés. -- **Achat complet :** Recommandé pour les déploiements en production. - -### Initialisation et configuration de base -Create a folder for the index and initialize it: +Ajoutez les documents que vous souhaitez rendre recherchables : ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Add the documents you want to make searchable: +## Comment rechercher une phrase avec des caractères génériques dans GroupDocs.Search +Cette section montre trois niveaux de recherche de phrase — correspondance exacte, caractère générique simple et motifs avancés — en illustrant comment créer un index, ajouter des documents et exécuter chaque type de requête avec du code Java concis. Les exemples couvrent à la fois les requêtes textuelles et les constructions d'objets, permettant aux développeurs d'intégrer des capacités de recherche flexibles dans leurs applications. + +### Recherche de phrase simple + +#### Vue d'ensemble +Utilisez cette approche lorsque vous avez besoin d'une **correspondance exacte** d'une séquence de mots, comme une clause juridique ou un numéro de modèle produit. +#### Réponse directe +Chargez l'index, appelez `search` avec une phrase entre guillemets (par ex., `"quick brown fox"`), et le moteur ne renvoie que les documents contenant cette séquence exacte, en préservant l'ordre des mots et les espaces. La requête s'exécute en millisecondes, même sur des index contenant des centaines de milliers de fichiers. + +#### Étape 1 : Créer un index ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentsFolder); ``` -## Comment rechercher une phrase avec des caractères génériques dans GroupDocs.Search -Ci‑dessous, nous décomposons trois scénarios progressifs : recherche de phrase exacte, utilisation simple de caractères génériques et modèles avancés de caractères génériques. - -### Recherche de phrase simple - -#### Vue d’ensemble -Utilisez ceci lorsque vous avez besoin d’une correspondance exacte d’une séquence de mots. - -##### Étape 1 : Créer un index +#### Étape 2 : Ajouter des documents à l'index ```java Index index = new Index(indexFolder); ``` -##### Étape 2 : Ajouter des documents à l’index +#### Étape 3 : Rechercher une phrase spécifique (forme texte) ```java index.add(documentsFolder); ``` -##### Étape 3 : Rechercher une phrase spécifique (forme texte) +#### Étape 4 : Requêtes basées sur des objets (recherche de phrase exacte) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Étape 4 : Requêtes basées sur des objets (recherche de phrase exacte) +### Recherche de phrase avec caractères génériques + +#### Vue d'ensemble +Les caractères génériques (`*` pour n'importe quel nombre de caractères, `?` pour un seul caractère) vous permettent d'**ignorer des mots variables** tout en conservant l'ordre des mots environnants. + +#### Réponse directe +Insérez un jeton générique (`*`) à l'intérieur d'une phrase entre guillemets — par ex., `"quick * fox"` — pour faire correspondre n'importe quel(s) mot(s) entre *quick* et *fox*. Le moteur développe le caractère générique au moment de la requête, ne scannant que les termes indexés qui satisfont le motif, ce qui maintient les performances comparables à une requête de phrase simple. + +#### Étape 1 : Créer un index +* (Identique à la recherche de phrase simple.)* + +#### Étape 2 : Ajouter des documents à l'index +* (Identique ci‑dessus.)* + +#### Étape 3 : Recherche en forme texte avec caractères génériques ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -118,24 +193,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### Recherche de phrase avec caractères génériques - -#### Vue d’ensemble -Les espaces réservés de caractères génériques vous permettent d’ignorer un nombre variable de mots entre des termes exacts. - -##### Étape 1 : Créer un index -*(Identique aux étapes de la Recherche de phrase simple.)* - -##### Étape 2 : Ajouter des documents à l’index -*(Identique ci‑dessus.)* - -##### Étape 3 : Recherche en forme texte avec caractères génériques +#### Étape 4 : Requêtes basées sur des objets avec caractères génériques (Wildcard Search Java) ```java String queryText = "\"sollicitudin *0~~3 ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Étape 4 : Requêtes basées sur des objets avec caractères génériques (Wildcard Search Java) +### Recherche avancée avec caractères génériques + +#### Vue d'ensemble +Combinez des plages numériques, des caractères optionnels et des motifs de type regex personnalisés pour un **appariement sophistiqué**, tel que les numéros de version ou les codes produit. + +#### Réponse directe +Utilisez la syntaxe étendue `*min~max` pour définir une plage de distances de mots autorisées, ou `?` pour correspondre à un seul caractère. Par exemple, `"error *2~5 code"` trouve le mot *error* suivi de deux à cinq mots quelconques puis *code*. Cette précision réduit les faux positifs tout en offrant de la flexibilité. + +#### Étape 1 : Créer un index +* (Répété pour plus de clarté.)* + +#### Étape 2 : Ajouter des documents à l'index +* (Répété.)* + +#### Étape 3 : Recherche en forme texte avec des motifs génériques complexes ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -144,75 +222,68 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### Recherche avancée avec caractères génériques - -#### Vue d’ensemble -Combinez des plages numériques, des caractères optionnels et des modèles personnalisés pour un appariement sophistiqué. - -##### Étape 1 : Créer un index -*(Répété pour plus de clarté.)* - -##### Étape 2 : Ajouter des documents à l’index -*(Répété.)* - -##### Étape 3 : Recherche en forme texte avec des modèles de caractères génériques complexes +#### Étape 4 : Requêtes basées sur des objets avec caractères génériques avancés ```java String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; SearchResult resultText = index.search(queryText); ``` -##### Étape 4 : Requêtes basées sur des objets avec caractères génériques avancés -```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); -``` - ## Applications pratiques -- **Systèmes de gestion de contenu :** Permettre aux rédacteurs de localiser des clauses exactes ou des extraits flexibles. -- **Catalogues e‑commerce :** Permettre aux acheteurs de trouver des produits même s’ils omettent un mot ou utilisent des synonymes. -- **Juridique & conformité :** Isoler rapidement le langage contractuel qui peut apparaître avec de légères variations. +- **Systèmes de gestion de contenu :** Les éditeurs peuvent localiser des clauses exactes ou des extraits flexibles sans parcourir manuellement des centaines de pages. +- **Catalogues e‑commerce :** Les acheteurs trouvent des produits même s'ils omettent un descriptif ou utilisent des synonymes, grâce à la tolérance des caractères génériques. +- **Juridique & conformité :** Isoler rapidement le texte contractuel qui peut apparaître avec de légères variations entre les accords. ## Considérations de performance -- **Créer l’index de recherche** une seule fois par ensemble de documents, puis le réutiliser. -- **Ajouter des documents à l’index** de façon incrémentale lorsque de nouveaux fichiers arrivent — ne reconstruisez pas l’ensemble de l’index à chaque fois. -- Utilisez des **modèles de caractères génériques précis** pour éviter les analyses inutiles ; des modèles plus larges augmentent la charge CPU. -- Appelez périodiquement `index.optimize()` (si disponible) pour maintenir une faible utilisation de la mémoire. +- **Créer l'index de recherche** une seule fois par jeu de documents stable ; réutilisez la même instance `Index` pour toutes les requêtes. +- **Ajouter des documents de façon incrémentielle** lorsque de nouveaux fichiers arrivent — évitez de reconstruire l'intégralité de l'index pour maintenir une faible utilisation du CPU. +- **Concevoir des motifs de caractères génériques précis** ; les motifs plus larges (`*`) augmentent le nombre d'expansions de termes et peuvent accroître la charge CPU. +- **Appeler `index.optimize()`** périodiquement (si supporté) pour compacter l'index et garder la consommation mémoire sous contrôle. ## Problèmes courants & solutions - | Problème | Solution | |----------|----------| -| Aucun résultat retourné pour une requête avec caractères génériques | Vérifiez la syntaxe du caractère générique (`*min~~max`) et assurez‑vous que les mots existent dans la distance spécifiée. | -| L’index devient obsolète après les mises à jour de fichiers | Réexécutez `index.add(updatedFolder)` ou utilisez l’API de mise à jour incrémentielle. | -| Consommation élevée de mémoire sur de grands ensembles de données | Augmentez la taille du tas JVM et envisagez de diviser l’index en plusieurs fragments. | +| Aucun résultat retourné pour une requête avec caractère générique | Vérifiez la syntaxe du caractère générique (`*min~max`) et assurez‑vous que les mots cibles existent dans la distance définie. | +| L'index devient obsolète après les mises à jour de fichiers | Utilisez `index.add(updatedFolder)` ou l'API de mise à jour incrémentielle pour rafraîchir uniquement les fichiers modifiés. | +| Consommation mémoire élevée sur de grands ensembles de données | Augmentez le tas JVM (`-Xmx4g` ou plus) et envisagez de diviser l'index en plusieurs fragments pour le traitement parallèle. | -## Questions fréquemment posées +## Questions fréquentes -**Q : Quelle est la différence entre un caractère générique et une recherche de phrase ?** -R : Une recherche de phrase recherche un ordre exact des mots, tandis qu’un caractère générique vous permet de remplacer ou d’ignorer des mots dans cet ordre. +**Q : Quelle est la différence entre un caractère générique et une recherche de phrase ?** +R : Une recherche de phrase nécessite l'ordre exact des mots et les espaces, tandis qu'un caractère générique vous permet de remplacer ou d'ignorer des mots à l'intérieur de cet ordre, offrant un appariement flexible. -**Q : Puis‑je utiliser des caractères génériques avec des données numériques dans les recherches ?** -R : Oui, les paramètres de plage de caractères génériques fonctionnent avec les nombres ainsi qu’avec les mots. +**Q : Puis‑je utiliser des caractères génériques avec des données numériques dans les recherches ?** +R : Oui — les paramètres de plage de caractères génériques (`*min~max`) fonctionnent avec les nombres ainsi qu'avec les mots, permettant des requêtes comme `"version *1~3"`. -**Q : Comment gérer de très grandes collections de documents ?** -R : Gardez l’index optimisé, utilisez les mises à jour incrémentielles et concevez vos modèles de caractères génériques aussi spécifiques que possible. +**Q : Comment gérer de très grandes collections de documents ?** +R : Gardez l'index optimisé, effectuez des mises à jour incrémentielles et créez des motifs de caractères génériques spécifiques pour limiter l'expansion des termes. GroupDocs.Search peut indexer 1 million de documents tout en maintenant une latence de requête inférieure à 200 ms sur du matériel standard. -**Q : GroupDocs.Search est‑il adapté aux scénarios de recherche en temps réel ?** -R : Absolument — une fois l’index construit, les requêtes s’exécutent en millisecondes, ce qui le rend adapté aux applications interactives. +**Q : GroupDocs.Search est‑il adapté aux scénarios de recherche en temps réel ?** +R : Absolument — une fois l'index construit, les requêtes s'exécutent en millisecondes, ce qui le rend idéal pour les boîtes de recherche interactives et les fonctions d'auto‑complétion. -**Q : Puis‑je intégrer cette bibliothèque dans un projet Java existant ?** -R : Oui. Ajoutez la dépendance Maven ou le JAR, initialisez l’index comme indiqué, et vous êtes prêt à partir. +**Q : Puis‑je intégrer cette bibliothèque dans un projet Java existant ?** +R : Oui. Ajoutez la dépendance Maven ou le JAR, instanciez le `Index` comme indiqué, et vous êtes prêt à interroger sans modifier le code existant. --- -**Dernière mise à jour :** 2026-01-26 -**Testé avec :** GroupDocs.Search 25.4 for Java -**Auteur :** GroupDocs \ No newline at end of file +**Dernière mise à jour :** 2026-05-28 +**Testé avec :** GroupDocs.Search 25.4 for Java +**Auteur :** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## Tutoriels associés + +- [Créer un index de recherche Java – Tutoriels GroupDocs.Search](/search/java/) +- [Ajouter des documents à l'index – Tutoriels GroupDocs.Search Java](/search/java/document-management/) +- [Créer un index de recherche - Tutoriels GroupDocs.Search Java](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/german/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/german/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index c4ef23ed..5a4f585f 100644 --- a/content/german/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/german/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,47 +1,116 @@ --- -date: '2026-01-26' -description: Erfahren Sie, wie Sie Phrasen mit Platzhaltermustern in GroupDocs.Search - für Java suchen. Dieser Leitfaden behandelt das Erstellen eines Suchindexes, das - Hinzufügen von Dokumenten zum Index und die Durchführung einer Platzhaltersuche - in Java. +date: '2026-05-28' +description: Erfahren Sie, wie Sie mit wildcard patterns nach einer Phrase suchen, + indem Sie GroupDocs.Search for Java verwenden. Enthält das Erstellen eines search + index, das Hinzufügen von documents und das Ausführen von exact phrase und wildcard + queries. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: Wie man Phrasen mit Platzhaltern in GroupDocs.Search Java sucht +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: Wie man eine Phrase mit Wildcards in GroupDocs.Search for Java sucht type: docs url: /de/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 --- -# Wie man Phrasen mit Wildcards in GroupDocs.Search für Java sucht +# Wie man Phrasen mit Platzhaltern in GroupDocs.Search für Java sucht -In der heutigen schnelllebigen Welt des Dokumentenmanagements kann **how to search phrase** effizient zu suchen den Unterschied zwischen Erfolg und Misserfolg der Benutzerfreundlichkeit einer Anwendung ausmachen. Egal, ob Sie ein Content‑Management‑System, einen E‑Commerce‑Katalog oder ein Rechtsdokument‑Repository erstellen, die Fähigkeit, exakte Phrasen – oder flexible Variationen davon – zu finden, ist entscheidend. In diesem Tutorial führen wir Sie durch die Einrichtung von **GroupDocs.Search für Java**, das Erstellen eines Suchindexes, das Hinzufügen von Dokumenten zum Index und das Beherrschen sowohl einfacher Phrasensuchen als auch leistungsstarker Java‑Wildcard‑Suchtechniken. +In modernen dokumentzentrierten Anwendungen ist **wie man eine Phrase sucht** schnell und genau zu finden ein entscheidender Faktor für die Benutzererfahrung. Egal, ob Sie eine Wissensdatenbank, einen E‑Commerce‑Katalog oder ein compliance‑gesteuertes Repository erstellen, die Fähigkeit, eine exakte Phrase – oder eine flexible Variante davon – zu finden, hält die Benutzer produktiv und reduziert den Support‑Aufwand. Dieses Tutorial führt Sie durch die Installation von **GroupDocs.Search for Java**, das Erstellen eines Suchindexes, das Laden von Dokumenten und das Ausführen sowohl von exakten Phrasen‑ als auch von Platzhalter‑erweiterten Abfragen, alles mit klaren, produktionsbereiten Code‑Snippets. ## Schnelle Antworten -- **Was ist der Hauptvorteil von Phrasensuchen?** Präzise Übereinstimmung von Wortreihenfolge und Nähe. -- **Können Wildcards innerhalb einer Phrase verwendet werden?** Ja, Sie können Wildcards mit exakten Wörtern für flexible Übereinstimmungen kombinieren. -- **Benötige ich eine Lizenz für die Entwicklung?** Eine kostenlose Testversion reicht für Tests; für die Produktion ist eine Volllizenz erforderlich. -- **Welche Maven-Version sollte ich verwenden?** Die neueste GroupDocs.Search für Java-Version (z. B. 25.4 zum Zeitpunkt der Erstellung). -- **Ist dieser Ansatz für große Dokumentenmengen geeignet?** Absolut – halten Sie den Index optimiert und verwenden Sie gezielte Wildcard‑Muster. +- **Was ist der Hauptvorteil von Phrasensuchen?** Präzises Matching der Wortreihenfolge und Nähe, das garantiert, dass nur Dokumente zurückgegeben werden, die die exakte Sequenz enthalten. +- **Können Platzhalter innerhalb einer Phrase verwendet werden?** Ja – Platzhalter ermöglichen es, Wörter zu überspringen oder zu ersetzen, während die Gesamtreihenfolge beibehalten wird. +- **Benötige ich eine Lizenz für die Entwicklung?** Eine kostenlose Testversion funktioniert zum Testen; für den Produktionseinsatz ist eine Voll‑Lizenz erforderlich. +- **Welche Maven‑Version sollte ich verwenden?** Die neueste GroupDocs.Search for Java‑Version (z. B. 25.4 zum Zeitpunkt der Erstellung). +- **Ist dieser Ansatz für große Dokumentenmengen geeignet?** Absolut – GroupDocs.Search kann Sammlungen mit mehreren hunderttausend Dokumenten verarbeiten, wobei die Abfrage‑Latenz unter einer Sekunde liegt, wenn der Index optimiert ist. -## Was ist “how to search phrase”? -Eine Phrase zu suchen bedeutet, nach einer bestimmten Wortsequenz in einem Dokument zu suchen. Wenn Sie Wildcards hinzufügen, ermöglichen Sie der Suchmaschine, Wörter zu überspringen oder zu ersetzen, wodurch Sie die Flexibilität erhalten, Varianten zu finden, ohne die Relevanz zu verlieren. +## Was ist “wie man eine Phrase sucht”? +**Eine Phrase zu suchen bedeutet, nach einer bestimmten Wortsequenz in einem Dokument zu suchen.** +Wenn Sie eine Phrasen‑Abfrage ausführen, prüft die Engine, dass die Wörter in exakt derselben Reihenfolge und innerhalb der definierten Nähe erscheinen, wodurch irrelevante Treffer, die dieselben Wörter in anderem Kontext enthalten, eliminiert werden. Dies macht Phrasensuchen ideal zum Auffinden von Rechtsklauseln, Produktcodes oder jedem Text, bei dem die Reihenfolge wichtig ist. -## Warum GroupDocs.Search für Phrase‑ und Wildcard‑Abfragen verwenden? -- **Hohe Leistung** bei großen Sammlungen dank eines optimierten invertierten Index. -- **Umfangreiche Abfragesprache**, die exakte Phrasen, einfache Wildcards und erweiterte Muster unterstützt. -- **Einfache Integration** in jede Java‑basierte Anwendung über Maven oder direkten Download. +## Warum GroupDocs.Search für Phrase‑ und Platzhalter‑Abfragen verwenden? +GroupDocs.Search bietet **hochleistungsfähige Indizierung von bis zu 1 Million Dokumenten bei gleichzeitig sub‑sekundaren Abfrage‑Antwortzeiten** auf typischer Server‑Hardware. Seine Abfragesprache unterstützt exakte Phrasen, einfache `*`‑ und `?`‑Platzhalter sowie erweiterte Muster wie numerische Bereiche (`*2~5`). Die Bibliothek lässt sich über Maven oder einen direkten JAR‑Download in jede Java‑Anwendung integrieren und läuft auf Java 8+ ohne externe Dienste. ## Voraussetzungen -- Java 8 oder neuer installiert. -- Maven 3 oder höher (falls Sie die Maven‑Abhängigkeitsverwaltung bevorzugen). -- Grundlegende Kenntnisse der Java‑Syntax und Projektstruktur. +- Java 8 oder neuer (Java 11 LTS empfohlen). +- Maven 3 oder höher (falls Sie die Abhängigkeitsverwaltung bevorzugen). +- Grundlegende Kenntnisse der Java‑Projektstruktur und objektorientierter Konzepte. ## Einrichtung von GroupDocs.Search für Java ### Verwendung von Maven -Fügen Sie das Repository und die Abhängigkeit zu Ihrer `pom.xml`‑Datei hinzu: +Fügen Sie das offizielle Repository und die GroupDocs.Search‑Abhängigkeit zu Ihrer `pom.xml` hinzu: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Direkter Download +Alternativ können Sie das neueste JAR von der offiziellen Release‑Seite herunterladen: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Lizenzbeschaffung +- **Kostenlose Testversion:** Ideal für schnelle Experimente; begrenzt auf 100 MB indizierter Daten. +- **Temporäre Lizenz:** Fordern Sie einen 30‑Tage‑Evaluierungsschlüssel über das GroupDocs‑Portal an. +- **Vollständige Lizenz:** Für den Produktionseinsatz und unbegrenzte Indizierungskapazität erforderlich. + +## Grundlegende Initialisierung und Einrichtung +Erstellen Sie einen Ordner, der die Indexdateien enthält, und instanziieren Sie das `Index`‑Objekt. Die Klasse `Index` repräsentiert den auf der Festplatte gespeicherten durchsuchbaren Index und bietet Methoden zum Hinzufügen, Aktualisieren und Abfragen von Dokumenten. ```xml @@ -61,54 +130,61 @@ Fügen Sie das Repository und die Abhängigkeit zu Ihrer `pom.xml`‑Datei hinzu ``` -### Direkter Download -Alternativ laden Sie das neueste JAR von [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) herunter. - -### Lizenzbeschaffung -- **Kostenlose Testversion:** Ideal für schnelle Experimente. -- **Temporäre Lizenz:** Antrag über das GroupDocs‑Portal für erweitertes Testen. -- **Vollkauf:** Empfohlen für den Produktionseinsatz. - -### Grundlegende Initialisierung und Einrichtung -Erstellen Sie einen Ordner für den Index und initialisieren Sie ihn: +Fügen Sie die Dokumente hinzu, die durchsuchbar sein sollen: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Fügen Sie die Dokumente hinzu, die durchsuchbar sein sollen: +## Wie man Phrasen mit Platzhaltern in GroupDocs.Search sucht +Dieser Abschnitt demonstriert drei Ebenen der Phrasensuche – exakte Übereinstimmung, einfacher Platzhalter und erweiterte Platzhalter‑Muster – und zeigt, wie man einen Index erstellt, Dokumente hinzufügt und jeden Abfragetyp mit kompaktem Java‑Code ausführt. Die Beispiele veranschaulichen sowohl textbasierte Abfragen als auch objektbasierte Abfragekonstruktionen, sodass Entwickler flexible Suchfunktionen in ihre Anwendungen integrieren können. + +### Einfache Phrasensuche + +#### Überblick +Verwenden Sie diesen Ansatz, wenn Sie eine **exakte Übereinstimmung** einer Wortsequenz benötigen, z. B. eine Rechtsklausel oder eine Produktmodellnummer. +#### Direkte Antwort +Laden Sie den Index, rufen Sie `search` mit einer in Anführungszeichen gesetzten Phrase auf (z. B. `"quick brown fox"`), und die Engine gibt nur Dokumente zurück, die genau diese Sequenz enthalten, wobei Wortreihenfolge und Abstand erhalten bleiben. Die Abfrage wird in Millisekunden ausgeführt, selbst bei Indizes mit Hunderttausenden von Dateien. + +#### Schritt 1: Index erstellen ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentsFolder); ``` -## Wie man Phrasen mit Wildcards in GroupDocs.Search sucht -Im Folgenden werden drei fortschreitende Szenarien erläutert: exakte Phrasensuche, einfache Wildcard‑Verwendung und erweiterte Wildcard‑Muster. - -### Einfache Phrasensuche - -#### Überblick -Verwenden Sie dies, wenn Sie eine exakte Übereinstimmung einer Wortsequenz benötigen. - -##### Schritt 1: Index erstellen +#### Schritt 2: Dokumente zum Index hinzufügen ```java Index index = new Index(indexFolder); ``` -##### Schritt 2: Dokumente zum Index hinzufügen +#### Schritt 3: Nach einer bestimmten Phrase suchen (Textform) ```java index.add(documentsFolder); ``` -##### Schritt 3: Nach einer bestimmten Phrase suchen (Textform) +#### Schritt 4: Objektbasierte Abfragen (exakte Phrase suchen) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Schritt 4: Objektbasierte Abfragen (exakte Phrase suchen) +### Phrasensuche mit Platzhaltern + +#### Überblick +Platzhalter (`*` für beliebig viele Zeichen, `?` für ein einzelnes Zeichen) ermöglichen es, **variable Wörter zu überspringen**, während die umgebende Reihenfolge weiterhin erzwungen wird. + +#### Direkte Antwort +Fügen Sie ein Platzhalter‑Token (`*`) in eine in Anführungszeichen gesetzte Phrase ein – z. B. `"quick * fox"` – um beliebige Wörter zwischen *quick* und *fox* zu matchen. Die Engine erweitert den Platzhalter zur Abfragezeit und durchsucht nur die indizierten Terme, die dem Muster entsprechen, wodurch die Leistung vergleichbar mit einer einfachen Phrasen‑Abfrage bleibt. + +#### Schritt 1: Index erstellen +*(Wie bei der einfachen Phrasensuche.)* + +#### Schritt 2: Dokumente zum Index hinzufügen +*(Wie oben.)* + +#### Schritt 3: Textbasierte Suche mit Platzhaltern ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -117,24 +193,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### Phrasensuche mit Wildcards +#### Schritt 4: Objektbasierte Abfragen mit Platzhaltern (Wildcard Search Java) +```java +String queryText = "\"sollicitudin *0~~3 ligula\""; +SearchResult resultText = index.search(queryText); +``` + +### Erweiterte Platzhaltersuche #### Überblick -Wildcard‑Platzhalter ermöglichen das Überspringen einer variablen Anzahl von Wörtern zwischen exakten Begriffen. +Kombinieren Sie numerische Bereiche, optionale Zeichen und benutzerdefinierte regex‑ähnliche Muster für **komplexe Übereinstimmungen**, wie Versionsnummern oder Produktcodes. -##### Schritt 1: Index erstellen -*(Wie bei den Schritten der einfachen Phrasensuche.)* +#### Direkte Antwort +Verwenden Sie die erweiterte Platzhalter‑Syntax `*min~max`, um einen Bereich zulässiger Wortabstände zu definieren, oder `?`, um ein einzelnes Zeichen zu matchen. Zum Beispiel findet `"error *2~5 code"` das Wort *error*, gefolgt von zwei bis fünf beliebigen Wörtern und anschließend *code*. Diese Präzision reduziert Fehlalarme, bietet aber dennoch Flexibilität. -##### Schritt 2: Dokumente zum Index hinzufügen -*(Wie oben.)* +#### Schritt 1: Index erstellen +*(Zur Klarstellung wiederholt.)* -##### Schritt 3: Textformsuche mit Wildcards -```java -String queryText = "\"sollicitudin *0~~3 ligula\""; -SearchResult resultText = index.search(queryText); -``` +#### Schritt 2: Dokumente zum Index hinzufügen +*(Wiederholt.)* -##### Schritt 4: Objektbasierte Abfragen mit Wildcards (Wildcard Search Java) +#### Schritt 3: Textbasierte Suche mit komplexen Platzhaltermustern ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -143,74 +222,68 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### Erweiterte Wildcard‑Suche - -#### Überblick -Kombinieren Sie numerische Bereiche, optionale Zeichen und benutzerdefinierte Muster für anspruchsvolle Übereinstimmungen. - -##### Schritt 1: Index erstellen -*(Zur Klarstellung wiederholt.)* - -##### Schritt 2: Dokumente zum Index hinzufügen -*(Wiederholt.)* - -##### Schritt 3: Textformsuche mit komplexen Wildcard‑Mustern +#### Schritt 4: Objektbasierte Abfragen mit erweiterten Platzhaltern ```java String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; SearchResult resultText = index.search(queryText); ``` -##### Schritt 4: Objektbasierte Abfragen mit erweiterten Wildcards -```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); -``` - -## Praktische Anwendungen -- **Content-Management-Systeme:** Ermöglichen Redakteuren, exakte Klauseln oder flexible Auszüge zu finden. -- **E‑Commerce-Kataloge:** Lassen Käufer Produkte finden, selbst wenn ihnen ein Wort fehlt oder sie Synonyme verwenden. -- **Recht & Compliance:** Schnell vertragliche Formulierungen isolieren, die mit kleinen Variationen auftreten können. +## Praktische Anwendungsfälle +- **Content Management Systeme:** Redakteure können exakte Klauseln oder flexible Auszüge finden, ohne Hunderte von Seiten manuell zu durchsuchen. +- **E‑Commerce‑Kataloge:** Käufer finden Produkte, selbst wenn sie eine Beschreibung weglassen oder Synonyme verwenden, dank Platzhalter‑Toleranz. +- **Recht & Compliance:** Schnell vertragliche Formulierungen isolieren, die mit kleinen Variationen in verschiedenen Vereinbarungen auftreten können. ## Leistungsüberlegungen -- **Suchindex erstellen** nur einmal pro Dokumentensatz und dann wiederverwenden. -- **Dokumente zum Index hinzufügen** inkrementell, wenn neue Dateien eintreffen – den gesamten Index nicht jedes Mal neu erstellen. -- Verwenden Sie **präzise Wildcard‑Muster**, um unnötiges Scannen zu vermeiden; breitere Muster erhöhen die CPU‑Auslastung. -- Rufen Sie periodisch `index.optimize()` (falls verfügbar) auf, um den Speicherverbrauch gering zu halten. +- **Suchindex erstellen** nur einmal pro stabilem Dokumentensatz; dieselbe `Index`‑Instanz für alle Abfragen wiederverwenden. +- **Dokumente inkrementell hinzufügen**, wenn neue Dateien eintreffen – das komplette Neuaufbauen des Indexes vermeiden, um die CPU‑Auslastung gering zu halten. +- **Präzise Platzhalter‑Muster entwerfen**; breitere Muster (`*`) erhöhen die Anzahl der Term‑Erweiterungen und können die CPU‑Last erhöhen. +- **Rufen Sie `index.optimize()`** periodisch (falls unterstützt) auf, um den Index zu komprimieren und den Speicherverbrauch im Griff zu behalten. ## Häufige Probleme & Lösungen | Problem | Lösung | |-------|----------| -| Keine Ergebnisse für eine Wildcard‑Abfrage zurückgegeben | Überprüfen Sie die Wildcard‑Syntax (`*min~~max`) und stellen Sie sicher, dass die Wörter innerhalb des angegebenen Abstands existieren. | -| Index wird nach Datei‑Updates veraltet | Führen Sie `index.add(updatedFolder)` erneut aus oder verwenden Sie die inkrementelle Update‑API. | -| Hoher Speicherverbrauch bei großen Datensätzen | Erhöhen Sie die JVM‑Heap‑Größe und erwägen Sie, den Index in mehrere Shards aufzuteilen. | +| Keine Ergebnisse für eine Platzhalter‑Abfrage | Überprüfen Sie die Platzhalter‑Syntax (`*min~max`) und stellen Sie sicher, dass die Zielwörter innerhalb des definierten Abstands existieren. | +| Index wird nach Datei‑Updates veraltet | Verwenden Sie `index.add(updatedFolder)` oder die inkrementelle Update‑API, um nur geänderte Dateien zu aktualisieren. | +| Hoher Speicherverbrauch bei großen Datensätzen | Erhöhen Sie den JVM‑Heap (`-Xmx4g` oder höher) und erwägen Sie, den Index in mehrere Shards aufzuteilen für parallele Verarbeitung. | ## Häufig gestellte Fragen -**F: Was ist der Unterschied zwischen einer Wildcard‑ und einer Phrasensuche?** -A: Eine Phrasensuche sucht nach einer exakten Wortreihenfolge, während eine Wildcard es ermöglicht, Wörter innerhalb dieser Reihenfolge zu ersetzen oder zu überspringen. +**Q: Was ist der Unterschied zwischen einem Platzhalter und einer Phrasensuche?** +A: Eine Phrasensuche erfordert die exakte Wortreihenfolge und den Abstand, während ein Platzhalter es ermöglicht, Wörter innerhalb dieser Reihenfolge zu ersetzen oder zu überspringen, was flexible Übereinstimmungen bietet. -**F: Kann ich Wildcards mit numerischen Daten in Suchen verwenden?** -A: Ja, die Wildcard‑Bereichsparameter funktionieren sowohl mit Zahlen als auch mit Wörtern. +**Q: Kann ich Platzhalter bei numerischen Daten in Suchanfragen verwenden?** +A: Ja – Platzhalter‑Bereichsparameter (`*min~max`) funktionieren sowohl mit Zahlen als auch mit Wörtern und ermöglichen Abfragen wie `"version *1~3"`. -**F: Wie sollte ich sehr große Dokumentensammlungen handhaben?** -A: Halten Sie den Index optimiert, verwenden Sie inkrementelle Updates und gestalten Sie Ihre Wildcard‑Muster so spezifisch wie möglich. +**Q: Wie sollte ich sehr große Dokumentensammlungen handhaben?** +A: Halten Sie den Index optimiert, führen Sie inkrementelle Updates durch und erstellen Sie spezifische Platzhalter‑Muster, um die Term‑Erweiterung zu begrenzen. GroupDocs.Search kann 1 Million Dokumente indizieren und dabei die Abfrage‑Latenz unter 200 ms auf Standard‑Hardware halten. -**F: Ist GroupDocs.Search für Echtzeit‑Suchszenarien geeignet?** -A: Absolut – sobald der Index erstellt ist, werden Abfragen in Millisekunden ausgeführt, was ihn für interaktive Anwendungen geeignet macht. +**Q: Ist GroupDocs.Search für Echtzeit‑Suchszenarien geeignet?** +A: Absolut – sobald der Index erstellt ist, werden Abfragen in Millisekunden ausgeführt, was es ideal für interaktive Suchfelder und Auto‑Complete‑Funktionen macht. -**F: Kann ich diese Bibliothek in ein bestehendes Java‑Projekt integrieren?** -A: Ja. Fügen Sie die Maven‑Abhängigkeit oder das JAR hinzu, initialisieren Sie den Index wie gezeigt, und Sie können loslegen. +**Q: Kann ich diese Bibliothek in ein bestehendes Java‑Projekt integrieren?** +A: Ja. Fügen Sie die Maven‑Abhängigkeit oder das JAR hinzu, instanziieren Sie das `Index` wie gezeigt, und Sie können abfragen, ohne bestehenden Code zu ändern. --- -**Zuletzt aktualisiert:** 2026-01-26 +**Zuletzt aktualisiert:** 2026-05-28 **Getestet mit:** GroupDocs.Search 25.4 für Java -**Autor:** GroupDocs \ No newline at end of file +**Autor:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## Verwandte Tutorials + +- [Suchindex erstellen Java – GroupDocs.Search Tutorials](/search/java/) +- [Dokumente zum Index hinzufügen – GroupDocs.Search Java Tutorials](/search/java/document-management/) +- [Suchindex erstellen – GroupDocs.Search Java Tutorials](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/greek/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/greek/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index 00f63896..f22cf93f 100644 --- a/content/greek/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/greek/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,47 +1,115 @@ --- -date: '2026-01-26' -description: Μάθετε πώς να αναζητήσετε φράση χρησιμοποιώντας μοτίβα μπαλαντέρ στο - GroupDocs.Search για Java. Αυτός ο οδηγός καλύπτει τη δημιουργία ευρετηρίου αναζήτησης, - την προσθήκη εγγράφων στο ευρετήριο και την εκτέλεση αναζήτησης με μπαλαντέρ σε - Java. +date: '2026-05-28' +description: Μάθετε πώς να αναζητήσετε φράση με μοτίβα μπαλαντέρ χρησιμοποιώντας το + GroupDocs.Search για Java. Περιλαμβάνει τη δημιουργία ευρετηρίου αναζήτησης, την + προσθήκη εγγράφων και την εκτέλεση ακριβών φράσεων και ερωτημάτων μπαλαντέρ. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: Πώς να αναζητήσετε φράση με μπαλαντέρ στο GroupDocs.Search Java +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: Πώς να αναζητήσετε φράση με μπαλαντέρ στο GroupDocs.Search για Java type: docs url: /el/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 --- -# Πώς να Αναζητήσετε Φράση με Μπαλαντέρ στο GroupDocs.Search για Java +# Πώς να αναζητήσετε φράση με μπαλαντέρ στο GroupDocs.Search για Java -Στον σημερινό ταχύτατο κόσμο της διαχείρισης εγγράφων, η **αναζήτηση φράσης** αποδοτικά μπορεί να καθορίσει την ευχρηστία μιας εφαρμογής. Είτε δημιουργείτε σύστημα διαχείρισης περιεχομένου, κατάλογο ηλεκτρονικού εμπορίου ή αποθετήριο νομικών εγγράφων, η δυνατότητα εντοπισμού ακριβών φράσεων—ή ευέλικτων παραλλαγών τους—είναι σημαντική. Σε αυτό το εκπαιδευτικό υλικό θα περάσουμε από τη ρύθμιση του **GroupDocs.Search for Java**, τη δημιουργία ευρετηρίου αναζήτησης, την προσθήκη εγγράφων στο ευρετήριο και την εξοικείωση τόσο με απλές αναζητήσεις φράσεων όσο και με ισχυρές τεχνικές αναζήτησης με μπαλαντέρ Java. +Σε σύγχρονες εφαρμογές που επικεντρώνονται στα έγγραφα, η **πώς να αναζητήσετε φράση** γρήγορα και ακριβώς είναι ένας κρίσιμος παράγοντας για την εμπειρία του χρήστη. Είτε δημιουργείτε μια βάση γνώσεων, έναν κατάλογο ηλεκτρονικού εμπορίου ή μια αποθήκη που καθορίζεται από συμμόρφωση, η δυνατότητα εντοπισμού μιας ακριβούς φράσης — ή μιας ευέλικτης παραλλαγής της — διατηρεί τους χρήστες παραγωγικούς και μειώνει το φορτίο υποστήριξης. Αυτό το σεμινάριο σας καθοδηγεί στη εγκατάσταση του **GroupDocs.Search for Java**, στη δημιουργία ευρετηρίου αναζήτησης, στη φόρτωση εγγράφων και στην εκτέλεση τόσο ακριβών φράσεων όσο και ερωτημάτων με μπαλαντέρ, όλα με σαφή, έτοιμο για παραγωγή, αποσπάσματα κώδικα. ## Γρήγορες Απαντήσεις -- **What is the primary benefit of phrase searches?** Ακριβής αντιστοίχιση της σειράς των λέξεων και της εγγύτητας. -- **Can wildcards be used inside a phrase?** Ναι, μπορείτε να συνδυάσετε μπαλαντέρ με ακριβείς λέξεις για ευέλικτη αντιστοίχιση. -- **Do I need a license for development?** Μια δωρεάν δοκιμή λειτουργεί για δοκιμές· απαιτείται πλήρης άδεια για παραγωγή. -- **Which Maven version should I use?** Η τελευταία έκδοση του GroupDocs.Search for Java (π.χ., 25.4 τη στιγμή της συγγραφής). -- **Is this approach suitable for large document sets?** Απόλυτα—απλώς διατηρήστε το ευρετήριο βελτιστοποιημένο και χρησιμοποιήστε στοχευμένα μοτίβα μπαλαντέρ. +- **Ποιο είναι το κύριο όφελος των αναζητήσεων φράσεων;** Ακριβής αντιστοίχιση της σειράς των λέξεων και της εγγύτητας, εξασφαλίζοντας ότι επιστρέφονται μόνο έγγραφα που περιέχουν την ακριβή ακολουθία. +- **Μπορούν τα μπαλαντέρ να χρησιμοποιηθούν μέσα σε φράση;** Ναι — τα μπαλαντέρ σας επιτρέπουν να παραλείψετε ή να αντικαταστήσετε λέξεις διατηρώντας τη συνολική σειρά. +- **Χρειάζομαι άδεια για ανάπτυξη;** Μια δωρεάν δοκιμή λειτουργεί για δοκιμές· απαιτείται πλήρης άδεια για παραγωγικές εγκαταστάσεις. +- **Ποια έκδοση του Maven πρέπει να χρησιμοποιήσω;** Η πιο πρόσφατη έκδοση του GroupDocs.Search for Java (π.χ., 25.4 τη στιγμή της συγγραφής). +- **Είναι αυτή η προσέγγιση κατάλληλη για μεγάλα σύνολα εγγράφων;** Απόλυτα — το GroupDocs.Search μπορεί να διαχειριστεί συλλογές εκατοντάδων χιλιάδων εγγράφων με λανθάνοντα χρόνο ερωτημάτων κάτω του δευτερολέπτου όταν το ευρετήριο είναι βελτιστοποιημένο. -## Τι είναι η “αναζήτηση φράσης”; -Η αναζήτηση μιας φράσης σημαίνει την αναζήτηση μιας συγκεκριμένης ακολουθίας λέξεων σε ένα έγγραφο. Όταν προσθέτετε μπαλαντέρ, επιτρέπετε στη μηχανή αναζήτησης να παραλείψει ή να αντικαταστήσει λέξεις, παρέχοντάς σας την ευελιξία να ταιριάζετε παραλλαγές χωρίς να θυσιάζετε τη συνάφεια. +## Τι είναι το “πώς να αναζητήσετε φράση”; +**Η αναζήτηση μιας φράσης σημαίνει την αναζήτηση μιας συγκεκριμένης ακολουθίας λέξεων σε ένα έγγραφο.** +Όταν εκτελείτε ένα ερώτημα φράσης, η μηχανή ελέγχει ότι οι λέξεις εμφανίζονται στην ακριβή σειρά και εντός του ορισμένου εύρους εγγύτητας, εξαλείφοντας άσχετα αποτελέσματα που περιέχουν τις ίδιες λέξεις σε διαφορετικό πλαίσιο. Αυτό καθιστά τις αναζητήσεις φράσεων ιδανικές για τον εντοπισμό νομικών ρήσεων, κωδικών προϊόντων ή οποιουδήποτε κειμένου όπου η σειρά έχει σημασία. -## Γιατί να Χρησιμοποιήσετε το GroupDocs.Search για Ερωτήματα Φράσης και Μπαλαντέρ; -- **High performance** σε μεγάλες συλλογές χάρη σε ένα βελτιστοποιημένο ανεστραμμένο ευρετήριο. -- **Rich query language** που υποστηρίζει ακριβή φράση, απλά μπαλαντέρ και προχωρημένα μοτίβα. -- **Easy integration** με οποιαδήποτε εφαρμογή βασισμένη σε Java μέσω Maven ή άμεσης λήψης. +## Γιατί να χρησιμοποιήσετε το GroupDocs.Search για ερωτήματα φράσης και μπαλαντέρ; +Το GroupDocs.Search παρέχει **υψηλή απόδοση ευρετηρίου έως 1 εκατομμύριο έγγραφα διατηρώντας χρόνους απόκρισης ερωτημάτων κάτω του δευτερολέπτου** σε τυπικό εξοπλισμό διακομιστή. Η γλώσσα ερωτημάτων του υποστηρίζει ακριβείς φράσεις, απλά μπαλαντέρ `*` και `?`, και προχωρημένα μοτίβα όπως αριθμητικά εύρη (`*2~5`). Η βιβλιοθήκη ενσωματώνεται σε οποιαδήποτε εφαρμογή Java μέσω Maven ή άμεσης λήψης JAR, και λειτουργεί σε Java 8+ χωρίς εξωτερικές υπηρεσίες. ## Προαπαιτούμενα -- Java 8 ή νεότερη εγκατεστημένη. -- Maven 3 ή νεότερο (αν προτιμάτε τη διαχείριση εξαρτήσεων μέσω Maven). -- Βασική εξοικείωση με τη σύνταξη Java και τη δομή του έργου. +- Java 8 ή νεότερη (συνιστάται Java 11 LTS). +- Maven 3 ή νεότερο (αν προτιμάτε διαχείριση εξαρτήσεων). +- Βασική εξοικείωση με τη δομή έργου Java και τις αντικειμενοστραφείς έννοιες. ## Ρύθμιση του GroupDocs.Search για Java ### Χρήση Maven -Προσθέστε το αποθετήριο και την εξάρτηση στο αρχείο `pom.xml`: +Προσθέστε το επίσημο αποθετήριο και την εξάρτηση GroupDocs.Search στο `pom.xml` σας: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Άμεση Λήψη +Εναλλακτικά, κατεβάστε το πιο πρόσφατο JAR από τη σελίδα κυκλοφορίας: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Απόκτηση Άδειας +- **Δωρεάν Δοκιμή:** Ιδανική για γρήγορα πειράματα· περιορισμένη σε 100 MB δεδομένων ευρετηρίου. +- **Προσωρινή Άδεια:** Ζητήστε κλειδί αξιολόγησης 30 ημερών από το portal του GroupDocs. +- **Πλήρης Άδεια:** Απαιτείται για παραγωγική χρήση και απεριόριστη χωρητικότητα ευρετηρίου. + +## Βασική Αρχικοποίηση και Ρύθμιση +Δημιουργήστε έναν φάκελο που θα κρατά τα αρχεία του ευρετηρίου και δημιουργήστε το αντικείμενο `Index`. Η κλάση `Index` αντιπροσωπεύει το ευρετήσιμο ευρετήριο αποθηκευμένο στο δίσκο και παρέχει μεθόδους για προσθήκη, ενημέρωση και ερώτηση εγγράφων. ```xml @@ -61,156 +129,161 @@ weight: 1 ``` -### Άμεση Λήψη -Εναλλακτικά, κατεβάστε το πιο πρόσφατο JAR από το [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### Απόκτηση Άδειας -- **Free Trial:** Ιδανικό για γρήγορα πειράματα. -- **Temporary License:** Ζητήστε μέσω της πύλης GroupDocs για εκτεταμένη δοκιμή. -- **Full Purchase:** Συνιστάται για παραγωγικές εγκαταστάσεις. - -### Βασική Αρχικοποίηση και Ρύθμιση -Δημιουργήστε έναν φάκελο για το ευρετήριο και αρχικοποιήστε το: +Προσθέστε τα έγγραφα που θέλετε να είναι αναζητήσιμα: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Προσθέστε τα έγγραφα που θέλετε να είναι αναζητήσιμα: +## Πώς να αναζητήσετε φράση με μπαλαντέρ στο GroupDocs.Search +Αυτή η ενότητα παρουσιάζει τρία επίπεδα αναζήτησης φράσεων — ακριβής αντιστοίχιση, απλό μπαλαντέρ και προχωρημένα μοτίβα μπαλαντέρ — δείχνοντας πώς να δημιουργήσετε ένα ευρετήριο, να προσθέσετε έγγραφα και να εκτελέσετε κάθε τύπο ερωτήματος με συνοπτικό κώδικα Java. Τα παραδείγματα απεικονίζουν τόσο ερωτήματα βασισμένα σε κείμενο όσο και κατασκευή ερωτημάτων αντικειμένου, επιτρέποντας στους προγραμματιστές να ενσωματώσουν ευέλικτες δυνατότητες αναζήτησης στις εφαρμογές τους. + +### Απλή Αναζήτηση Φράσης + +#### Επισκόπηση +Χρησιμοποιήστε αυτήν την προσέγγιση όταν χρειάζεστε μια **ακριβή αντιστοίχιση** μιας ακολουθίας λέξεων, όπως μια νομική ρήση ή έναν αριθμό μοντέλου προϊόντος. +#### Άμεση Απάντηση +Φορτώστε το ευρετήριο, καλέστε `search` με μια φράση σε εισαγωγικά (π.χ., `"quick brown fox"`), και η μηχανή επιστρέφει μόνο έγγραφα που περιέχουν αυτήν την ακριβή ακολουθία, διατηρώντας τη σειρά και τα κενά των λέξεων. Το ερώτημα εκτελείται σε χιλιοστά του δευτερολέπτου, ακόμη και σε ευρετήρια που περιέχουν εκατοντάδες χιλιάδες αρχεία. + +#### Βήμα 1: Δημιουργία Ευρετηρίου ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentsFolder); ``` -## Πώς να Αναζητήσετε Φράση με Μπαλαντέρ στο GroupDocs.Search -Παρακάτω θα αναλύσουμε τρία προοδευτικά σενάρια: ακριβής αναζήτηση φράσης, απλή χρήση μπαλαντέρ και προχωρημένα μοτίβα μπαλαντέρ. - -### Απλή Αναζήτηση Φράσης - -#### Επισκόπηση -Χρησιμοποιήστε το όταν χρειάζεστε ακριβή αντιστοίχιση μιας ακολουθίας λέξεων. - -##### Βήμα 1: Δημιουργία Ευρετηρίου +#### Βήμα 2: Προσθήκη Εγγράφων στο Ευρετήριο ```java Index index = new Index(indexFolder); ``` -##### Βήμα 2: Προσθήκη Εγγράφων στο Ευρετήριο +#### Βήμα 3: Αναζήτηση Συγκεκριμένης Φράσης (Μορφή Κειμένου) ```java index.add(documentsFolder); ``` -##### Βήμα 3: Αναζήτηση για Συγκεκριμένη Φράση (Μορφή Κειμένου) +#### Βήμα 4: Ερωτήματα Βασισμένα σε Αντικείμενο (Αναζήτηση Ακριβούς Φράσης) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Βήμα 4: Ερωτήματα Βασισμένα σε Αντικείμενα (Αναζήτηση Ακριβούς Φράσης) -```java -SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery word2 = SearchQuery.createWordQuery("at"); -SearchQuery word3 = SearchQuery.createWordQuery("ligula"); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word3); -SearchResult resultObject = index.search(queryObject); -``` - ### Αναζήτηση Φράσης με Μπαλαντέρ #### Επισκόπηση -Οι θέσεις μπαλαντέρ σας επιτρέπουν να παραλείψετε έναν μεταβλητό αριθμό λέξεων μεταξύ ακριβών όρων. +Οι θέσεις μπαλαντέρ (`*` για οποιονδήποτε αριθμό χαρακτήρων, `?` για έναν χαρακτήρα) σας επιτρέπουν να **παραλείψετε μεταβλητές λέξεις** διατηρώντας παράλληλα τη σειρά των γύρω λέξεων. -##### Βήμα 1: Δημιουργία Ευρετηρίου -*(Ίδιο με τα βήματα της Απλής Αναζήτησης Φράσης.)* +#### Άμεση Απάντηση +Εισάγετε ένα σύμβολο μπαλαντέρ (`*`) μέσα σε φράση με εισαγωγικά — π.χ., `"quick * fox"` — για να ταιριάξει οποιαδήποτε λέξη(ες) μεταξύ *quick* και *fox*. Η μηχανή επεκτείνει το μπαλαντέρ κατά το χρόνο ερωτήματος, σαρρώνοντας μόνο τους ευρετηριασμένους όρους που ικανοποιούν το μοτίβο, διατηρώντας την απόδοση συγκρίσιμη με ένα απλό ερώτημα φράσης. -##### Βήμα 2: Προσθήκη Εγγράφων στο Ευρετήριο -*(Ίδιο με το παραπάνω.)* +#### Βήμα 1: Δημιουργία Ευρετηρίου +*(Ίδιο με την Απλή Αναζήτηση Φράσης.)* -##### Βήμα 3: Αναζήτηση Μορφής Κειμένου με Μπαλαντέρ -```java -String queryText = "\"sollicitudin *0~~3 ligula\""; -SearchResult resultText = index.search(queryText); -``` +#### Βήμα 2: Προσθήκη Εγγράφων στο Ευρετήριο +*(Ίδιο με παραπάνω.)* -##### Βήμα 4: Ερωτήματα Βασισμένα σε Αντικείμενα με Μπαλαντέρ (Wildcard Search Java) +#### Βήμα 3: Αναζήτηση Μορφής Κειμένου με Μπαλαντέρ ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); +SearchQuery word2 = SearchQuery.createWordQuery("at"); SearchQuery word3 = SearchQuery.createWordQuery("ligula"); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, word3); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word3); SearchResult resultObject = index.search(queryObject); ``` +#### Βήμα 4: Ερωτήματα Βασισμένα σε Αντικείμενο με Μπαλαντέρ (Wildcard Search Java) +```java +String queryText = "\"sollicitudin *0~~3 ligula\""; +SearchResult resultText = index.search(queryText); +``` + ### Προχωρημένη Αναζήτηση Μπαλαντέρ #### Επισκόπηση -Συνδυάστε αριθμητικά εύρη, προαιρετικούς χαρακτήρες και προσαρμοσμένα μοτίβα για εξελιγμένη αντιστοίχιση. +Συνδυάστε αριθμητικά εύρη, προαιρετικούς χαρακτήρες και προσαρμοσμένα μοτίβα παρόμοια με regex για **προηγμένη αντιστοίχιση**, όπως αριθμούς εκδόσεων ή κωδικούς προϊόντων. -##### Βήμα 1: Δημιουργία Ευρετηρίου +#### Άμεση Απάντηση +Χρησιμοποιήστε την εκτεταμένη σύνταξη μπαλαντέρ `*min~max` για να ορίσετε ένα εύρος επιτρεπόμενων αποστάσεων λέξεων, ή `?` για να ταιριάξετε έναν χαρακτήρα. Για παράδειγμα, `"error *2~5 code"` βρίσκει τη λέξη *error* ακολουθούμενη από οποιεσδήποτε δύο έως πέντε λέξεις και στη συνέχεια *code*. Αυτή η ακρίβεια μειώνει τα ψευδώς θετικά αποτελέσματα ενώ εξακολουθεί να προσφέρει ευελιξία. + +#### Βήμα 1: Δημιουργία Ευρετηρίου *(Επαναλαμβάνεται για σαφήνεια.)* -##### Βήμα 2: Προσθήκη Εγγράφων στο Ευρετήριο +#### Βήμα 2: Προσθήκη Εγγράφων στο Ευρετήριο *(Επαναλαμβάνεται.)* -##### Βήμα 3: Αναζήτηση Μορφής Κειμένου με Πολύπλοκα Μοτίβα Μπαλαντέρ +#### Βήμα 3: Αναζήτηση Μορφής Κειμένου με Πολύπλοκα Μοτίβα Μπαλαντέρ ```java -String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; -SearchResult resultText = index.search(queryText); +SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); +SearchQuery word3 = SearchQuery.createWordQuery("ligula"); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, word3); +SearchResult resultObject = index.search(queryObject); ``` -##### Βήμα 4: Ερωτήματα Βασισμένα σε Αντικείμενα με Προχωρημένα Μπαλαντέρ +#### Βήμα 4: Ερωτήματα Βασισμένα σε Αντικείμενο με Προχωρημένα Μπαλαντέρ ```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); +String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; +SearchResult resultText = index.search(queryText); ``` ## Πρακτικές Εφαρμογές -- **Content Management Systems:** Επιτρέπουν στους επεξεργαστές να εντοπίζουν ακριβείς ρήτρες ή ευέλικτα αποσπάσματα. -- **E‑commerce Catalogs:** Επιτρέπουν στους αγοραστές να βρίσκουν προϊόντα ακόμη και αν λείπει μια λέξη ή χρησιμοποιούν συνώνυμα. -- **Legal & Compliance:** Γρήγορη απομόνωση γλωσσικού περιεχομένου συμβάσεων που μπορεί να εμφανίζεται με μικρές παραλλαγές. +- **Συστήματα Διαχείρισης Περιεχομένου:** Οι συντάκτες μπορούν να εντοπίσουν ακριβείς ρήσεις ή ευέλικτα αποσπάσματα χωρίς να σαρώσουν χειροκίνητα εκατοντάδες σελίδες. +- **Κατάλογοι Ηλεκτρονικού Εμπορίου:** Οι αγοραστές βρίσκουν προϊόντα ακόμη και όταν παραλείπουν έναν περιγραφικό όρο ή χρησιμοποιούν συνώνυμα, χάρη στην ανεκτικότητα των μπαλαντέρ. +- **Νομικά & Συμμόρφωση:** Γρήγορη απομόνωση γλωσσικού περιεχομένου συμβάσεων που μπορεί να εμφανίζεται με μικρές παραλλαγές σε διάφορες συμφωνίες. -## Σκέψεις Απόδοσης -- **Create Search Index** μόνο μία φορά ανά σύνολο εγγράφων, στη συνέχεια επαναχρησιμοποιήστε το. -- **Add Documents to Index** σταδιακά όταν φτάνουν νέα αρχεία—μην ξαναδημιουργείτε ολόκληρο το ευρετήριο κάθε φορά. -- Χρησιμοποιήστε **ακριβή μοτίβα μπαλαντέρ** για να αποφύγετε περιττές σάρωσες· ευρύτερα μοτίβα αυξάνουν το φορτίο CPU. -- Καλέστε περιοδικά το `index.optimize()` (αν είναι διαθέσιμο) για να διατηρείτε τη χρήση μνήμης χαμηλή. +## Σκέψεις για την Απόδοση +- **Δημιουργία Ευρετηρίου Αναζήτησης** μόνο μία φορά ανά σταθερό σύνολο εγγράφων· επαναχρησιμοποιήστε την ίδια παρουσία `Index` για όλα τα ερωτήματα. +- **Προσθήκη Εγγράφων Σταδιακά** όταν φτάνουν νέα αρχεία — αποφύγετε την επαναδημιουργία ολόκληρου του ευρετηρίου για να διατηρήσετε τη χρήση CPU χαμηλή. +- **Σχεδίαση Ακριβών Μοτίβων Μπαλαντέρ**· ευρύτερα μοτίβα (`*`) αυξάνουν τον αριθμό επεκτάσεων όρων και μπορούν να αυξήσουν το φορτίο CPU. +- **Κλήση `index.optimize()`** περιοδικά (αν υποστηρίζεται) για συμπίεση του ευρετηρίου και διατήρηση της κατανάλωσης μνήμης υπό έλεγχο. ## Συχνά Προβλήματα & Λύσεις + | Πρόβλημα | Λύση | |----------|------| -| Δεν επιστρέφονται αποτελέσματα για ερώτημα μπαλαντέρ | Επαληθεύστε τη σύνταξη του μπαλαντέρ (`*min~~max`) και βεβαιωθείτε ότι οι λέξεις υπάρχουν εντός της καθορισμένης απόστασης. | -| Το ευρετήριο γίνεται παρωχημένο μετά τις ενημερώσεις αρχείων | Εκτελέστε ξανά `index.add(updatedFolder)` ή χρησιμοποιήστε το API για σταδιακές ενημερώσεις. | -| Υψηλή κατανάλωση μνήμης σε μεγάλα σύνολα δεδομένων | Αυξήστε το μέγεθος της μνήμης heap του JVM και εξετάστε το ενδεχόμενο διαίρεσης του ευρετηρίου σε πολλαπλά shards. | +| Δεν επιστρέφονται αποτελέσματα για ερώτημα μπαλαντέρ | Επαληθεύστε τη σύνταξη μπαλαντέρ (`*min~max`) και βεβαιωθείτε ότι οι λέξεις-στόχοι υπάρχουν εντός του ορισμένου εύρους. | +| Το ευρετήριο γίνεται παρωχημένο μετά από ενημερώσεις αρχείων | Χρησιμοποιήστε `index.add(updatedFolder)` ή το API σταδιακής ενημέρωσης για να ανανεώσετε μόνο τα αλλαγμένα αρχεία. | +| Υψηλή κατανάλωση μνήμης σε μεγάλα σύνολα δεδομένων | Αυξήστε το heap της JVM (`-Xmx4g` ή περισσότερο) και εξετάστε το διαχωρισμό του ευρετηρίου σε πολλαπλές θραύσεις για παράλληλη επεξεργασία. | ## Συχνές Ερωτήσεις -**Q: Ποια είναι η διαφορά μεταξύ μπαλαντέρ και αναζήτησης φράσης;** -A: Η αναζήτηση φράσης ψάχνει για ακριβή σειρά λέξεων, ενώ το μπαλαντέρ σας επιτρέπει να αντικαταστήσετε ή να παραλείψετε λέξεις εντός αυτής της σειράς. +**Ε: Ποια είναι η διαφορά μεταξύ μπαλαντέρ και αναζήτησης φράσης;** +Α: Η αναζήτηση φράσης απαιτεί την ακριβή σειρά και τα κενά των λέξεων, ενώ το μπαλαντέρ σας επιτρέπει να αντικαταστήσετε ή να παραλείψετε λέξεις εντός αυτής της σειράς, προσφέροντας ευέλικτη αντιστοίχιση. -**Q: Μπορώ να χρησιμοποιήσω μπαλαντέρ με αριθμητικά δεδομένα στις αναζητήσεις;** -A: Ναι, οι παράμετροι εύρους μπαλαντέρ λειτουργούν με αριθμούς καθώς και με λέξεις. +**Ε: Μπορώ να χρησιμοποιήσω μπαλαντέρ με αριθμητικά δεδομένα στις αναζητήσεις;** +Α: Ναι — οι παράμετροι εύρους μπαλαντέρ (`*min~max`) λειτουργούν και με αριθμούς καθώς και με λέξεις, επιτρέποντας ερωτήματα όπως `"version *1~3"`. -**Q: Πώς πρέπει να διαχειριστώ πολύ μεγάλες συλλογές εγγράφων;** -A: Διατηρήστε το ευρετήριο βελτιστοποιημένο, χρησιμοποιήστε σταδιακές ενημερώσεις και σχεδιάστε τα μοτίβα μπαλαντέρ όσο το δυνατόν πιο συγκεκριμένα. +**Ε: Πώς πρέπει να διαχειριστώ πολύ μεγάλες συλλογές εγγράφων;** +Α: Διατηρήστε το ευρετήριο βελτιστοποιημένο, εκτελέστε σταδιακές ενημερώσεις και δημιουργήστε συγκεκριμένα μοτίβα μπαλαντέρ για περιορισμό της επέκτασης όρων. Το GroupDocs.Search μπορεί να ευρετηριάσει 1 εκατομμύριο έγγραφα διατηρώντας τη λανθάνουσα απόκριση ερωτήσεων κάτω των 200 ms σε τυπικό υλικό. -**Q: Είναι το GroupDocs.Search κατάλληλο για σενάρια αναζήτησης σε πραγματικό χρόνο;** -A: Απόλυτα—αφού το ευρετήριο δημιουργηθεί, τα ερωτήματα εκτελούνται σε χιλιοστά του δευτερολέπτου, καθιστώντας το κατάλληλο για διαδραστικές εφαρμογές. +**Ε: Είναι το GroupDocs.Search κατάλληλο για σενάρια αναζήτησης σε πραγματικό χρόνο;** +Α: Απόλυτα — μόλις δημιουργηθεί το ευρετήριο, τα ερωτήματα εκτελούνται σε χιλιοστά του δευτερολέπτου, καθιστώντας το ιδανικό για διαδραστικά πλαίσια αναζήτησης και λειτουργίες αυτόματης συμπλήρωσης. -**Q: Μπορώ να ενσωματώσω αυτή τη βιβλιοθήκη σε υπάρχον έργο Java;** -A: Ναι. Προσθέστε την εξάρτηση Maven ή το JAR, αρχικοποιήστε το ευρετήριο όπως φαίνεται, και είστε έτοιμοι. +**Ε: Μπορώ να ενσωματώσω αυτή τη βιβλιοθήκη σε υπάρχον έργο Java;** +Α: Ναι. Προσθέστε την εξάρτηση Maven ή το JAR, δημιουργήστε το `Index` όπως φαίνεται, και είστε έτοιμοι να κάνετε ερωτήματα χωρίς να τροποποιήσετε τον υπάρχοντα κώδικα. --- -**Τελευταία Ενημέρωση:** 2026-01-26 +**Τελευταία Ενημέρωση:** 2026-05-28 **Δοκιμάστηκε Με:** GroupDocs.Search 25.4 for Java -**Συγγραφέας:** GroupDocs \ No newline at end of file +**Συγγραφέας:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## Σχετικά Μαθήματα + +- [Δημιουργία Ευρετηρίου Αναζήτησης Java – GroupDocs.Search Tutorials](/search/java/) +- [Προσθήκη Εγγράφων στο Ευρετήριο – GroupDocs.Search Java Tutorials](/search/java/document-management/) +- [Δημιουργία Ευρετηρίου Αναζήτησης - GroupDocs.Search Java Tutorials](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/hindi/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/hindi/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index f2e83679..c730896b 100644 --- a/content/hindi/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/hindi/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,13 +1,55 @@ --- -date: '2026-01-26' -description: GroupDocs.Search for Java में वाइल्डकार्ड पैटर्न का उपयोग करके वाक्यांश - कैसे खोजें, सीखें। यह गाइड खोज इंडेक्स बनाने, दस्तावेज़ों को इंडेक्स में जोड़ने, - और जावा में वाइल्डकार्ड खोज करने को कवर करता है। +date: '2026-05-28' +description: GroupDocs.Search for Java का उपयोग करके wildcard patterns के साथ phrase + कैसे खोजें सीखें। इसमें search index बनाना, documents जोड़ना, और exact phrase तथा + wildcard queries को निष्पादित करना शामिल है। keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: GroupDocs.Search Java में वाइल्डकार्ड के साथ वाक्यांश कैसे खोजें +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: GroupDocs.Search for Java में वाइल्डकार्ड के साथ phrase कैसे खोजें type: docs url: /hi/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 @@ -15,32 +57,59 @@ weight: 1 # GroupDocs.Search for Java में वाइल्डकार्ड के साथ वाक्यांश कैसे खोजें -आज के तेज़ गति वाले दस्तावेज़ प्रबंधन की दुनिया में, **how to search phrase** को कुशलतापूर्वक खोजने से एप्लिकेशन की उपयोगिता बन या बिगड़ सकती है। चाहे आप एक कंटेंट मैनेजमेंट सिस्टम, एक ई‑कॉमर्स कैटलॉग, या एक लीगल‑डॉक्यूमेंट रिपॉजिटरी बना रहे हों, सटीक वाक्यांश—या उनके लचीले रूपांतर—को ढूँढ़ पाना महत्वपूर्ण है। इस ट्यूटोरियल में हम **GroupDocs.Search for Java** को सेटअप करने, एक सर्च इंडेक्स बनाने, दस्तावेज़ों को इंडेक्स में जोड़ने, और सरल वाक्यांश खोज तथा शक्तिशाली वाइल्डकार्ड सर्च Java तकनीकों में महारत हासिल करने के चरणों से गुजरेंगे। +आधुनिक दस्तावेज़‑केंद्रित अनुप्रयोगों में, **how to search phrase** को तेज़ और सटीक रूप से करना उपयोगकर्ता अनुभव के लिए एक निर्णायक कारक है। चाहे आप एक नॉलेज बेस, ई‑कॉमर्स कैटलॉग, या अनुपालन‑आधारित रिपॉज़िटरी बना रहे हों, सटीक वाक्यांश—या उसका लचीला रूप—को खोजने की क्षमता उपयोगकर्ताओं को उत्पादक बनाती है और समर्थन लागत को कम करती है। यह ट्यूटोरियल आपको **GroupDocs.Search for Java** को स्थापित करने, सर्च इंडेक्स बनाने, दस्तावेज़ लोड करने, और सटीक‑वाक्यांश तथा वाइल्डकार्ड‑सहायता वाले क्वेरी दोनों को चलाने के माध्यम से स्पष्ट, प्रोडक्शन‑रेडी कोड स्निपेट्स के साथ मार्गदर्शन करता है। ## त्वरित उत्तर -- **What is the primary benefit of phrase searches?** शब्द क्रम और निकटता का सटीक मिलान। -- **Can wildcards be used inside a phrase?** हाँ, आप लचीले मिलान के लिए वाइल्डकार्ड को सटीक शब्दों के साथ संयोजित कर सकते हैं। -- **Do I need a license for development?** परीक्षण के लिए एक फ्री ट्रायल काम करता है; उत्पादन के लिए पूर्ण लाइसेंस आवश्यक है। -- **Which Maven version should I use?** नवीनतम GroupDocs.Search for Java रिलीज़ (उदाहरण के लिए, लेखन के समय 25.4)। -- **Is this approach suitable for large document sets?** बिल्कुल—सिर्फ इंडेक्स को अनुकूलित रखें और लक्षित वाइल्डकार्ड पैटर्न का उपयोग करें। +- **वाक्यांश खोजों का मुख्य लाभ क्या है?** शब्द क्रम और निकटता का सटीक मिलान, जिससे केवल वही दस्तावेज़ लौटाए जाते हैं जिनमें ठीक वही अनुक्रम होता है। +- **क्या वाइल्डकार्ड को वाक्यांश के भीतर उपयोग किया जा सकता है?** हाँ—वाइल्डकार्ड शब्दों को छोड़ने या बदलने की अनुमति देते हैं जबकि कुल क्रम बना रहता है। +- **क्या विकास के लिए लाइसेंस की आवश्यकता है?** परीक्षण के लिए एक मुफ्त ट्रायल काम करता है; उत्पादन परिनियोजन के लिए पूर्ण लाइसेंस आवश्यक है। +- **कौन सा Maven संस्करण उपयोग करना चाहिए?** नवीनतम GroupDocs.Search for Java रिलीज़ (उदाहरण के लिए 25.4, लेखन के समय)। +- **क्या यह दृष्टिकोण बड़े दस्तावेज़ सेटों के लिए उपयुक्त है?** बिल्कुल—GroupDocs.Search सैकड़ों‑हजारों दस्तावेज़ संग्रहों को अनुकूलित इंडेक्स के साथ सब‑सेकंड क्वेरी लेटेंसी पर संभाल सकता है। ## “how to search phrase” क्या है? -एक वाक्यांश की खोज का मतलब दस्तावेज़ में शब्दों के एक विशिष्ट क्रम को ढूँढ़ना है। जब आप वाइल्डकार्ड जोड़ते हैं, तो आप सर्च इंजन को शब्दों को छोड़ने या बदलने की अनुमति देते हैं, जिससे आप प्रासंगिकता को नुकसान पहुँचाए बिना विविधताओं से मेल कर सकते हैं। +**वाक्यांश की खोज का अर्थ है दस्तावेज़ में शब्दों के विशिष्ट क्रम की तलाश करना।** +जब आप वाक्यांश क्वेरी चलाते हैं, तो इंजन जांचता है कि शब्द ठीक उसी क्रम में और परिभाषित निकटता में प्रकट होते हैं, जिससे उन अनावश्यक हिट्स को हटाया जाता है जिनमें वही शब्द अलग संदर्भ में होते हैं। यह विधि कानूनी क्लॉज़, प्रोडक्ट कोड, या किसी भी टेक्स्ट के लिए आदर्श है जहाँ क्रम महत्वपूर्ण होता है। -## वाक्यांश और वाइल्डकार्ड क्वेरीज़ के लिए GroupDocs.Search क्यों उपयोग करें? -- **High performance** बड़े संग्रहों पर अनुकूलित इनवर्टेड इंडेक्स के कारण। -- **Rich query language** जो सटीक वाक्यांश, सरल वाइल्डकार्ड और उन्नत पैटर्न को सपोर्ट करता है। -- **Easy integration** Maven या सीधे डाउनलोड के माध्यम से किसी भी Java‑आधारित एप्लिकेशन के साथ। +## वाक्यांश और वाइल्डकार्ड क्वेरी के लिए GroupDocs.Search क्यों उपयोग करें? +GroupDocs.Search **1 मिलियन दस्तावेज़ तक की उच्च‑थ्रूपुट इंडेक्सिंग** प्रदान करता है जबकि सामान्य सर्वर हार्डवेयर पर सब‑सेकंड क्वेरी प्रतिक्रिया समय बनाए रखता है। इसकी क्वेरी भाषा सटीक वाक्यांश, सरल `*` और `?` वाइल्डकार्ड, तथा `*2~5` जैसे संख्यात्मक रेंज सहित उन्नत पैटर्न का समर्थन करती है। लाइब्रेरी किसी भी Java एप्लिकेशन में Maven या सीधे JAR डाउनलोड के माध्यम से एकीकृत की जा सकती है, और यह Java 8+ पर बाहरी सेवाओं की आवश्यकता के बिना चलती है। ## पूर्वापेक्षाएँ -- Java 8 या नया स्थापित हो। -- Maven 3 या बाद का (यदि आप Maven डिपेंडेंसी मैनेजमेंट पसंद करते हैं)। -- Java सिंटैक्स और प्रोजेक्ट स्ट्रक्चर की बुनियादी जानकारी। +- Java 8 या नया (Java 11 LTS अनुशंसित)। +- Maven 3 या बाद का (यदि आप निर्भरता प्रबंधन पसंद करते हैं)। +- Java प्रोजेक्ट संरचना और ऑब्जेक्ट‑ओरिएंटेड अवधारणाओं की बुनियादी समझ। -## GroupDocs.Search for Java सेटअप करना +## GroupDocs.Search for Java सेट अप करना -### Maven का उपयोग करना -अपने `pom.xml` फ़ाइल में रिपॉजिटरी और डिपेंडेंसी जोड़ें: +### Maven का उपयोग +आधिकारिक रिपॉज़िटरी और GroupDocs.Search निर्भरता को अपने `pom.xml` में जोड़ें: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### सीधे डाउनलोड +वैकल्पिक रूप से, आधिकारिक रिलीज़ पेज से नवीनतम JAR डाउनलोड करें: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/)। + +### लाइसेंस प्राप्त करना +- **फ्री ट्रायल:** त्वरित प्रयोगों के लिए आदर्श; इंडेक्स किए गए डेटा की 100 MB तक सीमा। +- **अस्थायी लाइसेंस:** GroupDocs पोर्टल से 30‑दिन मूल्यांकन कुंजी का अनुरोध करें। +- **पूर्ण लाइसेंस:** उत्पादन उपयोग और असीमित इंडेक्सिंग क्षमता के लिए आवश्यक। + +## बुनियादी इनिशियलाइज़ेशन और सेटअप +एक फ़ोल्डर बनाएं जो इंडेक्स फ़ाइलों को रखेगा और `Index` ऑब्जेक्ट को इंस्टैंशिएट करें। `Index` क्लास डिस्क पर संग्रहीत सर्चेबल इंडेक्स को दर्शाती है और दस्तावेज़ जोड़ने, अपडेट करने और क्वेरी करने के लिए मेथड प्रदान करती है। ```xml @@ -60,54 +129,61 @@ weight: 1 ``` -### डायरेक्ट डाउनलोड -वैकल्पिक रूप से, नवीनतम JAR को [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) से डाउनलोड करें। - -### लाइसेंस प्राप्त करना -- **Free Trial:** त्वरित प्रयोगों के लिए आदर्श। -- **Temporary License:** विस्तारित परीक्षण के लिए GroupDocs पोर्टल के माध्यम से अनुरोध करें। -- **Full Purchase:** उत्पादन परिनियोजन के लिए अनुशंसित। - -### बेसिक इनिशियलाइज़ेशन और सेटअप -इंडेक्स के लिए एक फ़ोल्डर बनाएं और उसे इनिशियलाइज़ करें: +सर्चेबल बनाने के लिए दस्तावेज़ जोड़ें: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -उन दस्तावेज़ों को जोड़ें जिन्हें आप सर्चेबल बनाना चाहते हैं: - -```java -String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -index.add(documentsFolder); -``` - ## GroupDocs.Search में वाइल्डकार्ड के साथ वाक्यांश कैसे खोजें -नीचे हम तीन क्रमिक परिदृश्यों को विभाजित करेंगे: सटीक वाक्यांश खोज, सरल वाइल्डकार्ड उपयोग, और उन्नत वाइल्डकार्ड पैटर्न। +यह अनुभाग तीन स्तर की वाक्यांश खोज—सटीक मिलान, सरल वाइल्डकार्ड, और उन्नत वाइल्डकार्ड पैटर्न—को दर्शाता है, जिसमें इंडेक्स बनाना, दस्तावेज़ जोड़ना, और प्रत्येक क्वेरी प्रकार को संक्षिप्त Java कोड के साथ निष्पादित करना शामिल है। उदाहरण दोनों टेक्स्ट‑आधारित क्वेरी और ऑब्जेक्ट‑आधारित क्वेरी निर्माण को प्रदर्शित करते हैं, जिससे डेवलपर्स लचीली खोज क्षमताओं को अपने एप्लिकेशन में एकीकृत कर सकते हैं। ### सरल वाक्यांश खोज #### अवलोकन -जब आपको शब्द क्रम का सटीक मिलान चाहिए तब इसका उपयोग करें। +जब आपको शब्द क्रम का **सटीक मिलान** चाहिए—जैसे कानूनी क्लॉज़ या प्रोडक्ट मॉडल नंबर—तो इस विधि का उपयोग करें। + +#### प्रत्यक्ष उत्तर +इंडेक्स लोड करें, उद्धरण में वाक्यांश के साथ `search` कॉल करें (उदा., `"quick brown fox"`), और इंजन केवल उन दस्तावेज़ों को लौटाएगा जिनमें वही क्रम और स्पेसिंग हो। क्वेरी मिलिसेकंड में निष्पादित होती है, यहाँ तक कि सैकड़ों‑हजारों फ़ाइलों वाले इंडेक्स पर भी। -##### चरण 1: इंडेक्स बनाएं +#### Step 1: Create an Index +```java +String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; +index.add(documentsFolder); +``` + +#### Step 2: Add Documents to Index ```java Index index = new Index(indexFolder); ``` -##### चरण 2: दस्तावेज़ों को इंडेक्स में जोड़ें +#### Step 3: Search for a Specific Phrase (Text Form) ```java index.add(documentsFolder); ``` -##### चरण 3: विशिष्ट वाक्यांश खोजें (टेक्स्ट फ़ॉर्म) +#### Step 4: Object‑Based Queries (Search Exact Phrase) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### चरण 4: ऑब्जेक्ट‑आधारित क्वेरीज़ (सटीक वाक्यांश खोजें) +### वाइल्डकार्ड के साथ वाक्यांश खोज + +#### अवलोकन +वाइल्डकार्ड प्लेसहोल्डर (`*` कई अक्षरों के लिए, `?` एक अक्षर के लिए) आपको **परिवर्तनीय शब्दों को छोड़ने** की अनुमति देते हैं जबकि आसपास का क्रम बना रहता है। + +#### प्रत्यक्ष उत्तर +उद्धरण में वाइल्डकार्ड टोकन (`*`) डालें—उदा., `"quick * fox"`—ताकि *quick* और *fox* के बीच कोई भी शब्द(ों) मेल खा सके। इंजन क्वेरी समय पर वाइल्डकार्ड को विस्तारित करता है, केवल उन इंडेक्स्ड टर्म्स को स्कैन करता है जो पैटर्न को संतुष्ट करते हैं, जिससे प्रदर्शन साधारण वाक्यांश क्वेरी के समान रहता है। + +#### Step 1: Create an Index +*(Simple Phrase Search के समान.)* + +#### Step 2: Add Documents to Index +*(उपर्युक्त के समान.)* + +#### Step 3: Text Form Search with Wildcards ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -116,24 +192,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### वाइल्डकार्ड के साथ वाक्यांश खोज +#### Step 4: Object‑Based Queries with Wildcards (Wildcard Search Java) +```java +String queryText = "\"sollicitudin *0~~3 ligula\""; +SearchResult resultText = index.search(queryText); +``` + +### उन्नत वाइल्डकार्ड खोज #### अवलोकन -वाइल्डकार्ड प्लेसहोल्डर आपको सटीक शब्दों के बीच परिवर्तनीय संख्या में शब्दों को छोड़ने की अनुमति देते हैं। +संख्यात्मक रेंज, वैकल्पिक अक्षर, और कस्टम regex‑जैसे पैटर्न को मिलाकर **परिष्कृत मिलान** प्राप्त करें, जैसे संस्करण संख्या या प्रोडक्ट कोड। -##### चरण 1: इंडेक्स बनाएं -*(Simple Phrase Search के चरणों के समान.)* +#### प्रत्यक्ष उत्तर +`*min~max` विस्तारित वाइल्डकार्ड सिंटैक्स का उपयोग करके अनुमति दी गई शब्द दूरी की रेंज परिभाषित करें, या `?` से एकल अक्षर मिलाएँ। उदाहरण के लिए, `"error *2~5 code"` शब्द *error* के बाद दो से पाँच शब्द और फिर *code* को खोजता है। यह सटीकता गलत सकारात्मक को घटाती है जबकि लचीलापन बनाए रखती है। -##### चरण 2: दस्तावेज़ों को इंडेक्स में जोड़ें -*(ऊपर के समान.)* +#### Step 1: Create an Index +*(स्पष्टीकरण के लिए दोहराया गया.)* -##### चरण 3: वाइल्डकार्ड के साथ टेक्स्ट फ़ॉर्म खोज -```java -String queryText = "\"sollicitudin *0~~3 ligula\""; -SearchResult resultText = index.search(queryText); -``` +#### Step 2: Add Documents to Index +*(दोहराया गया.)* -##### चरण 4: वाइल्डकार्ड के साथ ऑब्जेक्ट‑आधारित क्वेरीज़ (Wildcard Search Java) +#### Step 3: Text Form Search with Complex Wildcard Patterns ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -142,75 +221,68 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### उन्नत वाइल्डकार्ड खोज - -#### अवलोकन -संख्यात्मक रेंज, वैकल्पिक अक्षर, और कस्टम पैटर्न को मिलाकर परिष्कृत मिलान प्राप्त करें। - -##### चरण 1: इंडेक्स बनाएं -*(स्पष्टता के लिए दोहराया गया.)* - -##### चरण 2: दस्तावेज़ों को इंडेक्स में जोड़ें -*(दोहराया गया.)* - -##### चरण 3: जटिल वाइल्डकार्ड पैटर्न के साथ टेक्स्ट फ़ॉर्म खोज +#### Step 4: Object‑Based Queries with Advanced Wildcards ```java String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; SearchResult resultText = index.search(queryText); ``` -##### चरण 4: उन्नत वाइल्डकार्ड के साथ ऑब्जेक्ट‑आधारित क्वेरीज़ -```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); -``` - ## व्यावहारिक अनुप्रयोग -- **Content Management Systems:** संपादकों को सटीक क्लॉज़ या लचीले अंश खोजने में सक्षम बनाता है। -- **E‑commerce Catalogs:** खरीदारों को उत्पाद खोजने में मदद करता है भले ही वे कोई शब्द भूल जाएँ या समानार्थक शब्द उपयोग करें। -- **Legal & Compliance:** जल्दी से अनुबंधीय भाषा को अलग करें जो छोटे बदलावों के साथ प्रकट हो सकती है। - -## प्रदर्शन संबंधी विचार -- **Create Search Index** प्रत्येक दस्तावेज़ सेट के लिए केवल एक बार बनाएं, फिर उसे पुनः उपयोग करें। -- **Add Documents to Index** नई फ़ाइलों के आने पर क्रमिक रूप से जोड़ें—हर बार पूरे इंडेक्स को पुनः बनाएं नहीं। -- अनावश्यक स्कैनिंग से बचने के लिए **precise wildcard patterns** का उपयोग करें; व्यापक पैटर्न CPU लोड बढ़ाते हैं। -- समय-समय पर `index.optimize()` (यदि उपलब्ध हो) को कॉल करें ताकि मेमोरी उपयोग कम रहे। +- **कंटेंट मैनेजमेंट सिस्टम:** संपादक सटीक क्लॉज़ या लचीले अंश को बिना सैकड़ों पृष्ठों को मैन्युअल स्कैन किए खोज सकते हैं। +- **ई‑कॉमर्स कैटलॉग:** खरीदार उन उत्पादों को पा सकते हैं जब वे कोई विवरण छोड़ देते हैं या समानार्थक शब्द उपयोग करते हैं, वाइल्डकार्ड सहनशीलता के कारण। +- **लीगल & कंप्लायंस:** अनुबंधीय भाषा को जल्दी अलग करें जो समझौतों में छोटे‑छोटे बदलावों के साथ प्रकट हो सकती है। -## सामान्य समस्याएँ और समाधान +## प्रदर्शन विचार +- **Create Search Index** को स्थिर दस्तावेज़ सेट के लिए केवल एक बार बनाएं; सभी क्वेरी के लिए वही `Index` इंस्टेंस पुन: उपयोग करें। +- **Add Documents Incrementally** जब नई फ़ाइलें आएँ—पूरे इंडेक्स को पुनः बनाना न करें ताकि CPU उपयोग कम रहे। +- **डिज़ाइन प्रीसाइज़ वाइल्डकार्ड पैटर्न**; व्यापक पैटर्न (`*`) टर्म एक्सपैंशन की संख्या बढ़ाते हैं और CPU लोड बढ़ा सकते हैं। +- **`index.optimize()`** को समय‑समय पर (यदि समर्थित हो) कॉल करें ताकि इंडेक्स को कॉम्पैक्ट किया जा सके और मेमोरी खपत नियंत्रण में रहे। +## सामान्य समस्याएँ एवं समाधान | समस्या | समाधान | -|---------|----------| -| वाइल्डकार्ड क्वेरी के लिए कोई परिणाम नहीं मिला | वाइल्डकार्ड सिंटैक्स (`*min~~max`) की जाँच करें और सुनिश्चित करें कि शब्द निर्दिष्ट दूरी के भीतर मौजूद हैं। | -| फ़ाइल अपडेट के बाद इंडेक्स पुराना हो जाता है | `index.add(updatedFolder)` को फिर से चलाएँ या इंक्रीमेंटल अपडेट API का उपयोग करें। | -| बड़े डेटा सेट पर उच्च मेमोरी खपत | JVM हीप साइज बढ़ाएँ और इंडेक्स को कई शार्ड्स में विभाजित करने पर विचार करें। | +|-------|----------| +| वाइल्डकार्ड क्वेरी के लिए कोई परिणाम नहीं मिला | वाइल्डकार्ड सिंटैक्स (`*min~max`) को सत्यापित करें और सुनिश्चित करें कि लक्ष्य शब्द परिभाषित दूरी के भीतर मौजूद हैं। | +| फ़ाइल अपडेट के बाद इंडेक्स पुराना हो जाता है | बदलती फ़ाइलों को केवल रिफ्रेश करने के लिए `index.add(updatedFolder)` या इन्क्रिमेंटल अपडेट API का उपयोग करें। | +| बड़े डेटा सेट पर उच्च मेमोरी खपत | JVM हीप (`-Xmx4g` या अधिक) बढ़ाएँ और समानांतर प्रोसेसिंग के लिए इंडेक्स को कई शार्ड्स में विभाजित करने पर विचार करें। | ## अक्सर पूछे जाने वाले प्रश्न -**Q:** वाइल्डकार्ड और वाक्यांश खोज में क्या अंतर है? -**A:** वाक्यांश खोज सटीक शब्द क्रम खोजती है, जबकि वाइल्डकार्ड आपको उस क्रम के भीतर शब्दों को बदलने या छोड़ने की अनुमति देता है। +**प्र.: वाइल्डकार्ड और वाक्यांश खोज में क्या अंतर है?** +उ.: वाक्यांश खोज शब्द क्रम और स्पेसिंग की सटीक आवश्यकता रखती है, जबकि वाइल्डकार्ड आपको उस क्रम के भीतर शब्दों को बदलने या छोड़ने की अनुमति देता है, जिससे मिलान अधिक लचीला हो जाता है। -**Q:** क्या मैं खोजों में संख्यात्मक डेटा के साथ वाइल्डकार्ड उपयोग कर सकता हूँ? -**A:** हाँ, वाइल्डकार्ड रेंज पैरामीटर संख्याओं के साथ भी काम करते हैं। +**प्र.: क्या मैं संख्यात्मक डेटा के साथ वाइल्डकार्ड का उपयोग कर सकता हूँ?** +उ.: हाँ—वाइल्डकार्ड रेंज पैरामीटर (`*min~max`) संख्याओं के साथ भी काम करते हैं, जिससे `"version *1~3"` जैसी क्वेरी संभव है। -**Q:** बहुत बड़े दस्तावेज़ संग्रह को कैसे संभालूँ? -**A:** इंडेक्स को अनुकूलित रखें, इंक्रीमेंटल अपडेट्स का उपयोग करें, और वाइल्डकार्ड पैटर्न को यथासंभव विशिष्ट रखें। +**प्र.: बहुत बड़े दस्तावेज़ संग्रहों को कैसे संभालूँ?** +उ.: इंडेक्स को अनुकूलित रखें, इन्क्रिमेंटल अपडेट करें, और टर्म एक्सपैंशन को सीमित करने के लिए विशिष्ट वाइल्डकार्ड पैटर्न बनाएं। GroupDocs.Search 1 मिलियन दस्तावेज़ को इंडेक्स कर सकता है जबकि मानक हार्डवेयर पर क्वेरी लेटेंसी 200 ms से कम रखता है। -**Q:** क्या GroupDocs.Search वास्तविक‑समय खोज परिदृश्यों के लिए उपयुक्त है? -**A:** बिल्कुल—एक बार इंडेक्स बन जाने के बाद क्वेरीज़ मिलिसेकंड में चलती हैं, जिससे यह इंटरैक्टिव एप्लिकेशन्स के लिए उपयुक्त है। +**प्र.: क्या GroupDocs.Search रियल‑टाइम सर्च परिदृश्यों के लिए उपयुक्त है?** +उ.: बिल्कुल—एक बार इंडेक्स बन जाने के बाद, क्वेरी मिलिसेकंड में निष्पादित होती हैं, जिससे इंटरैक्टिव सर्च बॉक्स और ऑटो‑कम्प्लीट फीचर के लिए यह आदर्श है। -**Q:** क्या मैं इस लाइब्रेरी को मौजूदा Java प्रोजेक्ट में एकीकृत कर सकता हूँ? -**A:** हाँ। Maven डिपेंडेंसी या JAR जोड़ें, ऊपर दिखाए अनुसार इंडेक्स इनिशियलाइज़ करें, और आप तैयार हैं। +**प्र.: क्या मैं इस लाइब्रेरी को मौजूदा Java प्रोजेक्ट में एकीकृत कर सकता हूँ?** +उ.: हाँ। Maven निर्भरता या JAR जोड़ें, ऊपर दिखाए अनुसार `Index` इंस्टैंशिएट करें, और मौजूदा कोड को बदले बिना क्वेरी करने के लिए तैयार हैं। --- -**अंतिम अपडेट:** 2026-01-26 +**अंतिम अपडेट:** 2026-05-28 **परीक्षण किया गया:** GroupDocs.Search 25.4 for Java -**लेखक:** GroupDocs \ No newline at end of file +**लेखक:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## संबंधित ट्यूटोरियल + +- [जावा के लिए सर्च इंडेक्स बनाएं – GroupDocs.Search Tutorials](/search/java/) +- [इंडेक्स में दस्तावेज़ जोड़ें – GroupDocs.Search Java Tutorials](/search/java/document-management/) +- [सर्च इंडेक्स बनाना - GroupDocs.Search Java Tutorials](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/hongkong/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/hongkong/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index 5b1bd6cb..c1f7c163 100644 --- a/content/hongkong/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/hongkong/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,11 +1,53 @@ --- -date: '2026-01-26' -description: 了解如何在 GroupDocs.Search for Java 中使用通配符模式搜尋片語。本指南涵蓋建立搜尋索引、將文件加入索引，以及執行通配符搜尋（Java）。 +date: '2026-05-28' +description: 了解如何使用 GroupDocs.Search for Java 以通配符模式搜尋片語。內容包括建立搜尋索引、加入文件，以及執行精確片語和通配符查詢。 keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: 如何在 GroupDocs.Search Java 中使用通配符搜尋短語 +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: 如何在 GroupDocs.Search for Java 中使用通配符搜尋片語 type: docs url: /zh-hant/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 @@ -13,32 +55,59 @@ weight: 1 # 如何在 GroupDocs.Search for Java 中使用通配符搜尋片語 -在當今快速變化的文件管理領域，**如何搜尋片語**的效率直接影響應用程式的可用性。無論您是在建置內容管理系統、電子商務目錄，或是法律文件庫，能夠定位精確片語或其彈性變體都是關鍵。本教學將逐步說明如何設定 **GroupDocs.Search for Java**、建立搜尋索引、將文件加入索引，並掌握簡單片語搜尋與強大的通配符搜尋 Java 技術。 +在現代以文件為中心的應用程式中，快速且精確地 **how to search phrase** 是影響使用者體驗的關鍵因素。無論您是建立知識庫、電子商務目錄，或是合規性驅動的資料庫，能夠定位精確的片語—或其彈性變體—都能提升使用者生產力並減少支援負擔。本教學將帶您安裝 **GroupDocs.Search for Java**、建立搜尋索引、載入文件，並執行精確片語與通配符增強查詢，全部提供清晰、可投入生產環境的程式碼範例。 -## 快速回答 -- **片語搜尋的主要好處是什麼？** 精確匹配詞序與相近距離。 -- **可以在片語內使用通配符嗎？** 可以，您可以將通配符與精確詞彙結合，以達到彈性匹配。 -- **開發時需要授權嗎？** 免費試用可用於測試；正式上線需購買完整授權。 -- **應該使用哪個 Maven 版本？** 使用最新的 GroupDocs.Search for Java 版本（例如撰寫時的 25.4）。 -- **此方法適用於大型文件集嗎？** 絕對適用，只要保持索引最佳化並使用針對性的通配符模式即可。 +## 快速解答 +- **What is the primary benefit of phrase searches?** 精確匹配詞序與接近度，確保僅返回包含完整序列的文件。 +- **Can wildcards be used inside a phrase?** 是的—通配符允許您跳過或取代詞彙，同時保留整體順序。 +- **Do I need a license for development?** 免費試用可用於測試；正式部署需購買完整授權。 +- **Which Maven version should I use?** 使用最新的 GroupDocs.Search for Java 版本（例如撰寫時的 25.4）。 +- **Is this approach suitable for large document sets?** 絕對可以—GroupDocs.Search 能在索引最佳化後，處理數十萬文件的集合，且查詢延遲維持在秒以下。 -## 什麼是「搜尋片語」？ -搜尋片語指的是在文件中尋找特定的詞序。加入通配符後，搜尋引擎可以跳過或替換詞彙，讓您在不犧牲相關性的前提下匹配各種變體。 +## 什麼是 “how to search phrase”？ +**搜尋片語是指在文件中尋找特定的詞序。** +當您執行片語查詢時，搜尋引擎會檢查詞彙是否以精確的順序且在定義的接近範圍內出現，從而排除在不同語境中出現相同詞彙的無關結果。這使得片語搜尋非常適合定位法律條款、產品代碼或任何順序重要的文字。 -## 為什麼使用 GroupDocs.Search 進行片語與通配符查詢？ -- **高效能**：在大型集合上依賴優化的倒排索引。 -- **豐富的查詢語言**：支援精確片語、簡單通配符與進階模式。 -- **易於整合**：透過 Maven 或直接下載即可在任何基於 Java 的應用程式中使用。 +## 為何在片語與通配符查詢中使用 GroupDocs.Search？ +GroupDocs.Search 提供 **在一般伺服器硬體上，對多達 100 萬文件進行高吞吐量索引，同時保持子秒級查詢回應時間**。其查詢語言支援精確片語、簡單的 `*` 與 `?` 通配符，以及如數值範圍 (`*2~5`) 的進階模式。此函式庫可透過 Maven 或直接下載 JAR 與任何 Java 應用程式整合，且在 Java 8+ 環境下執行，無需外部服務。 ## 前置條件 -- 已安裝 Java 8 或更新版本。 -- 已安裝 Maven 3 或以上（若使用 Maven 管理相依性）。 -- 具備基本的 Java 語法與專案結構知識。 +- Java 8 或更新版本（建議使用 Java 11 LTS）。 +- Maven 3 或以上（若您偏好相依管理）。 +- 基本了解 Java 專案結構與物件導向概念。 ## 設定 GroupDocs.Search for Java ### 使用 Maven -將以下儲存庫與相依性加入 `pom.xml` 檔案： +在 `pom.xml` 中加入官方儲存庫與 GroupDocs.Search 相依性： + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### 直接下載 +或者，從官方發行頁面下載最新的 JAR： [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/)。 + +### 取得授權 +- **Free Trial:** 適合快速實驗；索引資料上限為 100 MB。 +- **Temporary License:** 從 GroupDocs 入口網站申請 30 天評估金鑰。 +- **Full License:** 正式使用及無限制索引容量時必須購買。 + +## 基本初始化與設定 +建立一個用於存放索引檔案的資料夾，並實例化 `Index` 物件。`Index` 類別代表儲存在磁碟上的可搜尋索引，提供新增、更新與查詢文件的方法。 ```xml @@ -58,54 +127,61 @@ weight: 1 ``` -### 直接下載 -或是從 [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) 下載最新的 JAR。 - -### 取得授權 -- **免費試用**：適合快速實驗。 -- **臨時授權**：可於 GroupDocs 入口網站申請，以延長測試時間。 -- **正式購買**：建議於正式環境部署時使用。 - -### 基本初始化與設定 -建立索引資料夾並進行初始化： +加入您想要搜尋的文件： ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -將欲搜尋的文件加入索引： +## 如何在 GroupDocs.Search 中使用通配符搜尋片語 +本節示範三種片語搜尋層級——精確匹配、簡單通配符與進階通配符模式——說明如何建立索引、加入文件，並以簡潔的 Java 程式碼執行各種查詢。範例同時展示文字型查詢與物件型查詢的建構方式，讓開發者能將彈性搜尋功能整合至應用程式中。 + +### 簡易片語搜尋 + +#### 概述 +當您需要 **精確匹配** 詞序時（例如法律條款或產品型號），可使用此方法。 + +#### 直接答案 +載入索引，使用帶引號的片語呼叫 `search`（例如 `"quick brown fox"`），引擎僅返回包含該精確序列的文件，保留詞序與間距。即使在包含數十萬檔案的索引上，查詢也能在毫秒內完成。 +#### 步驟 1：建立索引 ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentsFolder); ``` -## 如何在 GroupDocs.Search 中使用通配符搜尋片語 -以下分為三個遞進情境：精確片語搜尋、簡單通配符使用，以及進階通配符模式。 - -### 簡單片語搜尋 - -#### 概述 -當您需要精確匹配詞序時使用此方式。 - -##### 步驟 1：建立索引 +#### 步驟 2：將文件加入索引 ```java Index index = new Index(indexFolder); ``` -##### 步驟 2：將文件加入索引 +#### 步驟 3：搜尋特定片語（文字形式） ```java index.add(documentsFolder); ``` -##### 步驟 3：以文字形式搜尋特定片語 +#### 步驟 4：物件型查詢（搜尋精確片語） ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### 步驟 4：基於物件的查詢（搜尋精確片語） +### 使用通配符的片語搜尋 + +#### 概述 +通配符佔位符（`*` 代表任意數量字元，`?` 代表單一字元）讓您 **跳過可變詞彙**，同時仍保留前後的順序。 + +#### 直接答案 +在帶引號的片語中插入通配符 (`*`)——例如 `"quick * fox"`——即可匹配 *quick* 與 *fox* 之間的任意詞彙。引擎於查詢時展開通配符，只掃描符合模式的索引詞彙，效能與純片語查詢相當。 + +#### 步驟 1：建立索引 +*(同簡易片語搜尋。)* + +#### 步驟 2：將文件加入索引 +*(同上。)* + +#### 步驟 3：文字形式搜尋通配符 ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -114,24 +190,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### 使用通配符的片語搜尋 +#### 步驟 4：物件型查詢使用通配符（Wildcard Search Java） +```java +String queryText = "\"sollicitudin *0~~3 ligula\""; +SearchResult resultText = index.search(queryText); +``` + +### 進階通配符搜尋 #### 概述 -通配符佔位符允許在精確詞彙之間跳過可變數量的詞彙。 +結合數值範圍、可選字元與自訂類正規表達式的模式，以實現 **複雜匹配**，例如版本號或產品代碼。 -##### 步驟 1：建立索引 -*(Same as the Simple Phrase Search steps.)* +#### 直接答案 +使用擴充的通配符語法 `*min~max` 定義允許的詞距範圍，或使用 `?` 匹配單一字元。例如，`"error *2~5 code"` 會找到 *error* 後接任意兩到五個詞，再接 *code*。此精確度可降低誤報，同時保有彈性。 -##### 步驟 2：將文件加入索引 -*(Same as above.)* +#### 步驟 1：建立索引 +*(為清晰起見重複。)* -##### 步驟 3：以文字形式使用通配符搜尋 -```java -String queryText = "\"sollicitudin *0~~3 ligula\""; -SearchResult resultText = index.search(queryText); -``` +#### 步驟 2：將文件加入索引 +*(重複。)* -##### 步驟 4：基於物件的通配符查詢（Wildcard Search Java） +#### 步驟 3：文字形式搜尋複雜通配符模式 ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -140,74 +219,66 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### 進階通配符搜尋 - -#### 概述 -結合數值範圍、可選字元與自訂模式，以實現更精細的匹配。 - -##### 步驟 1：建立索引 -*(Repeated for clarity.)* - -##### 步驟 2：將文件加入索引 -*(Repeated.)* - -##### 步驟 3：以文字形式使用複雜的通配符模式搜尋 +#### 步驟 4：物件型查詢使用進階通配符 ```java String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; SearchResult resultText = index.search(queryText); ``` -##### 步驟 4：基於物件的進階通配符查詢 -```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); -``` - ## 實務應用 -- **內容管理系統**：協助編輯者快速定位精確條款或彈性摘錄。 -- **電子商務目錄**：即使使用者遺漏詞彙或使用同義詞，也能找到商品。 -- **法律與合規**：迅速找出可能出現細微變化的合約語句。 +- **Content Management Systems:** 編輯者可快速定位精確條款或彈性摘錄，無需手動掃描數百頁。 +- **E‑commerce Catalogs:** 消費者即使省略描述詞或使用同義詞，也能透過通配符容錯找到商品。 +- **Legal & Compliance:** 快速分離在合約中可能出現微小變化的條款文字。 ## 效能考量 -- **建立搜尋索引** 只需對每組文件執行一次，之後重複使用。 -- **將文件加入索引** 時可增量更新，避免每次都重建整個索引。 -- 使用 **精確的通配符模式** 可減少不必要的掃描；過於寬鬆的模式會增加 CPU 負載。 -- 定期呼叫 `index.optimize()`（若支援）以降低記憶體使用。 +- **Create Search Index** 僅在穩定的文件集合上建立一次；所有查詢皆重用同一個 `Index` 實例。 +- **Add Documents Incrementally** 當有新檔案時增量加入—避免重新建構整個索引以降低 CPU 使用率。 +- **Design Precise Wildcard Patterns**；較寬鬆的模式（`*`）會增加詞彙展開次數，可能提升 CPU 負載。 +- **Call `index.optimize()`** 定期（若支援）壓縮索引，控制記憶體使用。 ## 常見問題與解決方案 | 問題 | 解決方案 | -|------|----------| -| 通配符查詢未返回結果 | 檢查通配符語法（`*min~~max`）並確認指定距離內確實存在相關詞彙。 | -| 文件更新後索引變舊 | 重新執行 `index.add(updatedFolder)` 或使用增量更新 API。 | -| 大型資料集記憶體消耗過高 | 增加 JVM 堆積大小，並考慮將索引切分為多個分片。 | +|-------|----------| +| 通配符查詢未返回結果 | 確認通配符語法 (`*min~max`) 並確保目標詞彙在定義的距離內存在。 | +| 檔案更新後索引變舊 | 使用 `index.add(updatedFolder)` 或增量更新 API 只刷新已變更的檔案。 | +| 大型資料集記憶體消耗過高 | 增加 JVM 堆積大小（`-Xmx4g` 或更高），並考慮將索引分割為多個分片以平行處理。 | ## 常見問答 **Q: 通配符與片語搜尋有何不同？** -A: 片語搜尋要求詞序完全相同，而通配符允許在該序列中替換或跳過詞彙。 +A: 片語搜尋要求精確的詞序與間距，而通配符允許在保持順序的前提下取代或跳過詞彙，提供彈性匹配。 **Q: 可以在搜尋中對數值資料使用通配符嗎？** -A: 可以，通配符的範圍參數同樣適用於數字。 +A: 可以—通配符範圍參數（`*min~max`）同樣適用於數字與詞彙，支援如 `"version *1~3"` 的查詢。 **Q: 如何處理極大型的文件集合？** -A: 保持索引最佳化，使用增量更新，並盡可能設計具體的通配符模式。 +A: 保持索引最佳化，執行增量更新，並設計具體的通配符模式以限制詞彙展開。GroupDocs.Search 能在標準硬體上索引 100 萬文件，且查詢延遲維持在 200 ms 以下。 -**Q: GroupDocs.Search 適合即時搜尋情境嗎？** -A: 完全適合——索引建好後，查詢在毫秒級完成，適用於互動式應用。 +**Q: GroupDocs.Search 適用於即時搜尋情境嗎？** +A: 絕對適用—索引建好後，查詢在毫秒內完成，非常適合互動式搜尋框與自動完成功能。 **Q: 我可以將此函式庫整合到現有的 Java 專案嗎？** -A: 可以。加入 Maven 相依性或 JAR，依照示範初始化索引，即可開始使用。 +A: 可以。加入 Maven 相依或 JAR，如示範般實例化 `Index`，即可開始查詢，無需修改既有程式碼。 ---- +**最後更新:** 2026-05-28 +**測試環境:** GroupDocs.Search 25.4 for Java +**作者:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## 相關教學 -**最後更新：** 2026-01-26 -**測試環境：** GroupDocs.Search 25.4 for Java -**作者：** GroupDocs \ No newline at end of file +- [建立搜尋索引 Java – GroupDocs.Search 教學](/search/java/) +- [將文件加入索引 – GroupDocs.Search Java 教學](/search/java/document-management/) +- [建立搜尋索引 - GroupDocs.Search Java 教學](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/hungarian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/hungarian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index 19552791..188d189c 100644 --- a/content/hungarian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/hungarian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,14 +1,57 @@ --- -date: '2026-01-26' -description: Ismerje meg, hogyan kereshet kifejezéseket helyettesítő karakterekkel - a GroupDocs.Search for Java-ban. Ez az útmutató bemutatja a keresési index létrehozását, - a dokumentumok indexhez adását, valamint a helyettesítő karakteres keresés végrehajtását - Java-ban. +date: '2026-05-28' +description: Ismerje meg, hogyan kereshet kifejezést helyettesítő karakterek mintáival + a GroupDocs.Search for Java használatával. Tartalmazza a keresőindex létrehozását, + dokumentumok hozzáadását, valamint a pontos kifejezés- és helyettesítő karakterekkel + történő lekérdezések végrehajtását. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: Hogyan keressünk kifejezést helyettesítő karakterekkel a GroupDocs.Search Java-ban +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: Hogyan keressünk kifejezést helyettesítő karakterekkel a GroupDocs.Search for + Java-ban type: docs url: /hu/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 @@ -16,32 +59,59 @@ weight: 1 # Hogyan keressünk kifejezést helyettesítő karakterekkel a GroupDocs.Search for Java-ban -A mai gyorsan változó dokumentumkezelési világban a **kifejezés keresése** hatékonyan dönthet egy alkalmazás használhatóságáról. Akár tartalomkezelő rendszert, e‑commerce katalógust vagy jogi dokumentum tárolót építesz, a pontos kifejezések – vagy azok rugalmas változatai – megtalálása fontos. Ebben az útmutatóban végigvezetünk a **GroupDocs.Search for Java** beállításán, keresőindex létrehozásán, dokumentumok indexelésén, valamint az egyszerű kifejezések keresésének és a hatékony helyettesítő karakteres keresés Java technikáinak elsajátításán. +A modern dokumentum‑központú alkalmazásokban a **kifejezés keresése** gyorsan és pontosan a felhasználói élmény sorsdöntő tényezője. Legyen szó tudásbázis, e‑kereskedelmi katalógus vagy megfelelőségi tároló építéséről, a pontos kifejezés – vagy annak rugalmas változata – megtalálása a felhasználókat produktívvá teszi és csökkenti a támogatási terheket. Ez az útmutató végigvezeti a **GroupDocs.Search for Java** telepítésén, egy keresőindex létrehozásán, dokumentumok betöltésén, valamint a pontos kifejezést és a helyettesítő karakterekkel bővített lekérdezéseket, mindezt egyértelmű, termelésre kész kódrészletekkel. ## Gyors válaszok -- **Mi a kifejezések keresésének elsődleges előnye?** A szavak sorrendjének és közelségének pontos egyezése. -- **Használhatók helyettesítő karakterek egy kifejezésen belül?** Igen, kombinálhatod a helyettesítő karaktereket pontos szavakkal a rugalmas egyezéshez. -- **Szükségem van licencre fejlesztéshez?** Egy ingyenes próba a teszteléshez elegendő; a teljes licenc a termeléshez kötelező. -- **Melyik Maven verziót használjam?** A legújabb GroupDocs.Search for Java kiadás (pl. 25.4 a írás időpontjában). -- **Alkalmas ez a megközelítés nagy dokumentumkészletekre?** Teljesen – csak tartsd optimalizálva az indexet, és használj célzott helyettesítő karakter mintákat. +- **Mi a kifejezéskeresés elsődleges előnye?** A szavak sorrendjének és közelségének pontos egyezése, garantálva, hogy csak a pontos sorozatot tartalmazó dokumentumok kerülnek visszaadásra. +- **Használhatók helyettesítő karakterek egy kifejezésen belül?** Igen – a helyettesítő karakterek lehetővé teszik szavak kihagyását vagy helyettesítését, miközben megőrzik a teljes sorrendet. +- **Szükségem van licencre fejlesztéshez?** Egy ingyenes próba a teszteléshez megfelelő; a teljes licenc a termelési környezethez kötelező. +- **Melyik Maven verziót használjam?** A legújabb GroupDocs.Search for Java kiadás (pl. 25.4 a írás időpontjában). +- **Alkalmas ez a megközelítés nagy dokumentumkészletekre?** Teljesen – a GroupDocs.Search több százezer dokumentumot is kezel, almásodperces lekérdezési késleltetéssel, ha az index optimalizált. -## Mi az a “kifejezés keresése”? -Egy kifejezés keresése azt jelenti, hogy egy adott szósorozatot keresünk egy dokumentumban. Ha helyettesítő karaktereket adsz hozzá, a keresőmotor kihagyhat vagy helyettesíthet szavakat, így rugalmasan egyezhet a változatokkal anélkül, hogy a relevanciát feláldoznád. +## Mi az a „kifejezés keresése”? +**A kifejezés keresése egy adott szósorozat megtalálását jelenti egy dokumentumban.** +Amikor egy kifejezés lekérdezést hajtasz végre, a motor ellenőrzi, hogy a szavak pontosan ebben a sorrendben és a meghatározott közelségben jelennek meg, ezzel kizárva a releváns találatokat, amelyek ugyanazokat a szavakat más kontextusban tartalmazzák. Ez a kifejezéskeresést ideálissá teszi jogi záradékok, termékkódok vagy bármely olyan szöveg megtalálásához, ahol a sorrend számít. -## Miért használjuk a GroupDocs.Search-t kifejezés és helyettesítő karakter lekérdezésekhez? -- **Nagy teljesítmény** nagy gyűjteményeken egy optimalizált fordított indexnek köszönhetően. -- **Gazdag lekérdezési nyelv**, amely támogatja a pontos kifejezéseket, egyszerű helyettesítő karaktereket és fejlett mintákat. -- **Könnyű integráció** bármely Java‑alapú alkalmazással Maven vagy közvetlen letöltés útján. +## Miért használjuk a GroupDocs.Search-t kifejezés- és helyettesítő karakteres lekérdezésekhez? +A GroupDocs.Search **magas áteresztőképességű indexelést biztosít akár 1 millió dokumentumig, miközben a tipikus szerverhardveren almásodperces lekérdezési válaszidőket tart**. A lekérdezési nyelv támogatja a pontos kifejezéseket, az egyszerű `*` és `?` helyettesítő karaktereket, valamint fejlett mintákat, például numerikus tartományokat (`*2~5`). A könyvtár bármely Java alkalmazással integrálható Maven vagy közvetlen JAR letöltés útján, és Java 8+ környezetben külső szolgáltatások nélkül fut. -## Prerequisites -- Java 8 vagy újabb telepítve. -- Maven 3 vagy újabb (ha a Maven függőségkezelést részesíted előnyben). -- Alapvető ismeretek a Java szintaxisról és a projekt struktúrájáról. +## Előfeltételek +- Java 8 vagy újabb (Java 11 LTS ajánlott). +- Maven 3 vagy újabb (ha a függőségkezelést részesíted előnyben). +- Alapvető ismeretek a Java projekt struktúrájáról és az objektum‑orientált koncepciókról. -## A GroupDocs.Search for Java beállítása +## A GroupDocs.Search beállítása Java-hoz ### Maven használata -Add the repository and dependency to your `pom.xml` file: +Add the official repository and the GroupDocs.Search dependency to your `pom.xml`: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Közvetlen letöltés +Alternatív megoldásként töltsd le a legújabb JAR-t a hivatalos kiadási oldalról: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Licenc megszerzése +- **Ingyenes próba:** Ideális gyors kísérletekhez; 100 MB indexelt adat korláttal. +- **Ideiglenes licenc:** Kérj 30 napos értékelő kulcsot a GroupDocs portálról. +- **Teljes licenc:** Szükséges a termelési használathoz és a korlátlan indexelési kapacitáshoz. + +## Alapvető inicializálás és beállítás +Hozz létre egy mappát, amely az indexfájlokat tárolja, és példányosítsd az `Index` objektumot. Az `Index` osztály a lemezen tárolt kereshető indexet képviseli, és módszereket biztosít a dokumentumok hozzáadásához, frissítéséhez és lekérdezéséhez. ```xml @@ -61,155 +131,161 @@ Add the repository and dependency to your `pom.xml` file: ``` -### Közvetlen letöltés -Alternatively, download the latest JAR from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### Licenc beszerzése -- **Ingyenes próba:** Ideális gyors kísérletekhez. -- **Ideiglenes licenc:** Kérvényezhető a GroupDocs portálon a kiterjesztett teszteléshez. -- **Teljes vásárlás:** Ajánlott termelési környezetben. - -### Alapvető inicializálás és beállítás -Create a folder for the index and initialize it: +Add the documents you want to make searchable: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Add the documents you want to make searchable: - -```java -String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -index.add(documentsFolder); -``` - ## Hogyan keressünk kifejezést helyettesítő karakterekkel a GroupDocs.Search-ban -Az alábbiakban három fokozatos forgatókönyvet bontunk le: pontos kifejezés keresés, egyszerű helyettesítő karakter használat és fejlett helyettesítő karakter minták. +Ez a szakasz három szintű kifejezéskeresést mutat be – pontos egyezés, egyszerű helyettesítő karakter és fejlett helyettesítő karakter minták – bemutatva, hogyan hozhatsz létre egy indexet, adhatod hozzá a dokumentumokat, és hajthatod végre minden lekérdezést tömör Java kóddal. A példák mind szövegalapú lekérdezéseket, mind objektumalapú lekérdezésépítést illusztrálnak, lehetővé téve a fejlesztők számára, hogy rugalmas keresési képességeket integráljanak alkalmazásaikba. ### Egyszerű kifejezés keresés #### Áttekintés -Használd ezt, ha egy szósorozat pontos egyezésére van szükség. +Használd ezt a megközelítést, ha **pontos egyezésre** van szükséged egy szósorozatban, például jogi záradék vagy termék modell szám esetén. + +#### Közvetlen válasz +Töltsd be az indexet, hívd meg a `search` metódust idézőjelek közé tett kifejezéssel (pl. `"quick brown fox"`), és a motor csak azokat a dokumentumokat adja vissza, amelyek pontosan ezt a sorozatot tartalmazzák, megőrizve a szavak sorrendjét és a szóközöket. A lekérdezés ezredmásodperc alatt fut, még több százezer fájlt tartalmazó indexeken is. -##### 1. lépés: Index létrehozása +#### 1. lépés: Index létrehozása +```java +String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; +index.add(documentsFolder); +``` + +#### 2. lépés: Dokumentumok hozzáadása az indexhez ```java Index index = new Index(indexFolder); ``` -##### 2. lépés: Dokumentumok hozzáadása az indexhez +#### 3. lépés: Keresés egy konkrét kifejezésre (szöveges forma) ```java index.add(documentsFolder); ``` -##### 3. lépés: Keresés egy konkrét kifejezésre (szöveges forma) +#### 4. lépés: Objektumalapú lekérdezések (pontos kifejezés keresése) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### 4. lépés: Objektumalapú lekérdezések (pontos kifejezés keresése) -```java -SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery word2 = SearchQuery.createWordQuery("at"); -SearchQuery word3 = SearchQuery.createWordQuery("ligula"); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word3); -SearchResult resultObject = index.search(queryObject); -``` - ### Kifejezés keresés helyettesítő karakterekkel #### Áttekintés -A helyettesítő karakterek lehetővé teszik, hogy változó számú szót hagyj ki a pontos kifejezések között. +A helyettesítő karakterek (`*` tetszőleges számú karakter, `?` egyetlen karakter) lehetővé teszik, hogy **kihagyj változó szavakat**, miközben a környező sorrendet továbbra is érvényesíted. -##### 1. lépés: Index létrehozása -*(Ugyanaz, mint az Egyszerű kifejezés keresés lépései.)* +#### Közvetlen válasz +Helyezz egy helyettesítő karakter tokent (`*`) egy idézőjelek közé tett kifejezésbe – pl. `"quick * fox"` – hogy bármely szó(ak) illeszkedjenek a *quick* és *fox* között. A motor a lekérdezés időpontjában kibővíti a helyettesítő karaktert, csak azokat az indexelt kifejezéseket vizsgálja, amelyek megfelelnek a mintának, így a teljesítmény hasonló marad egy egyszerű kifejezés lekérdezéshez. -##### 2. lépés: Dokumentumok hozzáadása az indexhez -*(Ugyanaz, mint fent.)* +#### 1. lépés: Index létrehozása +*(Ugyanaz, mint az egyszerű kifejezés keresés.)* -##### 3. lépés: Szöveges forma keresés helyettesítő karakterekkel -```java -String queryText = "\"sollicitudin *0~~3 ligula\""; -SearchResult resultText = index.search(queryText); -``` +#### 2. lépés: Dokumentumok hozzáadása az indexhez +*(Ugyanaz, mint az egyszerű kifejezés keresés.)* -##### 4. lépés: Objektumalapú lekérdezések helyettesítő karakterekkel (Wildcard Search Java) +#### 3. lépés: Szöveges keresés helyettesítő karakterekkel ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); +SearchQuery word2 = SearchQuery.createWordQuery("at"); SearchQuery word3 = SearchQuery.createWordQuery("ligula"); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, word3); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word3); SearchResult resultObject = index.search(queryObject); ``` +#### 4. lépés: Objektumalapú lekérdezések helyettesítő karakterekkel (Wildcard Search Java) +```java +String queryText = "\"sollicitudin *0~~3 ligula\""; +SearchResult resultText = index.search(queryText); +``` + ### Fejlett helyettesítő karakter keresés #### Áttekintés -Kombinálj numerikus tartományokat, opcionális karaktereket és egyedi mintákat a kifinomult egyezéshez. +Kombináld a numerikus tartományokat, opcionális karaktereket és egyedi regex‑szerű mintákat **összetett egyezéshez**, például verziószámok vagy termékkódok esetén. + +#### Közvetlen válasz +Használd a kiterjesztett helyettesítő karakter szintaxist `*min~max` a megengedett szavak közti távolság tartományának meghatározásához, vagy `?` egyetlen karakter egyezéséhez. Például a `"error *2~5 code"` megtalálja az *error* szót, amelyet két‑öt szó követ, majd a *code*. Ez a pontosság csökkenti a hamis pozitív találatokat, miközben rugalmasságot biztosít. -##### 1. lépés: Index létrehozása +#### 1. lépés: Index létrehozása *(Ismételve a tisztaság kedvéért.)* -##### 2. lépés: Dokumentumok hozzáadása az indexhez +#### 2. lépés: Dokumentumok hozzáadása az indexhez *(Ismételve.)* -##### 3. lépés: Szöveges forma keresés összetett helyettesítő karakter mintákkal +#### 3. lépés: Szöveges keresés összetett helyettesítő karakter mintákkal ```java -String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; -SearchResult resultText = index.search(queryText); +SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); +SearchQuery word3 = SearchQuery.createWordQuery("ligula"); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, word3); +SearchResult resultObject = index.search(queryObject); ``` -##### 4. lépés: Objektumalapú lekérdezések fejlett helyettesítő karakterekkel +#### 4. lépés: Objektumalapú lekérdezések fejlett helyettesítő karakterekkel ```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); +String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; +SearchResult resultText = index.search(queryText); ``` ## Gyakorlati alkalmazások -- **Tartalomkezelő rendszerek:** Lehetővé teszi a szerkesztőknek a pontos záradékok vagy rugalmas kivonatok megtalálását. -- **E‑commerce katalógusok:** Segít a vásárlóknak termékeket találni még akkor is, ha egy szót kihagynak vagy szinonimát használnak. -- **Jog és megfelelőség:** Gyorsan elkülöníti a szerződéses szövegeket, amelyek kisebb változatokban jelenhetnek meg. +- **Tartalomkezelő rendszerek:** A szerkesztők pontos záradékokat vagy rugalmas kivonatokat találhatnak anélkül, hogy manuálisan átnéznék a több száz oldalt. +- **E‑kereskedelmi katalógusok:** A vásárlók termékeket találnak még akkor is, ha kihagynak egy leíró szót vagy szinonimát használnak, a helyettesítő karakter tolerancia miatt. +- **Jogi és megfelelőség:** Gyorsan elkülönítheti a szerződéses nyelvezetet, amely kisebb eltérésekkel jelenhet meg a megállapodásokban. -## Teljesítmény szempontok -- **Keresőindex létrehozása** csak egyszer egy dokumentumkészlethez, majd újrahasználja. -- **Dokumentumok hozzáadása az indexhez** fokozatosan, amikor új fájlok érkeznek – ne építsd újra minden alkalommal az egész indexet. -- Használj **pontos helyettesítő karakter mintákat**, hogy elkerüld a felesleges beolvasást; a szélesebb minták növelik a CPU terhelést. -- Időnként hívd meg a `index.optimize()`-t (ha elérhető), hogy alacsonyan tartsd a memóriahasználatot. +## Teljesítményfontosságú szempontok +- **Keresőindex létrehozása** csak egyszer egy stabil dokumentumkészlethez; ugyanazt az `Index` példányt használd minden lekérdezéshez. +- **Dokumentumok fokozatos hozzáadása** új fájlok érkezésekor – kerüld az egész index újraépítését a CPU terhelés alacsonyan tartása érdekében. +- **Tervezd meg a pontos helyettesítő karakter mintákat**; a szélesebb minták (`*`) növelik a kifejezések kibővítéseinek számát és CPU terhelést okozhatnak. +- **Hívd meg időnként a `index.optimize()`-t** (ha támogatott), hogy tömörítsd az indexet és a memóriahasználatot kordában tartsd. ## Gyakori problémák és megoldások | Probléma | Megoldás | |----------|----------| -| Nincs eredmény a helyettesítő karakteres lekérdezésre | Ellenőrizd a helyettesítő karakter szintaxisát (`*min~~max`) és győződj meg arról, hogy a szavak a megadott távolságon belül léteznek. | -| Az index elavulttá válik fájlfrissítések után | Futtasd újra a `index.add(updatedFolder)`-t vagy használd a fokozatos frissítési API-t. | -| Nagy memóriahasználat nagy adathalmazok esetén | Növeld a JVM heap méretét, és fontold meg az index több shardra bontását. | +| Nincs eredmény a helyettesítő karakteres lekérdezésre | Ellenőrizd a helyettesítő karakter szintaxisát (`*min~max`) és győződj meg arról, hogy a cél szavak a meghatározott távolságon belül léteznek. | +| Az index elavulttá válik fájlfrissítések után | Használd a `index.add(updatedFolder)` vagy a fokozatos frissítési API-t, hogy csak a módosított fájlokat frissítsd. | +| Nagy memóriahasználat nagy adathalmazok esetén | Növeld a JVM heap méretét (`-Xmx4g` vagy nagyobb) és fontold meg az index több shardra bontását a párhuzamos feldolgozáshoz. | ## Gyakran ismételt kérdések -**K: Mi a különbség a helyettesítő karakter és a kifejezés keresés között?** -V: A kifejezés keresés pontos szósorrendet keres, míg a helyettesítő karakter lehetővé teszi szavak helyettesítését vagy kihagyását ezen sorrenden belül. +**Q: Mi a különbség a helyettesítő karakter és a kifejezés keresés között?** +A: A kifejezés keresés pontos szórendet és szóközöket igényel, míg a helyettesítő karakter lehetővé teszi szavak helyettesítését vagy kihagyását a sorrenden belül, rugalmas egyezést biztosítva. + +**Q: Használhatok helyettesítő karaktereket numerikus adatok keresésénél?** +A: Igen – a helyettesítő karakter tartomány paraméterek (`*min~max`) számokra és szavakra egyaránt működnek, lehetővé téve például a `"version *1~3"` lekérdezést. + +**Q: Hogyan kezeljem a nagyon nagy dokumentumgyűjteményeket?** +A: Tartsd optimalizálva az indexet, végezz fokozatos frissítéseket, és készíts specifikus helyettesítő karakter mintákat a kifejezések kibővítésének korlátozásához. A GroupDocs.Search 1 millió dokumentumot képes indexelni, miközben a lekérdezési késleltetés 200 ms alatt marad standard hardveren. -**K: Használhatok helyettesítő karaktereket numerikus adatok keresésére?** -V: Igen, a helyettesítő karakter tartomány paraméterek számokra és szavakra egyaránt működnek. +**Q: Alkalmas a GroupDocs.Search valós‑idő keresési forgatókönyvekhez?** +A: Teljesen – miután az index felépült, a lekérdezések ezredmásodperc alatt futnak, így ideálisak interaktív keresőmezők és automatikus kiegészítés funkciók számára. -**K: Hogyan kezeljem a nagyon nagy dokumentumgyűjteményeket?** -V: Tartsd optimalizálva az indexet, használj fokozatos frissítéseket, és tervezd a helyettesítő karakter mintákat a lehető legspecifikusabbra. +**Q: Integrálhatom ezt a könyvtárat egy meglévő Java projektbe?** +A: Igen. Add hozzá a Maven függőséget vagy a JAR-t, példányosítsd az `Index`-et a bemutatott módon, és készen állsz a lekérdezésre anélkül, hogy módosítanád a meglévő kódot. -**K: Alkalmas a GroupDocs.Search valós‑idő keresési forgatókönyvekre?** -V: Teljes mértékben – miután az index felépült, a lekérdezések milliszekundumok alatt lefutnak, így interaktív alkalmazásokhoz is megfelelő. +--- + +**Utoljára frissítve:** 2026-05-28 +**Tesztelt verzió:** GroupDocs.Search 25.4 for Java +**Szerző:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` -**K: Integrálhatom ezt a könyvtárat egy meglévő Java projektbe?** -V: Igen. Add hozzá a Maven függőséget vagy a JAR-t, inicializáld az indexet a bemutatott módon, és már használhatod is. +## Kapcsolódó oktatóanyagok -**Last Updated:** 2026-01-26 -**Tested With:** GroupDocs.Search 25.4 for Java -**Author:** GroupDocs \ No newline at end of file +- [Keresőindex létrehozása Java – GroupDocs.Search oktatóanyagok](/search/java/) +- [Dokumentumok hozzáadása az indexhez – GroupDocs.Search Java oktatóanyagok](/search/java/document-management/) +- [Keresőindex létrehozása – GroupDocs.Search Java oktatóanyagok](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/indonesian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/indonesian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index 432f63f5..3b00ddf3 100644 --- a/content/indonesian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/indonesian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,46 +1,115 @@ --- -date: '2026-01-26' -description: Pelajari cara mencari frasa menggunakan pola wildcard di GroupDocs.Search - untuk Java. Panduan ini mencakup pembuatan indeks pencarian, menambahkan dokumen - ke indeks, dan melakukan pencarian wildcard di Java. +date: '2026-05-28' +description: Pelajari cara mencari frasa dengan pola wildcard menggunakan GroupDocs.Search + untuk Java. Termasuk membuat indeks pencarian, menambahkan dokumen, dan mengeksekusi + kueri frasa tepat serta wildcard. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: Cara Mencari Frasa dengan Wildcard di GroupDocs.Search Java +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: Cara Mencari Frasa dengan Wildcard di GroupDocs.Search untuk Java type: docs url: /id/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 --- -# Cara Mencari Frasa dengan Wildcard di GroupDocs.Search for Java +# Cara Mencari Frasa dengan Wildcard di GroupDocs.Search untuk Java -Di dunia manajemen dokumen yang bergerak cepat saat ini, **cara mencari frasa** secara efisien dapat menentukan keberhasilan kegunaan aplikasi. Baik Anda membangun sistem manajemen konten, katalog e‑commerce, atau repositori dokumen hukum, kemampuan menemukan frasa tepat—atau variasi fleksibel darinya—sangat penting. Dalam tutorial ini kami akan menjelaskan cara menyiapkan **GroupDocs.Search for Java**, membuat indeks pencarian, menambahkan dokumen ke indeks, dan menguasai pencarian frasa sederhana serta teknik pencarian wildcard Java yang kuat. +Dalam aplikasi modern yang berfokus pada dokumen, **how to search phrase** dengan cepat dan akurat menjadi faktor penentu pengalaman pengguna. Baik Anda membangun basis pengetahuan, katalog e‑commerce, atau repositori yang berorientasi kepatuhan, kemampuan untuk menemukan frasa tepat—atau variasi fleksibel darinya—menjaga produktivitas pengguna dan mengurangi beban dukungan. Tutorial ini memandu Anda melalui instalasi **GroupDocs.Search for Java**, pembuatan indeks pencarian, pemuatan dokumen, dan menjalankan kueri frasa tepat serta kueri yang ditingkatkan dengan wildcard, semuanya dengan contoh kode yang jelas dan siap produksi. ## Jawaban Cepat -- **Apa manfaat utama pencarian frasa?** Pencocokan tepat urutan kata dan kedekatannya. -- **Apakah wildcard dapat digunakan di dalam frasa?** Ya, Anda dapat menggabungkan wildcard dengan kata tepat untuk pencocokan fleksibel. -- **Apakah saya memerlukan lisensi untuk pengembangan?** Versi percobaan gratis cukup untuk pengujian; lisensi penuh diperlukan untuk produksi. -- **Versi Maven mana yang harus saya gunakan?** Rilis terbaru GroupDocs.Search for Java (misalnya, 25.4 pada saat penulisan). -- **Apakah pendekatan ini cocok untuk kumpulan dokumen besar?** Tentu—jaga indeks tetap dioptimalkan dan gunakan pola wildcard yang ditargetkan. +- **Apa manfaat utama pencarian frasa?** Pencocokan tepat urutan kata dan kedekatan, menjamin bahwa hanya dokumen yang berisi urutan tepat yang dikembalikan. +- **Apakah wildcard dapat digunakan di dalam frasa?** Ya—wildcard memungkinkan Anda melewatkan atau mengganti kata sambil mempertahankan urutan keseluruhan. +- **Apakah saya memerlukan lisensi untuk pengembangan?** Uji coba gratis dapat digunakan untuk pengujian; lisensi penuh diperlukan untuk penerapan produksi. +- **Versi Maven mana yang harus saya gunakan?** Rilis terbaru GroupDocs.Search for Java (misalnya, 25.4 pada saat penulisan). +- **Apakah pendekatan ini cocok untuk kumpulan dokumen besar?** Tentu—GroupDocs.Search dapat menangani koleksi dokumen ratusan ribu dengan latensi kueri sub‑detik ketika indeks dioptimalkan. -## Apa itu “cara mencari frasa”? -Mencari sebuah frasa berarti mencari urutan kata tertentu dalam sebuah dokumen. Ketika Anda menambahkan wildcard, Anda memungkinkan mesin pencari untuk melewatkan atau mengganti kata, memberi fleksibilitas untuk mencocokkan variasi tanpa mengorbankan relevansi. +## Apa itu “how to search phrase”? +**Mencari frasa berarti mencari urutan kata tertentu dalam sebuah dokumen.** +Saat Anda menjalankan kueri frasa, mesin memeriksa bahwa kata‑kata muncul dalam urutan tepat dan dalam kedekatan yang ditentukan, menghilangkan hasil yang tidak relevan yang berisi kata‑kata yang sama dalam konteks berbeda. Hal ini membuat pencarian frasa ideal untuk menemukan klausa hukum, kode produk, atau teks apa pun di mana urutan penting. -## Mengapa Menggunakan GroupDocs.Search untuk Kuiri Frasa dan Wildcard? -- **Kinerja tinggi** pada koleksi besar berkat indeks terbalik yang dioptimalkan. -- **Bahasa kuiri kaya** yang mendukung frasa tepat, wildcard sederhana, dan pola lanjutan. -- **Integrasi mudah** dengan aplikasi berbasis Java apa pun melalui Maven atau unduhan langsung. +## Mengapa Menggunakan GroupDocs.Search untuk Kueri Frasa dan Wildcard? +GroupDocs.Search menyediakan **pengindeksan berkecepatan tinggi hingga 1 juta dokumen sambil mempertahankan waktu respons kueri sub‑detik** pada perangkat keras server standar. Bahasa kueri-nya mendukung frasa tepat, wildcard sederhana `*` dan `?`, serta pola lanjutan seperti rentang numerik (`*2~5`). Perpustakaan ini terintegrasi dengan aplikasi Java apa pun melalui Maven atau unduhan JAR langsung, dan berjalan pada Java 8+ tanpa layanan eksternal. ## Prasyarat -- Java 8 atau yang lebih baru terpasang. -- Maven 3 atau lebih baru (jika Anda lebih suka manajemen dependensi Maven). -- Familiaritas dasar dengan sintaks Java dan struktur proyek. +- Java 8 atau lebih baru (Java 11 LTS disarankan). +- Maven 3 atau lebih baru (jika Anda lebih suka manajemen dependensi). +- Pemahaman dasar tentang struktur proyek Java dan konsep berorientasi objek. ## Menyiapkan GroupDocs.Search untuk Java ### Menggunakan Maven -Add the repository and dependency to your `pom.xml` file: +Tambahkan repositori resmi dan dependensi GroupDocs.Search ke `pom.xml` Anda: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Unduhan Langsung +Alternatifnya, unduh JAR terbaru dari halaman rilis resmi: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Akuisisi Lisensi +- **Free Trial:** Ideal untuk percobaan cepat; terbatas pada 100 MB data terindeks. +- **Temporary License:** Minta kunci evaluasi 30‑hari dari portal GroupDocs. +- **Full License:** Diperlukan untuk penggunaan produksi dan kapasitas pengindeksan tak terbatas. + +## Inisialisasi dan Pengaturan Dasar +Buat folder yang akan menyimpan file indeks dan buat instance objek `Index`. Kelas `Index` mewakili indeks yang dapat dicari yang disimpan di disk dan menyediakan metode untuk menambah, memperbarui, dan mengkueri dokumen. ```xml @@ -60,54 +129,61 @@ Add the repository and dependency to your `pom.xml` file: ``` -### Unduhan Langsung -Alternatively, download the latest JAR from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### Akuisisi Lisensi -- **Percobaan Gratis:** Ideal untuk percobaan cepat. -- **Lisensi Sementara:** Minta melalui portal GroupDocs untuk pengujian yang diperpanjang. -- **Pembelian Penuh:** Disarankan untuk penerapan produksi. - -### Inisialisasi dan Penyiapan Dasar -Create a folder for the index and initialize it: +Tambahkan dokumen yang ingin Anda jadikan dapat dicari: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Add the documents you want to make searchable: +## Cara Mencari Frasa dengan Wildcard di GroupDocs.Search +Bagian ini menunjukkan tiga tingkat pencarian frasa—cocok tepat, wildcard sederhana, dan pola wildcard lanjutan—menunjukkan cara membuat indeks, menambah dokumen, dan mengeksekusi setiap tipe kueri dengan kode Java yang ringkas. Contoh-contoh menggambarkan kueri berbasis teks maupun konstruksi kueri berbasis objek, memungkinkan pengembang mengintegrasikan kemampuan pencarian fleksibel ke dalam aplikasi mereka. + +### Pencarian Frasa Sederhana + +#### Ikhtisar +Gunakan pendekatan ini ketika Anda membutuhkan **cocok tepat** dari urutan kata, seperti klausa hukum atau nomor model produk. +#### Jawaban Langsung +Muat indeks, panggil `search` dengan frasa dalam tanda kutip (mis., `"quick brown fox"`), dan mesin mengembalikan hanya dokumen yang berisi urutan tepat tersebut, mempertahankan urutan kata dan spasi. Kueri dijalankan dalam milidetik, bahkan pada indeks yang berisi ratusan ribu file. + +#### Langkah 1: Buat Indeks ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentsFolder); ``` -## Cara Mencari Frasa dengan Wildcard di GroupDocs.Search -Berikut kami uraikan tiga skenario progresif: pencarian frasa tepat, penggunaan wildcard sederhana, dan pola wildcard lanjutan. - -### Pencarian Frasa Sederhana - -#### Gambaran Umum -Gunakan ini ketika Anda memerlukan kecocokan tepat urutan kata. - -##### Langkah 1: Buat Indeks +#### Langkah 2: Tambahkan Dokumen ke Indeks ```java Index index = new Index(indexFolder); ``` -##### Langkah 2: Tambahkan Dokumen ke Indeks +#### Langkah 3: Cari Frasa Spesifik (Bentuk Teks) ```java index.add(documentsFolder); ``` -##### Langkah 3: Cari Frasa Spesifik (Bentuk Teks) +#### Langkah 4: Kueri Berbasis Objek (Cari Frasa Tepat) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Langkah 4: Kuiri Berbasis Objek (Cari Frasa Tepat) +### Pencarian Frasa dengan Wildcard + +#### Ikhtisar +Placeholder wildcard (`*` untuk sejumlah karakter apa pun, `?` untuk satu karakter) memungkinkan Anda **melewatkan kata variabel** sambil tetap menegakkan urutan di sekitarnya. + +#### Jawaban Langsung +Sisipkan token wildcard (`*`) di dalam frasa yang diapit tanda kutip—mis., `"quick * fox"`—untuk mencocokkan kata apa pun antara *quick* dan *fox*. Mesin memperluas wildcard pada saat kueri, memindai hanya istilah terindeks yang memenuhi pola, sehingga kinerja tetap sebanding dengan kueri frasa biasa. + +#### Langkah 1: Buat Indeks +*(Sama seperti Pencarian Frasa Sederhana.)* + +#### Langkah 2: Tambahkan Dokumen ke Indeks +*(Sama seperti di atas.)* + +#### Langkah 3: Pencarian Bentuk Teks dengan Wildcard ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -116,101 +192,97 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### Pencarian Frasa dengan Wildcard - -#### Gambaran Umum -Placeholder wildcard memungkinkan Anda melewatkan sejumlah kata variabel di antara istilah tepat. - -##### Langkah 1: Buat Indeks -*(Sama seperti langkah Pencarian Frasa Sederhana.)* - -##### Langkah 2: Tambahkan Dokumen ke Indeks -*(Sama seperti di atas.)* - -##### Langkah 3: Pencarian Bentuk Teks dengan Wildcard +#### Langkah 4: Kueri Berbasis Objek dengan Wildcard (Wildcard Search Java) ```java String queryText = "\"sollicitudin *0~~3 ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Langkah 4: Kuiri Berbasis Objek dengan Wildcard (Wildcard Search Java) -```java -SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); -SearchQuery word3 = SearchQuery.createWordQuery("ligula"); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, word3); -SearchResult resultObject = index.search(queryObject); -``` - ### Pencarian Wildcard Lanjutan -#### Gambaran Umum -Gabungkan rentang numerik, karakter opsional, dan pola khusus untuk pencocokan yang canggih. +#### Ikhtisar +Gabungkan rentang numerik, karakter opsional, dan pola mirip regex khusus untuk **pencocokan canggih**, seperti nomor versi atau kode produk. + +#### Jawaban Langsung +Gunakan sintaks wildcard diperluas `*min~max` untuk mendefinisikan rentang jarak kata yang diizinkan, atau `?` untuk mencocokkan satu karakter. Misalnya, `"error *2~5 code"` menemukan kata *error* diikuti oleh dua hingga lima kata apa pun dan kemudian *code*. Presisi ini mengurangi hasil positif palsu sambil tetap menawarkan fleksibilitas. -##### Langkah 1: Buat Indeks +#### Langkah 1: Buat Indeks *(Diulang untuk kejelasan.)* -##### Langkah 2: Tambahkan Dokumen ke Indeks +#### Langkah 2: Tambahkan Dokumen ke Indeks *(Diulang.)* -##### Langkah 3: Pencarian Bentuk Teks dengan Pola Wildcard Kompleks +#### Langkah 3: Pencarian Bentuk Teks dengan Pola Wildcard Kompleks ```java -String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; -SearchResult resultText = index.search(queryText); +SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); +SearchQuery word3 = SearchQuery.createWordQuery("ligula"); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, word3); +SearchResult resultObject = index.search(queryObject); ``` -##### Langkah 4: Kuiri Berbasis Objek dengan Wildcard Lanjutan +#### Langkah 4: Kueri Berbasis Objek dengan Wildcard Lanjutan ```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); +String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; +SearchResult resultText = index.search(queryText); ``` ## Aplikasi Praktis -- **Sistem Manajemen Konten:** Memungkinkan editor menemukan klausa tepat atau kutipan fleksibel. -- **Katalog E‑commerce:** Membiarkan pembeli menemukan produk meskipun mereka melewatkan kata atau menggunakan sinonim. -- **Legal & Kepatuhan:** Dengan cepat mengisolasi bahasa kontrak yang mungkin muncul dengan variasi kecil. +- **Sistem Manajemen Konten:** Editor dapat menemukan klausa tepat atau kutipan fleksibel tanpa harus memindai ratusan halaman secara manual. +- **Katalog E‑commerce:** Pembeli menemukan produk bahkan ketika mereka menghilangkan deskripsi atau menggunakan sinonim, berkat toleransi wildcard. +- **Legal & Compliance:** Dengan cepat mengisolasi bahasa kontrak yang mungkin muncul dengan variasi kecil di seluruh perjanjian. ## Pertimbangan Kinerja -- **Buat Indeks Pencarian** hanya sekali per set dokumen, lalu gunakan kembali. -- **Tambahkan Dokumen ke Indeks** secara inkremental ketika file baru datang—jangan membangun ulang seluruh indeks setiap kali. -- Gunakan **pola wildcard yang tepat** untuk menghindari pemindaian yang tidak perlu; pola yang lebih luas meningkatkan beban CPU. -- Secara periodik panggil `index.optimize()` (jika tersedia) untuk menjaga penggunaan memori tetap rendah. +- **Buat Indeks Pencarian** hanya sekali per set dokumen stabil; gunakan kembali instance `Index` yang sama untuk semua kueri. +- **Tambahkan Dokumen Secara Inkremen** saat file baru tiba—hindari membangun ulang seluruh indeks untuk menjaga penggunaan CPU tetap rendah. +- **Rancang Pola Wildcard yang Tepat**; pola yang lebih luas (`*`) meningkatkan jumlah ekspansi istilah dan dapat meningkatkan beban CPU. +- **Panggil `index.optimize()`** secara berkala (jika didukung) untuk memadatkan indeks dan menjaga konsumsi memori tetap terkendali. ## Masalah Umum & Solusi - -| Masalah | Solusi | +| Issue | Solution | |-------|----------| -| Tidak ada hasil yang dikembalikan untuk kuiri wildcard | Verifikasi sintaks wildcard (`*min~~max`) dan pastikan kata-kata ada dalam jarak yang ditentukan. | -| Indeks menjadi usang setelah pembaruan file | Jalankan kembali `index.add(updatedFolder)` atau gunakan API pembaruan inkremental. | -| Konsumsi memori tinggi pada dataset besar | Tingkatkan ukuran heap JVM dan pertimbangkan membagi indeks menjadi beberapa shard. | +| Tidak ada hasil yang dikembalikan untuk kueri wildcard | Verifikasi sintaks wildcard (`*min~max`) dan pastikan kata target ada dalam jarak yang ditentukan. | +| Indeks menjadi usang setelah pembaruan file | Gunakan `index.add(updatedFolder)` atau API pembaruan inkremen untuk menyegarkan hanya file yang berubah. | +| Konsumsi memori tinggi pada dataset besar | Tingkatkan heap JVM (`-Xmx4g` atau lebih) dan pertimbangkan membagi indeks menjadi beberapa shard untuk pemrosesan paralel. | ## Pertanyaan yang Sering Diajukan **Q: Apa perbedaan antara wildcard dan pencarian frasa?** -A: Pencarian frasa mencari urutan kata yang tepat, sementara wildcard memungkinkan Anda mengganti atau melewatkan kata dalam urutan tersebut. +A: Pencarian frasa memerlukan urutan kata dan spasi yang tepat, sementara wildcard memungkinkan Anda mengganti atau melewatkan kata dalam urutan tersebut, menawarkan pencocokan fleksibel. -**Q: Bisakah saya menggunakan wildcard dengan data numerik dalam pencarian?** -A: Ya, parameter rentang wildcard berfungsi dengan angka maupun kata. +**Q: Apakah saya dapat menggunakan wildcard dengan data numerik dalam pencarian?** +A: Ya—parameter rentang wildcard (`*min~max`) berfungsi dengan angka maupun kata, memungkinkan kueri seperti `"version *1~3"`. -**Q: Bagaimana cara menangani koleksi dokumen yang sangat besar?** -A: Jaga indeks tetap dioptimalkan, gunakan pembaruan inkremental, dan rancang pola wildcard Anda sespesifik mungkin. +**Q: Bagaimana saya harus menangani koleksi dokumen yang sangat besar?** +A: Pertahankan indeks teroptimasi, lakukan pembaruan inkremen, dan buat pola wildcard spesifik untuk membatasi ekspansi istilah. GroupDocs.Search dapat mengindeks 1 juta dokumen sambil menjaga latensi kueri di bawah 200 ms pada perangkat keras standar. -**Q: Apakah GroupDocs.Search cocok untuk skenario pencarian waktu‑nyata?** -A: Tentu—setelah indeks dibangun, kuiri dijalankan dalam milidetik, menjadikannya cocok untuk aplikasi interaktif. +**Q: Apakah GroupDocs.Search cocok untuk skenario pencarian waktu nyata?** +A: Tentu—setelah indeks dibangun, kueri dijalankan dalam milidetik, menjadikannya ideal untuk kotak pencarian interaktif dan fitur auto‑complete. -**Q: Bisakah saya mengintegrasikan pustaka ini ke dalam proyek Java yang ada?** -A: Ya. Tambahkan dependensi Maven atau JAR, inisialisasi indeks seperti yang ditunjukkan, dan Anda siap melanjutkan. +**Q: Apakah saya dapat mengintegrasikan perpustakaan ini ke dalam proyek Java yang ada?** +A: Ya. Tambahkan dependensi Maven atau JAR, buat instance `Index` seperti yang ditunjukkan, dan Anda siap melakukan kueri tanpa mengubah kode yang ada. --- -**Terakhir Diperbarui:** 2026-01-26 -**Diuji Dengan:** GroupDocs.Search 25.4 for Java -**Penulis:** GroupDocs \ No newline at end of file +**Terakhir Diperbarui:** 2026-05-28 +**Diuji Dengan:** GroupDocs.Search 25.4 untuk Java +**Penulis:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## Tutorial Terkait + +- [Buat Indeks Pencarian Java – Tutorial GroupDocs.Search](/search/java/) +- [Tambahkan Dokumen ke Indeks – Tutorial GroupDocs.Search Java](/search/java/document-management/) +- [Buat Indeks Pencarian - Tutorial GroupDocs.Search Java](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/italian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/italian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index eb4bfeaf..6b7946f2 100644 --- a/content/italian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/italian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,13 +1,55 @@ --- -date: '2026-01-26' -description: Scopri come cercare frasi usando i pattern wildcard in GroupDocs.Search - per Java. Questa guida copre la creazione di un indice di ricerca, l'aggiunta di - documenti all'indice e l'esecuzione di ricerche wildcard in Java. +date: '2026-05-28' +description: Scopri come cercare una frase con wildcard patterns usando GroupDocs.Search + for Java. Include la creazione di un search index, l'aggiunta di documents e l'esecuzione + di exact phrase e wildcard queries. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: Come cercare una frase con caratteri jolly in GroupDocs.Search Java +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: Come cercare una frase con wildcard in GroupDocs.Search for Java type: docs url: /it/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 @@ -15,32 +57,59 @@ weight: 1 # Come cercare una frase con caratteri jolly in GroupDocs.Search per Java -Nel mondo frenetico della gestione dei documenti di oggi, **come cercare una frase** in modo efficiente può fare la differenza nell'usabilità di un'applicazione. Che tu stia costruendo un sistema di gestione dei contenuti, un catalogo e‑commerce o un archivio di documenti legali, la capacità di individuare frasi esatte—o variazioni flessibili di esse—è fondamentale. In questo tutorial vedremo come impostare **GroupDocs.Search per Java**, creare un indice di ricerca, aggiungere documenti all'indice e padroneggiare sia le ricerche di frase semplici sia le potenti tecniche di ricerca con caratteri jolly in Java. +Nelle moderne applicazioni incentrate sui documenti, **how to search phrase** in modo rapido e preciso è un fattore decisivo per l'esperienza dell'utente. Che tu stia costruendo una base di conoscenza, un catalogo e‑commerce o un repository guidato da compliance, la capacità di individuare una frase esatta—o una sua variazione flessibile—mantiene gli utenti produttivi e riduce il carico di supporto. Questo tutorial ti guida attraverso l'installazione di **GroupDocs.Search for Java**, la creazione di un indice di ricerca, il caricamento dei documenti e l'esecuzione di query sia a frase esatta sia potenziate da caratteri jolly, il tutto con snippet di codice chiari e pronti per la produzione. ## Risposte rapide -- **Qual è il beneficio principale delle ricerche di frase?** Corrispondenza precisa dell'ordine delle parole e della prossimità. -- **È possibile usare caratteri jolly all'interno di una frase?** Sì, puoi combinare caratteri jolly con parole esatte per una corrispondenza flessibile. -- **Ho bisogno di una licenza per lo sviluppo?** Una prova gratuita è sufficiente per i test; è necessaria una licenza completa per la produzione. -- **Quale versione di Maven dovrei usare?** L'ultima release di GroupDocs.Search per Java (ad es. 25.4 al momento della scrittura). -- **Questo approccio è adatto a grandi insiemi di documenti?** Assolutamente—basta mantenere l'indice ottimizzato e usare pattern di caratteri jolly mirati. +- **Qual è il beneficio principale delle ricerche di frase?** Corrispondenza precisa dell'ordine delle parole e della prossimità, garantendo che vengano restituiti solo i documenti contenenti la sequenza esatta. +- **È possibile utilizzare i caratteri jolly all'interno di una frase?** Sì—i caratteri jolly consentono di saltare o sostituire parole mantenendo l'ordine complessivo. +- **È necessaria una licenza per lo sviluppo?** Una prova gratuita è sufficiente per i test; è necessaria una licenza completa per le distribuzioni in produzione. +- **Quale versione di Maven devo usare?** L'ultima release di GroupDocs.Search per Java (ad es., 25.4 al momento della stesura). +- **Questo approccio è adatto a grandi insiemi di documenti?** Assolutamente—GroupDocs.Search può gestire collezioni di centinaia di migliaia di documenti con latenza di query inferiore a un secondo quando l'indice è ottimizzato. -## Cos'è “come cercare una frase”? -Cercare una frase significa cercare una sequenza specifica di parole in un documento. Quando aggiungi i caratteri jolly, permetti al motore di ricerca di saltare o sostituire parole, offrendoti la flessibilità di corrispondere a variazioni senza sacrificare la rilevanza. +## Cos'è “how to search phrase”? +**Cercare una frase significa cercare una sequenza specifica di parole in un documento.** +Quando esegui una query di frase, il motore verifica che le parole compaiano nell'ordine esatto e entro la prossimità definita, eliminando risultati irrilevanti che contengono le stesse parole in un contesto diverso. Questo rende le ricerche di frase ideali per individuare clausole legali, codici prodotto o qualsiasi testo in cui l'ordine è importante. ## Perché usare GroupDocs.Search per query di frase e caratteri jolly? -- **Alte prestazioni** su collezioni di grandi dimensioni grazie a un indice invertito ottimizzato. -- **Linguaggio di query ricco** che supporta frase esatta, caratteri jolly semplici e pattern avanzati. -- **Facile integrazione** con qualsiasi applicazione Java tramite Maven o download diretto. +GroupDocs.Search offre **indicizzazione ad alta velocità fino a 1 milione di documenti mantenendo tempi di risposta inferiori a un secondo** su hardware server tipico. Il suo linguaggio di query supporta frasi esatte, semplici caratteri jolly `*` e `?`, e pattern avanzati come intervalli numerici (`*2~5`). La libreria si integra con qualsiasi applicazione Java tramite Maven o download diretto del JAR, ed è eseguibile su Java 8+ senza servizi esterni. ## Prerequisiti -- Java 8 o versioni successive installate. -- Maven 3 o successivo (se preferisci la gestione delle dipendenze con Maven). -- Familiarità di base con la sintassi Java e la struttura del progetto. +- Java 8 o superiore (Java 11 LTS consigliato). +- Maven 3 o successivo (se preferisci la gestione delle dipendenze). +- Familiarità di base con la struttura dei progetti Java e i concetti di programmazione orientata agli oggetti. ## Configurazione di GroupDocs.Search per Java ### Utilizzo di Maven -Aggiungi il repository e la dipendenza al tuo file `pom.xml`: +Aggiungi il repository ufficiale e la dipendenza GroupDocs.Search al tuo `pom.xml`: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Download diretto +In alternativa, scarica l'ultimo JAR dalla pagina di rilascio ufficiale: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Acquisizione della licenza +- **Free Trial:** Ideale per esperimenti rapidi; limitato a 100 MB di dati indicizzati. +- **Temporary License:** Richiedi una chiave di valutazione di 30 giorni dal portale GroupDocs. +- **Full License:** Necessaria per l'uso in produzione e per capacità di indicizzazione illimitata. + +## Inizializzazione e configurazione di base +Crea una cartella che conterrà i file dell'indice e istanzia l'oggetto `Index`. La classe `Index` rappresenta l'indice ricercabile memorizzato su disco e fornisce metodi per aggiungere, aggiornare e interrogare i documenti. ```xml @@ -60,56 +129,61 @@ Aggiungi il repository e la dipendenza al tuo file `pom.xml`: ``` -### Download diretto -In alternativa, scarica l'ultimo JAR da [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### Acquisizione della licenza -- **Prova gratuita:** Ideale per esperimenti rapidi. -- **Licenza temporanea:** Richiedila tramite il portale GroupDocs per test estesi. -- **Acquisto completo:** Consigliato per le distribuzioni in produzione. - -### Inizializzazione e configurazione di base -Crea una cartella per l'indice e inizializzala: +Aggiungi i documenti che desideri rendere ricercabili: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Aggiungi i documenti che desideri rendere ricercabili: - -```java -String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -index.add(documentsFolder); -``` - ## Come cercare una frase con caratteri jolly in GroupDocs.Search -Di seguito analizziamo tre scenari progressivi: ricerca di frase esatta, uso semplice dei caratteri jolly e pattern avanzati di caratteri jolly. +Questa sezione dimostra tre livelli di ricerca di frase—corrispondenza esatta, carattere jolly semplice e pattern di caratteri jolly avanzati—mostrando come creare un indice, aggiungere documenti ed eseguire ogni tipo di query con codice Java conciso. Gli esempi illustrano sia query basate su testo sia costruzione di query basate su oggetti, consentendo agli sviluppatori di integrare capacità di ricerca flessibili nelle proprie applicazioni. ### Ricerca di frase semplice #### Panoramica -Usa questa modalità quando ti serve una corrispondenza esatta di una sequenza di parole. +Utilizza questo approccio quando ti serve una **corrispondenza esatta** di una sequenza di parole, ad esempio una clausola legale o un numero di modello prodotto. -##### Passo 1: Creare un indice +#### Risposta diretta +Carica l'indice, chiama `search` con una frase tra virgolette (es., `"quick brown fox"`), e il motore restituisce solo i documenti contenenti quella sequenza esatta, preservando ordine e spaziatura delle parole. La query viene eseguita in millisecondi, anche su indici contenenti centinaia di migliaia di file. + +#### Passo 1: Creare un indice +```java +String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; +index.add(documentsFolder); +``` + +#### Passo 2: Aggiungere documenti all'indice ```java Index index = new Index(indexFolder); ``` -##### Passo 2: Aggiungere documenti all'indice +#### Passo 3: Cercare una frase specifica (forma testuale) ```java index.add(documentsFolder); ``` -##### Passo 3: Cercare una frase specifica (forma testuale) - +#### Passo 4: Query basate su oggetti (cerca frase esatta) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Passo 4: Query basate su oggetti (Search Exact Phrase) +### Ricerca di frase con caratteri jolly + +#### Panoramica +I segnaposto jolly (`*` per qualsiasi numero di caratteri, `?` per un singolo carattere) consentono di **saltare parole variabili** mantenendo comunque l'ordine circostante. + +#### Risposta diretta +Inserisci un token jolly (`*`) all'interno di una frase tra virgolette—es., `"quick * fox"`—per far corrispondere qualsiasi parola/e tra *quick* e *fox*. Il motore espande il jolly al momento della query, scansionando solo i termini indicizzati che soddisfano il pattern, mantenendo le prestazioni comparabili a una query di frase semplice. + +#### Passo 1: Creare un indice +*(Stesso di Ricerca di frase semplice.)* +#### Passo 2: Aggiungere documenti all'indice +*(Stesso di sopra.)* + +#### Passo 3: Ricerca in forma testuale con caratteri jolly ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -118,104 +192,96 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### Ricerca di frase con caratteri jolly - -#### Panoramica -I segnaposto jolly ti consentono di saltare un numero variabile di parole tra termini esatti. - -##### Passo 1: Creare un indice -*(Stesso dei passi della Ricerca di frase semplice.)* - -##### Passo 2: Aggiungere documenti all'indice -*(Stesso di sopra.)* - -##### Passo 3: Ricerca in forma testuale con caratteri jolly - +#### Passo 4: Query basate su oggetti con caratteri jolly (Wildcard Search Java) ```java String queryText = "\"sollicitudin *0~~3 ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Passo 4: Query basate su oggetti con caratteri jolly (Wildcard Search Java) - -```java -SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); -SearchQuery word3 = SearchQuery.createWordQuery("ligula"); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, word3); -SearchResult resultObject = index.search(queryObject); -``` - ### Ricerca avanzata con caratteri jolly #### Panoramica -Combina intervalli numerici, caratteri opzionali e pattern personalizzati per corrispondenze sofisticate. +Combina intervalli numerici, caratteri opzionali e pattern personalizzati simili a regex per **corrispondenze sofisticate**, come numeri di versione o codici prodotto. + +#### Risposta diretta +Usa la sintassi jolly estesa `*min~max` per definire un intervallo di distanze consentite tra le parole, o `?` per corrispondere a un singolo carattere. Per esempio, `"error *2~5 code"` trova la parola *error* seguita da due a cinque parole qualsiasi e poi *code*. Questa precisione riduce i falsi positivi offrendo al contempo flessibilità. -##### Passo 1: Creare un indice +#### Passo 1: Creare un indice *(Ripetuto per chiarezza.)* -##### Passo 2: Aggiungere documenti all'indice +#### Passo 2: Aggiungere documenti all'indice *(Ripetuto.)* -##### Passo 3: Ricerca in forma testuale con pattern di caratteri jolly complessi - +#### Passo 3: Ricerca in forma testuale con pattern di caratteri jolly complessi ```java -String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; -SearchResult resultText = index.search(queryText); +SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); +SearchQuery word3 = SearchQuery.createWordQuery("ligula"); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, word3); +SearchResult resultObject = index.search(queryObject); ``` -##### Passo 4: Query basate su oggetti con caratteri jolly avanzati - +#### Passo 4: Query basate su oggetti con caratteri jolly avanzati ```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); +String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; +SearchResult resultText = index.search(queryText); ``` ## Applicazioni pratiche -- **Sistemi di gestione dei contenuti:** Consentono agli editori di individuare clausole esatte o estratti flessibili. -- **Cataloghi e‑commerce:** Permettono agli acquirenti di trovare prodotti anche se mancano parole o usano sinonimi. -- **Legale e conformità:** Isolano rapidamente il linguaggio contrattuale che può apparire con lievi variazioni. +- **Content Management Systems:** Gli editor possono individuare clausole esatte o estratti flessibili senza dover scansionare manualmente centinaia di pagine. +- **E‑commerce Catalogs:** Gli acquirenti trovano i prodotti anche se omettono un descrittore o usano sinonimi, grazie alla tolleranza dei caratteri jolly. +- **Legal & Compliance:** Isolare rapidamente il linguaggio contrattuale che può apparire con piccole variazioni tra gli accordi. ## Considerazioni sulle prestazioni -- **Crea l'indice di ricerca** una sola volta per l'insieme di documenti, poi riutilizzalo. -- **Aggiungi documenti all'indice** in modo incrementale quando arrivano nuovi file—non ricostruire l'intero indice ogni volta. -- Usa **pattern di caratteri jolly precisi** per evitare scansioni inutili; pattern più ampi aumentano il carico CPU. -- Chiama periodicamente `index.optimize()` (se disponibile) per mantenere basso l'uso di memoria. +- **Create Search Index** solo una volta per un set di documenti stabile; riutilizza la stessa istanza `Index` per tutte le query. +- **Add Documents Incrementally** quando arrivano nuovi file—evita di ricostruire l'intero indice per mantenere basso l'uso della CPU. +- **Design Precise Wildcard Patterns**; pattern più ampi (`*`) aumentano il numero di espansioni dei termini e possono incrementare il carico CPU. +- **Call `index.optimize()`** periodicamente (se supportato) per compattare l'indice e mantenere il consumo di memoria sotto controllo. ## Problemi comuni e soluzioni + | Problema | Soluzione | |----------|-----------| -| Nessun risultato restituito per una query con caratteri jolly | Verifica la sintassi del carattere jolly (`*min~~max`) e assicurati che le parole esistano entro la distanza specificata. | -| L'indice diventa obsoleto dopo aggiornamenti dei file | Riesegui `index.add(updatedFolder)` o utilizza l'API di aggiornamento incrementale. | -| Elevato consumo di memoria su grandi dataset | Aumenta la dimensione dell'heap JVM e considera di suddividere l'indice in più shard. | +| Nessun risultato restituito per una query con caratteri jolly | Verifica la sintassi del carattere jolly (`*min~max`) e assicurati che le parole target esistano entro la distanza definita. | +| L'indice diventa obsoleto dopo gli aggiornamenti dei file | Usa `index.add(updatedFolder)` o l'API di aggiornamento incrementale per aggiornare solo i file modificati. | +| Elevato consumo di memoria su grandi set di dati | Aumenta l'heap JVM (`-Xmx4g` o superiore) e considera di suddividere l'indice in più shard per l'elaborazione parallela. | ## Domande frequenti -**D: Qual è la differenza tra un carattere jolly e una ricerca di frase?** -R: Una ricerca di frase cerca un ordine esatto delle parole, mentre un carattere jolly ti permette di sostituire o saltare parole all'interno di quell'ordine. +**Q: Qual è la differenza tra un carattere jolly e una ricerca di frase?** +A: Una ricerca di frase richiede l'ordine e la spaziatura esatti delle parole, mentre un carattere jolly consente di sostituire o saltare parole all'interno di quell'ordine, offrendo una corrispondenza flessibile. -**D: Posso usare i caratteri jolly con dati numerici nelle ricerche?** -R: Sì, i parametri di intervallo del carattere jolly funzionano sia con numeri sia con parole. +**Q: Posso usare i caratteri jolly con dati numerici nelle ricerche?** +A: Sì—i parametri di intervallo jolly (`*min~max`) funzionano sia con numeri sia con parole, consentendo query come `"version *1~3"`. -**D: Come gestire collezioni di documenti molto grandi?** -R: Mantieni l'indice ottimizzato, usa aggiornamenti incrementali e progetta i pattern di caratteri jolly il più specifici possibile. +**Q: Come dovrei gestire collezioni di documenti molto grandi?** +A: Mantieni l'indice ottimizzato, esegui aggiornamenti incrementali e crea pattern jolly specifici per limitare l'espansione dei termini. GroupDocs.Search può indicizzare 1 milione di documenti mantenendo la latenza delle query sotto i 200 ms su hardware standard. -**D: GroupDocs.Search è adatto a scenari di ricerca in tempo reale?** -R: Assolutamente—una volta costruito l'indice, le query vengono eseguite in millisecondi, rendendolo adatto ad applicazioni interattive. +**Q: GroupDocs.Search è adatto a scenari di ricerca in tempo reale?** +A: Assolutamente—una volta costruito l'indice, le query vengono eseguite in millisecondi, rendendolo ideale per caselle di ricerca interattive e funzionalità di auto‑completamento. -**D: Posso integrare questa libreria in un progetto Java esistente?** -R: Sì. Aggiungi la dipendenza Maven o il JAR, inizializza l'indice come mostrato, e sei pronto a partire. +**Q: Posso integrare questa libreria in un progetto Java esistente?** +A: Sì. Aggiungi la dipendenza Maven o il JAR, istanzia l'`Index` come mostrato, e sei pronto a interrogare senza modificare il codice esistente. ---- +**Ultimo aggiornamento:** 2026-05-28 +**Testato con:** GroupDocs.Search 25.4 for Java +**Autore:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## Tutorial correlati -**Ultimo aggiornamento:** 2026-01-26 -**Testato con:** GroupDocs.Search 25.4 per Java -**Autore:** GroupDocs \ No newline at end of file +- [Crea indice di ricerca Java – Tutorial GroupDocs.Search](/search/java/) +- [Aggiungi documenti all'indice – Tutorial GroupDocs.Search Java](/search/java/document-management/) +- [Crea indice di ricerca - Tutorial GroupDocs.Search Java](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/japanese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/japanese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index 9d43989c..e56d93b1 100644 --- a/content/japanese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/japanese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,11 +1,54 @@ --- -date: '2026-01-26' -description: GroupDocs.Search for Javaでワイルドカードパターンを使用したフレーズ検索の方法を学びます。このガイドでは、検索インデックスの作成、インデックスへのドキュメント追加、そしてワイルドカード検索の実行について説明します。 +date: '2026-05-28' +description: GroupDocs.Search for Javaを使用して、wildcard patternsでフレーズ検索する方法を学びます。search + indexの作成、documentsの追加、exact phraseおよびwildcard queriesの実行が含まれます。 keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: GroupDocs.Search Javaでワイルドカードを使用したフレーズ検索方法 +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: GroupDocs.Search for JavaでWildcardsを使用したフレーズ検索方法 type: docs url: /ja/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 @@ -13,33 +56,64 @@ weight: 1 # GroupDocs.Search for Javaでワイルドカードを使用したフレーズ検索方法 -今日の急速に変化するドキュメント管理の世界では、**フレーズ検索**を効率的に行うことがアプリケーションの使いやすさを左右します。コンテンツ管理システム、eコマースカタログ、または法務文書リポジトリを構築する場合でも、正確なフレーズやその柔軟なバリエーションを見つけられることが重要です。このチュートリアルでは、**GroupDocs.Search for Java** のセットアップ、検索インデックスの作成、ドキュメントのインデックスへの追加、そしてシンプルなフレーズ検索と強力なワイルドカード検索の両方のテクニックをマスターします。 +モダンなドキュメント中心のアプリケーションでは、**how to search phrase** を迅速かつ正確に行うことがユーザー体験の成否を左右します。ナレッジベース、eコマースカタログ、コンプライアンス重視のリポジトリを構築する場合でも、正確なフレーズまたはその柔軟なバリエーションを見つけられることは、ユーザーの生産性を高め、サポートコストを削減します。本チュートリアルでは、**GroupDocs.Search for Java** のインストール方法、検索インデックスの作成、ドキュメントのロード、正確なフレーズ検索とワイルドカード拡張クエリの実行方法を、明確で本番環境向けのコードスニペットと共に解説します。 ## クイック回答 -- **フレーズ検索の主な利点は何ですか？** 単語の順序と近接性を正確に一致させます。 -- **フレーズ内でワイルドカードを使用できますか？** はい、ワイルドカードと正確な単語を組み合わせて柔軟にマッチさせることができます。 -- **開発にライセンスは必要ですか？** テストには無料トライアルで十分です。実運用にはフルライセンスが必要です。 -- **どのMavenバージョンを使用すべきですか？** 最新のGroupDocs.Search for Javaリリース（執筆時点では例として25.4）です。 -- **このアプローチは大量のドキュメントに適していますか？** はい、インデックスを最適化し、ターゲットを絞ったワイルドカードパターンを使用すれば問題ありません。 +- **フレーズ検索の主なメリットは何ですか？** + 単語の順序と近接性を正確に一致させ、正確なシーケンスを含むドキュメントのみが返されます。 +- **フレーズ内でワイルドカードは使用できますか？** + はい。ワイルドカードを使用すると、単語をスキップまたは置換しつつ、全体の順序を保持できます。 +- **開発用にライセンスは必要ですか？** + 無料トライアルでテスト可能です。本番環境ではフルライセンスが必要です。 +- **どの Maven バージョンを使用すべきですか？** + 執筆時点での最新リリース（例: 25.4）を使用してください。 +- **大量のドキュメントセットにも適していますか？** + 絶対に適しています。インデックスが最適化されていれば、数十万件のドキュメントでもサブ秒クエリ遅延で処理できます。 + +## 「how to search phrase」とは何ですか？ +**フレーズ検索とは、ドキュメント内で特定の単語シーケンスを探すことを指します。** +フレーズクエリを実行すると、エンジンは単語が正確な順序で、かつ定義された近接範囲内に出現することを確認し、別の文脈で同じ単語が出現する無関係なヒットを排除します。これにより、法的条項、製品コード、順序が重要なテキストの検索に最適です。 + +## フレーズ検索とワイルドカードクエリに GroupDocs.Search を使用する理由 +GroupDocs.Search は **1 百万ドキュメントまでの高スループットインデックス作成と、サブ秒クエリ応答時間** を典型的なサーバーハードウェア上で実現します。クエリ言語は正確なフレーズ、シンプルな `*` と `?` ワイルドカード、数値範囲（`*2~5`）などの高度なパターンをサポートします。ライブラリは Maven または直接 JAR ダウンロードで任意の Java アプリケーションに統合でき、Java 8+ で外部サービスなしで動作します。 -## “how to search phrase”とは +## 前提条件 +- Java 8 以上（Java 11 LTS 推奨）。 +- Maven 3 以上（依存関係管理を利用する場合）。 +- Java プロジェクト構造とオブジェクト指向概念の基本的な理解。 -フレーズ検索とは、ドキュメント内で特定の単語列を探すことです。ワイルドカードを追加すると、検索エンジンが単語をスキップまたは置換できるようになり、関連性を損なうことなくバリエーションに柔軟にマッチさせることができます。 +## GroupDocs.Search for Java のセットアップ -## フレーズおよびワイルドカードクエリにGroupDocs.Searchを使用する理由 -- **高パフォーマンス**：最適化されたインバーテッドインデックスにより、大規模コレクションでも高速です。 -- **豊富なクエリ言語**：正確なフレーズ、シンプルなワイルドカード、そして高度なパターンをサポートします。 -- **簡単な統合**：Mavenまたは直接ダウンロードで、任意のJavaベースのアプリケーションに組み込めます。 +### Maven を使用する場合 +公式リポジトリと GroupDocs.Search の依存関係を `pom.xml` に追加します。 -## 前提条件 -- Java 8 以上がインストールされていること。 -- Maven 3 以上（Maven依存管理を使用する場合）。 -- Javaの構文とプロジェクト構造に関する基本的な知識。 +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + -## GroupDocs.Search for Javaの設定 + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### 直接ダウンロード +または、公式リリースページから最新 JAR をダウンロードしてください: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/)。 + +### ライセンス取得 +- **無料トライアル:** 手軽な実験に最適。インデックス対象データは 100 MB に制限されます。 +- **一時ライセンス:** GroupDocs ポータルから 30 日間の評価キーをリクエストできます。 +- **フルライセンス:** 本番利用と無制限インデックス容量に必須です。 -### Mavenの使用 -`pom.xml` ファイルにリポジトリと依存関係を追加します: +## 基本的な初期化とセットアップ +インデックスファイルを格納するフォルダーを作成し、`Index` オブジェクトをインスタンス化します。`Index` クラスはディスク上に保存された検索可能インデックスを表し、ドキュメントの追加、更新、クエリ実行メソッドを提供します。 ```xml @@ -59,55 +133,61 @@ weight: 1 ``` -### 直接ダウンロード -あるいは、最新のJARを [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) からダウンロードしてください。 - -### ライセンス取得 -- **Free Trial:** 短時間の実験に最適です。 -- **Temporary License:** 長期テスト用にGroupDocsポータルからリクエストしてください。 -- **Full Purchase:** 本番環境への導入を推奨します。 - -### 基本的な初期化と設定 -インデックス用のフォルダーを作成し、初期化します: +検索対象にしたいドキュメントを追加します。 ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -検索対象にしたいドキュメントを追加します: +## GroupDocs.Search でワイルドカード付きフレーズ検索を行う方法 +このセクションでは、正確一致、シンプルワイルドカード、拡張ワイルドカードパターンの 3 つのレベルでフレーズ検索を実演し、インデックス作成、ドキュメント追加、各クエリタイプの実行方法を簡潔な Java コードで示します。テキストベースのクエリとオブジェクトベースのクエリ構築の両方を例示し、柔軟な検索機能をアプリケーションに統合できるようにします。 + +### シンプルフレーズ検索 +#### 概要 +法的条項や製品モデル番号など、**正確な単語シーケンス** が必要な場合に使用します。 + +#### 直接回答 +インデックスをロードし、引用符で囲んだフレーズ（例: `"quick brown fox"`）で `search` を呼び出すと、エンジンはその正確なシーケンスを含むドキュメントのみを返します。クエリは数ミリ秒で実行され、数十万件のファイルを含むインデックスでも高速です。 + +#### 手順 1: インデックス作成 ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentsFolder); ``` -## GroupDocs.Searchでワイルドカードを使用したフレーズ検索方法 - -以下では、3つの段階的シナリオ（正確なフレーズ検索、シンプルなワイルドカード使用、そして高度なワイルドカードパターン）を解説します。 - -### シンプルなフレーズ検索 - -#### 概要 -単語列の正確な一致が必要なときに使用します。 - -##### 手順 1: インデックスの作成 +#### 手順 2: ドキュメントをインデックスに追加 ```java Index index = new Index(indexFolder); ``` -##### 手順 2: ドキュメントをインデックスに追加 +#### 手順 3: 特定フレーズのテキスト検索 ```java index.add(documentsFolder); ``` -##### 手順 3: 特定のフレーズを検索（テキスト形式） +#### 手順 4: オブジェクトベースクエリ（正確フレーズ検索） ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### 手順 4: オブジェクトベースのクエリ（正確なフレーズ検索） +### ワイルドカード付きフレーズ検索 + +#### 概要 +ワイルドカードプレースホルダー（`*` は任意の文字数、`?` は単一文字）を使用すると、**可変単語をスキップ** しつつ周囲の順序を保持できます。 + +#### 直接回答 +引用符で囲んだフレーズ内にワイルドカードトークン（`*`）を挿入すると、例として `"quick * fox"` は *quick* と *fox* の間に任意の単語が入っていても一致します。エンジンはクエリ時にワイルドカードを展開し、パターンに合致するインデックス用語のみを走査するため、パフォーマンスはプレーンフレーズ検索と同等です。 + +#### 手順 1: インデックス作成 +*(シンプルフレーズ検索と同様)* + +#### 手順 2: ドキュメントをインデックスに追加 +*(上記と同様)* + +#### 手順 3: テキスト形式のワイルドカード検索 ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -116,24 +196,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### ワイルドカード付きフレーズ検索 +#### 手順 4: ワイルドカード付きオブジェクトベースクエリ（Wildcard Search Java） +```java +String queryText = "\"sollicitudin *0~~3 ligula\""; +SearchResult resultText = index.search(queryText); +``` + +### 高度なワイルドカード検索 #### 概要 -ワイルドカードプレースホルダーを使用すると、正確な語句間の可変数の単語をスキップできます。 +数値範囲、オプション文字、カスタム正規表現風パターンを組み合わせて、**高度なマッチング**（バージョン番号や製品コードなど）を実現します。 -##### 手順 1: インデックスの作成 -*（シンプルなフレーズ検索の手順と同じです。）* +#### 直接回答 +拡張ワイルドカード構文 `*min~max` を使用して許容単語距離の範囲を定義したり、`?` で単一文字をマッチさせます。例として、`"error *2~5 code"` は *error* の後に 2〜5 語が続き、最後に *code* が来るケースを検索します。この精度は偽陽性を減らしつつ柔軟性を提供します。 -##### 手順 2: ドキュメントをインデックスに追加 -*（上記と同じです。）* +#### 手順 1: インデックス作成 +*(明確化のため再掲)* -##### 手順 3: ワイルドカード付きテキスト形式検索 -```java -String queryText = "\"sollicitudin *0~~3 ligula\""; -SearchResult resultText = index.search(queryText); -``` +#### 手順 2: ドキュメントをインデックスに追加 +*(再掲)* -##### 手順 4: ワイルドカード付きオブジェクトベースクエリ（Wildcard Search Java） +#### 手順 3: 複雑なワイルドカードパターンのテキスト検索 ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -142,75 +225,68 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### 高度なワイルドカード検索 - -#### 概要 -数値範囲、任意文字、カスタムパターンを組み合わせて、洗練されたマッチングを実現します。 - -##### 手順 1: インデックスの作成 -*（明確にするために繰り返しです。）* - -##### 手順 2: ドキュメントをインデックスに追加 -*（繰り返しです。）* - -##### 手順 3: 複雑なワイルドカードパターンを使用したテキスト形式検索 +#### 手順 4: 高度なワイルドカードを使用したオブジェクトベースクエリ ```java String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; SearchResult resultText = index.search(queryText); ``` -##### 手順 4: 高度なワイルドカードを使用したオブジェクトベースクエリ -```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); -``` - -## 実用的な応用例 -- **Content Management Systems:** エディタが正確な条項や柔軟な抜粋を見つけられるようにします。 -- **E‑commerce Catalogs:** ユーザーが単語を抜かしたり同義語を使用した場合でも、製品を見つけられます。 -- **Legal & Compliance:** 微細なバリエーションで出現する契約文言を迅速に抽出できます。 +## 実用的な活用例 +- **コンテンツ管理システム:** エディタは正確な条項や柔軟な抜粋を数百ページを手作業でスキャンせずに特定できます。 +- **Eコマースカタログ:** 購入者は記述子を省略したり同義語を使用したりしても、ワイルドカード許容により商品を見つけられます。 +- **法務・コンプライアンス:** 契約書間でわずかな表記揺れがある条項を迅速に抽出できます。 -## パフォーマンスに関する考慮点 -- **Create Search Index**：ドキュメントセットごとにインデックスは一度だけ作成し、再利用します。 -- **Add Documents to Index**：新しいファイルが届いたらインクリメンタルに追加し、毎回インデックス全体を再構築しないでください。 -- **precise wildcard patterns** を使用して不要なスキャンを避けます。広範なパターンはCPU負荷を高めます。 -- 定期的に `index.optimize()`（利用可能な場合）を呼び出し、メモリ使用量を抑えます。 +## パフォーマンス上の考慮点 +- **インデックス作成は** 安定したドキュメントセットにつき一度だけ行い、すべてのクエリで同じ `Index` インスタンスを再利用します。 +- **新規ファイルが追加されたら** インデックスをインクリメンタルに更新し、全体再構築を避けて CPU 使用率を抑えます。 +- **ワイルドカードパターンは具体的に** 設計してください。広範囲の `*` は用語展開数を増やし CPU 負荷を上げる可能性があります。 +- **`index.optimize()` を定期的に呼び出す**（サポートされている場合）ことでインデックスを圧縮し、メモリ消費を抑制します。 ## よくある問題と解決策 - | 問題 | 解決策 | -|-------|----------| -| ワイルドカードクエリで結果が返されない | ワイルドカード構文（`*min~~max`）を確認し、指定された距離内に単語が存在することを確認してください。 | -| ファイル更新後にインデックスが古くなる | `index.add(updatedFolder)` を再実行するか、インクリメンタル更新APIを使用してください。 | -| 大規模データセットでのメモリ使用量が高い | JVMヒープサイズを増やし、インデックスを複数のシャードに分割することを検討してください。 | +|------|--------| +| ワイルドカードクエリで結果が返らない | ワイルドカード構文（`*min~max`）を確認し、対象単語が定義距離内に存在することを確認してください。 | +| ファイル更新後にインデックスが古くなる | `index.add(updatedFolder)` またはインクリメンタル更新 API を使用して変更されたファイルのみをリフレッシュします。 | +| 大規模データセットでメモリ使用量が高い | JVM ヒープを増やす（例: `-Xmx4g` 以上）と、インデックスを複数のシャードに分割して並列処理を検討してください。 | -## よくある質問 +## FAQ **Q: ワイルドカードとフレーズ検索の違いは何ですか？** -A: フレーズ検索は正確な単語順を探しますが、ワイルドカードはその順序内で単語を置換またはスキップできます。 +A: フレーズ検索は正確な単語順と間隔を要求しますが、ワイルドカードはその順序内で単語を置換またはスキップでき、柔軟なマッチングを提供します。 -**Q: 検索で数値データにワイルドカードを使用できますか？** -A: はい、ワイルドカードの範囲パラメータは数値でも単語でも機能します。 +**Q: 数値データにワイルドカードを使用できますか？** +A: はい。ワイルドカード範囲パラメータ（`*min~max`）は数値にも適用でき、`"version *1~3"` のようなクエリが可能です。 -**Q: 非常に大規模なドキュメントコレクションをどのように扱うべきですか？** -A: インデックスを最適化し、インクリメンタル更新を使用し、ワイルドカードパターンはできるだけ具体的に設計してください。 +**Q: 非常に大規模なドキュメントコレクションはどう扱うべきですか？** +A: インデックスを最適化し、インクリメンタル更新を行い、特定的なワイルドカードパターンで用語展開を制限します。GroupDocs.Search は 1 百万ドキュメントをインデックスし、標準ハードウェアでクエリ遅延を 200 ms 未満に抑えられます。 -**Q: GroupDocs.Searchはリアルタイム検索シナリオに適していますか？** -A: はい、インデックスが構築されれば、クエリはミリ秒単位で実行され、インタラクティブなアプリケーションに適しています。 +**Q: リアルタイム検索シナリオに適していますか？** +A: 絶対に適しています。インデックスが構築された後はクエリがミリ秒単位で実行され、インタラクティブな検索ボックスやオートコンプリート機能に最適です。 -**Q: 既存のJavaプロジェクトにこのライブラリを統合できますか？** -A: はい。Maven依存関係またはJARを追加し、示したようにインデックスを初期化すればすぐに使用できます。 +**Q: 既存の Java プロジェクトにこのライブラリを統合できますか？** +A: はい。Maven 依存関係または JAR を追加し、上記のように `Index` をインスタンス化すれば、既存コードを変更せずにクエリが可能です。 --- -**最終更新日:** 2026-01-26 +**最終更新日:** 2026-05-28 **テスト環境:** GroupDocs.Search 25.4 for Java -**作者:** GroupDocs \ No newline at end of file +**作者:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## 関連チュートリアル + +- [Java 用検索インデックス作成 – GroupDocs.Search チュートリアル](/search/java/) +- [インデックスへのドキュメント追加 – GroupDocs.Search Java チュートリアル](/search/java/document-management/) +- [検索インデックス作成 - GroupDocs.Search Java チュートリアル](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/korean/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/korean/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index 05ae942c..4f644a51 100644 --- a/content/korean/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/korean/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,45 +1,114 @@ --- -date: '2026-01-26' -description: GroupDocs.Search for Java에서 와일드카드 패턴을 사용하여 구문을 검색하는 방법을 배웁니다. 이 가이드는 - 검색 인덱스 생성, 인덱스에 문서 추가 및 와일드카드 검색 수행에 대해 다룹니다. +date: '2026-05-28' +description: GroupDocs.Search for Java를 사용하여 와일드카드 패턴으로 구문을 검색하는 방법을 배웁니다. search + index 생성, 문서 추가, exact phrase 및 wildcard queries 실행을 포함합니다. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: GroupDocs.Search Java에서 와일드카드를 사용한 구문 검색 방법 +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: GroupDocs.Search for Java에서 와일드카드로 구문 검색하는 방법 type: docs url: /ko/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 --- -# How to Search Phrase with Wildcards in GroupDocs.Search for Java +# GroupDocs.Search for Java에서 와일드카드와 함께 구문 검색하는 방법 -오늘날 빠르게 변화하는 문서 관리 환경에서 **how to search phrase**를 효율적으로 수행하는 것은 애플리케이션 사용성을 좌우합니다. 콘텐츠 관리 시스템, 전자상거래 카탈로그, 법률 문서 저장소 등을 구축하든, 정확한 구문이나 유연한 변형을 찾아낼 수 있는 능력은 매우 중요합니다. 이 튜토리얼에서는 **GroupDocs.Search for Java**를 설정하고, 검색 인덱스를 생성하며, 문서를 인덱스에 추가하고, 간단한 구문 검색과 강력한 와일드카드 검색 Java 기술을 마스터하는 과정을 단계별로 안내합니다. +현대의 문서 중심 애플리케이션에서 **구문 검색 방법**을 빠르고 정확하게 수행하는 것은 사용자 경험에 있어 결정적인 요소입니다. 지식 베이스, 전자상거래 카탈로그, 혹은 규정 기반 저장소를 구축하든, 정확한 구문 또는 그 변형을 찾을 수 있는 능력은 사용자의 생산성을 유지하고 지원 비용을 줄여줍니다. 이 튜토리얼에서는 **GroupDocs.Search for Java** 설치, 검색 인덱스 생성, 문서 로드, 정확한 구문 및 와일드카드 강화 쿼리 실행을 명확하고 프로덕션 준비된 코드 스니펫과 함께 안내합니다. -## Quick Answers -- **What is the primary benefit of phrase searches?** Precise matching of word order and proximity. -- **Can wildcards be used inside a phrase?** Yes, you can combine wildcards with exact words for flexible matching. -- **Do I need a license for development?** A free trial works for testing; a full license is required for production. -- **Which Maven version should I use?** The latest GroupDocs.Search for Java release (e.g., 25.4 at the time of writing). -- **Is this approach suitable for large document sets?** Absolutely—just keep the index optimized and use targeted wildcard patterns. +## 빠른 답변 +- **구문 검색의 주요 이점은 무엇인가요?** 단어 순서와 근접성을 정확히 일치시켜 정확한 시퀀스를 포함하는 문서만 반환됩니다. +- **구문 안에 와일드카드를 사용할 수 있나요?** 예—와일드카드는 전체 순서를 유지하면서 단어를 건너뛰거나 교체할 수 있게 해줍니다. +- **개발에 라이선스가 필요합니까?** 무료 체험판으로 테스트가 가능하며, 프로덕션 배포에는 정식 라이선스가 필요합니다. +- **어떤 Maven 버전을 사용해야 하나요?** 최신 GroupDocs.Search for Java 릴리스(예: 작성 시점 25.4)입니다. +- **이 접근 방식이 대규모 문서 집합에 적합한가요?** 물론입니다—인덱스가 최적화된 경우 GroupDocs.Search는 수십만 개 문서 컬렉션을 서브초 수준의 쿼리 지연 시간으로 처리할 수 있습니다. -## What is “how to search phrase”? -구문 검색이란 문서 내에서 특정 단어 순서를 찾는 것을 의미합니다. 와일드카드를 추가하면 검색 엔진이 단어를 건너뛰거나 대체하도록 허용하여, 관련성을 유지하면서 변형을 매칭할 수 있는 유연성을 제공합니다. +## “구문 검색 방법”이란? +**구문을 검색한다는 것은 문서에서 특정 단어 순서를 찾는 것을 의미합니다.** +구문 쿼리를 실행하면 엔진은 단어가 정확한 순서와 정의된 근접성 내에 나타나는지 확인하여, 다른 문맥에서 동일한 단어가 포함된 관련 없는 결과를 제거합니다. 이는 구문 검색이 법적 조항, 제품 코드 또는 순서가 중요한 모든 텍스트를 찾는 데 이상적임을 의미합니다. -## Why Use GroupDocs.Search for Phrase and Wildcard Queries? -- **High performance** on large collections thanks to an optimized inverted index. -- **Rich query language** that supports exact phrase, simple wildcards, and advanced patterns. -- **Easy integration** with any Java‑based application via Maven or direct download. +## 구문 및 와일드카드 쿼리에 GroupDocs.Search를 사용하는 이유 +GroupDocs.Search는 일반 서버 하드웨어에서 **최대 100만 문서까지 고처리량 인덱싱을 제공하면서 서브초 수준의 쿼리 응답 시간을 유지**합니다. 쿼리 언어는 정확한 구문, 간단한 `*` 및 `?` 와일드카드, 그리고 숫자 범위(`*2~5`)와 같은 고급 패턴을 지원합니다. 이 라이브러리는 Maven이나 직접 JAR 다운로드를 통해 모든 Java 애플리케이션에 통합될 수 있으며, 외부 서비스 없이 Java 8+에서 실행됩니다. -## Prerequisites -- Java 8 or newer installed. -- Maven 3 or later (if you prefer Maven dependency management). -- Basic familiarity with Java syntax and project structure. +## 사전 요구 사항 +- Java 8 이상 (Java 11 LTS 권장). +- Maven 3 이상(의존성 관리를 선호하는 경우). +- Java 프로젝트 구조와 객체 지향 개념에 대한 기본적인 이해. -## Setting Up GroupDocs.Search for Java +## GroupDocs.Search for Java 설정 -### Using Maven -Add the repository and dependency to your `pom.xml` file: +### Maven 사용 +공식 리포지토리와 GroupDocs.Search 의존성을 `pom.xml`에 추가합니다: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### 직접 다운로드 +또는 공식 릴리스 페이지에서 최신 JAR를 다운로드하세요: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### 라이선스 획득 +- **무료 체험:** 빠른 실험에 이상적이며, 인덱싱된 데이터가 100 MB로 제한됩니다. +- **임시 라이선스:** GroupDocs 포털에서 30일 평가 키를 요청하세요. +- **정식 라이선스:** 프로덕션 사용 및 무제한 인덱싱 용량에 필요합니다. + +## 기본 초기화 및 설정 +인덱스 파일을 보관할 폴더를 만들고 `Index` 객체를 인스턴스화합니다. `Index` 클래스는 디스크에 저장된 검색 가능한 인덱스를 나타내며, 문서를 추가, 업데이트 및 쿼리하는 메서드를 제공합니다. ```xml @@ -59,56 +128,61 @@ Add the repository and dependency to your `pom.xml` file: ``` -### Direct Download -Alternatively, download the latest JAR from [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### License Acquisition -- **Free Trial:** Ideal for quick experiments. -- **Temporary License:** Request via the GroupDocs portal for extended testing. -- **Full Purchase:** Recommended for production deployments. - -### Basic Initialization and Setup -Create a folder for the index and initialize it: +검색 가능하도록 만들 문서를 추가합니다: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Add the documents you want to make searchable: +## GroupDocs.Search에서 와일드카드와 함께 구문 검색하는 방법 +이 섹션에서는 구문 검색의 세 단계—정확히 일치, 간단한 와일드카드, 고급 와일드카드 패턴—를 시연하며, 인덱스 생성, 문서 추가 및 각 쿼리 유형을 간결한 Java 코드로 실행하는 방법을 보여줍니다. 예제는 텍스트 기반 쿼리와 객체 기반 쿼리 구성을 모두 설명하여 개발자가 애플리케이션에 유연한 검색 기능을 통합할 수 있게 합니다. + +### 간단한 구문 검색 +#### 개요 +법적 조항이나 제품 모델 번호와 같이 단어 순서의 **정확히 일치**가 필요할 때 이 방법을 사용합니다. + +#### 직접 답변 +인덱스를 로드하고, 인용된 구문(예: `"quick brown fox"`)으로 `search`를 호출하면 엔진은 정확히 그 순서와 공백을 유지하는 문서만 반환합니다. 쿼리는 수백만 파일이 포함된 인덱스에서도 밀리초 단위로 실행됩니다. + +#### 단계 1: 인덱스 생성 ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentsFolder); ``` -## How to Search Phrase with Wildcards in GroupDocs.Search -Below we break down three progressive scenarios: exact phrase search, simple wildcard usage, and advanced wildcard patterns. - -### Simple Phrase Search - -#### Overview -Use this when you need an exact match of a word sequence. - -##### Step 1: Create an Index +#### 단계 2: 인덱스에 문서 추가 ```java Index index = new Index(indexFolder); ``` -##### Step 2: Add Documents to Index +#### 단계 3: 특정 구문 검색 (텍스트 형태) ```java index.add(documentsFolder); ``` -##### Step 3: Search for a Specific Phrase (Text Form) - +#### 단계 4: 객체 기반 쿼리 (정확한 구문 검색) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Step 4: Object‑Based Queries (Search Exact Phrase) +### 와일드카드가 포함된 구문 검색 + +#### 개요 +와일드카드 자리표시자(`*`는 임의의 문자 수, `?`는 단일 문자)는 주변 순서를 유지하면서 **가변 단어를 건너뛸** 수 있게 합니다. +#### 직접 답변 +인용된 구문 안에 와일드카드 토큰(`*`)을 삽입—예: `"quick * fox"`—하면 *quick*과 *fox* 사이의 모든 단어와 일치합니다. 엔진은 쿼리 시점에 와일드카드를 확장하여 패턴을 만족하는 인덱스된 용어만 스캔하므로 성능이 일반 구문 쿼리와 비슷합니다. + +#### 단계 1: 인덱스 생성 +*(Simple Phrase Search와 동일합니다.)* + +#### 단계 2: 인덱스에 문서 추가 +*(위와 동일합니다.)* + +#### 단계 3: 와일드카드가 포함된 텍스트 형태 검색 ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -117,26 +191,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### Phrase Search with Wildcards - -#### Overview -Wildcard placeholders let you skip a variable number of words between exact terms. - -##### Step 1: Create an Index -*(Same as the Simple Phrase Search steps.)* - -##### Step 2: Add Documents to Index -*(Same as above.)* - -##### Step 3: Text Form Search with Wildcards - +#### 단계 4: 와일드카드가 포함된 객체 기반 쿼리 (Wildcard Search Java) ```java String queryText = "\"sollicitudin *0~~3 ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Step 4: Object‑Based Queries with Wildcards (Wildcard Search Java) +### 고급 와일드카드 검색 + +#### 개요 +숫자 범위, 선택적 문자 및 사용자 정의 정규식 유사 패턴을 결합하여 **정교한 매칭**을 수행합니다(예: 버전 번호 또는 제품 코드). + +#### 직접 답변 +확장된 와일드카드 구문 `*min~max`를 사용해 허용되는 단어 거리 범위를 정의하거나 `?`로 단일 문자를 매칭합니다. 예를 들어, `"error *2~5 code"`는 *error* 뒤에 2~5개의 단어가 오고 그 뒤에 *code*가 오는 경우를 찾습니다. 이러한 정밀도는 거짓 양성을 줄이면서도 유연성을 제공합니다. + +#### 단계 1: 인덱스 생성 +*(명확성을 위해 반복합니다.)* +#### 단계 2: 인덱스에 문서 추가 +*(반복합니다.)* + +#### 단계 3: 복잡한 와일드카드 패턴이 포함된 텍스트 형태 검색 ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -145,25 +220,52 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### Advanced Wildcard Search +#### 단계 4: 고급 와일드카드가 포함된 객체 기반 쿼리 +```java +String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; +SearchResult resultText = index.search(queryText); +``` -#### Overview -Combine numeric ranges, optional characters, and custom patterns for sophisticated matching. +## 실용적인 적용 사례 +- **콘텐츠 관리 시스템:** 편집자는 수백 페이지를 수동으로 스캔하지 않고도 정확한 조항이나 유연한 발췌를 찾을 수 있습니다. +- **전자상거래 카탈로그:** 와일드카드 허용 덕분에 구매자는 설명자를 생략하거나 동의어를 사용해도 제품을 찾을 수 있습니다. +- **법률 및 컴플라이언스:** 계약서 전반에 걸쳐 약간의 변형이 있을 수 있는 계약 언어를 신속하게 분리할 수 있습니다. -##### Step 1: Create an Index -*(Repeated for clarity.)* +## 성능 고려 사항 +- **Create Search Index**는 안정적인 문서 집합당 한 번만 수행하고, 모든 쿼리에서 동일한 `Index` 인스턴스를 재사용합니다. +- **Add Documents Incrementally** 새 파일이 도착하면 점진적으로 추가합니다—전체 인덱스를 재구축하는 것을 피해 CPU 사용량을 낮게 유지합니다. +- **Design Precise Wildcard Patterns**; 더 넓은 패턴(`*`)은 용어 확장 수를 늘려 CPU 부하를 증가시킬 수 있습니다. +- **Call `index.optimize()`**를 주기적으로(지원되는 경우) 호출하여 인덱스를 압축하고 메모리 사용량을 제어합니다. -##### Step 2: Add Documents to Index -*(Repeated.)* +## 일반적인 문제 및 해결책 +| 문제 | 해결책 | +|-------|----------| +| 와일드카드 쿼리에서 결과가 반환되지 않음 | 와일드카드 구문(`*min~max`)을 확인하고 대상 단어가 정의된 거리 내에 존재하는지 확인합니다. | +| 파일 업데이트 후 인덱스가 오래됨 | `index.add(updatedFolder)` 또는 증분 업데이트 API를 사용해 변경된 파일만 새로 고칩니다. | +| 대규모 데이터셋에서 높은 메모리 사용량 | JVM 힙을 늘립니다(`-Xmx4g` 이상) 및 병렬 처리를 위해 인덱스를 여러 샤드로 분할하는 것을 고려합니다. | -##### Step 3: Text Form Search with Complex Wildcard Patterns +## 자주 묻는 질문 -```java -String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; -SearchResult resultText = index.search(queryText); -``` +**Q: 와일드카드와 구문 검색의 차이점은 무엇인가요?** +A: 구문 검색은 정확한 단어 순서와 공백을 요구하는 반면, 와일드카드는 그 순서 내에서 단어를 교체하거나 건너뛰어 유연한 매칭을 제공합니다. + +**Q: 검색에서 숫자 데이터와 함께 와일드카드를 사용할 수 있나요?** +A: 예—와일드카드 범위 매개변수(`*min~max`)는 숫자와 단어 모두에 적용되어 `"version *1~3"`와 같은 쿼리를 가능하게 합니다. + +**Q: 매우 큰 문서 컬렉션을 어떻게 처리해야 하나요?** +A: 인덱스를 최적화하고, 증분 업데이트를 수행하며, 용어 확장을 제한하도록 구체적인 와일드카드 패턴을 설계합니다. GroupDocs.Search는 표준 하드웨어에서 쿼리 지연 시간을 200 ms 이하로 유지하면서 100만 문서를 인덱싱할 수 있습니다. -##### Step 4: Object‑Based Queries with Advanced Wildcards +**Q: GroupDocs.Search가 실시간 검색 시나리오에 적합한가요?** +A: 물론입니다—인덱스가 구축되면 쿼리는 밀리초 단위로 실행되어 인터랙티브 검색 박스와 자동 완성 기능에 이상적입니다. + +**Q: 기존 Java 프로젝트에 이 라이브러리를 통합할 수 있나요?** +A: 예. Maven 의존성이나 JAR를 추가하고, 예시와 같이 `Index`를 인스턴스화하면 기존 코드를 변경하지 않고도 바로 쿼리를 실행할 수 있습니다. + +--- + +**Last Updated:** 2026-05-28 +**Tested With:** GroupDocs.Search 25.4 for Java +**Author:** GroupDocs ```java double word1 = SearchQuery.createWordQuery("sollicitudin"); @@ -178,43 +280,8 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -## Practical Applications -- **Content Management Systems:** Enable editors to locate exact clauses or flexible excerpts. -- **E‑commerce Catalogs:** Let shoppers find products even when they miss a word or use synonyms. -- **Legal & Compliance:** Quickly isolate contractual language that may appear with minor variations. - -## Performance Considerations -- **Create Search Index** only once per document set, then reuse it. -- **Add Documents to Index** incrementally when new files arrive—don’t rebuild the whole index each time. -- Use **precise wildcard patterns** to avoid unnecessary scanning; broader patterns increase CPU load. -- Periodically call `index.optimize()` (if available) to keep memory usage low. - -## Common Issues & Solutions -| Issue | Solution | -|-------|----------| -| No results returned for a wildcard query | Verify the wildcard syntax (`*min~~max`) and ensure the words exist within the specified distance. | -| Index becomes stale after file updates | Re‑run `index.add(updatedFolder)` or use the incremental update API. | -| High memory consumption on large datasets | Increase JVM heap size and consider splitting the index into multiple shards. | - -## Frequently Asked Questions - -**Q: What is the difference between a wildcard and a phrase search?** -A: A phrase search looks for an exact word order, while a wildcard allows you to replace or skip words within that order. +## 관련 튜토리얼 -**Q: Can I use wildcards with numeric data in searches?** -A: Yes, the wildcard range parameters work with numbers as well as words. - -**Q: How should I handle very large document collections?** -A: Keep the index optimized, use incremental updates, and design your wildcard patterns to be as specific as possible. - -**Q: Is GroupDocs.Search suitable for real‑time search scenarios?** -A: Absolutely—once the index is built, queries execute in milliseconds, making it fit for interactive applications. - -**Q: Can I integrate this library into an existing Java project?** -A: Yes. Add the Maven dependency or JAR, initialize the index as shown, and you’re ready to go. - ---- - -**Last Updated:** 2026-01-26 -**Tested With:** GroupDocs.Search 25.4 for Java -**Author:** GroupDocs \ No newline at end of file +- [Create Search Index Java – GroupDocs.Search 튜토리얼](/search/java/) +- [Add Documents to Index – GroupDocs.Search Java 튜토리얼](/search/java/document-management/) +- [Create Search Index - GroupDocs.Search Java 튜토리얼](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/polish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/polish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index c531f032..1d17a9e5 100644 --- a/content/polish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/polish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,13 +1,55 @@ --- -date: '2026-01-26' -description: Dowiedz się, jak wyszukiwać frazy przy użyciu wzorców wieloznacznych - w GroupDocs.Search dla Javy. Ten przewodnik obejmuje tworzenie indeksu wyszukiwania, - dodawanie dokumentów do indeksu oraz wykonywanie wyszukiwania wieloznacznego w Javie. +date: '2026-05-28' +description: Dowiedz się, jak wyszukiwać frazy przy użyciu wildcard patterns w GroupDocs.Search + dla Javy. Zawiera tworzenie search index, dodawanie dokumentów oraz wykonywanie + exact phrase i wildcard queries. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: Jak wyszukać frazę z znakami wieloznacznych w GroupDocs.Search Java +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: Jak wyszukać frazę z użyciem wildcards w GroupDocs.Search dla Javy type: docs url: /pl/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 @@ -15,32 +57,59 @@ weight: 1 # Jak wyszukiwać frazy z wieloznacznikami w GroupDocs.Search dla Javy -W dzisiejszym szybkim świecie zarządzania dokumentami, **how to search phrase** efektywne może decydować o użyteczności aplikacji. Niezależnie od tego, czy tworzysz system zarządzania treścią, katalog e‑commerce, czy repozytorium dokumentów prawnych, możliwość odnalezienia dokładnych fraz — lub ich elastycznych wariantów — ma znaczenie. W tym samouczku przeprowadzimy Cię przez konfigurację **GroupDocs.Search for Java**, tworzenie indeksu wyszukiwania, dodawanie dokumentów do indeksu oraz opanowanie zarówno prostych wyszukiwań fraz, jak i potężnych technik wyszukiwania z wieloznacznikami w Javie. +W nowoczesnych aplikacjach skoncentrowanych na dokumentach, **how to search phrase** szybko i dokładnie jest czynnikiem decydującym o doświadczeniu użytkownika. Niezależnie od tego, czy budujesz bazę wiedzy, katalog e‑commerce, czy repozytorium oparte na zgodności, możliwość zlokalizowania dokładnej frazy — lub jej elastycznej wariacji — utrzymuje użytkowników produktywnych i zmniejsza obciążenie wsparcia. Ten samouczek przeprowadzi Cię przez instalację **GroupDocs.Search for Java**, tworzenie indeksu wyszukiwania, ładowanie dokumentów oraz uruchamianie zarówno zapytań dokładnych, jak i wzbogaconych o wieloznaczniki, wszystko przy użyciu przejrzystych, gotowych do produkcji fragmentów kodu. -## Quick Answers -- **Jaka jest główna korzyść wyszukiwania fraz?** Precyzyjne dopasowanie kolejności słów i ich bliskości. -- **Czy wieloznaczniki mogą być używane wewnątrz frazy?** Tak, możesz łączyć wieloznaczniki z dokładnymi słowami, aby uzyskać elastyczne dopasowanie. -- **Czy potrzebuję licencji do rozwoju?** Darmowa wersja próbna wystarcza do testów; pełna licencja jest wymagana w produkcji. -- **Jaką wersję Maven powinienem używać?** Najnowsze wydanie GroupDocs.Search for Java (np. 25.4 w momencie pisania). -- **Czy to podejście jest odpowiednie dla dużych zbiorów dokumentów?** Zdecydowanie — wystarczy utrzymać zoptymalizowany indeks i używać ukierunkowanych wzorców wieloznaczników. +## Szybkie odpowiedzi +- **What is the primary benefit of phrase searches?** Precyzyjne dopasowanie kolejności słów i ich bliskości, gwarantujące, że zwrócone zostaną tylko dokumenty zawierające dokładną sekwencję. +- **Can wildcards be used inside a phrase?** Tak — wieloznaczniki pozwalają pominąć lub zastąpić słowa, zachowując ogólną kolejność. +- **Do I need a license for development?** Darmowa wersja próbna działa do testów; pełna licencja jest wymagana w środowiskach produkcyjnych. +- **Which Maven version should I use?** Najnowsze wydanie GroupDocs.Search for Java (np. 25.4 w momencie pisania). +- **Is this approach suitable for large document sets?** Absolutnie — GroupDocs.Search radzi sobie z kolekcjami liczącymi setki tysięcy dokumentów przy opóźnieniu zapytań poniżej sekundy, gdy indeks jest zoptymalizowany. -## Czym jest „how to search phrase”? -Wyszukiwanie frazy oznacza poszukiwanie określonej sekwencji słów w dokumencie. Dodając wieloznaczniki, pozwalasz silnikowi wyszukiwania pomijać lub zastępować słowa, co daje elastyczność dopasowywania wariantów bez utraty trafności. +## Co to jest „how to search phrase”? +**Wyszukiwanie frazy oznacza szukanie określonej sekwencji słów w dokumencie.** +Gdy wykonujesz zapytanie frazowe, silnik sprawdza, czy słowa pojawiają się w dokładnej kolejności i w określonej bliskości, eliminując nieistotne trafienia, które zawierają te same słowa w innym kontekście. Dzięki temu wyszukiwanie fraz jest idealne do znajdowania klauzul prawnych, kodów produktów lub dowolnego tekstu, w którym kolejność ma znaczenie. -## Dlaczego używać GroupDocs.Search do zapytań frazowych i z wieloznacznikami? -- **Wysoka wydajność** przy dużych kolekcjach dzięki zoptymalizowanemu odwróconemu indeksowi. -- **Bogaty język zapytań** obsługujący dokładne frazy, proste wieloznaczniki i zaawansowane wzorce. -- **Łatwa integracja** z dowolną aplikacją opartą na Javie poprzez Maven lub bezpośrednie pobranie. +## Dlaczego warto używać GroupDocs.Search do zapytań frazowych i z wieloznacznikami? +GroupDocs.Search zapewnia **wysoką przepustowość indeksowania do 1 miliona dokumentów przy zachowaniu odpowiedzi na zapytania w czasie poniżej sekundy** na typowym sprzęcie serwerowym. Jego język zapytań obsługuje dokładne frazy, proste wieloznaczniki `*` i `?`, oraz zaawansowane wzorce, takie jak zakresy liczbowe (`*2~5`). Biblioteka integruje się z dowolną aplikacją Java poprzez Maven lub bezpośrednie pobranie JAR‑a i działa na Java 8+ bez zewnętrznych usług. -## Prerequisites -- Java 8 lub nowsza zainstalowana. -- Maven 3 lub nowszy (jeśli preferujesz zarządzanie zależnościami przez Maven). -- Podstawowa znajomość składni Javy i struktury projektu. +## Wymagania wstępne +- Java 8 lub nowsza (zalecany Java 11 LTS). +- Maven 3 lub nowszy (jeśli preferujesz zarządzanie zależnościami). +- Podstawowa znajomość struktury projektu Java oraz koncepcji obiektowo‑zorientowanych. -## Setting Up GroupDocs.Search for Java +## Konfiguracja GroupDocs.Search dla Javy -### Using Maven -Add the repository and dependency to your `pom.xml` file: +### Korzystanie z Maven +Dodaj oficjalne repozytorium i zależność GroupDocs.Search do swojego `pom.xml`: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Bezpośrednie pobranie +Alternatywnie, pobierz najnowszy JAR z oficjalnej strony wydań: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Uzyskanie licencji +- **Free Trial:** Idealna do szybkich eksperymentów; ograniczona do 100 MB indeksowanych danych. +- **Temporary License:** Poproś o 30‑dniowy klucz ewaluacyjny w portalu GroupDocs. +- **Full License:** Wymagana do użytku produkcyjnego i nieograniczonej pojemności indeksowania. + +## Podstawowa inicjalizacja i konfiguracja +Utwórz folder, w którym będą przechowywane pliki indeksu, i zainicjalizuj obiekt `Index`. Klasa `Index` reprezentuje indeks wyszukiwalny przechowywany na dysku i udostępnia metody dodawania, aktualizacji i zapytań dokumentów. ```xml @@ -60,54 +129,60 @@ Add the repository and dependency to your `pom.xml` file: ``` -### Direct Download -Alternatywnie, pobierz najnowszy plik JAR z [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### License Acquisition -- **Free Trial:** Idealny do szybkich eksperymentów. -- **Temporary License:** Wniosek przez portal GroupDocs w celu przedłużonych testów. -- **Full Purchase:** Zalecany do wdrożeń produkcyjnych. - -### Basic Initialization and Setup -Create a folder for the index and initialize it: - +### Dodaj dokumenty, które mają być przeszukiwane: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Add the documents you want to make searchable: +## Jak wyszukiwać frazy z wieloznacznikami w GroupDocs.Search +Ten rozdział demonstruje trzy poziomy wyszukiwania fraz — dokładne dopasowanie, prosty wieloznacznik oraz zaawansowane wzorce wieloznaczników — pokazując, jak utworzyć indeks, dodać dokumenty i wykonać każdy typ zapytania przy użyciu zwięzłego kodu Java. Przykłady ilustrują zarówno zapytania tekstowe, jak i oparte na obiektach, umożliwiając deweloperom integrację elastycznych możliwości wyszukiwania w swoich aplikacjach. + +### Proste wyszukiwanie frazy +#### Przegląd +Użyj tego podejścia, gdy potrzebujesz **dokładnego dopasowania** sekwencji słów, np. klauzuli prawnej lub numeru modelu produktu. + +#### Bezpośrednia odpowiedź +Załaduj indeks, wywołaj `search` z frazą w cudzysłowie (np. `"quick brown fox"`), a silnik zwróci tylko dokumenty zawierające tę dokładną sekwencję, zachowując kolejność słów i odstępy. Zapytanie wykonuje się w milisekundach, nawet przy indeksach zawierających setki tysięcy plików. + +#### Krok 1: Utwórz indeks ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentsFolder); ``` -## Jak wyszukiwać frazy z wieloznacznikami w GroupDocs.Search -Poniżej przedstawiamy trzy rosnące scenariusze: dokładne wyszukiwanie frazy, proste użycie wieloznaczników oraz zaawansowane wzorce wieloznaczników. - -### Simple Phrase Search - -#### Overview -Użyj tego, gdy potrzebne jest dokładne dopasowanie kolejności słów. - -##### Step 1: Create an Index +#### Krok 2: Dodaj dokumenty do indeksu ```java Index index = new Index(indexFolder); ``` -##### Step 2: Add Documents to Index +#### Krok 3: Wyszukaj konkretną frazę (forma tekstowa) ```java index.add(documentsFolder); ``` -##### Step 3: Search for a Specific Phrase (Text Form) +#### Krok 4: Zapytania oparte na obiektach (wyszukiwanie dokładnej frazy) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Step 4: Object‑Based Queries (Search Exact Phrase) +### Wyszukiwanie frazy z wieloznacznikami + +#### Przegląd +Wieloznaczniki (`*` dla dowolnej liczby znaków, `?` dla jednego znaku) pozwalają **pominąć zmienne słowa**, zachowując jednocześnie otaczający je porządek. + +#### Bezpośrednia odpowiedź +Wstaw token wieloznacznika (`*`) wewnątrz frazy w cudzysłowie — np. `"quick * fox"` — aby dopasować dowolne słowo(a) pomiędzy *quick* a *fox*. Silnik rozwija wieloznacznik w czasie zapytania, przeszukując tylko indeksowane terminy spełniające wzorzec, co utrzymuje wydajność porównywalną z prostym zapytaniem frazowym. + +#### Krok 1: Utwórz indeks +*(Tak samo jak w prostym wyszukiwaniu frazy.)* + +#### Krok 2: Dodaj dokumenty do indeksu +*(Tak samo jak powyżej.)* + +#### Krok 3: Wyszukiwanie w formie tekstowej z wieloznacznikami ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -116,99 +191,95 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### Phrase Search with Wildcards - -#### Overview -Symboliczne wieloznaczniki pozwalają pominąć zmienną liczbę słów pomiędzy dokładnymi terminami. - -##### Step 1: Create an Index -*(Takie same jak kroki w prostym wyszukiwaniu frazy.)* - -##### Step 2: Add Documents to Index -*(Takie same jak powyżej.)* - -##### Step 3: Text Form Search with Wildcards +#### Krok 4: Zapytania oparte na obiektach z wieloznacznikami (Wildcard Search Java) ```java String queryText = "\"sollicitudin *0~~3 ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Step 4: Object‑Based Queries with Wildcards (Wildcard Search Java) -```java -SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); -SearchQuery word3 = SearchQuery.createWordQuery("ligula"); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, word3); -SearchResult resultObject = index.search(queryObject); -``` +### Zaawansowane wyszukiwanie wieloznacznikami -### Advanced Wildcard Search +#### Przegląd +Łącz zakresy liczbowe, opcjonalne znaki i własne wzorce podobne do wyrażeń regularnych, aby uzyskać **zaawansowane dopasowanie**, np. numerów wersji lub kodów produktów. -#### Overview -Łącz zakresy liczbowe, znaki opcjonalne i własne wzorce, aby uzyskać zaawansowane dopasowanie. +#### Bezpośrednia odpowiedź +Użyj rozszerzonej składni wieloznaczników `*min~max`, aby określić zakres dopuszczalnych odległości słów, lub `?` do dopasowania jednego znaku. Na przykład, `"error *2~5 code"` znajdzie słowo *error* po którym nastąpi od dwóch do pięciu słów, a następnie *code*. Ta precyzja zmniejsza liczbę fałszywych trafień, jednocześnie oferując elastyczność. -##### Step 1: Create an Index +#### Krok 1: Utwórz indeks *(Powtórzone dla jasności.)* -##### Step 2: Add Documents to Index +#### Krok 2: Dodaj dokumenty do indeksu *(Powtórzone.)* -##### Step 3: Text Form Search with Complex Wildcard Patterns +#### Krok 3: Wyszukiwanie w formie tekstowej z złożonymi wzorcami wieloznaczników ```java -String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; -SearchResult resultText = index.search(queryText); +SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); +SearchQuery word3 = SearchQuery.createWordQuery("ligula"); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, word3); +SearchResult resultObject = index.search(queryObject); ``` -##### Step 4: Object‑Based Queries with Advanced Wildcards +#### Krok 4: Zapytania oparte na obiektach z zaawansowanymi wieloznacznikami ```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); +String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; +SearchResult resultText = index.search(queryText); ``` ## Praktyczne zastosowania -- **Content Management Systems:** Umożliwiają redaktorom znajdowanie dokładnych klauzul lub elastycznych fragmentów. -- **E‑commerce Catalogs:** Pozwalają klientom znaleźć produkty, nawet jeśli pomijają słowo lub używają synonimów. -- **Legal & Compliance:** Szybko izolują język umowny, który może występować z drobnymi wariacjami. +- **Systemy zarządzania treścią:** Redaktorzy mogą szybko znajdować dokładne klauzule lub elastyczne fragmenty bez ręcznego przeglądania setek stron. +- **Katalogi e‑commerce:** Klienci znajdują produkty, nawet gdy pomijają opis lub używają synonimów, dzięki tolerancji na wieloznaczniki. +- **Prawo i zgodność:** Szybko izolują fragmenty umów, które mogą występować z drobnymi wariacjami w różnych dokumentach. ## Rozważania dotyczące wydajności -- **Create Search Index** tylko raz na zestaw dokumentów, a następnie go ponownie używać. -- **Add Documents to Index** stopniowo, gdy pojawiają się nowe pliki — nie przebudowuj całego indeksu za każdym razem. -- Używaj **precyzyjnych wzorców wieloznaczników**, aby uniknąć niepotrzebnego skanowania; szersze wzorce zwiększają obciążenie CPU. -- Okresowo wywołuj `index.optimize()` (jeśli dostępne), aby utrzymać niskie zużycie pamięci. +- **Utwórz indeks wyszukiwania** tylko raz dla stabilnego zestawu dokumentów; używaj tego samego obiektu `Index` dla wszystkich zapytań. +- **Dodawaj dokumenty stopniowo**, gdy pojawiają się nowe pliki — unikaj przebudowy całego indeksu, aby utrzymać niskie zużycie CPU. +- **Projektuj precyzyjne wzorce wieloznaczników**; szersze wzorce (`*`) zwiększają liczbę rozwinięć terminów i mogą podnieść obciążenie CPU. +- **Wywołuj `index.optimize()`** okresowo (jeśli jest wspierane), aby skompaktować indeks i utrzymać kontrolę nad zużyciem pamięci. ## Typowe problemy i rozwiązania - | Problem | Rozwiązanie | |-------|----------| -| Brak wyników dla zapytania z wieloznacznikiem | Sprawdź składnię wieloznacznika (`*min~~max`) i upewnij się, że słowa występują w określonej odległości. | -| Indeks staje się nieaktualny po aktualizacji plików | Ponownie uruchom `index.add(updatedFolder)` lub użyj API aktualizacji przyrostowej. | -| Wysokie zużycie pamięci przy dużych zestawach danych | Zwiększ rozmiar sterty JVM i rozważ podzielenie indeksu na wiele fragmentów. | +| Brak wyników dla zapytania z wieloznacznikiem | Zweryfikuj składnię wieloznacznika (`*min~max`) i upewnij się, że docelowe słowa występują w określonej odległości. | +| Indeks staje się nieaktualny po aktualizacji plików | Użyj `index.add(updatedFolder)` lub API aktualizacji przyrostowej, aby odświeżyć tylko zmienione pliki. | +| Wysokie zużycie pamięci przy dużych zbiorach danych | Zwiększ przydział pamięci JVM (`-Xmx4g` lub wyższy) i rozważ podzielenie indeksu na wiele shardów w celu równoległego przetwarzania. | ## Najczęściej zadawane pytania -**P: Jaka jest różnica między wieloznacznikiem a wyszukiwaniem frazy?** -O: Wyszukiwanie frazy szuka dokładnej kolejności słów, podczas gdy wieloznacznik pozwala zastąpić lub pominąć słowa w tej kolejności. +**Q: Jaka jest różnica między wieloznacznikiem a wyszukiwaniem frazy?** +A: Wyszukiwanie frazy wymaga dokładnej kolejności słów i odstępów, natomiast wieloznacznik pozwala zastąpić lub pominąć słowa w tej kolejności, oferując elastyczne dopasowanie. -**P: Czy mogę używać wieloznaczników z danymi liczbowymi w wyszukiwaniach?** -O: Tak, parametry zakresu wieloznacznika działają zarówno z liczbami, jak i ze słowami. +**Q: Czy mogę używać wieloznaczników z danymi liczbowymi w wyszukiwaniach?** +A: Tak — parametry zakresu wieloznacznika (`*min~max`) działają zarówno na liczbach, jak i na słowach, umożliwiając zapytania typu `"version *1~3"`. -**P: Jak powinienem obsługiwać bardzo duże kolekcje dokumentów?** -O: Utrzymuj zoptymalizowany indeks, używaj aktualizacji przyrostowych i projektuj wzorce wieloznaczników tak, aby były jak najbardziej konkretne. +**Q: Jak radzić sobie z bardzo dużymi kolekcjami dokumentów?** +A: Utrzymuj indeks zoptymalizowany, wykonuj aktualizacje przyrostowe i twórz konkretne wzorce wieloznaczników, aby ograniczyć rozwinięcia terminów. GroupDocs.Search może indeksować 1 milion dokumentów przy opóźnieniu zapytań poniżej 200 ms na standardowym sprzęcie. -**P: Czy GroupDocs.Search jest odpowiedni do scenariuszy wyszukiwania w czasie rzeczywistym?** -O: Zdecydowanie — po zbudowaniu indeksu zapytania wykonują się w milisekundach, co sprawia, że nadaje się do aplikacji interaktywnych. +**Q: Czy GroupDocs.Search nadaje się do scenariuszy wyszukiwania w czasie rzeczywistym?** +A: Absolutnie — po zbudowaniu indeksu zapytania wykonują się w milisekundach, co czyni go idealnym dla interaktywnych pól wyszukiwania i funkcji autouzupełniania. -**P: Czy mogę zintegrować tę bibliotekę z istniejącym projektem Java?** -O: Tak. Dodaj zależność Maven lub plik JAR, zainicjalizuj indeks jak pokazano i jesteś gotowy do działania. +**Q: Czy mogę zintegrować tę bibliotekę z istniejącym projektem Java?** +A: Tak. Dodaj zależność Maven lub JAR, zainicjalizuj `Index` jak pokazano i możesz od razu wykonywać zapytania bez modyfikacji istniejącego kodu. -**Ostatnia aktualizacja:** 2026-01-26 +**Ostatnia aktualizacja:** 2026-05-28 **Testowano z:** GroupDocs.Search 25.4 for Java -**Autor:** GroupDocs \ No newline at end of file +**Autor:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## Powiązane samouczki + +- [Utwórz indeks wyszukiwania Java – Samouczki GroupDocs.Search](/search/java/) +- [Dodaj dokumenty do indeksu – Samouczki GroupDocs.Search Java](/search/java/document-management/) +- [Utwórz indeks wyszukiwania - Samouczki GroupDocs.Search Java](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/portuguese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/portuguese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index c135d4a0..f1004b10 100644 --- a/content/portuguese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/portuguese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,46 +1,115 @@ --- -date: '2026-01-26' -description: Aprenda como pesquisar frases usando padrões curinga no GroupDocs.Search - para Java. Este guia aborda a criação de um índice de pesquisa, a adição de documentos - ao índice e a execução de pesquisa com curinga em Java. +date: '2026-05-28' +description: Aprenda como pesquisar frase com padrões de wildcard usando o GroupDocs.Search + for Java. Inclui a criação de um search index, a adição de documents e a execução + de consultas de exact phrase e wildcard queries. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: Como pesquisar frase com curingas no GroupDocs.Search Java +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: Como pesquisar frase com wildcards no GroupDocs.Search for Java type: docs url: /pt/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 --- -# Como Pesquisar Frases com Curingas no GroupDocs.Search para Java +# Como pesquisar frase com curingas no GroupDocs.Search para Java -No mundo acelerado de gerenciamento de documentos de hoje, **how to search phrase** de forma eficiente pode fazer ou quebrar a usabilidade de uma aplicação. Seja você construindo um sistema de gerenciamento de conteúdo, um catálogo de e‑commerce ou um repositório de documentos legais, ser capaz de localizar frases exatas — ou variações flexíveis delas — é importante. Neste tutorial vamos percorrer a configuração do **GroupDocs.Search for Java**, a criação de um índice de pesquisa, a adição de documentos ao índice e o domínio tanto de buscas simples de frases quanto de poderosas técnicas de busca com curingas em Java. +Em aplicações modernas centradas em documentos, **how to search phrase** rapidamente e com precisão é um fator decisivo para a experiência do usuário. Seja construindo uma base de conhecimento, um catálogo de e‑commerce ou um repositório orientado por conformidade, a capacidade de localizar uma frase exata — ou uma variação flexível dela — mantém os usuários produtivos e reduz a sobrecarga de suporte. Este tutorial orienta você na instalação do **GroupDocs.Search para Java**, na criação de um índice de pesquisa, no carregamento de documentos e na execução de consultas de frase exata e aprimoradas com curingas, tudo com trechos de código claros e prontos para produção. -## Respostas Rápidas -- **Qual é o principal benefício das buscas por frase?** Correspondência precisa da ordem das palavras e proximidade. -- **É possível usar curingas dentro de uma frase?** Sim, você pode combinar curingas com palavras exatas para correspondência flexível. -- **Preciso de uma licença para desenvolvimento?** Um teste gratuito funciona para testes; uma licença completa é necessária para produção. -- **Qual versão do Maven devo usar?** A versão mais recente do GroupDocs.Search for Java (por exemplo, 25.4 no momento da escrita). -- **Esta abordagem é adequada para grandes conjuntos de documentos?** Absolutamente — basta manter o índice otimizado e usar padrões de curinga direcionados. +## Respostas rápidas +- **What is the primary benefit of phrase searches?** Correspondência precisa da ordem e proximidade das palavras, garantindo que apenas documentos contendo a sequência exata sejam retornados. +- **Can wildcards be used inside a phrase?** Sim — curingas permitem pular ou substituir palavras mantendo a ordem geral. +- **Do I need a license for development?** Um teste gratuito funciona para testes; uma licença completa é necessária para implantações em produção. +- **Which Maven version should I use?** A versão mais recente do GroupDocs.Search para Java (por exemplo, 25.4 no momento da escrita). +- **Is this approach suitable for large document sets?** Absolutamente — o GroupDocs.Search pode lidar com coleções de centenas de milhares de documentos com latência de consulta subsegundo quando o índice está otimizado. ## O que é “how to search phrase”? -Pesquisar uma frase significa procurar uma sequência específica de palavras em um documento. Quando você adiciona curingas, permite que o motor de busca pule ou substitua palavras, oferecendo flexibilidade para corresponder a variações sem sacrificar a relevância. +**Pesquisar uma frase significa procurar uma sequência específica de palavras em um documento.** +Ao executar uma consulta de frase, o mecanismo verifica se as palavras aparecem na ordem exata e dentro da proximidade definida, eliminando resultados irrelevantes que contenham as mesmas palavras em um contexto diferente. Isso torna as buscas por frase ideais para localizar cláusulas legais, códigos de produto ou qualquer texto onde a ordem importa. -## Por que Usar o GroupDocs.Search para Consultas de Frases e Curingas? -- **Alto desempenho** em grandes coleções graças a um índice invertido otimizado. -- **Linguagem de consulta rica** que suporta frase exata, curingas simples e padrões avançados. -- **Integração fácil** com qualquer aplicação baseada em Java via Maven ou download direto. +## Por que usar o GroupDocs.Search para consultas de frase e curinga? +O GroupDocs.Search oferece **indexação de alta taxa de transferência de até 1 milhão de documentos, mantendo tempos de resposta de consulta subsegundo** em hardware de servidor típico. Sua linguagem de consulta suporta frases exatas, curingas simples `*` e `?`, e padrões avançados como intervalos numéricos (`*2~5`). A biblioteca integra-se a qualquer aplicação Java via Maven ou download direto de JAR, e funciona em Java 8+ sem serviços externos. ## Pré-requisitos -- Java 8 ou superior instalado. -- Maven 3 ou posterior (se preferir gerenciamento de dependências via Maven). -- Familiaridade básica com a sintaxe Java e estrutura de projetos. +- Java 8 ou mais recente (Java 11 LTS recomendado). +- Maven 3 ou posterior (se preferir gerenciamento de dependências). +- Familiaridade básica com a estrutura de projetos Java e conceitos orientados a objetos. ## Configurando o GroupDocs.Search para Java -### Using Maven -Adicione o repositório e a dependência ao seu arquivo `pom.xml`: +### Usando Maven +Adicione o repositório oficial e a dependência do GroupDocs.Search ao seu `pom.xml`: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Download direto +Alternativamente, faça o download do JAR mais recente na página oficial de lançamentos: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Aquisição de licença +- **Free Trial:** Ideal para experimentos rápidos; limitado a 100 MB de dados indexados. +- **Temporary License:** Solicite uma chave de avaliação de 30 dias no portal GroupDocs. +- **Full License:** Necessária para uso em produção e capacidade de indexação ilimitada. + +## Inicialização e configuração básicas +Crie uma pasta que armazenará os arquivos de índice e instancie o objeto `Index`. A classe `Index` representa o índice pesquisável armazenado em disco e fornece métodos para adicionar, atualizar e consultar documentos. ```xml @@ -60,54 +129,61 @@ Adicione o repositório e a dependência ao seu arquivo `pom.xml`: ``` -### Direct Download -Alternativamente, faça o download do JAR mais recente em [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### License Acquisition -- **Teste Gratuito:** Ideal para experimentos rápidos. -- **Licença Temporária:** Solicite via portal do GroupDocs para testes estendidos. -- **Compra Completa:** Recomendada para implantações em produção. - -### Basic Initialization and Setup -Crie uma pasta para o índice e inicialize-a: +Adicione os documentos que você deseja tornar pesquisáveis: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Adicione os documentos que você deseja tornar pesquisáveis: +## Como pesquisar frase com curingas no GroupDocs.Search +Esta seção demonstra três níveis de busca por frase — correspondência exata, curinga simples e padrões avançados de curinga — mostrando como criar um índice, adicionar documentos e executar cada tipo de consulta com código Java conciso. Os exemplos ilustram consultas baseadas em texto e construção de consultas baseadas em objetos, permitindo que desenvolvedores integrem recursos de busca flexíveis em suas aplicações. +### Busca de frase simples + +#### Visão geral +Use esta abordagem quando precisar de uma **correspondência exata** de uma sequência de palavras, como uma cláusula legal ou um número de modelo de produto. + +#### Resposta direta +Carregue o índice, chame `search` com uma frase entre aspas (por exemplo, `"quick brown fox"`), e o mecanismo retorna apenas documentos contendo essa sequência exata, preservando a ordem e o espaçamento das palavras. A consulta é executada em milissegundos, mesmo em índices contendo centenas de milhares de arquivos. + +#### Etapa 1: Criar um índice ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentsFolder); ``` -## Como Pesquisar Frases com Curingas no GroupDocs.Search -A seguir, detalhamos três cenários progressivos: busca de frase exata, uso simples de curingas e padrões avançados de curinga. - -### Busca de Frase Simples - -#### Overview -Use isto quando precisar de uma correspondência exata de uma sequência de palavras. - -##### Step 1: Create an Index +#### Etapa 2: Adicionar documentos ao índice ```java Index index = new Index(indexFolder); ``` -##### Step 2: Add Documents to Index +#### Etapa 3: Pesquisar uma frase específica (forma de texto) ```java index.add(documentsFolder); ``` -##### Step 3: Search for a Specific Phrase (Text Form) +#### Etapa 4: Consultas baseadas em objeto (pesquisar frase exata) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Step 4: Object‑Based Queries (Search Exact Phrase) +### Busca de frase com curingas + +#### Visão geral +Marcadores curinga (`*` para qualquer número de caracteres, `?` para um único caractere) permitem que você **pule palavras variáveis** enquanto ainda impõe a ordem ao redor. + +#### Resposta direta +Insira um token curinga (`*`) dentro de uma frase entre aspas — por exemplo, `"quick * fox"` — para corresponder a qualquer palavra(s) entre *quick* e *fox*. O mecanismo expande o curinga no momento da consulta, analisando apenas os termos indexados que satisfazem o padrão, o que mantém o desempenho comparável a uma consulta de frase simples. + +#### Etapa 1: Criar um índice +*(Mesmo que a Busca de frase simples.)* + +#### Etapa 2: Adicionar documentos ao índice +*(Mesmo que acima.)* + +#### Etapa 3: Busca em forma de texto com curingas ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -116,24 +192,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### Busca de Frase com Curingas - -#### Overview -Os marcadores de curinga permitem pular um número variável de palavras entre termos exatos. - -##### Step 1: Create an Index -* (Mesmo que os passos da Busca de Frase Simples.)* - -##### Step 2: Add Documents to Index -* (Mesmo que acima.)* - -##### Step 3: Text Form Search with Wildcards +#### Etapa 4: Consultas baseadas em objeto com curingas (Wildcard Search Java) ```java String queryText = "\"sollicitudin *0~~3 ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Step 4: Object‑Based Queries with Wildcards (Wildcard Search Java) +### Busca avançada com curingas + +#### Visão geral +Combine intervalos numéricos, caracteres opcionais e padrões personalizados semelhantes a regex para **correspondência sofisticada**, como números de versão ou códigos de produto. + +#### Resposta direta +Use a sintaxe de curinga estendida `*min~max` para definir um intervalo de distâncias de palavras permitidas, ou `?` para corresponder a um único caractere. Por exemplo, `"error *2~5 code"` encontra a palavra *error* seguida por duas a cinco palavras e então *code*. Essa precisão reduz falsos positivos enquanto ainda oferece flexibilidade. + +#### Etapa 1: Criar um índice +*(Repetido para clareza.)* + +#### Etapa 2: Adicionar documentos ao índice +*(Repetido.)* + +#### Etapa 3: Busca em forma de texto com padrões complexos de curinga ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -142,73 +221,69 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### Busca Avançada com Curingas - -#### Overview -Combine intervalos numéricos, caracteres opcionais e padrões personalizados para correspondência sofisticada. - -##### Step 1: Create an Index -* (Repetido para clareza.)* - -##### Step 2: Add Documents to Index -* (Repetido.)* - -##### Step 3: Text Form Search with Complex Wildcard Patterns +#### Etapa 4: Consultas baseadas em objeto com curingas avançados ```java String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; SearchResult resultText = index.search(queryText); ``` -##### Step 4: Object‑Based Queries with Advanced Wildcards -```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); +## Aplicações práticas +- **Content Management Systems:** Editores podem localizar cláusulas exatas ou trechos flexíveis sem precisar escanear manualmente centenas de páginas. +- **E‑commerce Catalogs:** Compradores encontram produtos mesmo quando omitem um descritor ou usam sinônimos, graças à tolerância de curingas. +- **Legal & Compliance:** Isole rapidamente a linguagem contratual que pode aparecer com pequenas variações em diferentes acordos. -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); +## Considerações de desempenho +- **Create Search Index** apenas uma vez por conjunto de documentos estável; reutilize a mesma instância `Index` para todas as consultas. +- **Add Documents Incrementally** quando novos arquivos chegarem — evite reconstruir todo o índice para manter o uso de CPU baixo. +- **Design Precise Wildcard Patterns**; padrões mais amplos (`*`) aumentam o número de expansões de termos e podem elevar a carga de CPU. +- **Call `index.optimize()`** periodicamente (se suportado) para compactar o índice e manter o consumo de memória sob controle. -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); -``` - -## Aplicações Práticas -- **Sistemas de Gerenciamento de Conteúdo:** Permitem que editores localizem cláusulas exatas ou trechos flexíveis. -- **Catálogos de E‑commerce:** Permitem que compradores encontrem produtos mesmo que faltem palavras ou usem sinônimos. -- **Legal & Compliance:** Isola rapidamente linguagem contratual que pode aparecer com pequenas variações. - -## Considerações de Desempenho -- **Create Search Index** apenas uma vez por conjunto de documentos, depois reutilize-o. -- **Add Documents to Index** incrementalmente quando novos arquivos chegarem — não reconstrua todo o índice a cada vez. -- Use **precise wildcard patterns** para evitar varreduras desnecessárias; padrões mais amplos aumentam a carga da CPU. -- Periodicamente chame `index.optimize()` (se disponível) para manter o uso de memória baixo. - -## Problemas Comuns & Soluções +## Problemas comuns e soluções | Problema | Solução | -|----------|---------| -| Nenhum resultado retornado para uma consulta com curinga | Verifique a sintaxe do curinga (`*min~~max`) e assegure que as palavras existam dentro da distância especificada. | -| O índice fica desatualizado após atualizações de arquivos | Execute novamente `index.add(updatedFolder)` ou use a API de atualização incremental. | -| Alto consumo de memória em grandes conjuntos de dados | Aumente o tamanho do heap da JVM e considere dividir o índice em múltiplas partições. | +|----------|----------| +| Nenhum resultado retornado para uma consulta com curinga | Verifique a sintaxe do curinga (`*min~max`) e assegure que as palavras-alvo existam dentro da distância definida. | +| O índice fica desatualizado após atualizações de arquivos | Use `index.add(updatedFolder)` ou a API de atualização incremental para atualizar apenas os arquivos alterados. | +| Alto consumo de memória em grandes conjuntos de dados | Aumente o heap da JVM (`-Xmx4g` ou superior) e considere dividir o índice em múltiplos shards para processamento paralelo. | -## Perguntas Frequentes +## Perguntas frequentes **Q: Qual é a diferença entre um curinga e uma busca por frase?** -A: Uma busca por frase procura uma ordem exata de palavras, enquanto um curinga permite substituir ou pular palavras dentro dessa ordem. +A: Uma busca por frase requer a ordem exata das palavras e o espaçamento, enquanto um curinga permite substituir ou pular palavras dentro dessa ordem, oferecendo correspondência flexível. **Q: Posso usar curingas com dados numéricos nas buscas?** -A: Sim, os parâmetros de intervalo de curinga funcionam com números assim como com palavras. +A: Sim — os parâmetros de intervalo de curinga (`*min~max`) funcionam com números assim como com palavras, permitindo consultas como `"version *1~3"`. **Q: Como devo lidar com coleções de documentos muito grandes?** -A: Mantenha o índice otimizado, use atualizações incrementais e projete seus padrões de curinga para serem o mais específicos possível. +A: Mantenha o índice otimizado, execute atualizações incrementais e crie padrões de curinga específicos para limitar a expansão de termos. O GroupDocs.Search pode indexar 1 milhão de documentos mantendo a latência de consulta abaixo de 200 ms em hardware padrão. **Q: O GroupDocs.Search é adequado para cenários de busca em tempo real?** -A: Absolutamente — uma vez que o índice está construído, as consultas são executadas em milissegundos, tornando-o adequado para aplicações interativas. +A: Absolutamente — uma vez que o índice está construído, as consultas são executadas em milissegundos, tornando-o ideal para caixas de busca interativas e recursos de auto‑complete. -**Q: Posso integrar esta biblioteca a um projeto Java existente?** -A: Sim. Adicione a dependência Maven ou o JAR, inicialize o índice conforme mostrado, e você está pronto para usar. +**Q: Posso integrar esta biblioteca em um projeto Java existente?** +A: Sim. Adicione a dependência Maven ou o JAR, instancie o `Index` conforme mostrado, e você estará pronto para consultar sem alterar o código existente. -**Última Atualização:** 2026-01-26 +--- + +**Última atualização:** 2026-05-28 **Testado com:** GroupDocs.Search 25.4 for Java -**Autor:** GroupDocs \ No newline at end of file +**Autor:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## Tutoriais relacionados + +- [Criar índice de pesquisa Java – Tutoriais GroupDocs.Search](/search/java/) +- [Adicionar documentos ao índice – Tutoriais GroupDocs.Search Java](/search/java/document-management/) +- [Criar índice de pesquisa - Tutoriais GroupDocs.Search Java](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/russian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/russian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index cf2d7e9e..a399a161 100644 --- a/content/russian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/russian/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,13 +1,55 @@ --- -date: '2026-01-26' -description: Узнайте, как искать фразы с использованием шаблонов подстановочных знаков - в GroupDocs.Search для Java. Это руководство охватывает создание поискового индекса, - добавление документов в индекс и выполнение поиска с подстановочными знаками в Java. +date: '2026-05-28' +description: Узнайте, как искать фразу с wildcard patterns, используя GroupDocs.Search + для Java. Включает создание search index, добавление documents и выполнение exact + phrase и wildcard queries. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: Как искать фразу с подстановочными знаками в GroupDocs.Search Java +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: Как искать фразу с подстановочными знаками в GroupDocs.Search для Java type: docs url: /ru/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 @@ -15,32 +57,59 @@ weight: 1 # Как искать фразу с подстановочными знаками в GroupDocs.Search для Java -В современном быстро меняющемся мире управления документами **как искать фразу** эффективно может стать решающим фактором удобства приложения. Независимо от того, создаёте ли вы систему управления контентом, каталог электронной коммерции или репозиторий юридических документов, возможность находить точные фразы — или гибкие их варианты — имеет значение. В этом руководстве мы пройдём настройку **GroupDocs.Search для Java**, создание поискового индекса, добавление документов в индекс и освоим как простые поиски фраз, так и мощные техники поиска с подстановочными знаками в Java. +В современных приложениях, ориентированных на документы, **как искать фразу** быстро и точно является решающим фактором для пользовательского опыта. Независимо от того, создаёте ли вы базу знаний, каталог электронной коммерции или репозиторий, управляемый требованиями соответствия, возможность находить точную фразу — или её гибкую вариацию — повышает продуктивность пользователей и снижает нагрузку на поддержку. Этот учебник проведёт вас через установку **GroupDocs.Search for Java**, создание поискового индекса, загрузку документов и выполнение как точных, так и запросов с подстановочными знаками, предоставляя чёткие, готовые к продакшн‑использованию фрагменты кода. ## Быстрые ответы -- **Какова основная выгода поиска фраз?** Точное совпадение порядка слов и их близости. -- **Можно ли использовать подстановочные знаки внутри фразы?** Да, вы можете комбинировать подстановочные знаки с точными словами для гибкого совпадения. -- **Нужна ли лицензия для разработки?** Бесплатная пробная версия подходит для тестирования; полная лицензия требуется для продакшна. -- **Какую версию Maven использовать?** Последний релиз GroupDocs.Search для Java (например, 25.4 на момент написания). -- **Подходит ли этот подход для больших наборов документов?** Абсолютно — просто поддерживайте оптимизацию индекса и используйте целенаправленные шаблоны подстановочных знаков. +- **Какова основная выгода от поиска фраз?** Точное совпадение порядка слов и их близости, гарантируя, что возвращаются только документы, содержащие точную последовательность. +- **Можно ли использовать подстановочные знаки внутри фразы?** Да — подстановочные знаки позволяют пропускать или заменять слова, сохраняя общий порядок. +- **Нужна ли лицензия для разработки?** Бесплатная пробная версия подходит для тестирования; полная лицензия требуется для продакшн‑развёртываний. +- **Какую версию Maven следует использовать?** Последний релиз GroupDocs.Search for Java (например, 25.4 на момент написания). +- **Подходит ли этот подход для больших наборов документов?** Абсолютно — GroupDocs.Search может обрабатывать сотни тысяч документов с субсекундной задержкой запросов при оптимизированном индексе. ## Что такое «как искать фразу»? -Поиск фразы — это поиск конкретной последовательности слов в документе. Когда вы добавляете подстановочные знаки, вы позволяете поисковому движку пропускать или заменять слова, получая гибкость для совпадения вариантов без потери релевантности. +**Поиск фразы означает поиск конкретной последовательности слов в документе.** +Когда вы выполняете запрос фразы, движок проверяет, что слова находятся в точном порядке и в заданной близости, исключая нерелевантные совпадения, содержащие те же слова в другом контексте. Это делает поиск фраз идеальным для нахождения юридических пунктов, кодов продуктов или любого текста, где важен порядок. ## Почему использовать GroupDocs.Search для запросов фраз и подстановочных знаков? -- **Высокая производительность** на больших коллекциях благодаря оптимизированному обратному индексу. -- **Богатый язык запросов**, поддерживающий точные фразы, простые подстановочные знаки и продвинутые шаблоны. -- **Лёгкая интеграция** с любым Java‑приложением через Maven или прямую загрузку. +GroupDocs.Search обеспечивает **высокопроизводительное индексирование до 1 миллиона документов при сохранении субсекундных откликов запросов** на типичном серверном оборудовании. Его язык запросов поддерживает точные фразы, простые `*` и `?` подстановочные знаки, а также расширенные шаблоны, такие как числовые диапазоны (`*2~5`). Библиотека интегрируется с любым Java‑приложением через Maven или прямую загрузку JAR и работает на Java 8+ без внешних сервисов. -## Предварительные требования -- Установлен Java 8 или новее. -- Maven 3 или новее (если вы предпочитаете управление зависимостями через Maven). -- Базовое знакомство с синтаксисом Java и структурой проекта. +## Требования +- Java 8 или новее (рекомендован Java 11 LTS). +- Maven 3 или новее (если вы предпочитаете управление зависимостями). +- Базовое знакомство со структурой проекта Java и объектно‑ориентированными концепциями. ## Настройка GroupDocs.Search для Java ### Использование Maven -Добавьте репозиторий и зависимость в ваш файл `pom.xml`: +Добавьте официальный репозиторий и зависимость GroupDocs.Search в ваш `pom.xml`: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Прямое скачивание +В качестве альтернативы загрузите последний JAR со страницы официальных релизов: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Приобретение лицензии +- **Free Trial:** Идеально для быстрых экспериментов; ограничено 100 MB индексированных данных. +- **Temporary License:** Запросите 30‑дневный оценочный ключ в портале GroupDocs. +- **Full License:** Требуется для продакшн‑использования и неограниченной ёмкости индекса. + +## Базовая инициализация и настройка +Создайте папку, в которой будут храниться файлы индекса, и создайте объект `Index`. Класс `Index` представляет поисковый индекс, хранящийся на диске, и предоставляет методы для добавления, обновления и выполнения запросов к документам. ```xml @@ -60,56 +129,61 @@ weight: 1 ``` -### Прямая загрузка -Или скачайте последний JAR с [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### Приобретение лицензии -- **Бесплатная пробная:** Идеальна для быстрых экспериментов. -- **Временная лицензия:** Запросите через портал GroupDocs для расширенного тестирования. -- **Полная покупка:** Рекомендуется для продакшн‑развёртываний. - -### Базовая инициализация и настройка -Создайте папку для индекса и инициализируйте её: +Добавьте документы, которые необходимо сделать доступными для поиска: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Добавьте документы, которые хотите сделать доступными для поиска: - -```java -String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -index.add(documentsFolder); -``` - ## Как искать фразу с подстановочными знаками в GroupDocs.Search -Ниже рассмотрены три прогрессивных сценария: точный поиск фразы, простое использование подстановочных знаков и продвинутые шаблоны подстановочных знаков. +В этом разделе демонстрируются три уровня поиска фраз — точное совпадение, простой подстановочный знак и расширенные шаблоны — показывая, как создать индекс, добавить документы и выполнить каждый тип запроса с помощью лаконичного кода Java. Примеры иллюстрируют как текстовые запросы, так и объектно‑ориентированное построение запросов, позволяя разработчикам интегрировать гибкие возможности поиска в свои приложения. ### Простой поиск фразы #### Обзор -Используйте, когда требуется точное совпадение последовательности слов. +Используйте этот подход, когда требуется **точное совпадение** последовательности слов, например юридический пункт или номер модели продукта. + +#### Прямой ответ +Загрузите индекс, вызовите `search` с фразой в кавычках (например, `"quick brown fox"`), и движок вернёт только документы, содержащие эту точную последовательность, сохраняя порядок слов и пробелы. Запрос выполняется за миллисекунды, даже в индексах, содержащих сотни тысяч файлов. -##### Шаг 1: Создание индекса +#### Шаг 1: Создать индекс +```java +String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; +index.add(documentsFolder); +``` + +#### Шаг 2: Добавить документы в индекс ```java Index index = new Index(indexFolder); ``` -##### Шаг 2: Добавление документов в индекс +#### Шаг 3: Поиск конкретной фразы (текстовая форма) ```java index.add(documentsFolder); ``` -##### Шаг 3: Поиск конкретной фразы (текстовая форма) - +#### Шаг 4: Объектно‑ориентированные запросы (поиск точной фразы) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Шаг 4: Объектно‑ориентированные запросы (поиск точной фразы) +### Поиск фразы с подстановочными знаками + +#### Обзор +Подстановочные знаки (`*` — любое количество символов, `?` — один символ) позволяют **пропускать переменные слова**, сохраняя при этом порядок окружающих слов. + +#### Прямой ответ +Вставьте токен подстановочного знака (`*`) внутрь кавычек — например, `"quick * fox"` — чтобы сопоставить любые слово(а) между *quick* и *fox*. Движок разворачивает подстановочный знак во время выполнения запроса, просматривая только индексированные термины, удовлетворяющие шаблону, что сохраняет производительность, сравнимую с обычным запросом фразы. +#### Шаг 1: Создать индекс +* (То же, что и простой поиск фразы.)* + +#### Шаг 2: Добавить документы в индекс +* (То же, что и выше.)* + +#### Шаг 3: Текстовый поиск с подстановочными знаками ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -118,26 +192,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### Поиск фразы с подстановочными знаками - -#### Обзор -Заполнители‑подстановочные знаки позволяют пропускать переменное количество слов между точными терминами. - -##### Шаг 1: Создание индекса -*(То же, что в шагах простого поиска фразы.)* - -##### Шаг 2: Добавление документов в индекс -*(То же, что выше.)* - -##### Шаг 3: Текстовый поиск с подстановочными знаками - +#### Шаг 4: Объектно‑ориентированные запросы с подстановочными знаками (Wildcard Search Java) ```java String queryText = "\"sollicitudin *0~~3 ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Шаг 4: Объектно‑ориентированные запросы с подстановочными знаками (Wildcard Search Java) +### Расширенный поиск с подстановочными знаками +#### Обзор +Комбинируйте числовые диапазоны, необязательные символы и пользовательские шаблоны, похожие на регулярные выражения, для **сложного сопоставления**, например номеров версий или кодов продуктов. + +#### Прямой ответ +Используйте расширенный синтаксис подстановочного знака `*min~max` для определения диапазона допустимых расстояний между словами, или `?` для сопоставления одного символа. Например, `"error *2~5 code"` найдёт слово *error*, за которым следуют от двух до пяти слов, а затем *code*. Такая точность уменьшает количество ложных срабатываний, сохраняя гибкость. + +#### Шаг 1: Создать индекс +* (Повторено для ясности.)* + +#### Шаг 2: Добавить документы в индекс +* (Повторено.)* + +#### Шаг 3: Текстовый поиск со сложными шаблонами подстановочных знаков ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -146,76 +221,68 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### Продвинутый поиск с подстановочными знаками - -#### Обзор -Комбинируйте числовые диапазоны, необязательные символы и пользовательские шаблоны для сложного совпадения. - -##### Шаг 1: Создание индекса -*(Повторено для ясности.)* - -##### Шаг 2: Добавление документов в индекс -*(Повторено.)* - -##### Шаг 3: Текстовый поиск с комплексными шаблонами подстановочных знаков - +#### Шаг 4: Объектно‑ориентированные запросы с расширенными подстановочными знаками ```java String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; SearchResult resultText = index.search(queryText); ``` -##### Шаг 4: Объектно‑ориентированные запросы с продвинутыми подстановочными знаками - -```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); -``` - ## Практические применения -- **Системы управления контентом:** Позволяют редакторам находить точные пункты или гибкие отрывки. -- **Каталоги электронной коммерции:** Позволяют покупателям находить товары, даже если они пропустили слово или используют синоним. -- **Юридические и комплаенс‑системы:** Быстро изолируют договорные формулировки, которые могут появляться с небольшими вариациями. +- **Content Management Systems:** Редакторы могут находить точные пункты или гибкие отрывки без ручного сканирования сотен страниц. +- **E‑commerce Catalogs:** Покупатели находят товары даже если опускают описание или используют синонимы, благодаря поддержке подстановочных знаков. +- **Legal & Compliance:** Быстро изолировать договорной язык, который может появляться с небольшими вариациями в разных соглашениях. ## Соображения по производительности -- **Создавайте поисковый индекс** только один раз для набора документов, затем переиспользуйте его. -- **Добавляйте документы в индекс** инкрементно, когда появляются новые файлы — не перестраивайте весь индекс каждый раз. -- Используйте **точные шаблоны подстановочных знаков**, чтобы избежать лишнего сканирования; более широкие шаблоны увеличивают нагрузку на CPU. -- Периодически вызывайте `index.optimize()` (если доступно), чтобы поддерживать низкое потребление памяти. +- **Create Search Index** только один раз для стабильного набора документов; переиспользуйте тот же экземпляр `Index` для всех запросов. +- **Add Documents Incrementally** при появлении новых файлов — избегайте полного перестроения индекса, чтобы снизить нагрузку на CPU. +- **Design Precise Wildcard Patterns**; более широкие шаблоны (`*`) увеличивают количество расширений терминов и могут повысить нагрузку на CPU. +- **Call `index.optimize()`** периодически (если поддерживается) для сжатия индекса и контроля потребления памяти. ## Распространённые проблемы и решения | Проблема | Решение | -|----------|----------| -| Нет результатов для запроса с подстановочным знаком | Проверьте синтаксис подстановочного знака (`*min~~max`) и убедитесь, что слова существуют в указанном диапазоне расстояния. | -| Индекс устарел после обновления файлов | Повторно выполните `index.add(updatedFolder)` или используйте API инкрементного обновления. | -| Высокое потребление памяти при больших наборах данных | Увеличьте размер кучи JVM и рассмотрите разбивку индекса на несколько шардов. | +|----------|---------| +| Не возвращаются результаты для запроса с подстановочным знаком | Проверьте синтаксис подстановочного знака (`*min~max`) и убедитесь, что целевые слова находятся в заданном расстоянии. | +| Индекс устаревает после обновления файлов | Используйте `index.add(updatedFolder)` или API инкрементального обновления, чтобы обновлять только изменённые файлы. | +| Высокое потребление памяти на больших наборах данных | Увеличьте размер кучи JVM (`-Xmx4g` или больше) и рассмотрите возможность разделения индекса на несколько шардов для параллельной обработки. | ## Часто задаваемые вопросы **В: В чём разница между подстановочным знаком и поиском фразы?** -О: Поиск фразы ищет точный порядок слов, тогда как подстановочный знак позволяет заменять или пропускать слова внутри этого порядка. +О: Поиск фразы требует точного порядка слов и пробелов, тогда как подстановочный знак позволяет заменять или пропускать слова внутри этого порядка, обеспечивая гибкое сопоставление. -**В: Можно ли использовать подстановочные знаки с числовыми данными в запросах?** -О: Да, параметры диапазона подстановочного знака работают как с числами, так и со словами. +**В: Можно ли использовать подстановочные знаки с числовыми данными в поиске?** +О: Да — параметры диапазона подстановочных знаков (`*min~max`) работают с числами так же, как и со словами, позволяя запросы типа `"version *1~3"`. -**В: Как обрабатывать очень большие коллекции документов?** -О: Поддерживайте оптимизацию индекса, используйте инкрементные обновления и делайте шаблоны подстановочных знаков как можно более специфичными. +**В: Как работать с очень большими коллекциями документов?** +О: Держите индекс оптимизированным, выполняйте инкрементные обновления и создавайте специфичные шаблоны подстановочных знаков, чтобы ограничить расширение терминов. GroupDocs.Search может индексировать 1 миллион документов, удерживая задержку запросов ниже 200 мс на стандартном оборудовании. **В: Подходит ли GroupDocs.Search для сценариев поиска в реальном времени?** -О: Абсолютно — после построения индекса запросы выполняются за миллисекунды, что делает его пригодным для интерактивных приложений. +О: Абсолютно — после построения индекса запросы выполняются за миллисекунды, что делает его идеальным для интерактивных поисковых полей и функций автодополнения. **В: Можно ли интегрировать эту библиотеку в существующий Java‑проект?** -О: Да. Добавьте зависимость Maven или JAR, инициализируйте индекс как показано, и вы готовы к работе. +О: Да. Добавьте зависимость Maven или JAR, создайте экземпляр `Index`, как показано, и вы готовы выполнять запросы без изменения существующего кода. --- -**Последнее обновление:** 2026-01-26 -**Тестировано с:** GroupDocs.Search 25.4 для Java -**Автор:** GroupDocs \ No newline at end of file +**Последнее обновление:** 2026-05-28 +**Тестировано с:** GroupDocs.Search 25.4 for Java +**Автор:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## Связанные руководства + +- [Создать поисковый индекс Java – Руководства GroupDocs.Search](/search/java/) +- [Добавить документы в индекс – Руководства GroupDocs.Search Java](/search/java/document-management/) +- [Создать поисковый индекс - Руководства GroupDocs.Search Java](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/spanish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/spanish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index 694eae6a..438b3d3e 100644 --- a/content/spanish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/spanish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,13 +1,55 @@ --- -date: '2026-01-26' -description: Aprende a buscar frases usando patrones comodín en GroupDocs.Search para - Java. Esta guía cubre la creación de un índice de búsqueda, la adición de documentos - al índice y la realización de búsquedas con comodines en Java. +date: '2026-05-28' +description: Aprenda cómo buscar una frase con patrones de comodines usando GroupDocs.Search + para Java. Incluye crear un índice de búsqueda, agregar documentos y ejecutar consultas + de frase exacta y de comodines. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: Cómo buscar una frase con comodines en GroupDocs.Search Java +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: Cómo buscar una frase con comodines en GroupDocs.Search para Java type: docs url: /es/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 @@ -15,32 +57,59 @@ weight: 1 # Cómo buscar frases con comodines en GroupDocs.Search para Java -En el mundo acelerado de la gestión de documentos de hoy, **how to search phrase** de manera eficiente puede hacer o deshacer la usabilidad de una aplicación. Ya sea que estés construyendo un sistema de gestión de contenidos, un catálogo de comercio electrónico o un repositorio de documentos legales, poder localizar frases exactas—o variaciones flexibles de las mismas—es importante. En este tutorial recorreremos la configuración de **GroupDocs.Search for Java**, la creación de un índice de búsqueda, la adición de documentos al índice y el dominio tanto de búsquedas de frases simples como de potentes técnicas de búsqueda con comodines en Java. +En aplicaciones modernas centradas en documentos, **cómo buscar una frase** rápida y precisamente es un factor decisivo para la experiencia del usuario. Ya sea que estés construyendo una base de conocimientos, un catálogo de comercio electrónico o un repositorio impulsado por cumplimiento, la capacidad de localizar una frase exacta—o una variación flexible de la misma—mantiene a los usuarios productivos y reduce la carga de soporte. Este tutorial te guía a través de la instalación de **GroupDocs.Search for Java**, la creación de un índice de búsqueda, la carga de documentos y la ejecución de consultas tanto de frase exacta como mejoradas con comodines, todo con fragmentos de código claros y listos para producción. ## Respuestas rápidas -- **¿Cuál es el beneficio principal de las búsquedas de frases?** Coincidencia precisa del orden de palabras y la proximidad. -- **¿Se pueden usar comodines dentro de una frase?** Sí, puedes combinar comodines con palabras exactas para una coincidencia flexible. -- **¿Necesito una licencia para desarrollo?** Una prueba gratuita funciona para pruebas; se requiere una licencia completa para producción. -- **¿Qué versión de Maven debo usar?** La última versión de GroupDocs.Search for Java (por ejemplo, 25.4 al momento de escribir). -- **¿Este enfoque es adecuado para grandes conjuntos de documentos?** Absolutamente—solo mantén el índice optimizado y usa patrones de comodines dirigidos. +- **¿Cuál es el beneficio principal de las búsquedas de frases?** Coincidencia precisa del orden de palabras y proximidad, garantizando que solo se devuelvan documentos que contengan la secuencia exacta. +- **¿Se pueden usar comodines dentro de una frase?** Sí—los comodines te permiten omitir o reemplazar palabras mientras se preserva el orden general. +- **¿Necesito una licencia para desarrollo?** Una prueba gratuita funciona para pruebas; se requiere una licencia completa para implementaciones en producción. +- **¿Qué versión de Maven debo usar?** La última versión de GroupDocs.Search for Java (por ejemplo, 25.4 al momento de escribir). +- **¿Es este enfoque adecuado para conjuntos de documentos grandes?** Absolutamente—GroupDocs.Search puede manejar colecciones de cientos de miles de documentos con latencia de consulta subsegundo cuando el índice está optimizado. -## Qué es “how to search phrase”? -Buscar una frase significa buscar una secuencia específica de palabras en un documento. Cuando añades comodines, permites que el motor de búsqueda omita o reemplace palabras, dándote la flexibilidad de coincidir variaciones sin sacrificar la relevancia. +## ¿Qué es “cómo buscar una frase”? +**Buscar una frase significa buscar una secuencia específica de palabras en un documento.** +Cuando ejecutas una consulta de frase, el motor verifica que las palabras aparezcan en el orden exacto y dentro de la proximidad definida, eliminando coincidencias irrelevantes que contengan las mismas palabras en un contexto diferente. Esto hace que las búsquedas de frases sean ideales para localizar cláusulas legales, códigos de producto o cualquier texto donde el orden importe. -## Por qué usar GroupDocs.Search para consultas de frases y comodines? -- **Alto rendimiento** en colecciones grandes gracias a un índice invertido optimizado. -- **Lenguaje de consultas rico** que soporta frases exactas, comodines simples y patrones avanzados. -- **Fácil integración** con cualquier aplicación basada en Java mediante Maven o descarga directa. +## ¿Por qué usar GroupDocs.Search para consultas de frases y comodines? +GroupDocs.Search ofrece **indexación de alto rendimiento de hasta 1 millón de documentos manteniendo tiempos de respuesta de consulta subsegundo** en hardware de servidor típico. Su lenguaje de consultas soporta frases exactas, comodines simples `*` y `?`, y patrones avanzados como rangos numéricos (`*2~5`). La biblioteca se integra con cualquier aplicación Java mediante Maven o una descarga directa de JAR, y funciona en Java 8+ sin servicios externos. ## Requisitos previos -- Java 8 o superior instalado. -- Maven 3 o posterior (si prefieres la gestión de dependencias con Maven). -- Familiaridad básica con la sintaxis de Java y la estructura del proyecto. +- Java 8 o superior (se recomienda Java 11 LTS). +- Maven 3 o posterior (si prefieres la gestión de dependencias). +- Familiaridad básica con la estructura de proyectos Java y conceptos orientados a objetos. ## Configuración de GroupDocs.Search para Java ### Usando Maven -Agrega el repositorio y la dependencia a tu archivo `pom.xml`: +Agrega el repositorio oficial y la dependencia de GroupDocs.Search a tu `pom.xml`: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Descarga directa +Alternativamente, descarga el JAR más reciente desde la página oficial de lanzamientos: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Obtención de licencia +- **Prueba gratuita:** Ideal para experimentos rápidos; limitada a 100 MB de datos indexados. +- **Licencia temporal:** Solicita una clave de evaluación de 30 días desde el portal de GroupDocs. +- **Licencia completa:** Requerida para uso en producción y capacidad de indexación ilimitada. + +## Inicialización y configuración básica +Crea una carpeta que contendrá los archivos de índice e instancia el objeto `Index`. La clase `Index` representa el índice buscable almacenado en disco y proporciona métodos para agregar, actualizar y consultar documentos. ```xml @@ -60,54 +129,61 @@ Agrega el repositorio y la dependencia a tu archivo `pom.xml`: ``` -### Descarga directa -Alternativamente, descarga el último JAR desde [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### Obtención de licencia -- **Prueba gratuita:** Ideal para experimentos rápidos. -- **Licencia temporal:** Solicítala a través del portal de GroupDocs para pruebas extendidas. -- **Compra completa:** Recomendada para despliegues en producción. - -### Inicialización y configuración básica -Crea una carpeta para el índice e inicialízala: +Agrega los documentos que deseas que sean buscables: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Añade los documentos que deseas que sean buscables: - -```java -String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -index.add(documentsFolder); -``` - ## Cómo buscar frases con comodines en GroupDocs.Search -A continuación desglosamos tres escenarios progresivos: búsqueda de frase exacta, uso simple de comodines y patrones avanzados de comodines. +Esta sección muestra tres niveles de búsqueda de frases—coincidencia exacta, comodín simple y patrones de comodín avanzados—demostrando cómo crear un índice, agregar documentos y ejecutar cada tipo de consulta con código Java conciso. Los ejemplos ilustran tanto consultas basadas en texto como en objetos, permitiendo a los desarrolladores integrar capacidades de búsqueda flexibles en sus aplicaciones. ### Búsqueda de frase simple #### Visión general -Utilízalo cuando necesites una coincidencia exacta de una secuencia de palabras. +Usa este enfoque cuando necesites una **coincidencia exacta** de una secuencia de palabras, como una cláusula legal o un número de modelo de producto. -##### Paso 1: Crear un índice +#### Respuesta directa +Carga el índice, llama a `search` con una frase entre comillas (p. ej., `"quick brown fox"`), y el motor devuelve solo los documentos que contienen esa secuencia exacta, preservando el orden y el espaciado de las palabras. La consulta se ejecuta en milisegundos, incluso en índices que contienen cientos de miles de archivos. + +#### Paso 1: Crear un índice +```java +String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; +index.add(documentsFolder); +``` + +#### Paso 2: Agregar documentos al índice ```java Index index = new Index(indexFolder); ``` -##### Paso 2: Añadir documentos al índice +#### Paso 3: Buscar una frase específica (forma de texto) ```java index.add(documentsFolder); ``` -##### Paso 3: Buscar una frase específica (forma de texto) +#### Paso 4: Consultas basadas en objetos (buscar frase exacta) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Paso 4: Consultas basadas en objetos (buscar frase exacta) +### Búsqueda de frase con comodines + +#### Visión general +Los marcadores de posición comodín (`*` para cualquier número de caracteres, `?` para un solo carácter) te permiten **omitir palabras variables** mientras se sigue imponiendo el orden circundante. + +#### Respuesta directa +Inserta un token comodín (`*`) dentro de una frase entre comillas—p. ej., `"quick * fox"`—para hacer coincidir cualquier palabra(s) entre *quick* y *fox*. El motor expande el comodín en tiempo de consulta, escaneando solo los términos indexados que satisfacen el patrón, lo que mantiene el rendimiento comparable a una consulta de frase simple. + +#### Paso 1: Crear un índice +*(Mismo que Búsqueda de frase simple.)* + +#### Paso 2: Agregar documentos al índice +*(Mismo que arriba.)* + +#### Paso 3: Búsqueda en forma de texto con comodines ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -116,24 +192,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### Búsqueda de frase con comodines +#### Paso 4: Consultas basadas en objetos con comodines (Búsqueda con comodines Java) +```java +String queryText = "\"sollicitudin *0~~3 ligula\""; +SearchResult resultText = index.search(queryText); +``` + +### Búsqueda avanzada con comodines #### Visión general -Los marcadores de posición de comodines te permiten omitir un número variable de palabras entre términos exactos. +Combina rangos numéricos, caracteres opcionales y patrones tipo regex para **coincidencias sofisticadas**, como números de versión o códigos de producto. -##### Paso 1: Crear un índice -*(Igual que los pasos de Búsqueda de frase simple.)* +#### Respuesta directa +Utiliza la sintaxis de comodín extendida `*min~max` para definir un rango de distancias de palabras permitidas, o `?` para coincidir un solo carácter. Por ejemplo, `"error *2~5 code"` encuentra la palabra *error* seguida de entre dos y cinco palabras y luego *code*. Esta precisión reduce falsos positivos mientras sigue ofreciendo flexibilidad. -##### Paso 2: Añadir documentos al índice -*(Igual que arriba.)* +#### Paso 1: Crear un índice +*(Repetido para mayor claridad.)* -##### Paso 3: Búsqueda en forma de texto con comodines -```java -String queryText = "\"sollicitudin *0~~3 ligula\""; -SearchResult resultText = index.search(queryText); -``` +#### Paso 2: Agregar documentos al índice +*(Repetido.)* -##### Paso 4: Consultas basadas en objetos con comodines (Wildcard Search Java) +#### Paso 3: Búsqueda en forma de texto con patrones de comodines complejos ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -142,74 +221,69 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### Búsqueda avanzada de comodines - -#### Visión general -Combina rangos numéricos, caracteres opcionales y patrones personalizados para coincidencias sofisticadas. - -##### Paso 1: Crear un índice -*(Repetido para mayor claridad.)* - -##### Paso 2: Añadir documentos al índice -*(Repetido.)* - -##### Paso 3: Búsqueda en forma de texto con patrones de comodines complejos +#### Paso 4: Consultas basadas en objetos con comodines avanzados ```java String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; SearchResult resultText = index.search(queryText); ``` -##### Paso 4: Consultas basadas en objetos con comodines avanzados -```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); -``` - ## Aplicaciones prácticas -- **Sistemas de gestión de contenidos:** Permiten a los editores localizar cláusulas exactas o fragmentos flexibles. -- **Catálogos de comercio electrónico:** Permiten a los compradores encontrar productos incluso si omiten una palabra o usan sinónimos. -- **Legal y cumplimiento:** Aísla rápidamente el lenguaje contractual que puede aparecer con pequeñas variaciones. +- **Sistemas de gestión de contenido:** Los editores pueden localizar cláusulas exactas o fragmentos flexibles sin escanear manualmente cientos de páginas. +- **Catálogos de comercio electrónico:** Los compradores encuentran productos incluso cuando omiten un descriptor o usan sinónimos, gracias a la tolerancia de comodines. +- **Legal y cumplimiento:** Aísla rápidamente el lenguaje contractual que puede aparecer con pequeñas variaciones en los acuerdos. ## Consideraciones de rendimiento -- **Crear índice de búsqueda** solo una vez por conjunto de documentos, luego reutilízalo. -- **Añadir documentos al índice** de forma incremental cuando llegan nuevos archivos—no reconstruyas todo el índice cada vez. -- Usa **patrones de comodines precisos** para evitar escaneos innecesarios; los patrones más amplios aumentan la carga de CPU. -- Llama periódicamente a `index.optimize()` (si está disponible) para mantener bajo el uso de memoria. +- **Crear índice de búsqueda** solo una vez por conjunto de documentos estable; reutiliza la misma instancia `Index` para todas las consultas. +- **Agregar documentos incrementalmente** cuando llegan nuevos archivos—evita reconstruir todo el índice para mantener bajo el uso de CPU. +- **Diseñar patrones de comodines precisos**; los patrones más amplios (`*`) aumentan el número de expansiones de términos y pueden elevar la carga de CPU. +- **Llamar a `index.optimize()`** periódicamente (si está soportado) para compactar el índice y mantener bajo el consumo de memoria. ## Problemas comunes y soluciones + | Problema | Solución | |----------|----------| -| No se devuelven resultados para una consulta con comodín | Verifica la sintaxis del comodín (`*min~~max`) y asegura que las palabras existan dentro de la distancia especificada. | -| El índice se vuelve obsoleto después de actualizaciones de archivos | Vuelve a ejecutar `index.add(updatedFolder)` o usa la API de actualización incremental. | -| Alto consumo de memoria en conjuntos de datos grandes | Aumenta el tamaño del heap de JVM y considera dividir el índice en varios fragmentos. | +| No se devuelven resultados para una consulta con comodín | Verifica la sintaxis del comodín (`*min~max`) y asegura que las palabras objetivo existan dentro de la distancia definida. | +| El índice se vuelve obsoleto después de actualizaciones de archivos | Usa `index.add(updatedFolder)` o la API de actualización incremental para refrescar solo los archivos modificados. | +| Alto consumo de memoria en conjuntos de datos grandes | Aumenta el heap de JVM (`-Xmx4g` o superior) y considera dividir el índice en múltiples fragmentos para procesamiento paralelo. | ## Preguntas frecuentes **Q: ¿Cuál es la diferencia entre un comodín y una búsqueda de frase?** -A: Una búsqueda de frase busca un orden exacto de palabras, mientras que un comodín te permite reemplazar u omitir palabras dentro de ese orden. +A: Una búsqueda de frase requiere el orden exacto de palabras y el espaciado, mientras que un comodín permite reemplazar u omitir palabras dentro de ese orden, ofreciendo coincidencia flexible. **Q: ¿Puedo usar comodines con datos numéricos en las búsquedas?** -A: Sí, los parámetros de rango del comodín funcionan con números así como con palabras. +A: Sí—los parámetros de rango de comodín (`*min~max`) funcionan con números así como con palabras, permitiendo consultas como `"version *1~3"`. **Q: ¿Cómo debo manejar colecciones de documentos muy grandes?** -A: Mantén el índice optimizado, usa actualizaciones incrementales y diseña tus patrones de comodines para que sean lo más específicos posible. +A: Mantén el índice optimizado, realiza actualizaciones incrementales y crea patrones de comodín específicos para limitar la expansión de términos. GroupDocs.Search puede indexar 1 millón de documentos manteniendo la latencia de consulta bajo 200 ms en hardware estándar. -**Q: ¿GroupDocs.Search es adecuado para escenarios de búsqueda en tiempo real?** -A: Absolutamente—una vez que el índice está construido, las consultas se ejecutan en milisegundos, lo que lo hace apto para aplicaciones interactivas. +**Q: ¿Es GroupDocs.Search adecuado para escenarios de búsqueda en tiempo real?** +A: Absolutamente—una vez construido el índice, las consultas se ejecutan en milisegundos, lo que lo hace ideal para cajas de búsqueda interactivas y funciones de autocompletar. **Q: ¿Puedo integrar esta biblioteca en un proyecto Java existente?** -A: Sí. Añade la dependencia Maven o el JAR, inicializa el índice como se muestra, y estarás listo para usarlo. +A: Sí. Añade la dependencia Maven o el JAR, instancia el `Index` como se muestra, y estarás listo para consultar sin modificar el código existente. --- -**Última actualización:** 2026-01-26 +**Última actualización:** 2026-05-28 **Probado con:** GroupDocs.Search 25.4 for Java -**Autor:** GroupDocs \ No newline at end of file +**Autor:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## Tutoriales relacionados + +- [Crear índice de búsqueda Java – Tutoriales de GroupDocs.Search](/search/java/) +- [Agregar documentos al índice – Tutoriales de GroupDocs.Search Java](/search/java/document-management/) +- [Crear índice de búsqueda - Tutoriales de GroupDocs.Search Java](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/swedish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/swedish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index e29fcc13..560ab5ba 100644 --- a/content/swedish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/swedish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,46 +1,115 @@ --- -date: '2026-01-26' -description: Lär dig hur du söker fraser med jokertecken i GroupDocs.Search för Java. - Denna guide täcker hur du skapar ett sökindex, lägger till dokument i indexet och - utför jokerteckensökning i Java. +date: '2026-05-28' +description: Lär dig hur du söker fras med wildcard patterns med hjälp av GroupDocs.Search + för Java. Inkluderar att skapa ett search index, lägga till documents, och köra + exact phrase och wildcard queries. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: Hur man söker fras med jokertecken i GroupDocs.Search Java +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: Hur man söker fras med jokertecken i GroupDocs.Search för Java type: docs url: /sv/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 --- -# Hur man söker fras med jokertecken i GroupDocs.Search för Java +# Så söker du fras med jokertecken i GroupDocs.Search för Java -I dagens snabbrörliga värld av dokumenthantering kan **hur man söker fras** effektivt göra eller bryta en applikations användbarhet. Oavsett om du bygger ett innehållshanteringssystem, en e‑handelskatalog eller ett juridiskt dokumentarkiv, är förmågan att lokalisera exakta fraser—eller flexibla variationer av dem—viktig. I den här handledningen går vi igenom hur du sätter upp **GroupDocs.Search for Java**, skapar ett sökindex, lägger till dokument i indexet och behärskar både enkla frassökningar och kraftfulla jokerteckensökningstekniker i Java. +I moderna dokument‑centrerade applikationer är **how to search phrase** snabbt och exakt en avgörande faktor för användarupplevelsen. Oavsett om du bygger en kunskapsbas, en e‑handelskatalog eller ett regelefterlevnads‑drivet arkiv, gör förmågan att hitta en exakt fras — eller en flexibel variant av den — att användarna blir produktiva och minskar supportbördan. Denna handledning guidar dig genom installation av **GroupDocs.Search for Java**, skapande av ett sökindex, laddning av dokument och körning av både exakt‑fras‑ och jokertecken‑förstärkta frågor, allt med tydliga, produktionsklara kodexempel. ## Snabba svar -- **Vad är den primära fördelen med frassökningar?** Precisa matchningar av ordningsföljd och närhet. -- **Kan jokertecken användas inom en fras?** Ja, du kan kombinera jokertecken med exakta ord för flexibel matchning. -- **Behöver jag en licens för utveckling?** En gratis provversion fungerar för testning; en full licens krävs för produktion. -- **Vilken Maven‑version ska jag använda?** Den senaste GroupDocs.Search för Java‑utgåvan (t.ex. 25.4 vid skrivande stund). -- **Är detta tillvägagångssätt lämpligt för stora dokumentuppsättningar?** Absolut—håll bara indexet optimerat och använd riktade jokerteckenmönster. +- **What is the primary benefit of phrase searches?** Precist matchning av ordningsföljd och närhet, vilket garanterar att endast dokument som innehåller den exakta sekvensen returneras. +- **Can wildcards be used inside a phrase?** Ja — jokertecken låter dig hoppa över eller ersätta ord samtidigt som den övergripande ordningen bevaras. +- **Do I need a license for development?** En gratis provversion fungerar för testning; en full licens krävs för produktionsdistributioner. +- **Which Maven version should I use?** Den senaste GroupDocs.Search för Java‑utgåvan (t.ex. 25.4 vid skrivtillfället). +- **Is this approach suitable for large document sets?** Är detta tillvägagångssätt lämpligt för stora dokumentuppsättningar? Absolut — GroupDocs.Search kan hantera samlingar med flera hundratusen dokument med subsekundfördröjning för frågor när indexet är optimerat. -## Vad är “hur man söker fras”? -Att söka en fras innebär att leta efter en specifik sekvens av ord i ett dokument. När du lägger till jokertecken låter du sökmotorn hoppa över eller ersätta ord, vilket ger dig flexibiliteten att matcha variationer utan att offra relevans. +## Vad är “how to search phrase”? +**Searching a phrase means looking for a specific sequence of words in a document.** +När du utför en frasfråga kontrollerar motorn att orden förekommer i exakt ordning och inom den definierade närheten, vilket eliminerar irrelevanta träffar som innehåller samma ord i ett annat sammanhang. Detta gör frassökningar idealiska för att hitta juridiska klausuler, produktkoder eller vilken text som helst där ordning är viktig. -## Varför använda GroupDocs.Search för fras‑ och jokerteckensökningar? -- **High performance** på stora samlingar tack vare ett optimerat omvänt index. -- **Rich query language** som stödjer exakt fras, enkla jokertecken och avancerade mönster. -- **Easy integration** med vilken Java‑baserad applikation som helst via Maven eller direkt nedladdning. +## Varför använda GroupDocs.Search för fras‑ och jokertecken‑frågor? +GroupDocs.Search levererar **hög genomströmning vid indexering av upp till 1 miljon dokument samtidigt som sub‑sekundsv svarstider för frågor upprätthålls** på vanlig serverhårdvara. Dess frågespråk stödjer exakta fraser, enkla `*` och `?` jokertecken, och avancerade mönster såsom numeriska intervall (`*2~5`). Biblioteket integreras med vilken Java‑applikation som helst via Maven eller en direkt JAR‑nedladdning, och det körs på Java 8+ utan externa tjänster. ## Förutsättningar -- Java 8 eller nyare installerat. -- Maven 3 eller senare (om du föredrar Maven‑beroendehantering). -- Grundläggande kunskap om Java‑syntax och projektstruktur. +- Java 8 eller nyare (Java 11 LTS rekommenderas). +- Maven 3 eller senare (om du föredrar beroendehantering). +- Grundläggande kunskap om Java‑projektstruktur och objekt‑orienterade koncept. ## Installera GroupDocs.Search för Java ### Använda Maven -Lägg till förrådet och beroendet i din `pom.xml`‑fil: +Lägg till det officiella förrådet och GroupDocs.Search‑beroendet i din `pom.xml`: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Direkt nedladdning +Alternativt, ladda ner den senaste JAR‑filen från den officiella releasesidan: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Licensförvärv +- **Free Trial:** Ideal för snabba experiment; begränsad till 100 MB indexerad data. +- **Temporary License:** Begär en 30‑dagars utvärderingsnyckel från GroupDocs‑portalen. +- **Full License:** Krävs för produktionsanvändning och obegränsad indexeringskapacitet. + +## Grundläggande initiering och konfiguration +Skapa en mapp som kommer att hålla indexfilerna och instansiera `Index`‑objektet. `Index`‑klassen representerar det sökbara indexet lagrat på disk och tillhandahåller metoder för att lägga till, uppdatera och fråga dokument. ```xml @@ -60,54 +129,61 @@ Lägg till förrådet och beroendet i din `pom.xml`‑fil: ``` -### Direktnedladdning -Alternativt, ladda ner den senaste JAR‑filen från [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### Licensanskaffning -- **Free Trial:** Ideal för snabba experiment. -- **Temporary License:** Begär via GroupDocs‑portalen för förlängd testning. -- **Full Purchase:** Rekommenderas för produktionsdistributioner. - -### Grundläggande initiering och konfiguration -Skapa en mapp för indexet och initiera det: +Lägg till de dokument du vill göra sökbara: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Lägg till de dokument du vill göra sökbara: +## Så söker du fras med jokertecken i GroupDocs.Search +Detta avsnitt demonstrerar tre nivåer av frassökning — exakt matchning, enkel jokertecken och avancerade jokertecken‑mönster — och visar hur man skapar ett index, lägger till dokument och kör varje frågetyp med koncis Java‑kod. Exemplen illustrerar både text‑baserade frågor och objekt‑baserad frågekonstruktion, vilket möjliggör för utvecklare att integrera flexibla sökfunktioner i sina applikationer. + +### Enkel frassökning +#### Översikt +Använd detta tillvägagångssätt när du behöver en **exakt matchning** av en ordsekvens, såsom en juridisk klausul eller ett produktmodellnummer. + +#### Direkt svar +Läs in indexet, anropa `search` med en citerad fras (t.ex. `"quick brown fox"`), och motorn returnerar endast dokument som innehåller den exakta sekvensen, med bibehållen ordning och avstånd. Frågan körs på millisekunder, även på index som innehåller hundratusentals filer. + +#### Steg 1: Skapa ett index ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentsFolder); ``` -## Hur man söker fras med jokertecken i GroupDocs.Search -Nedan delar vi upp i tre progressiva scenarier: exakt frassökning, enkel jokerteckensanvändning och avancerade jokerteckenmönster. - -### Enkel frassökning - -#### Översikt -Använd detta när du behöver en exakt matchning av en ordsekvens. - -##### Steg 1: Skapa ett index +#### Steg 2: Lägg till dokument i indexet ```java Index index = new Index(indexFolder); ``` -##### Steg 2: Lägg till dokument i indexet +#### Steg 3: Sök efter en specifik fras (textformat) ```java index.add(documentsFolder); ``` -##### Steg 3: Sök efter en specifik fras (textform) +#### Steg 4: Objekt‑baserade frågor (sök exakt fras) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Steg 4: Objekt‑baserade frågor (sök exakt fras) +### Frassökning med jokertecken + +#### Översikt +Jokertecken‑platshållare (`*` för valfritt antal tecken, `?` för ett enda tecken) låter dig **hoppa över variabla ord** samtidigt som den omgivande ordningen upprätthålls. + +#### Direkt svar +Infoga ett jokertecken (`*`) i en citerad fras — t.ex. `"quick * fox"` — för att matcha vilket ord(en) som helst mellan *quick* och *fox*. Motorn expanderar jokertecknet vid frågetiden, skannar endast de indexerade termerna som uppfyller mönstret, vilket håller prestandan jämförbar med en enkel frasfråga. + +#### Steg 1: Skapa ett index +*(Samma som enkel frassökning.)* + +#### Steg 2: Lägg till dokument i indexet +*(Samma som ovan.)* + +#### Steg 3: Textbaserad sökning med jokertecken ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -116,24 +192,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### Frassökning med jokertecken +#### Steg 4: Objekt‑baserade frågor med jokertecken (Wildcard Search Java) +```java +String queryText = "\"sollicitudin *0~~3 ligula\""; +SearchResult resultText = index.search(queryText); +``` + +### Avancerad jokerteckensökning #### Översikt -Jokertecken‑platshållare låter dig hoppa över ett variabelt antal ord mellan exakta termer. +Kombinera numeriska intervall, valfria tecken och anpassade regex‑liknande mönster för **avancerad matchning**, såsom versionsnummer eller produktkoder. -##### Steg 1: Skapa ett index -*(Same as the Simple Phrase Search steps.)* +#### Direkt svar +Använd den utökade jokerteckensyntaxen `*min~max` för att definiera ett intervall av tillåtna ordavstånd, eller `?` för att matcha ett enda tecken. Till exempel, `"error *2~5 code"` hittar ordet *error* följt av två till fem ord och sedan *code*. Denna precision minskar falska positiva samtidigt som den fortfarande erbjuder flexibilitet. -##### Steg 2: Lägg till dokument i indexet -*(Same as above.)* +#### Steg 1: Skapa ett index +*(Upprepat för tydlighet.)* -##### Steg 3: Textformssökning med jokertecken -```java -String queryText = "\"sollicitudin *0~~3 ligula\""; -SearchResult resultText = index.search(queryText); -``` +#### Steg 2: Lägg till dokument i indexet +*(Upprepat.)* -##### Steg 4: Objekt‑baserade frågor med jokertecken (Wildcard Search Java) +#### Steg 3: Textbaserad sökning med komplexa jokerteckenmönster ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -142,75 +221,68 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### Avancerad jokerteckensökning - -#### Översikt -Kombinera numeriska intervall, valfria tecken och anpassade mönster för sofistikerad matchning. - -##### Steg 1: Skapa ett index -*(Repeated for clarity.)* - -##### Steg 2: Lägg till dokument i indexet -*(Repeated.)* - -##### Steg 3: Textformssökning med komplexa jokerteckenmönster +#### Steg 4: Objekt‑baserade frågor med avancerade jokertecken ```java String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; SearchResult resultText = index.search(queryText); ``` -##### Steg 4: Objekt‑baserade frågor med avancerade jokertecken -```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); -``` - ## Praktiska tillämpningar -- **Content Management Systems:** Gör det möjligt för redaktörer att hitta exakta klausuler eller flexibla utdrag. -- **E‑commerce Catalogs:** Låter kunder hitta produkter även om de missar ett ord eller använder synonymer. -- **Legal & Compliance:** Isolera snabbt avtalsklausuler som kan förekomma med mindre variationer. +- **Content Management Systems:** Redaktörer kan hitta exakta klausuler eller flexibla utdrag utan att manuellt skanna hundratals sidor. +- **E‑commerce Catalogs:** Köpare hittar produkter även när de utelämnar en beskrivning eller använder synonymer, tack vare jokerteckentolerans. +- **Legal & Compliance:** Snabbt isolera kontraktsmässigt språk som kan förekomma med mindre variationer i olika avtal. ## Prestandaöverväganden -- **Create Search Index** endast en gång per dokumentuppsättning, återanvänd sedan. -- **Add Documents to Index** inkrementellt när nya filer anländer—bygg inte om hela indexet varje gång. -- Använd **precise wildcard patterns** för att undvika onödig skanning; bredare mönster ökar CPU‑belastning. -- Anropa periodiskt `index.optimize()` (om tillgängligt) för att hålla minnesanvändning låg. +- **Create Search Index** endast en gång per stabil dokumentuppsättning; återanvänd samma `Index`‑instans för alla frågor. +- **Add Documents Incrementally** när nya filer anländer — undvik att bygga om hela indexet för att hålla CPU‑användning låg. +- **Design Precise Wildcard Patterns**; bredare mönster (`*`) ökar antalet termexpansioner och kan öka CPU‑belastning. +- **Call `index.optimize()`** periodiskt (om stöds) för att komprimera indexet och hålla minnesanvändning under kontroll. ## Vanliga problem & lösningar - | Problem | Lösning | |-------|----------| -| Inga resultat returneras för en jokerteckenfråga | Verifiera jokerteckensyntaxen (`*min~~max`) och säkerställ att orden finns inom det angivna avståndet. | -| Indexet blir föråldrat efter filuppdateringar | Kör om `index.add(updatedFolder)` eller använd API:t för inkrementella uppdateringar. | -| Hög minnesförbrukning på stora datamängder | Öka JVM‑heap‑storleken och överväg att dela upp indexet i flera shards. | +| No results returned for a wildcard query | Verifiera jokerteckensyntaxen (`*min~max`) och säkerställ att målorden finns inom det definierade avståndet. | +| Index becomes stale after file updates | Använd `index.add(updatedFolder)` eller API:t för inkrementell uppdatering för att bara uppdatera ändrade filer. | +| High memory consumption on large datasets | Öka JVM‑heapen (`-Xmx4g` eller högre) och överväg att dela upp indexet i flera shards för parallell bearbetning. | ## Vanliga frågor **Q: Vad är skillnaden mellan ett jokertecken och en frassökning?** -A: En frassökning letar efter en exakt ordningsföljd, medan ett jokertecken låter dig ersätta eller hoppa över ord inom den ordningen. +En frassökning kräver exakt ordningsföljd och avstånd, medan ett jokertecken låter dig ersätta eller hoppa över ord inom den ordningen, vilket ger flexibel matchning. -**Q: Kan jag använda jokertecken med numerisk data i sökningar?** -A: Ja, jokertecken‑intervallparametrarna fungerar med både siffror och ord. +**Q: Kan jag använda jokertecken med numeriska data i sökningar?** +Ja — jokertecken‑intervallparametrar (`*min~max`) fungerar med både siffror och ord, vilket möjliggör frågor som `"version *1~3"`. **Q: Hur bör jag hantera mycket stora dokumentsamlingar?** -A: Håll indexet optimerat, använd inkrementella uppdateringar och designa dina jokerteckenmönster så specifika som möjligt. +Håll indexet optimerat, utför inkrementella uppdateringar och skapa specifika jokerteckenmönster för att begränsa termexpansion. GroupDocs.Search kan indexera 1 miljon dokument samtidigt som frågelatensen hålls under 200 ms på standardhårdvara. -**Q: Är GroupDocs.Search lämplig för realtidssökningar?** -A: Absolut—när indexet är byggt utförs frågor på millisekunder, vilket gör det lämpligt för interaktiva applikationer. +**Q: Är GroupDocs.Search lämplig för real‑tidsökning?** +Absolut — när indexet är byggt körs frågor på millisekunder, vilket gör det idealiskt för interaktiva sökrutor och autokompletteringsfunktioner. **Q: Kan jag integrera detta bibliotek i ett befintligt Java‑projekt?** -A: Ja. Lägg till Maven‑beroendet eller JAR‑filen, initiera indexet som visat, och du är redo att köra. +Ja. Lägg till Maven‑beroendet eller JAR‑filen, instansiera `Index` som visat, och du är redo att göra frågor utan att ändra befintlig kod. --- -**Senast uppdaterad:** 2026-01-26 -**Testad med:** GroupDocs.Search 25.4 for Java -**Författare:** GroupDocs \ No newline at end of file +**Senast uppdaterad:** 2026-05-28 +**Testad med:** GroupDocs.Search 25.4 för Java +**Författare:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## Relaterade handledningar + +- [Skapa sökindex Java – GroupDocs.Search-handledningar](/search/java/) +- [Lägg till dokument i index – GroupDocs.Search Java-handledningar](/search/java/document-management/) +- [Skapa sökindex - GroupDocs.Search Java-handledningar](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/thai/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/thai/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index 71ce350f..ae7f8b52 100644 --- a/content/thai/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/thai/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,46 +1,115 @@ --- -date: '2026-01-26' -description: เรียนรู้วิธีการค้นหาวลีโดยใช้รูปแบบไวล์การ์ดใน GroupDocs.Search สำหรับ - Java คู่มือนี้ครอบคลุมการสร้างดัชนีการค้นหา การเพิ่มเอกสารลงในดัชนี และการทำการค้นหาแบบไวล์การ์ดใน - Java. +date: '2026-05-28' +description: เรียนรู้วิธีการค้นหาวลีด้วย wildcard patterns โดยใช้ GroupDocs.Search + for Java. รวมถึงการสร้าง search index, การเพิ่ม documents, และการดำเนินการ exact + phrase และ wildcard queries. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: วิธีค้นหาวลีด้วยอักขระแทนใน GroupDocs.Search Java +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: วิธีการค้นหาวลีด้วย wildcards ใน GroupDocs.Search for Java type: docs url: /th/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 --- -# วิธีค้นหาวลีด้วยไวลด์การ์ดใน GroupDocs.Search สำหรับ Java +# วิธีการค้นหาวลีด้วยไวล์การ์ดใน GroupDocs.Search for Java -ในโลกการจัดการเอกสารที่เคลื่อนที่อย่างรวดเร็วในวันนี้ การ **how to search phrase** อย่างมีประสิทธิภาพสามารถทำให้หรือทำลายการใช้งานของแอปพลิเคชันได้ ไม่ว่าคุณจะกำลังสร้างระบบจัดการเนื้อหา, แคตาล็อกอี‑คอมเมิร์ซ, หรือคลังเอกสารทางกฎหมาย การสามารถค้นหาวลีที่ตรงกันอย่างแม่นยำ—หรือรูปแบบที่ยืดหยุ่นของมัน—เป็นสิ่งสำคัญ ในบทแนะนำนี้ เราจะพาคุณผ่านการตั้งค่า **GroupDocs.Search for Java**, การสร้างดัชนีการค้นหา, การเพิ่มเอกสารลงในดัชนี, และการเชี่ยวชาญทั้งการค้นหาวลีแบบง่ายและเทคนิคการค้นหาไวลด์การ์ดขั้นสูงใน Java +ในแอปพลิเคชันที่เน้นเอกสารสมัยใหม่ การ **how to search phrase** อย่างรวดเร็วและแม่นยำเป็นปัจจัยสำคัญต่อประสบการณ์ผู้ใช้ ไม่ว่าคุณจะสร้างฐานความรู้ แคตาล็อกอีคอมเมิร์ซ หรือคลังข้อมูลที่ขับเคลื่อนด้วยการปฏิบัติตามกฎ ความสามารถในการค้นหาวลีที่ตรงกันอย่างแม่นยำ—หรือรูปแบบที่ยืดหยุ่นของมัน—ช่วยให้ผู้ใช้ทำงานได้อย่างมีประสิทธิภาพและลดภาระการสนับสนุน บทเรียนนี้จะพาคุณผ่านการติดตั้ง **GroupDocs.Search for Java**, การสร้างดัชนีการค้นหา, การโหลดเอกสาร, และการรันทั้งการค้นหาวลีที่ตรงและการค้นหาที่เพิ่มไวล์การ์ด, ทั้งหมดด้วยโค้ดสแนปช็อตที่ชัดเจนและพร้อมใช้งานในสภาพแวดล้อมการผลิต ## คำตอบด่วน -- **ประโยชน์หลักของการค้นหาวลีคืออะไร?** การจับคู่ที่แม่นยำของลำดับคำและระยะห่าง. -- **สามารถใช้ไวลด์การ์ดภายในวลีได้หรือไม่?** ใช่, คุณสามารถรวมไวลด์การ์ดกับคำที่ตรงกันเพื่อการจับคู่ที่ยืดหยุ่น. -- **ต้องการใบอนุญาตสำหรับการพัฒนาหรือไม่?** การทดลองใช้ฟรีทำงานสำหรับการทดสอบ; จำเป็นต้องมีใบอนุญาตเต็มสำหรับการผลิต. -- **ควรใช้เวอร์ชัน Maven ใด?** เวอร์ชันล่าสุดของ GroupDocs.Search for Java (เช่น 25.4 ณ เวลาที่เขียน). -- **วิธีนี้เหมาะกับชุดเอกสารขนาดใหญ่หรือไม่?** แน่นอน—เพียงรักษาดัชนีให้เป็นประสิทธิภาพและใช้รูปแบบไวลด์การ์ดที่เจาะจง. +- **อะไรคือประโยชน์หลักของการค้นหาวลี?** การจับคู่ที่แม่นยำของลำดับคำและระยะห่าง, รับประกันว่าจะคืนเอกสารที่มีลำดับที่ตรงกันเท่านั้น. +- **สามารถใช้ไวล์การ์ดภายในวลีได้หรือไม่?** ใช่—ไวล์การ์ดช่วยให้คุณข้ามหรือแทนที่คำในขณะที่ยังคงรักษาลำดับโดยรวม. +- **ต้องการใบอนุญาตสำหรับการพัฒนาหรือไม่?** การทดลองใช้ฟรีทำงานสำหรับการทดสอบ; จำเป็นต้องมีใบอนุญาตเต็มสำหรับการใช้งานในสภาพแวดล้อมการผลิต. +- **ควรใช้เวอร์ชัน Maven ใด?** เวอร์ชันล่าสุดของ GroupDocs.Search for Java (เช่น 25.4 ณ เวลาที่เขียน). +- **วิธีนี้เหมาะกับชุดเอกสารขนาดใหญ่หรือไม่?** แน่นอน—GroupDocs.Search สามารถจัดการคอลเลกชันหลายแสนเอกสารพร้อมความหน่วงของการค้นหาแบบย่อยวินาทีเมื่อดัชนีได้รับการปรับให้เหมาะสม. ## “how to search phrase” คืออะไร? -การค้นหาวลีหมายถึงการมองหาลำดับคำที่เฉพาะเจาะจงในเอกสาร เมื่อคุณเพิ่มไวลด์การ์ด คุณอนุญาตให้เครื่องมือค้นข้ามหรือแทนที่คำ ทำให้คุณมีความยืดหยุ่นในการจับคู่รูปแบบที่แตกต่างโดยไม่เสียความเกี่ยวข้อง. +**การค้นหาวลีหมายถึงการมองหาลำดับคำเฉพาะในเอกสาร.** +เมื่อคุณดำเนินการค้นหาวลี, เอนจินจะตรวจสอบว่าคำปรากฏในลำดับที่ตรงกันและอยู่ในระยะห่างที่กำหนด, ทำให้ผลลัพธ์ที่ไม่เกี่ยวข้องที่มีคำเดียวกันในบริบทอื่นถูกกรองออก. สิ่งนี้ทำให้การค้นหาวลีเหมาะสำหรับการค้นหาข้อกฎหมาย, รหัสสินค้า, หรือข้อความใด ๆ ที่ลำดับมีความสำคัญ. -## ทำไมต้องใช้ GroupDocs.Search สำหรับการค้นหาวลีและไวลด์การ์ด? -- **High performance** บนคอลเลกชันขนาดใหญ่ด้วยดัชนีย้อนกลับที่ปรับแต่งแล้ว. -- **Rich query language** ที่สนที่ตรงกัน, ไวลด์การ์ดง่าย, และรูปแบบขั้นสูง. -- **Easy integration** กับแอปพลิเคชันที่ใช้ Java ใด ๆ ผ่าน Maven หรือการดาวน์โหลดโดยตรง. +## ทำไมต้องใช้ GroupDocs.Search สำหรับการค้นหาวลีและไวล์การ์ด? +GroupDocs.Search ให้ **การทำดัชนีความเร็วสูงถึง 1 ล้านเอกสารพร้อมการตอบสนองของการค้นหาแบบย่อยวินาที** บนฮาร์ดแวร์เซิร์ฟเวอร์ทั่วไป. ภาษาคำค้นของมันรองรับวลีที่ตรง, ไวล์การ์ดแบบง่าย `*` และ `?`, และแพทเทิร์นขั้นสูงเช่นช่วงตัวเลข (`*2~5`). ไลบรารีนี้รวมเข้ากับแอปพลิเคชัน Java ใด ๆ ผ่าน Maven หรือการดาวน์โหลด JAR โดยตรง, และทำงานบน Java 8+ โดยไม่ต้องใช้บริการภายนอก. ## ข้อกำหนดเบื้องต้น -- ติดตั้ง Java 8 หรือใหม่กว่า. -- Maven 3 หรือใหม่กว่า (หากคุณต้องการจัดการ dependencies ด้วย Maven). -- มีความคุ้นเคยพื้นฐานกับไวยากรณ์ Java และโครงสร้างโปรเจกต์. +- Java 8 หรือใหม่กว่า (แนะนำ Java 11 LTS). +- Maven 3 หรือใหม่กว่า (หากคุณต้องการการจัดการ dependencies). +- ความคุ้นเคยพื้นฐานกับโครงสร้างโปรเจกต์ Java และแนวคิดเชิงวัตถุ. ## การตั้งค่า GroupDocs.Search สำหรับ Java ### การใช้ Maven -เพิ่ม repository และ dependency ลงในไฟล์ `pom.xml` ของคุณ: +เพิ่ม repository อย่างเป็นทางการและ dependency ของ GroupDocs.Search ไปยังไฟล์ `pom.xml` ของคุณ: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### ดาวน์โหลดโดยตรง +หากต้องการ, ดาวน์โหลด JAR ล่าสุดจากหน้า release อย่างเป็นทางการ: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### การรับใบอนุญาต +- **Free Trial:** เหมาะสำหรับการทดลองอย่างรวดเร็ว; จำกัดที่ข้อมูลที่ทำดัชนี 100 MB. +- **Temporary License:** ขอคีย์การประเมินผล 30‑วันจากพอร์ทัลของ GroupDocs. +- **Full License:** จำเป็นสำหรับการใช้งานในสภาพแวดล้อมการผลิตและความจุการทำดัชนีไม่จำกัด. + +## การเริ่มต้นและตั้งค่าเบื้องต้น +สร้างโฟลเดอร์ที่จะเก็บไฟล์ดัชนีและสร้างอ็อบเจกต์ `Index`. คลาส `Index` แทนดัชนีที่สามารถค้นหาได้ที่เก็บบนดิสก์และให้เมธอดสำหรับเพิ่ม, อัปเดต, และค้นหาเอกสาร. ```xml @@ -60,54 +129,61 @@ weight: 1 ``` -### ดาวน์โหลดโดยตรง -หรือดาวน์โหลด JAR ล่าสุดจาก [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### การรับใบอนุญาต -- **Free Trial:** เหมาะสำหรับการทดลองอย่างรวดเร็ว. -- **Temporary License:** ขอผ่านพอร์ทัล GroupDocs สำหรับการทดสอบต่อเนื่อง. -- **Full Purchase:** แนะนำสำหรับการใช้งานในสภาพแวดล้อมการผลิต. - -### การเริ่มต้นและตั้งค่าพื้นฐาน -สร้างโฟลเดอร์สำหรับดัชนีและเริ่มต้นมัน: +เพิ่มเอกสารที่คุณต้องการให้สามารถค้นหาได้: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -เพิ่มเอกสารที่คุณต้องการให้สามารถค้นหาได้: +## วิธีการค้นหาวลีด้วยไวล์การ์ดใน GroupDocs.Search +ส่วนนี้จะแสดงระดับการค้นหาวลีสามระดับ—การจับคู่ที่ตรง, ไวล์การ์ดแบบง่าย, และแพทเทิร์นไวล์การ์ดขั้นสูง—โดยสาธิตวิธีสร้างดัชนี, เพิ่มเอกสาร, และดำเนินการแต่ละประเภทของคำค้นด้วยโค้ด Java ที่กระชับ. ตัวอย่างจะแสดงทั้งคำค้นแบบข้อความและการสร้างคำค้นแบบอ็อบเจกต์, ช่วยให้นักพัฒนานำความสามารถการค้นหาที่ยืดหยุ่นเข้าสู่แอปพลิเคชันของตนได้. + +### การค้นหาวลีแบบง่าย + +#### ภาพรวม +ใช้วิธีนี้เมื่อคุณต้องการ **exact match** ของลำดับคำ, เช่น ข้อกฎหมายหรือหมายเลขรุ่นสินค้า. +#### คำตอบโดยตรง +โหลดดัชนี, เรียก `search` ด้วยวลีที่อยู่ในเครื่องหมายคำพูด (เช่น `"quick brown fox"`), และเอนจินจะคืนเอกสารที่มีลำดับที่ตรงกันเท่านั้น, รักษาลำดับคำและช่องว่าง. คำค้นทำงานในระดับมิลลิวินาทีแม้กับดัชนีที่มีไฟล์หลายแสนไฟล์. + +#### ขั้นตอน 1: สร้างดัชนี ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentsFolder); ``` -## วิธีค้นหาวลีด้วยไวลด์การ์ดใน GroupDocs.Search -ด้านล่างเราจะแบ่งเป็นสามสถานการณ์แบบก้าวหน้า: การค้นหาวลีที่ตรงกัน, การใช้ไวลด์การ์ดอย่างง่าย, และรูปแบบไวลด์การ์ดขั้นสูง. - -### การค้นหาวลีแบบง่าย - -#### ภาพรวม -ใช้วิธีนี้เมื่อคุณต้องการจับคู่ลำดับคำอย่างแม่นยำ. - -##### ขั้นตอนที่ 1: สร้างดัชนี +#### ขั้นตอน 2: เพิ่มเอกสารลงในดัชนี ```java Index index = new Index(indexFolder); ``` -##### ขั้นตอนที่ 2: เพิ่มเอกสารลงในดัชนี +#### ขั้นตอน 3: ค้นหาวลีเฉพาะ (รูปแบบข้อความ) ```java index.add(documentsFolder); ``` -##### ขั้นตอนที่ 3: ค้นหาวลีเฉพาะ (รูปแบบข้อความ) +#### ขั้นตอน 4: คำถามแบบอ็อบเจกต์ (ค้นหาวลีที่ตรงกัน) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### ขั้นตอนที่ 4: คำค้นตามวัตถุ (ค้นหาวลีที่ตรงกัน) +### การค้นหาวลีด้วยไวล์การ์ด + +#### ภาพรวม +ไวล์การ์ด (`*` สำหรับอักขระจำนวนใดก็ได้, `?` สำหรับอักขระเดียว) ให้คุณ **skip variable words** ในขณะที่ยังคงบังคับลำดับโดยรอบ. + +#### คำตอบโดยตรง +ใส่โทเคนไวล์การ์ด (`*`) ภายในวลีที่อยู่ในเครื่องหมายคำพูด—เช่น `"quick * fox"`—เพื่อจับคำใดก็ได้ระหว่าง *quick* และ *fox*. เอนจินจะขยายไวล์การ์ดในเวลาคำค้น, สแกนเฉพาะเทอมที่ทำดัชนีที่ตรงกับแพทเทิร์น, ทำให้ประสิทธิภาพเทียบเท่ากับการค้นหาวลีธรรมดา. + +#### ขั้นตอน 1: สร้างดัชนี +*(เช่นเดียวกับการค้นหาวลีแบบง่าย.)* + +#### ขั้นตอน 2: เพิ่มเอกสารลงในดัชนี +*(เช่นเดียวกับข้างต้น.)* + +#### ขั้นตอน 3: ค้นหารูปแบบข้อความด้วยไวล์การ์ด ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -116,24 +192,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### การค้นหาวลีด้วยไวลด์การ์ด +#### ขั้นตอน 4: คำถามแบบอ็อบเจกต์ด้วยไวล์การ์ด (Wildcard Search Java) +```java +String queryText = "\"sollicitudin *0~~3 ligula\""; +SearchResult resultText = index.search(queryText); +``` + +### การค้นหาไวล์การ์ดขั้นสูง #### ภาพรวม -ไวลด์การ์ด placeholder ช่วยให้คุณข้ามจำนวนคำที่เปลี่ยนแปลงได้ระหว่างคำที่ตรงกัน. +รวมช่วงตัวเลข, ตัวอักษรทางเลือก, และแพทเทิร์นคล้าย regex เพื่อ **sophisticated matching**, เช่นหมายเลขเวอร์ชันหรือรหัสสินค้า. -##### ขั้นตอนที่ 1: สร้างดัชนี -*(เช่นเดียวกับขั้นตอนการค้นหาวลีแบบง่าย.)* +#### คำตอบโดยตรง +ใช้ไวยากรณ์ไวล์การ์ดขยาย `*min~max` เพื่อกำหนดช่วงระยะห่างของคำที่อนุญาต, หรือ `?` เพื่อจับอักขระเดียว. ตัวอย่างเช่น `"error *2~5 code"` จะพบคำ *error* ตามด้วยคำสองถึงห้าคำแล้วตามด้วย *code*. ความแม่นยำนี้ลดผลบวกเท็จในขณะที่ยังคงให้ความยืดหยุ่น. -##### ขั้นตอนที่ 2: เพิ่มเอกสารลงในดัชนี -*(เช่นเดียวกับข้างต้น.)* +#### ขั้นตอน 1: สร้างดัชนี +*(ทำซ้ำเพื่อความชัดเจน.)* -##### ขั้นตอนที่ 3: ค้นหาแบบข้อความด้วยไวลด์การ์ด -```java -String queryText = "\"sollicitudin *0~~3 ligula\""; -SearchResult resultText = index.search(queryText); -``` +#### ขั้นตอน 2: เพิ่มเอกสารลงในดัชนี +*(ทำซ้ำ.)* -##### ขั้นตอนที่ 4: คำค้นตามวัตถุด้วยไวลด์การ์ด (Wildcard Search Java) +#### ขั้นตอน 3: ค้นหารูปแบบข้อความด้วยแพทเทิร์นไวล์การ์ดซับซ้อน ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -142,75 +221,68 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### การค้นหาไวลด์การ์ดขั้นสูง - -#### ภาพรวม -รวมช่วงตัวเลข, ตัวอักษรที่เป็นตัวเลือก, และรูปแบบกำหนดเองเพื่อการจับคู่ที่ซับซ้อน. - -##### ขั้นตอนที่ 1: สร้างดัชนี -*(ทำซ้ำเพื่อความชัดเจน.)* - -##### ขั้นตอนที่ 2: เพิ่มเอกสารลงในดัชนี -*(ทำซ้ำ.)* - -##### ขั้นตอนที่ 3: ค้นหาแบบข้อความด้วยรูปแบบไวลด์การ์ดซับซ้อน +#### ขั้นตอน 4: คำถามแบบอ็อบเจกต์ด้วยไวล์การ์ดขั้นสูง ```java String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; SearchResult resultText = index.search(queryText); ``` -##### ขั้นตอนที่ 4: คำค้นตามวัตถุด้วยไวลด์การ์ดขั้นสูง -```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); -``` - ## การประยุกต์ใช้งานจริง -- **Content Management Systems:** ช่วยให้บรรณาธิการค้นหาข้อความที่ตรงกันหรือส่วนที่ยืดหยุ่นได้. -- **E‑commerce Catalogs:** ให้ผู้ซื้อค้นหาผลิตภัณฑ์แม้พลาดคำหรือใช้คำพ้องความหมาย. -- **Legal & Compliance:** แยกภาษาสัญญาที่อาจปรากฏด้วยการเปลี่ยนแปลงเล็กน้อยได้อย่างรวดเร็ว. - -## การพิจารณาประสิทธิภาพ -- **Create Search Index** เพียงครั้งเดียวต่อชุดเอกสาร, จากนั้นใช้ซ้ำ. -- **Add Documents to Index** อย่างต่อเนื่องเมื่อไฟล์ใหม่เข้ามา—ไม่ต้องสร้างดัชนีใหม่ทั้งหมดทุกครั้ง. -- ใช้ **precise wildcard patterns** เพื่อหลีกเลี่ยงการสแกนที่ไม่จำเป็น; รูปแบบกว้างจะเพิ่มการใช้ CPU. -- เรียก `index.optimize()` เป็นระยะ (หากมี) เพื่อรักษาการใช้หน่วยความจำให้ต่ำ. +- **Content Management Systems:** ผู้แก้ไขสามารถค้นหาข้อความที่ตรงหรือส่วนที่ยืดหยุ่นได้โดยไม่ต้องสแกนหลายร้อยหน้าโดยมือ. +- **E‑commerce Catalogs:** ผู้ซื้อสามารถค้นหาผลิตภัณฑ์แม้จะละคำอธิบายหรือใช้คำพ้องความหมาย, ขอบคุณความทนทานของไวล์การ์ด. +- **Legal & Compliance:** แยกภาษาสัญญาที่อาจปรากฏด้วยความแตกต่างเล็กน้อยในหลายสัญญาได้อย่างรวดเร็ว. -## ปัญหาทั่วไปและวิธีแก้ +## ข้อควรพิจารณาด้านประสิทธิภาพ +- **Create Search Index** เพียงครั้งเดียวต่อชุดเอกสารที่คงที่; ใช้ `Index` ตัวเดียวสำหรับทุกคำค้น. +- **Add Documents Incrementally** เมื่อไฟล์ใหม่เข้ามา—หลีกเลี่ยงการสร้างดัชนีใหม่ทั้งหมดเพื่อรักษาการใช้ CPU ต่ำ. +- **Design Precise Wildcard Patterns**; แพทเทิร์นกว้าง (`*`) จะเพิ่มจำนวนการขยายเทอมและอาจทำให้โหลด CPU เพิ่มขึ้น. +- **Call `index.optimize()`** เป็นระยะ (หากรองรับ) เพื่อบีบอัดดัชนีและควบคุมการใช้หน่วยความจำ. +## ปัญหาและวิธีแก้ไขทั่วไป | Issue | Solution | |-------|----------| -| ไม่ได้ผลลัพธ์สำหรับการค้นหาไวลด์การ์ด | ตรวจสอบไวยากรณ์ไวลด์การ์ด (`*min~~max`) และให้แน่ใจว่าคำที่ต้องการอยู่ในระยะที่กำหนด. | -| ดัชนีล้าสมัยหลังจากอัปเดตไฟล์ | เรียก `index.add(updatedFolder)` อีกครั้งหรือใช้ API การอัปเดตแบบเพิ่มส่วน. | -| การใช้หน่วยความจำสูงบนชุดข้อมูลขนาดใหญ่ | เพิ่มขนาด heap ของ JVM และพิจารณาแบ่งดัชนีเป็นหลาย shard. | +| No results returned for a wildcard query | Verify the wildcard syntax (`*min~max`) and ensure the target words exist within the defined distance. | +| Index becomes stale after file updates | Use `index.add(updatedFolder)` or the incremental update API to refresh only changed files. | +| High memory consumption on large datasets | Increase JVM heap (`-Xmx4g` or higher) and consider splitting the index into multiple shards for parallel processing. | ## คำถามที่พบบ่อย -**Q: ความแตกต่างระหว่างไวลด์การ์ดและการค้นหาวลีคืออะไร?** -A: การค้นหาวลีมองหาลำดับคำที่ตรงกันอย่างแม่นยำ, ส่วนไวลด์การ์ดอนุญาตให้คุณแทนที่หรือข้ามคำภายในลำดับนั้น. +**Q: What is the difference between a wildcard and a phrase search?** +A: การค้นหาวลีต้องการลำดับคำและช่องว่างที่ตรงกัน, ในขณะที่ไวล์การ์ดอนุญาตให้คุณแทนที่หรือข้ามคำภายในลำดับนั้น, ให้การจับคู่ที่ยืดหยุ่น. -**Q: สามารถใช้ไวลด์การ์ดกับข้อมูลตัวเลขในการค้นหาได้หรือไม่?** -A: ใช่, พารามิเตอร์ช่วงของไวลด์การ์ดทำงานกับตัวเลขเช่นเดียวกับคำ. +**Q: Can I use wildcards with numeric data in searches?** +A: ใช่—พารามิเตอร์ช่วงไวล์การ์ด (`*min~max`) ทำงานกับตัวเลขเช่นกันกับคำ, ทำให้สามารถค้นหาเช่น `"version *1~3"` ได้. -**Q: ควรจัดการกับชุดเอกสารขนาดใหญ่มากอย่างไร?** -A: รักษาดัชนีให้เป็นประสิทธิภาพ, ใช้การอัปเดตแบบเพิ่มส่วน, และออกแบบรูปแบบไวลด์การ์ดให้เจาะจงที่สุดเท่าที่จะทำได้. +**Q: How should I handle very large document collections?** +A: รักษาดัชนีให้ปรับให้เหมาะสม, ทำการอัปเดตแบบเพิ่มส่วน, และออกแบบแพทเทิร์นไวล์การ์ดที่เฉพาะเจาะจงเพื่อจำกัดการขยายเทอม. GroupDocs.Search สามารถทำดัชนี 1 million เอกสารพร้อมความหน่วงของการค้นหาต่ำกว่า 200 ms บนฮาร์ดแวร์มาตรฐาน. -**Q: GroupDocs.Search เหมาะกับสถานการณ์การค้นหาแบบเรียลไทม์หรือไม่?** -A: แน่นอน—เมื่อดัชนีสร้างเสร็จ, คำค้นทำงานในระดับมิลลิวินาที, ทำให้เหมาะกับแอปพลิเคชันเชิงโต้ตอบ. +**Q: Is GroupDocs.Search suitable for real‑time search scenarios?** +A: แน่นอน—เมื่อดัชนีถูกสร้าง, คำค้นทำงานในระดับมิลลิวินาที, ทำให้เหมาะกับกล่องค้นหาแบบโต้ตอบและฟีเจอร์ auto‑complete. -**Q: สามารถผสานรวมไลบรารีนี้เข้ากับโปรเจกต์ Java ที่มีอยู่ได้หรือไม่?** -A: ได้. เพิ่ม dependency ของ Maven หรือ JAR, เริ่มต้นดัชนีตามที่แสดง, แล้วคุณพร้อมใช้งาน. +**Q: Can I integrate this library into an existing Java project?** +A: ใช่. เพิ่ม dependency ของ Maven หรือ JAR, สร้างอ็อบเจกต์ `Index` ตามที่แสดง, แล้วคุณพร้อมใช้คำค้นโดยไม่ต้องแก้ไขโค้ดเดิม. --- -**Last Updated:** 2026-01-26 -**Tested With:** GroupDocs.Search 25.4 for Java -**Author:** GroupDocs \ No newline at end of file +**อัปเดตล่าสุด:** 2026-05-28 +**ทดสอบด้วย:** GroupDocs.Search 25.4 for Java +**ผู้เขียน:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## บทเรียนที่เกี่ยวข้อง + +- [สร้างดัชนีการค้นหา Java – บทเรียน GroupDocs.Search](/search/java/) +- [เพิ่มเอกสารลงในดัชนี – บทเรียน GroupDocs.Search Java](/search/java/document-management/) +- [สร้างดัชนีการค้นหา - บทเรียน GroupDocs.Search Java](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/turkish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/turkish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index 31371713..98327086 100644 --- a/content/turkish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/turkish/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,46 +1,115 @@ --- -date: '2026-01-26' -description: GroupDocs.Search for Java'da joker karakter desenleri kullanarak ifade - aramayı öğrenin. Bu kılavuz, bir arama indeksi oluşturmayı, belgelere indeks eklemeyi - ve Java'da joker karakter araması yapmayı kapsar. +date: '2026-05-28' +description: GroupDocs.Search for Java kullanarak wildcard patterns ile ifadeyi nasıl + arayacağınızı öğrenin. search index oluşturma, belge ekleme ve exact phrase ve wildcard + queries yürütme konularını içerir. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: GroupDocs.Search Java'da Joker Karakterlerle İfade Nasıl Aranır +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: GroupDocs.Search for Java ile Joker Karakterli İfade Arama type: docs url: /tr/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 --- -# Wildcard'lı İfade Arama GroupDocs.Search for Java'da +# GroupDocs.Search for Java'da Joker Karakterli İfade Arama -Bugünün hızlı tempolu belge yönetimi dünyasında, **ifade arama** verimli bir şekilde yapılması bir uygulamanın kullanılabilirliğini belirleyebilir. İçerik yönetim sistemi, e‑ticaret kataloğu ya da yasal belge deposu oluşturuyor olun, tam ifadeleri—veya esnek varyasyonlarını—bulabilmek önemlidir. Bu öğreticide **GroupDocs.Search for Java**'yı kurmayı, bir arama indeksi oluşturmayı, belgelere indekse eklemeyi ve hem basit ifade aramalarını hem de güçlü wildcard arama Java tekniklerini nasıl ustalaştıracağınızı adım adım göstereceğiz. +Modern belge‑odaklı uygulamalarda, **ifade arama** hızlı ve doğru bir şekilde yapılması, kullanıcı deneyimi için belirleyici bir faktördür. Bilgi tabanı, e‑ticaret kataloğu ya da uyumluluk‑odaklı bir depo oluşturuyor olun, tam bir ifadeyi—veya esnek bir varyasyonunu—bulabilme yeteneği, kullanıcıların üretkenliğini artırır ve destek maliyetlerini azaltır. Bu öğretici, **GroupDocs.Search for Java** kurulumunu, arama indeksinin oluşturulmasını, belgelerin yüklenmesini ve hem tam‑ifade hem de joker‑karakter destekli sorguların çalıştırılmasını, net, üretim‑hazır kod parçacıklarıyla adım adım gösterir. ## Hızlı Yanıtlar -- **İfade aramalarının temel faydası nedir?** Kelime sırası ve yakınlığın kesin eşleşmesi. -- **Bir ifade içinde wildcard kullanılabilir mi?** Evet, esnek eşleşme için wildcard'ları kesin kelimelerle birleştirebilirsiniz. -- **Geliştirme için lisansa ihtiyacım var mı?** Ücretsiz deneme test için yeterlidir; üretim için tam lisans gereklidir. -- **Hangi Maven sürümünü kullanmalıyım?** En son GroupDocs.Search for Java sürümü (örneğin, yazı yazıldığı sırada 25.4). -- **Bu yaklaşım büyük belge setleri için uygun mu?** Kesinlikle—indeksi optimize tutun ve hedefli wildcard desenleri kullanın. +- **İfade aramalarının temel faydası nedir?** Kelime sırası ve yakınlığının kesin eşleşmesi, yalnızca tam diziyi içeren belgelerin döndürülmesini garanti eder. +- **Bir ifade içinde joker karakterler kullanılabilir mi?** Evet—joker karakterler, genel sıralamayı korurken kelimeleri atlamanıza veya değiştirmenize izin verir. +- **Geliştirme için lisansa ihtiyacım var mı?** Test için ücretsiz deneme çalışır; üretim dağıtımları için tam lisans gereklidir. +- **Hangi Maven sürümünü kullanmalıyım?** En son GroupDocs.Search for Java sürümü (örneğin, yazım sırasında 25.4). +- **Bu yaklaşım büyük belge setleri için uygun mu?** Kesinlikle—GroupDocs.Search, indeks optimize edildiğinde, yüz binlerce belge koleksiyonunu alt saniyelik sorgu gecikmesiyle işleyebilir. -## “İfade Arama” Nedir? -Bir ifadeyi aramak, bir belgede belirli bir kelime dizisini bulmak anlamına gelir. Wildcard eklediğinizde, arama motorunun kelimeleri atlamasına veya değiştirmesine izin verirsiniz; bu da alaka düzeyini kaybetmeden varyasyonları eşleştirme esnekliği sağlar. +## “ifade arama” nedir? +**Bir ifadeyi aramak, bir belgede belirli bir kelime dizisini aramak anlamına gelir.** +Bir ifade sorgusu yürüttüğünüzde, motor kelimelerin tam sırayla ve tanımlı yakınlıkta göründüğünü kontrol eder, farklı bağlamda aynı kelimeleri içeren alakasız sonuçları eleyerek. Bu, ifade aramalarını yasal maddeler, ürün kodları veya sıralamanın önemli olduğu herhangi bir metin bulmak için ideal kılar. -## Neden GroupDocs.Search'i İfade ve Wildcard Sorguları İçin Kullanmalısınız? -- **Yüksek performans** büyük koleksiyonlarda optimize edilmiş ters indeks sayesinde. -- **Zengin sorgu dili** kesin ifade, basit wildcard ve gelişmiş desenleri destekler. -- **Kolay entegrasyon** Maven veya doğrudan indirme yoluyla herhangi bir Java tabanlı uygulamayla. +## Neden GrupDocs.Search'i İfade ve Joker Karakter Sorguları İçin Kullanmalısınız? +GroupDocs.Search, tipik sunucu donanımında **1 milyon belgeye kadar yüksek verimli indeksleme ve alt saniyelik sorgu yanıt süreleri** sağlar. Sorgu dili, tam ifadeler, basit `*` ve `?` joker karakterler ve sayısal aralıklar (`*2~5`) gibi gelişmiş desenleri destekler. Kütüphane, Maven veya doğrudan JAR indirme yoluyla herhangi bir Java uygulamasıyla bütünleşir ve dış hizmetlere ihtiyaç duymadan Java 8+ üzerinde çalışır. ## Önkoşullar -- Java 8 veya daha yeni bir sürüm yüklü. -- Maven 3 veya üzeri (Maven bağımlılık yönetimini tercih ediyorsanız). -- Java sözdizimi ve proje yapısına temel aşinalık. +- Java 8 veya daha yeni (Java 11 LTS önerilir). +- Maven 3 veya üzeri (bağımlılık yönetimini tercih ediyorsanız). +- Java proje yapısı ve nesne‑yönelimli kavramlara temel aşinalık. -## GroupDocs.Search for Java Kurulumu +## GroupDocs.Search for Java'i Kurma ### Maven Kullanarak -Add the repository and dependency to your `pom.xml` file: +Resmi depoyu ve GroupDocs.Search bağımlılığını `pom.xml` dosyanıza ekleyin: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Doğrudan İndirme +Alternatif olarak, resmi sürüm sayfasından en son JAR'ı indirin: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Lisans Edinme +- **Ücretsiz Deneme:** Hızlı deneyler için ideal; indekslenen veri 100 MB ile sınırlıdır. +- **Geçici Lisans:** GroupDocs portalından 30‑günlük değerlendirme anahtarı talep edin. +- **Tam Lisans:** Üretim kullanımı ve sınırsız indeksleme kapasitesi için gereklidir. + +## Temel Başlatma ve Kurulum +İndeks dosyalarını tutacak bir klasör oluşturun ve `Index` nesnesini örnekleyin. `Index` sınıfı, disk üzerinde depolanan aranabilir indeksi temsil eder ve belgeleri ekleme, güncelleme ve sorgulama yöntemleri sağlar. ```xml @@ -60,54 +129,61 @@ Add the repository and dependency to your `pom.xml` file: ``` -### Doğrudan İndirme -Alternatif olarak, en son JAR dosyasını [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/) adresinden indirebilirsiniz. - -### Lisans Edinimi -- **Ücretsiz Deneme:** Hızlı deneyler için idealdir. -- **Geçici Lisans:** Uzun vadeli test için GroupDocs portalı üzerinden talep edin. -- **Tam Satın Alma:** Üretim ortamları için önerilir. - -### Temel Başlatma ve Kurulum -Create a folder for the index and initialize it: +Aranabilir hale getirmek istediğiniz belgeleri ekleyin: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Add the documents you want to make searchable: +## GroupDocs.Search'te Joker Karakterli İfade Arama +Bu bölüm, üç düzeyde ifade aramayı gösterir—tam eşleşme, basit joker karakter ve gelişmiş joker karakter desenleri—bir indeks oluşturmayı, belgeleri eklemeyi ve her sorgu türünü özlü Java kodu ile yürütmeyi. Örnekler, hem metin‑tabanlı sorguları hem de nesne‑tabanlı sorgu oluşturmayı göstererek geliştiricilerin uygulamalarına esnek arama yetenekleri entegre etmelerini sağlar. + +### Basit İfade Arama +#### Genel Bakış +Bir kelime dizisinin **tam eşleşmesi** gerektiğinde, örneğin yasal bir madde veya ürün model numarası gibi, bu yaklaşımı kullanın. + +#### Doğrudan Cevap +İndeksi yükleyin, `search` metodunu tırnak içinde bir ifadeyle (ör. `"quick brown fox"`) çağırın ve motor yalnızca bu tam diziyi içeren belgeleri, kelime sırasını ve boşlukları koruyarak döndürür. Sorgu, yüz binlerce dosya içeren indekslerde bile milisaniyeler içinde çalışır. + +#### Adım 1: Bir İndeks Oluşturun ```java String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; index.add(documentsFolder); ``` -## GroupDocs.Search'te Wildcard'lı İfade Nasıl Aranır -Aşağıda üç aşamalı senaryoyu ele alacağız: kesin ifade arama, basit wildcard kullanımı ve gelişmiş wildcard desenleri. - -### Basit İfade Arama - -#### Genel Bakış -Kelime dizisinin tam eşleşmesine ihtiyaç duyduğunuzda bunu kullanın. - -##### Adım 1: Bir İndeks Oluşturun +#### Adım 2: Belgeleri İndekse Ekleyin ```java Index index = new Index(indexFolder); ``` -##### Adım 2: Belgeleri İndekse Ekleyin +#### Adım 3: Belirli Bir İfadeyi (Metin Formu) Ara ```java index.add(documentsFolder); ``` -##### Adım 3: Belirli Bir İfadeyi (Metin Formu) Ara +#### Adım 4: Nesne‑Tabanlı Sorgular (Tam İfade Ara) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Adım 4: Nesne‑Tabanlı Sorgular (Kesin İfade Ara) +### Joker Karakterli İfade Arama + +#### Genel Bakış +Joker karakter yer tutucuları (`*` herhangi bir karakter sayısı için, `?` tek bir karakter için) çevredeki sıralamayı korurken **değişken kelimeleri atlamanıza** izin verir. + +#### Doğrudan Cevap +Tırnak içinde bir ifadeye joker karakter (`*`) ekleyin—ör. `"quick * fox"`—ve *quick* ile *fox* arasındaki herhangi bir kelimeyi eşleştirin. Motor, joker karakteri sorgu zamanında genişletir, yalnızca desene uyan indekslenmiş terimleri tarar; bu da performansı düz bir ifade sorgusuna benzer tutar. + +#### Adım 1: Bir İndeks Oluşturun +*(Basit İfade Arama ile aynı.)* + +#### Adım 2: Belgeleri İndekse Ekleyin +*(Basit İfade Arama ile aynı.)* + +#### Adım 3: Joker Karakterli Metin Formu Arama ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -116,24 +192,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### Wildcard'lı İfade Arama +#### Adım 4: Joker Karakterli Nesne‑Tabanlı Sorgular (Wildcard Search Java) +```java +String queryText = "\"sollicitudin *0~~3 ligula\""; +SearchResult resultText = index.search(queryText); +``` + +### Gelişmiş Joker Karakter Arama #### Genel Bakış -Wildcard yer tutucuları, kesin terimler arasında değişken sayıda kelime atlamanıza izin verir. +Sayısal aralıkları, isteğe bağlı karakterleri ve özel regex‑benzeri desenleri birleştirerek **gelişmiş eşleşme** elde edin; örneğin sürüm numaraları veya ürün kodları gibi. -##### Adım 1: Bir İndeks Oluşturun -*(Same as the Simple Phrase Search steps.)* +#### Doğrudan Cevap +İzin verilen kelime mesafesi aralığını tanımlamak için genişletilmiş joker karakter sözdizimini `*min~max` kullanın veya tek bir karakteri eşleştirmek için `?` kullanın. Örneğin, `"error *2~5 code"` ifadesi *error* kelimesini takip eden iki ila beş kelimeyi ve ardından *code* kelimesini bulur. Bu kesinlik, yanlış pozitifleri azaltırken hâlâ esneklik sunar. -##### Adım 2: Belgeleri İndekse Ekleyin -*(Same as above.)* +#### Adım 1: Bir İndeks Oluşturun +*(Açıklık için tekrarlanmıştır.)* -##### Adım 3: Wildcard'lı Metin Formu Arama -```java -String queryText = "\"sollicitudin *0~~3 ligula\""; -SearchResult resultText = index.search(queryText); -``` +#### Adım 2: Belgeleri İndekse Ekleyin +*(Açıklık için tekrarlanmıştır.)* -##### Adım 4: Wildcard'lı Nesne‑Tabanlı Sorgular (Wildcard Search Java) +#### Adım 3: Karmaşık Joker Karakter Desenleriyle Metin Formu Arama ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -142,75 +221,66 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### Gelişmiş Wildcard Arama - -#### Genel Bakış -Sayısal aralıkları, isteğe bağlı karakterleri ve özel desenleri birleştirerek karmaşık eşleşmeler elde edin. - -##### Adım 1: Bir İndeks Oluşturun -*(Repeated for clarity.)* - -##### Adım 2: Belgeleri İndekse Ekleyin -*(Repeated.)* - -##### Adım 3: Karmaşık Wildcard Desenleriyle Metin Formu Arama +#### Adım 4: Gelişmiş Joker Karakterli Nesne‑Tabanlı Sorgular ```java String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; SearchResult resultText = index.search(queryText); ``` -##### Adım 4: Gelişmiş Wildcard'lı Nesne‑Tabanlı Sorgular -```java -double word1 = SearchQuery.createWordQuery("sollicitudin"); -SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); - -WordPattern pattern = new WordPattern(); -pattern.appendWildcard(0, 4); -pattern.appendString("la"); - -SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); -SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); -SearchResult resultObject = index.search(queryObject); -``` - ## Pratik Uygulamalar -- **İçerik Yönetim Sistemleri:** Editörlerin kesin maddeleri veya esnek alıntıları bulmasını sağlar. -- **E‑ticaret Katalogları:** Alışveriş yapanların bir kelimeyi kaçırsa ya da eş anlamlı kullanırsa bile ürünleri bulmasını sağlar. -- **Hukuk & Uyumluluk:** Küçük varyasyonlarla ortaya çıkabilecek sözleşme dilini hızlıca izole eder. +- **İçerik Yönetim Sistemleri:** Editörler, yüzlerce sayfayı manuel olarak taramadan tam maddeleri veya esnek alıntıları bulabilir. +- **E‑ticaret Katalogları:** Alıcılar, bir tanımlamayı atlasalar ya da eş anlamlı kelimeler kullansalar bile, joker karakter toleransı sayesinde ürünleri bulabilir. +- **Hukuk & Uyum:** Sözleşmelerde küçük varyasyonlarla ortaya çıkabilecek sözleşme dilini hızlıca izole edin. ## Performans Düşünceleri -- **Arama İndeksi Oluşturma** belge seti başına sadece bir kez yapılır, ardından yeniden kullanılır. -- **Belgeleri İndekse Ekleme** yeni dosyalar geldiğinde artımlı olarak yapılır—her seferinde tüm indeksi yeniden oluşturmayın. -- Gereksiz taramayı önlemek için **kesin wildcard desenleri** kullanın; daha geniş desenler CPU yükünü artırır. -- Bellek kullanımını düşük tutmak için periyodik olarak `index.optimize()` (varsa) çağırın. +- **Arama İndeksini Oluşturun** yalnızca kararlı belge seti başına bir kez; tüm sorgular için aynı `Index` örneğini yeniden kullanın. +- **Belgeleri Artımlı Ekleyin** yeni dosyalar geldiğinde—CPU kullanımını düşük tutmak için tüm indeksi yeniden oluşturmayı önleyin. +- **Kesin Joker Karakter Desenleri Tasarlayın**; daha geniş desenler (`*`) terim genişlemelerinin sayısını artırır ve CPU yükünü yükseltebilir. +- **`index.optimize()`** metodunu periyodik olarak (destekleniyorsa) çağırarak indeksi sıkıştırın ve bellek tüketimini kontrol altında tutun. ## Yaygın Sorunlar ve Çözümler - | Sorun | Çözüm | |-------|----------| -| Wildcard sorgusu için sonuç dönmedi | Wildcard sözdizimini (`*min~~max`) doğrulayın ve kelimelerin belirtilen mesafe içinde mevcut olduğundan emin olun. | -| Dosya güncellemelerinden sonra indeks eski kalıyor | `index.add(updatedFolder)` komutunu yeniden çalıştırın veya artımlı güncelleme API'sini kullanın. | -| Büyük veri setlerinde yüksek bellek tüketimi | JVM heap boyutunu artırın ve indeksi birden fazla parçaya bölmeyi düşünün. | +| Joker karakter sorgusu için sonuç dönmüyor | Joker karakter sözdizimini (`*min~max`) doğrulayın ve hedef kelimelerin tanımlı mesafe içinde mevcut olduğundan emin olun. | +| Dosya güncellemelerinden sonra indeks eski hale geliyor | `index.add(updatedFolder)` metodunu veya artımlı güncelleme API'sini kullanarak yalnızca değişen dosyaları yenileyin. | +| Büyük veri setlerinde yüksek bellek tüketimi | JVM yığınını artırın (`-Xmx4g` veya daha yüksek) ve paralel işleme için indeksi birden fazla parçaya bölmeyi düşünün. | ## Sıkça Sorulan Sorular -**S: Wildcard ile ifade araması arasındaki fark nedir?** -C: İfade araması kesin kelime sırasını ararken, wildcard bu sıradaki kelimeleri değiştirme veya atlama imkanı verir. +**S: Joker karakter ile ifade araması arasındaki fark nedir?** +C: İfade araması tam kelime sırası ve boşluk gerektirirken, joker karakter bu sıradaki kelimeleri değiştirme veya atlama imkanı sunar ve esnek eşleşme sağlar. -**S: Aramalarda sayısal verilerle wildcard kullanabilir miyim?** -C: Evet, wildcard aralık parametreleri sayılarla da, kelimelerle de çalışır. +**S: Aramalarda sayısal verilerle joker karakter kullanabilir miyim?** +C: Evet—joker karakter aralık parametreleri (`*min~max`) sayılar ve kelimeler için çalışır, `"version *1~3"` gibi sorgulara olanak tanır. **S: Çok büyük belge koleksiyonlarıyla nasıl başa çıkmalıyım?** -C: İndeksi optimize tutun, artımlı güncellemeler kullanın ve wildcard desenlerinizi mümkün olduğunca spesifik tasarlayın. +C: İndeksi optimize tutun, artımlı güncellemeler yapın ve terim genişlemesini sınırlamak için belirli joker karakter desenleri oluşturun. GroupDocs.Search, standart donanımda sorgu gecikmesini 200 ms altında tutarak 1 milyon belgeyi indeksleyebilir. -**S: GroupDocs.Search gerçek zamanlı arama senaryoları için uygun mu?** -C: Kesinlikle—indeks oluşturulduktan sonra sorgular milisaniyeler içinde çalışır, bu da etkileşimli uygulamalara uygundur. +**S: GroupDocs.Search gerçek‑zamanlı arama senaryoları için uygun mu?** +C: Kesinlikle—indeks oluşturulduktan sonra sorgular milisaniyeler içinde çalışır, bu da etkileşimli arama kutuları ve otomatik tamamlama özellikleri için idealdir. **S: Bu kütüphaneyi mevcut bir Java projesine entegre edebilir miyim?** -C: Evet. Maven bağımlılığını veya JAR'ı ekleyin, gösterildiği gibi indeksi başlatın ve hazırsınız. - ---- +C: Evet. Maven bağımlılığını veya JAR'ı ekleyin, gösterildiği gibi `Index` nesnesini örnekleyin ve mevcut kodu değiştirmeden sorgulamaya hazırsınız. -**Son Güncelleme:** 2026-01-26 +**Last Updated:** 2026-05-28 **Test Edilen Versiyon:** GroupDocs.Search 25.4 for Java -**Yazar:** GroupDocs \ No newline at end of file +**Yazar:** GroupDocs + +```java +double word1 = SearchQuery.createWordQuery("sollicitudin"); +SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); + +WordPattern pattern = new WordPattern(); +pattern.appendWildcard(0, 4); +pattern.appendString("la"); + +SearchQuery wordPattern3 = SearchQuery.createWordPatternQuery(pattern); +SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, wordPattern3); +SearchResult resultObject = index.search(queryObject); +``` + +## İlgili Eğitimler + +- [Java için Arama İndeksi Oluşturma – GroupDocs.Search Eğitimleri](/search/java/) +- [İndekse Belge Ekleme – GroupDocs.Search Java Eğitimleri](/search/java/document-management/) +- [Arama İndeksi Oluşturma - GroupDocs.Search Java Eğitimleri](/search/java/advanced-features/) \ No newline at end of file diff --git a/content/vietnamese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md b/content/vietnamese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md index 6b14d4ed..baecd276 100644 --- a/content/vietnamese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md +++ b/content/vietnamese/java/searching/groupdocs-search-java-phrase-wildcard/_index.md @@ -1,13 +1,55 @@ --- -date: '2026-01-26' -description: Tìm hiểu cách tìm kiếm cụm từ bằng các mẫu ký tự đại diện trong GroupDocs.Search - cho Java. Hướng dẫn này bao gồm việc tạo chỉ mục tìm kiếm, thêm tài liệu vào chỉ - mục và thực hiện tìm kiếm ký tự đại diện trong Java. +date: '2026-05-28' +description: Tìm hiểu cách tìm kiếm cụm từ với các mẫu ký tự đại diện bằng GroupDocs.Search + cho Java. Bao gồm việc tạo search index, thêm documents, và thực hiện exact phrase + và wildcard queries. keywords: -- GroupDocs.Search for Java -- phrase searches -- wildcard patterns -title: Cách tìm kiếm cụm từ với ký tự đại diện trong GroupDocs.Search Java +- how to search phrase +- create search index +- java wildcard search +- exact phrase search +- wildcard pattern search +schemas: +- author: GroupDocs + dateModified: '2026-05-28' + description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + headline: How to Search Phrase with Wildcards in GroupDocs.Search for Java + type: TechArticle +- description: Learn how to search phrase with wildcard patterns using GroupDocs.Search + for Java. Includes creating a search index, adding documents, and executing exact + phrase and wildcard queries. + name: How to Search Phrase with Wildcards in GroupDocs.Search for Java + steps: + - name: Create an Index + text: '*(Same as Simple Phrase Search.)*' + - name: Add Documents to Index + text: '*(Same as above.)*' + - name: Create an Index + text: '*(Repeated for clarity.)*' + - name: Add Documents to Index + text: '*(Repeated.)*' + type: HowTo +- questions: + - answer: A phrase search requires the exact word order and spacing, while a wildcard + allows you to replace or skip words within that order, offering flexible matching. + question: What is the difference between a wildcard and a phrase search? + - answer: Yes—wildcard range parameters (`*min~max`) work with numbers as well as + words, enabling queries like `"version *1~3"`. + question: Can I use wildcards with numeric data in searches? + - answer: Keep the index optimized, perform incremental updates, and craft specific + wildcard patterns to limit term expansion. GroupDocs.Search can index 1 million + documents while keeping query latency under 200 ms on standard hardware. + question: How should I handle very large document collections? + - answer: Absolutely—once the index is built, queries execute in milliseconds, making + it ideal for interactive search boxes and auto‑complete features. + question: Is GroupDocs.Search suitable for real‑time search scenarios? + - answer: Yes. Add the Maven dependency or JAR, instantiate the `Index` as shown, + and you’re ready to query without altering existing code. + question: Can I integrate this library into an existing Java project? + type: FAQPage +title: Cách tìm kiếm cụm từ với ký tự đại diện trong GroupDocs.Search cho Java type: docs url: /vi/java/searching/groupdocs-search-java-phrase-wildcard/ weight: 1 @@ -15,32 +57,59 @@ weight: 1 # Cách Tìm Kiếm Cụm Từ với Ký Tự Đại Diện trong GroupDocs.Search cho Java -Trong thế giới quản lý tài liệu nhanh chóng ngày nay, **cách tìm kiếm cụm từ** một cách hiệu quả có thể quyết định tính khả dụng của một ứng dụng. Dù bạn đang xây dựng hệ thống quản lý nội dung, danh mục thương mại điện tử, hay kho lưu trữ tài liệu pháp lý, khả năng xác định các cụm từ chính xác — hoặc các biến thể linh hoạt của chúng — đều rất quan trọng. Trong hướng dẫn này, chúng ta sẽ đi qua cách thiết lập **GroupDocs.Search cho Java**, tạo chỉ mục tìm kiếm, thêm tài liệu vào chỉ mục, và làm chủ cả tìm kiếm cụm từ đơn giản và kỹ thuật tìm kiếm ký tự đại diện mạnh mẽ trong Java. +Trong các ứng dụng hiện đại tập trung vào tài liệu, **cách tìm kiếm cụm từ** nhanh chóng và chính xác là yếu tố quyết định trải nghiệm người dùng. Dù bạn đang xây dựng một kiến thức cơ sở, một danh mục thương mại điện tử, hay một kho lưu trữ tuân thủ, khả năng xác định một cụm từ chính xác—hoặc một biến thể linh hoạt của nó—giúp người dùng làm việc hiệu quả và giảm tải hỗ trợ. Hướng dẫn này sẽ chỉ cho bạn cách cài đặt **GroupDocs.Search cho Java**, tạo chỉ mục tìm kiếm, tải tài liệu, và chạy cả truy vấn cụm từ chính xác và truy vấn có ký tự đại diện, tất cả với các đoạn mã sẵn sàng cho môi trường sản xuất. ## Câu trả lời nhanh -- **Lợi ích chính của tìm kiếm cụm từ là gì?** Khớp chính xác thứ tự từ và khoảng cách. -- **Có thể sử dụng ký tự đại diện bên trong một cụm từ không?** Có, bạn có thể kết hợp ký tự đại diện với các từ chính xác để khớp linh hoạt. -- **Tôi có cần giấy phép cho việc phát triển không?** Bản dùng thử miễn phí đủ cho việc thử nghiệm; giấy phép đầy đủ cần thiết cho môi trường sản xuất. -- **Nên sử dụng phiên bản Maven nào?** Phiên bản mới nhất của GroupDocs.Search cho Java (ví dụ: 25.4 tại thời điểm viết). -- **Cách tiếp cận này có phù hợp với tập hợp tài liệu lớn không?** Chắc chắn — chỉ cần giữ chỉ mục được tối ưu và sử dụng các mẫu ký tự đại diện có mục tiêu. +- **Lợi ích chính của việc tìm kiếm cụm từ là gì?** Khớp chính xác thứ tự từ và khoảng cách, đảm bảo chỉ các tài liệu chứa chuỗi chính xác mới được trả về. +- **Có thể sử dụng ký tự đại diện bên trong một cụm từ không?** Có—ký tự đại diện cho phép bạn bỏ qua hoặc thay thế từ trong khi vẫn giữ thứ tự tổng thể. +- **Có cần giấy phép cho việc phát triển không?** Bản dùng thử miễn phí hoạt động cho việc thử nghiệm; giấy phép đầy đủ cần thiết cho triển khai sản xuất. +- **Nên sử dụng phiên bản Maven nào?** Phiên bản mới nhất của GroupDocs.Search cho Java (ví dụ, 25.4 tại thời điểm viết). +- **Phương pháp này có phù hợp với bộ tài liệu lớn không?** Chắc chắn—GroupDocs.Search có thể xử lý các bộ sưu tập hàng trăm nghìn tài liệu với độ trễ truy vấn dưới giây khi chỉ mục được tối ưu. ## “Cách tìm kiếm cụm từ” là gì? -Tìm kiếm một cụm từ có nghĩa là tìm một chuỗi từ cụ thể trong tài liệu. Khi bạn thêm ký tự đại diện, công cụ tìm kiếm sẽ cho phép bỏ qua hoặc thay thế các từ, mang lại sự linh hoạt để khớp các biến thể mà không làm giảm độ liên quan. +**Tìm kiếm một cụm từ có nghĩa là tìm kiếm một chuỗi từ cụ thể trong tài liệu.** +Khi bạn thực hiện một truy vấn cụm từ, công cụ sẽ kiểm tra các từ xuất hiện đúng thứ tự và trong khoảng cách đã định, loại bỏ các kết quả không liên quan chứa các từ giống nhau nhưng trong ngữ cảnh khác. Điều này làm cho tìm kiếm cụm từ trở nên lý tưởng cho việc xác định các điều khoản pháp lý, mã sản phẩm, hoặc bất kỳ văn bản nào mà thứ tự quan trọng. -## Tại sao nên dùng GroupDocs.Search cho Truy vấn Cụm Từ và Ký Tự Đại Diện? -- **Hiệu năng cao** trên các bộ sưu tập lớn nhờ chỉ mục đảo ngược được tối ưu. -- **Ngôn ngữ truy vấn phong phú** hỗ trợ cụm từ chính xác, ký tự đại diện đơn giản và các mẫu nâng cao. -- **Dễ dàng tích hợp** với bất kỳ ứng dụng Java nào qua Maven hoặc tải trực tiếp. +## Tại sao nên sử dụng GroupDocs.Search cho các truy vấn Cụm Từ và Ký Tự Đại Diện? +GroupDocs.Search cung cấp **đánh chỉ mục tốc độ cao lên tới 1 triệu tài liệu đồng thời duy trì thời gian phản hồi truy vấn dưới giây** trên phần cứng máy chủ tiêu chuẩn. Ngôn ngữ truy vấn của nó hỗ trợ cụm từ chính xác, ký tự đại diện đơn giản `*` và `?`, và các mẫu nâng cao như phạm vi số (`*2~5`). Thư viện tích hợp với bất kỳ ứng dụng Java nào qua Maven hoặc tải JAR trực tiếp, và chạy trên Java 8+ mà không cần dịch vụ bên ngoài. -## Các yêu cầu trước -- Java 8 hoặc mới hơn đã được cài đặt. -- Maven 3 hoặc cao hơn (nếu bạn ưu tiên quản lý phụ thuộc bằng Maven). -- Có kiến thức cơ bản về cú pháp Java và cấu trúc dự án. +## Yêu cầu trước +- Java 8 hoặc mới hơn (đề xuất Java 11 LTS). +- Maven 3 hoặc mới hơn (nếu bạn ưu tiên quản lý phụ thuộc). +- Hiểu biết cơ bản về cấu trúc dự án Java và các khái niệm hướng đối tượng. -## Thiết lập GroupDocs.Search cho Java +## Cài đặt GroupDocs.Search cho Java ### Sử dụng Maven -Thêm kho lưu trữ và phụ thuộc vào tệp `pom.xml` của bạn: +Thêm kho lưu trữ chính thức và phụ thuộc GroupDocs.Search vào tệp `pom.xml` của bạn: + +```xml + + + + groupdocs-releases + https://repository.groupdocs.com/release + + + + + + com.groupdocs + groupdocs-search + 25.4 + +``` + +### Tải trực tiếp +Hoặc, tải JAR mới nhất từ trang phát hành chính thức: [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). + +### Cách nhận giấy phép +- **Free Trial:** Lý tưởng cho các thí nghiệm nhanh; giới hạn 100 MB dữ liệu đã đánh chỉ mục. +- **Temporary License:** Yêu cầu khóa đánh giá 30 ngày từ cổng GroupDocs. +- **Full License:** Cần cho sử dụng trong môi trường sản xuất và khả năng đánh chỉ mục không giới hạn. + +## Khởi tạo và Cấu hình Cơ bản +Tạo một thư mục sẽ chứa các tệp chỉ mục và khởi tạo đối tượng `Index`. Lớp `Index` đại diện cho chỉ mục có thể tìm kiếm được lưu trên đĩa và cung cấp các phương thức để thêm, cập nhật và truy vấn tài liệu. ```xml @@ -60,56 +129,61 @@ Thêm kho lưu trữ và phụ thuộc vào tệp `pom.xml` của bạn: ``` -### Tải trực tiếp -Hoặc tải JAR mới nhất từ [GroupDocs.Search for Java releases](https://releases.groupdocs.com/search/java/). - -### Mua giấy phép -- **Bản dùng thử:** Thích hợp cho các thí nghiệm nhanh. -- **Giấy phép tạm thời:** Yêu cầu qua cổng GroupDocs để thử nghiệm kéo dài hơn. -- **Mua bản đầy đủ:** Được khuyến nghị cho triển khai sản xuất. - -### Khởi tạo và Cấu hình Cơ bản -Tạo thư mục cho chỉ mục và khởi tạo nó: +Thêm các tài liệu bạn muốn làm cho có thể tìm kiếm: ```java String indexFolder = "YOUR_OUTPUT_DIRECTORY/PhraseSearch"; Index index = new Index(indexFolder); ``` -Thêm các tài liệu bạn muốn đưa vào khả năng tìm kiếm: - -```java -String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; -index.add(documentsFolder); -``` - ## Cách Tìm Kiếm Cụm Từ với Ký Tự Đại Diện trong GroupDocs.Search -Dưới đây chúng ta sẽ phân tích ba kịch bản tiến bộ: tìm kiếm cụm từ chính xác, sử dụng ký tự đại diện đơn giản, và các mẫu ký tự đại diện nâng cao. +Phần này trình bày ba mức độ tìm kiếm cụm từ—khớp chính xác, ký tự đại diện đơn giản, và mẫu ký tự đại diện nâng cao—cho thấy cách tạo chỉ mục, thêm tài liệu, và thực thi mỗi loại truy vấn bằng mã Java ngắn gọn. Các ví dụ minh họa cả truy vấn dạng văn bản và truy vấn dựa trên đối tượng, cho phép nhà phát triển tích hợp khả năng tìm kiếm linh hoạt vào ứng dụng của mình. ### Tìm Kiếm Cụm Từ Đơn Giản #### Tổng quan -Sử dụng khi bạn cần khớp chính xác một chuỗi từ. +Sử dụng cách tiếp cận này khi bạn cần **khớp chính xác** một chuỗi từ, chẳng hạn một điều khoản pháp lý hoặc mã mẫu sản phẩm. + +#### Trả lời trực tiếp +Tải chỉ mục, gọi `search` với một cụm từ được đặt trong dấu ngoặc kép (ví dụ, `"quick brown fox"`), và công cụ sẽ chỉ trả về các tài liệu chứa chuỗi chính xác đó, giữ nguyên thứ tự và khoảng cách từ. Truy vấn thực thi trong mili giây, ngay cả trên các chỉ mục chứa hàng trăm nghìn tệp. -##### Bước 1: Tạo Chỉ mục +#### Bước 1: Tạo Index +```java +String documentsFolder = "YOUR_DOCUMENT_DIRECTORY"; +index.add(documentsFolder); +``` + +#### Bước 2: Thêm Tài liệu vào Index ```java Index index = new Index(indexFolder); ``` -##### Bước 2: Thêm Tài liệu vào Chỉ mục +#### Bước 3: Tìm kiếm Cụm Từ Cụ Thể (Dạng Văn Bản) ```java index.add(documentsFolder); ``` -##### Bước 3: Tìm Kiếm Cụm Từ Cụ Thể (Dạng Văn Bản) - +#### Bước 4: Truy vấn Dựa trên Đối tượng (Tìm kiếm Cụm Từ Chính Xác) ```java String queryText = "\"sollicitudin at ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Bước 4: Truy Vấn Dựa trên Đối Tượng (Tìm Cụm Từ Chính Xác) +### Tìm Kiếm Cụm Từ với Ký Tự Đại Diện + +#### Tổng quan +Các ký tự đại diện (`*` cho bất kỳ số ký tự nào, `?` cho một ký tự) cho phép bạn **bỏ qua các từ biến đổi** trong khi vẫn duy trì thứ tự xung quanh. + +#### Trả lời trực tiếp +Chèn một token ký tự đại diện (`*`) vào trong một cụm từ có dấu ngoặc kép—ví dụ, `"quick * fox"`—để khớp bất kỳ từ nào giữa *quick* và *fox*. Công cụ sẽ mở rộng ký tự đại diện tại thời điểm truy vấn, chỉ quét các thuật ngữ đã đánh chỉ mục thỏa mãn mẫu, giúp hiệu năng tương đương với truy vấn cụm từ thông thường. +#### Bước 1: Tạo Index +*(Giống như Tìm Kiếm Cụm Từ Đơn Giản.)* + +#### Bước 2: Thêm Tài liệu vào Index +*(Giống như trên.)* + +#### Bước 3: Tìm kiếm Dạng Văn Bản với Ký Tự Đại Diện ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery word2 = SearchQuery.createWordQuery("at"); @@ -118,26 +192,27 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, word2, word SearchResult resultObject = index.search(queryObject); ``` -### Tìm Kiếm Cụm Từ với Ký Tự Đại Diện - -#### Tổng quan -Các ký tự đại diện cho phép bạn bỏ qua một số lượng từ biến đổi giữa các thuật ngữ chính xác. - -##### Bước 1: Tạo Chỉ mục -*(Giống như các bước trong Tìm Kiếm Cụm Từ Đơn Giản.)* - -##### Bước 2: Thêm Tài liệu vào Chỉ mục -*(Giống như trên.)* - -##### Bước 3: Tìm Kiếm Dạng Văn Bản với Ký Tự Đại Diện - +#### Bước 4: Truy vấn Dựa trên Đối tượng với Ký Tự Đại Diện (Wildcard Search Java) ```java String queryText = "\"sollicitudin *0~~3 ligula\""; SearchResult resultText = index.search(queryText); ``` -##### Bước 4: Truy Vấn Dựa trên Đối Tượng với Ký Tự Đại Diện (Wildcard Search Java) +### Tìm Kiếm Ký Tự Đại Diện Nâng Cao + +#### Tổng quan +Kết hợp phạm vi số, ký tự tùy chọn, và các mẫu giống regex tùy chỉnh để **khớp phức tạp**, chẳng hạn số phiên bản hoặc mã sản phẩm. + +#### Trả lời trực tiếp +Sử dụng cú pháp ký tự đại diện mở rộng `*min~max` để định nghĩa khoảng cách từ cho phép, hoặc `?` để khớp một ký tự duy nhất. Ví dụ, `"error *2~5 code"` sẽ tìm từ *error* tiếp theo bởi bất kỳ hai đến năm từ và sau đó là *code*. Độ chính xác này giảm các kết quả sai trong khi vẫn cung cấp tính linh hoạt. +#### Bước 1: Tạo Index +*(Lặp lại để rõ ràng.)* + +#### Bước 2: Thêm Tài liệu vào Index +*(Lặp lại.)* + +#### Bước 3: Tìm kiếm Dạng Văn Bản với Mẫu Ký Tự Đại Diện Phức Tạp ```java SearchQuery word1 = SearchQuery.createWordQuery("sollicitudin"); SearchQuery wildcard2 = SearchQuery.createWildcardQuery(0, 3); @@ -146,25 +221,52 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -### Tìm Kiếm Ký Tự Đại Diện Nâng Cao +#### Bước 4: Truy vấn Dựa trên Đối tượng với Ký Tự Đại Diện Nâng Cao +```java +String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; +SearchResult resultText = index.search(queryText); +``` -#### Tổng quan -Kết hợp phạm vi số, ký tự tùy chọn và các mẫu tùy chỉnh để khớp phức tạp. +## Ứng dụng Thực tế +- **Content Management Systems:** Biên tập viên có thể xác định các điều khoản chính xác hoặc trích đoạn linh hoạt mà không cần quét thủ công hàng trăm trang. +- **E‑commerce Catalogs:** Người mua tìm sản phẩm ngay cả khi họ bỏ qua mô tả hoặc dùng từ đồng nghĩa, nhờ khả năng chịu ký tự đại diện. +- **Legal & Compliance:** Nhanh chóng cô lập ngôn ngữ hợp đồng có thể xuất hiện với những biến thể nhỏ trong các thỏa thuận. -##### Bước 1: Tạo Chỉ mục -*(Lặp lại để rõ ràng.)* +## Các yếu tố về hiệu năng +- **Create Search Index** chỉ một lần cho bộ tài liệu ổn định; tái sử dụng cùng một thể hiện `Index` cho mọi truy vấn. +- **Add Documents Incrementally** khi có tệp mới—tránh xây dựng lại toàn bộ chỉ mục để giảm tải CPU. +- **Design Precise Wildcard Patterns**; các mẫu rộng (`*`) làm tăng số lần mở rộng thuật ngữ và có thể làm tăng tải CPU. +- **Call `index.optimize()`** định kỳ (nếu hỗ trợ) để nén chỉ mục và kiểm soát mức tiêu thụ bộ nhớ. -##### Bước 2: Thêm Tài liệu vào Chỉ mục -*(Lặp lại.)* +## Các vấn đề thường gặp & Giải pháp +| Issue | Solution | +|-------|----------| +| No results returned for a wildcard query | Xác minh cú pháp ký tự đại diện (`*min~max`) và đảm bảo các từ mục tiêu tồn tại trong khoảng cách đã định. | +| Index becomes stale after file updates | Sử dụng `index.add(updatedFolder)` hoặc API cập nhật tăng dần để làm mới chỉ các tệp đã thay đổi. | +| High memory consumption on large datasets | Tăng bộ nhớ heap JVM (`-Xmx4g` hoặc cao hơn) và cân nhắc chia chỉ mục thành nhiều shard để xử lý song song. | -##### Bước 3: Tìm Kiếm Dạng Văn Bản với Các Mẫu Ký Tự Đại Diện Phức Tạp +## Câu hỏi thường gặp -```java -String queryText = "\"sollicitudin *0~~3 ?(0~4)la\""; -SearchResult resultText = index.search(queryText); -``` +**Q: Sự khác nhau giữa ký tự đại diện và tìm kiếm cụm từ là gì?** +A: Tìm kiếm cụm từ yêu cầu thứ tự và khoảng cách từ chính xác, trong khi ký tự đại diện cho phép bạn thay thế hoặc bỏ qua từ trong thứ tự đó, mang lại khả năng khớp linh hoạt. + +**Q: Có thể sử dụng ký tự đại diện với dữ liệu số trong truy vấn không?** +A: Có—các tham số phạm vi ký tự đại diện (`*min~max`) hoạt động với số cũng như từ, cho phép các truy vấn như `"version *1~3"`. + +**Q: Nên xử lý bộ sưu tập tài liệu rất lớn như thế nào?** +A: Giữ chỉ mục được tối ưu, thực hiện cập nhật tăng dần, và thiết kế các mẫu ký tự đại diện cụ thể để hạn chế mở rộng thuật ngữ. GroupDocs.Search có thể đánh chỉ mục 1 triệu tài liệu đồng thời duy trì độ trễ truy vấn dưới 200 ms trên phần cứng tiêu chuẩn. + +**Q: GroupDocs.Search có phù hợp cho các kịch bản tìm kiếm thời gian thực không?** +A: Chắc chắn—sau khi chỉ mục được xây dựng, các truy vấn thực thi trong mili giây, lý tưởng cho các hộp tìm kiếm tương tác và tính năng tự động hoàn thành. -##### Bước 4: Truy Vấn Dựa trên Đối Tượng với Ký Tự Đại Diện Nâng Cao +**Q: Có thể tích hợp thư viện này vào dự án Java hiện có không?** +A: Có. Thêm phụ thuộc Maven hoặc JAR, khởi tạo `Index` như đã minh họa, và bạn đã sẵn sàng truy vấn mà không cần thay đổi mã hiện có. + +--- + +**Cập nhật lần cuối:** 2026-05-28 +**Kiểm tra với:** GroupDocs.Search 25.4 cho Java +**Tác giả:** GroupDocs ```java double word1 = SearchQuery.createWordQuery("sollicitudin"); @@ -179,43 +281,8 @@ SearchQuery queryObject = SearchQuery.createPhraseSearchQuery(word1, wildcard2, SearchResult resultObject = index.search(queryObject); ``` -## Ứng Dụng Thực Tiễn -- **Hệ thống Quản lý Nội dung:** Cho phép biên tập viên tìm các điều khoản chính xác hoặc trích đoạn linh hoạt. -- **Danh mục Thương mại Điện tử:** Giúp khách hàng tìm sản phẩm ngay cả khi họ bỏ sót một từ hoặc dùng từ đồng nghĩa. -- **Pháp lý & Tuân thủ:** Nhanh chóng cô lập ngôn ngữ hợp đồng có thể xuất hiện với những biến thể nhỏ. - -## Các Lưu Ý Về Hiệu Năng -- **Tạo Chỉ mục Tìm Kiếm** chỉ cần thực hiện một lần cho mỗi tập hợp tài liệu, sau đó tái sử dụng. -- **Thêm Tài liệu vào Chỉ mục** một cách tăng dần khi có tệp mới — không cần xây dựng lại toàn bộ chỉ mục mỗi lần. -- Sử dụng **các mẫu ký tự đại diện chính xác** để tránh quét không cần thiết; các mẫu rộng hơn sẽ tăng tải CPU. -- Thỉnh thoảng gọi `index.optimize()` (nếu có) để giữ mức sử dụng bộ nhớ thấp. - -## Các Vấn Đề Thường Gặp & Giải Pháp -| Vấn đề | Giải pháp | -|-------|----------| -| Không có kết quả trả về cho truy vấn ký tự đại diện | Kiểm tra cú pháp ký tự đại diện (`*min~~max`) và đảm bảo các từ tồn tại trong khoảng cách đã chỉ định. | -| Chỉ mục trở nên lỗi thời sau khi cập nhật tệp | Chạy lại `index.add(updatedFolder)` hoặc sử dụng API cập nhật tăng dần. | -| Tiêu thụ bộ nhớ cao trên bộ dữ liệu lớn | Tăng kích thước heap JVM và cân nhắc chia chỉ mục thành nhiều shard. | - -## Câu Hỏi Thường Gặp - -**H: Sự khác nhau giữa ký tự đại diện và tìm kiếm cụm từ là gì?** -Đ: Tìm kiếm cụm từ tìm kiếm thứ tự từ chính xác, trong khi ký tự đại diện cho phép bạn thay thế hoặc bỏ qua các từ trong thứ tự đó. - -**H: Tôi có thể dùng ký tự đại diện với dữ liệu số trong tìm kiếm không?** -Đ: Có, các tham số phạm vi ký tự đại diện hoạt động với số cũng như với từ. - -**H: Làm sao xử lý các bộ sưu tập tài liệu rất lớn?** -Đ: Giữ chỉ mục được tối ưu, sử dụng cập nhật tăng dần, và thiết kế các mẫu ký tự đại diện càng cụ thể càng tốt. - -**H: GroupDocs.Search có phù hợp cho các kịch bản tìm kiếm thời gian thực không?** -Đ: Chắc chắn — một khi chỉ mục đã được xây dựng, các truy vấn thực thi trong mili giây, phù hợp cho các ứng dụng tương tác. - -**H: Tôi có thể tích hợp thư viện này vào dự án Java hiện có không?** -Đ: Có. Thêm phụ thuộc Maven hoặc JAR, khởi tạo chỉ mục như đã minh họa, và bạn đã sẵn sàng. - ---- +## Hướng dẫn liên quan -**Cập nhật lần cuối:** 2026-01-26 -**Đã kiểm tra với:** GroupDocs.Search 25.4 cho Java -**Tác giả:** GroupDocs \ No newline at end of file +- [Tạo Index Tìm Kiếm Java – Hướng dẫn GroupDocs.Search](/search/java/) +- [Thêm Tài liệu vào Index – Hướng dẫn GroupDocs.Search Java](/search/java/document-management/) +- [Tạo Index Tìm Kiếm - Hướng dẫn GroupDocs.Search Java](/search/java/advanced-features/) \ No newline at end of file