国产亚洲精品看片在线观看,亚洲av无码无在线观看红杏,久久精品国产69国产精品亚洲

Eric.Zhou — Sun, 09 Aug 2009 02:15:00 GMT

转蝲地址�Q�http://www.javaeye.com/news/9637

1. 基本介绍�Q?/strong>

paoding �Q�Lucene中文分词“庖丁解牛” Paoding Analysis
imdict �Q�imdict��词典所采用的智能中文分词程�?br /> mmseg4j �Q?�?Chih-Hao Tsai �?MMSeg ��法实现的中文分词器
ik �Q�采用了�Ҏ��?#8220;正向�q�代最�l�粒度切分算�?#8220;�Q�多子处理器分析模式

2. 开发者及开发活跃度�Q?/strong>

paoding �Q?a style="white-space: nowrap" target="_blank">qieqie.wang�Q?google code 上最后一�ơ代码提交：2008-06-12�Q�svn 版本�?132
imdict �Q?a target="_blank">XiaoPingGao�Q?�q�入�?lucene contribute�Q�lucene trunk �?contrib/analyzers/smartcn/ 最后一�ơ提交：2009-07-24�Q?br /> mmseg4j �Q?a style="white-space: nowrap" target="_blank">chenlb2008�Q�google code �?2009-08-03 �Q�昨天）�Q�版本号 57�Q�log为：mmseg4j-1.7 创徏分支
ik �Q?a style="white-space: nowrap" target="_blank">linliangyi2005�Q�google code �?2009-07-31�Q�版本号 41

3. 用户自定义词库：

paoding �Q�支持不限制个数的用戯��定义词库�Q�纯文本格式�Q�一行一词，使用后台�U�程��词库的更新�Q�自动编译更新过的词库到二进制版本，�q�加�?br /> imdict �Q�暂时不支持用户自定义词库。但原版 ICTCLAS 支持。支持用戯��定义 stop words
mmseg4j �Q�自带sogou词库�Q�支持名�?wordsxxx.dic�Q?utf8文本格式的用戯��定义词库�Q�一行一词。不支持自动��?-Dmmseg.dic.path
ik �Q?支持api�U�的用户词库加蝲�Q�和配置�U�的词库文�g指定�Q�无 BOM �?UTF-8 �~�码�Q�\r\n 分割。不支持自动��?/p>

4. 速度�Q�基于官方介�l�，非自己测试）

paoding �Q�在PIII 1G内存个�h机器上，1�U?/strong> 可准��分�?100�?/strong> 汉字
imdict �Q?strong>483.64 (字节/�U?�Q?strong>259517(汉字/�U?
mmseg4j �Q?complex 1200kb/s左右, simple 1900kb/s左右
ik �Q�具�?0万字/�U�的高速处理能�?/p>

5. ��法和代码复杂度

paoding �Q�svn src 目录一�?.3M�Q?个properties文�g�Q?8个java文�g�Q?895 行。��用不用的 Knife 切不同类型的��，不算很复杂�?br /> imdict �Q�词�?6.7M�Q�这个词库是必须的）�Q�src 目录 152k�Q?0个java文�g�Q?399行。��?ICTCLAS HHMM隐马��科夫模型，“利用大量语料库的训练来统计汉语词汇的词频和蟩转概率，从而根据这些统计结果对整个汉语句子计算最似然(likelihood)的切�?#8221;
mmseg4j �Q?svn src 目录一�?132k�Q?3个java文�g�Q?089行�?a target="_blank">MMSeg ��法 �Q�有点复杂�?br /> ik �Q?svn src 目录一�?.6M(词典文�g也在里面)�Q?2个java文�g�Q?217行。多子处理器分析�Q�跟paoding�c�M��Q�歧义分析算法还没有弄明白�?/p>

6. 文档

paoding �Q�几乎无。代码里有一些注释，但因为实现比较复杂，��M��码还是有一些难度的�?br /> imdict �Q?几乎无�?ICTCLAS 也没有详�l�的文档�Q�HHMM隐马��科夫模型的数学性太强，不太好理解�?br /> mmseg4j �Q?MMSeg ��法是英文的�Q�但原理比较��单。实��C��比较清晰�?br /> ik �Q?有一个pdf使用手册�Q�里面有使用�C�Z��和配�|�说明�?/p>

7. 其它

paoding �Q�引入隐喻，设计比较合理。search 1.0 版本��q��的这个。主要优势在于原生支持词库更新检��。主要劣势�ؓ作者已�l�不更新甚至不维护了�?br /> imdict �Q�进入了 lucene trunk�Q�原�?ictclas 在各�U�评��中都有不错的表玎ͼ�有坚实的理论基础�Q�不是个人山寨。缺点�ؓ暂时不支持用戯��库�?br /> mmseg4j �Q?在complex基础上实��C��最多分�?max-word)�Q�但是还不成熟，�q�有很多需要改�q�的地方�?br /> ik �Q?nbsp; 针对Lucene全文��索优化的查询分析器IKQueryParser

8. �l�论

个�h觉得�Q�可以在 mmseg4j �?paoding 中选一个。关于这两个分词效果的对比，可以参考：

http://blog.chenlb.com/2009/04/mmseg4j-max-word-segment-compare-with-paoding-in-effect.html

或者自己再包装一下，��?paoding 的词库更新检��做一个单独的模块实现�Q�然后就可以在所有基于词库的分词��法之间无缝切换了�?/p>

ps�Q�对不同�?field 使用不同的分词器是一个可以考虑的方法。比�?tag 字段�Q�就应该使用一个最��单的分词器，按空格分词就可以了�?/p>

Eric.Zhou 2009-08-09 10:15 发表评论

Eric.Zhou — Mon, 29 Jan 2007 01:57:00 GMT

HTML 解析�?/font>
package com.rain.util;

import Java.io.FileInputStream;
import Java.io.FileNotFoundException;
import Java.io.IOException;
import Java.io.InputStream;
import Java.io.InputStreamReader;
import Java.io.Reader;
import Java.io.UnsupportedEncodingException;

import org.apache.lucene.demo.html.HTMLParser;

public class HTMLDocParser {

private String htmlPath;
private HTMLParser htmlParser;

public HTMLDocParser(String htmlPath){
  this.htmlPath=htmlPath;
  initHtmlParser();
}
public void initHtmlParser(){
  InputStream inputStream=null;
  try{
   inputStream=new FileInputStream(htmlPath);
  }catch(FileNotFoundException e){
   e.printStackTrace();
  }
  if(null!=inputStream){
   try{
    htmlParser=new HTMLParser(new InputStreamReader(inputStream,"utf-8"));
   }catch(UnsupportedEncodingException e){
    e.printStackTrace();
   }
  }
}
public String getTitle(){
  if(null!=htmlParser){
   try{
    return htmlParser.getTitle();
   }catch(IOException e){
    e.printStackTrace();
   }catch(InterruptedException e){
    e.printStackTrace();
   }
  }
  return "";
}
public Reader getContent(){
  if(null!=htmlParser){
   try{
    return htmlParser.getReader();
   }catch(IOException e){
    e.printStackTrace();
   }
  }
  return null;
}
public String getPath(){
  return this.htmlPath;
}
}

描述搜烦�l�果的结构实体Bean
package com.rain.search;

public class SearchResultBean {
    private String htmlPath;

    private String htmlTitle;

public String getHtmlPath() {
  return htmlPath;
}

public void setHtmlPath(String htmlPath) {
  this.htmlPath = htmlPath;
}

public String getHtmlTitle() {
  return htmlTitle;
}

public void setHtmlTitle(String htmlTitle) {
  this.htmlTitle = htmlTitle;
}
}

索引子系�l�的实现

package com.rain.index;

import Java.io.File;
import Java.io.IOException;
import Java.io.Reader;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.document.Field;

import com.rain.util.HTMLDocParser;

public class IndexManager {

//the directory that stores HTML files
private final String dataDir="E:\\dataDir";

//the directory that is used to store a Lucene index
private final String indexDir="E:\\indexDir";

public boolean creatIndex()throws IOException{
  if(true==inIndexExist()){
   return true;
  }
  File dir=new File(dataDir);
  if(!dir.exists()){
   return false;
  }
  File[] htmls=dir.listFiles();
  Directory fsDirectory=FSDirectory.getDirectory(indexDir,true);
  Analyzer analyzer=new StandardAnalyzer();
  IndexWriter indexWriter=new IndexWriter(fsDirectory,analyzer,true);
  for(int i=0;i   String htmlPath=htmls[i].getAbsolutePath();
   if(htmlPath.endsWith(".html")||htmlPath.endsWith("htm")){
    addDocument(htmlPath,indexWriter);
   }
  }
  indexWriter.optimize();
  indexWriter.close();
  return true;
}

public void addDocument(String htmlPath,IndexWriter indexWriter){
  HTMLDocParser htmlParser=new HTMLDocParser(htmlPath);
  String path=htmlParser.getPath();
  String title=htmlParser.getTitle();
  Reader content=htmlParser.getContent();

  Document document=new Document();
  document.add(new Field("path",path,Field.Store.YES,Field.Index.NO));
  document.add(new Field("title",title,Field.Store.YES,Field.Index.TOKENIZED));
     document.add(new Field("content",content));
     try{
     indexWriter.addDocument(document);
     }catch(IOException e){
     e.printStackTrace();
     }
}
public String getDataDir(){
  return this.dataDir;
}

public String getIndexDir(){
  return this.indexDir;
}

public boolean inIndexExist(){
  File directory=new File(indexDir);
  if(0   return true;
  }else{
   return false;
  }
}
}

搜烦功能的实�?br />package com.rain.search;

import Java.io.IOException;
import Java.util.ArrayList;
import Java.util.List;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;

import com.rain.index.IndexManager;

public class SearchManager {
private String searchWord;
private IndexManager indexManager;
private Analyzer analyzer;

public SearchManager(String searchWord){
  this.searchWord=searchWord;
  this.indexManager=new IndexManager();
  this.analyzer=new StandardAnalyzer();
}

/**
     * do search
     */
public List search(){
  List searchResult=new ArrayList();
  if(false==indexManager.inIndexExist()){
   try{
    if(false==indexManager.creatIndex()){
     return searchResult;
    }
   }catch(IOException e){
    e.printStackTrace();
    return searchResult;
   }
  }
  IndexSearcher indexSearcher=null;
  try{
   indexSearcher=new IndexSearcher(indexManager.getIndexDir());
  }catch(IOException e){
   e.printStackTrace();
  }
  QueryParser queryParser=new QueryParser("content",analyzer);
  Query query=null;
  try{
   query=queryParser.parse(searchWord);
  }catch(ParseException e){
   e.printStackTrace();
  }
  if(null!=query&&null!=indexSearcher){
   try{
    Hits hits=indexSearcher.search(query);
    for(int i=0;i     SearchResultBean resultBean=new SearchResultBean();
     resultBean.setHtmlPath(hits.doc(i).get("path"));
     resultBean.setHtmlTitle(hits.doc(i).get("title"));
     searchResult.add(resultBean);
    }
   }catch(IOException e){
    e.printStackTrace();
   }
  }
   return searchResult;
}

}

��h��理器的实现

package com.rain.servlet;

import Java.io.IOException;
import Java.util.List;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.rain.search.SearchManager;

/**
* @author zhourui
* 2007-1-28
*/
public class SearchController extends HttpServlet {
private static final long serialVersionUID=1L;

/* (non-Javadoc)
* @see javax.servlet.http.HttpServlet#doPost(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
*/
@Override
protected void doPost(HttpServletRequest arg0, HttpServletResponse arg1) throws ServletException, IOException {
  // TODO Auto-generated method stub
  String searchWord=arg0.getParameter("searchWord");
  SearchManager searchManager=new SearchManager(searchWord);
  List searchResult=null;
  searchResult=searchManager.search();
  RequestDispatcher dispatcher=arg0.getRequestDispatcher("search.jsp");
  arg0.setAttribute("searchResult",searchResult);
        dispatcher.forward(arg0, arg1);
}

}

向Web服务器提交搜索请�?/strong>







            SearchWord:





昄��搜烦�l�果

      <%
        List searchResult=(List)request.getAttribute("searchResult");
        int resultCount=0;
        if(null!=searchResult){
        resultCount=searchResult.size();
        }
        for(int i=0;i        SearchResultBean resultBean=(SearchResultBean)searchResult.get(i);
        String title=resultBean.getHtmlTitle();
        String path=resultBean.getHtmlPath();
        %>



        <%
        }
      %>

<%=title%>

Eric.Zhou 2007-01-29 09:57 发表评论

Lucene基本使用介绍

Eric.Zhou — Sun, 28 Jan 2007 02:38:00 GMT

一. 概述

随着�pȝ��信息的越来越多，怎么样从�q�些信息��h��中捞赯��己想要的那一栚w��变得非帔R��要了�Q�全文检索是通常用于解决此类问题的方案，而Lucene则�ؓ实现全文��索的工具�Q��Q何应用都可通过嵌入它来实现全文��索�?/p>
�? 环境搭徏

从lucene.apache.org上下载最新版本的lucene.jar�Q�将此jar作�ؓ��目的build path�Q�那么在��目中就可以直接使用lucene了�?/p>
�? 使用说明

3.1.       基本概念

�q�里介绍的主要�ؓ在��用中�l�常��到一些概念，以大安��比较熟悉的数据库来进行类比的讲解�Q��用Lucene�q�行全文��索的�q�程有点�c�M��数据库的�q�个�q�程�Q�table---à查询相应的字�D�|��查询条�g----à�q�回相应的记录，首先是IndexWriter�Q�通过它徏立相应的索引表，相当于数据库中的table�Q�在构徏此烦引表旉��指定的�ؓ该烦引表采用何种方式�q�行构徏�Q�也��是说对于其中的记录的字�D�以什么方式来�q�行格式的划分，�q�个在Lucene中称为Analyzer�Q�Lucene提供了几�U�环境下使用的Analyzer�Q�SimpleAnalyzer、StandardAnalyzer、GermanAnalyzer�{�，其中StandardAnalyzer是经�怋�用的�Q�因为它提供了对于中文的支持�Q�在表徏好后我们��需要往里面插入用于索引的记录，在Lucene中这个称为Document�Q�有点类似数据库中table的一行记录，记录中的字段的添加方法，在Lucene中称为Field�Q�这个和数据库中基本一��P��对于Field Lucene分�ؓ可被索引的，可切分的�Q�不可被切分的，不可被烦引的几种�l�合�c�d��Q�通过�q�几个元素基本上��可以徏立�v索引了。在查询时经常碰到的为另外几个概念，首先是Query�Q�Lucene提供了几�U�经常可以用到的Query�Q�TermQuery、MultiTermQuery、BooleanQuery、WildcardQuery、PhraseQuery、PrefixQuery、PhrasePrefixQuery、FuzzyQuery、RangeQuery、SpanQuery�Q�Query其实也就是指对于需要查询的字段采用什么样的方式进行查询，如模�p�查询、语义查询、短语查询、范围查询、组合查询等�Q�还有就是QueryParser�Q�QueryParser可用于创��Z��同的Query�Q�还有一个MultiFieldQueryParser支持对于多个字段�q�行同一关键字的查询�Q�IndexSearcher概念指的为需要对何目录下的烦引文件进行何�U�方式的分析的查询，有点象对数据库的哪种索引表进行查询�ƈ按一定方式进行记录中字段的分解查询的概念�Q�通过IndexSearcher以及Query卛_��查询出需要的�l�果�Q�Lucene�q�回的�ؓHits.通过遍历Hits可获取返回的�l�果的Document�Q�通过Document则可获取Field中的相关信息了�?br />

比较一下Lucene和数据库�Q?/p>

Lucene 数据�?/td>

索引数据源：doc(field1,field2...) doc(field1,field2...)
\ indexer /
_____________
| Lucene Index|
--------------
/ searcher \
�l�果输出�Q�Hits(doc(field1,field2) doc(field1...))

索引数据源：record(field1,field2...) record(field1..)
\ SQL: insert/
_____________
| DB Index |
-------------
/ SQL: select \
�l�果输出�Q�results(record(field1,field2..) record(field1...))

Document�Q�一个需要进行烦引的“单元”
一个Document由多个字�D늻��?/td> Record�Q�记录，包含多个字段

Field�Q�字�D?/td> Field�Q�字�D?/td>

Hits�Q�查询结果集�Q�由匚w��的Document�l�成 RecordSet�Q�查询结果集�Q�由多个Record�l�成

通过对于上面在徏立烦引和全文��索的基本概念的介�l�希望能让你对Lucene建立一定的了解�?br />
需要熟悉几个接口：
分析器Analyzer
        分析器主要工作是�{�选，一�D�|��档进来以后，�l�过它，出去的时候只剩下那些有用的部分，其他则剔除。而这个分析器也可以自己根据需要而编写�?br />        org.apache.lucene.analysis.Analyzer�Q�这是一个虚构类�Q�以下两个借口均��承它而来�?/span>
        org.apache.lucene.analysis.SimpleAnalyzer�Q�分析器�Q�支持最��单拉丁语�a��?br />        org.apache.lucene.analysis.standard.StandardAnalyzer�Q�标准分析器�Q�除了拉丁语�a��q�支持亚�z�语�a��Q��ƈ在一些匹配功能上�q�行完善。在�q�个接口中还有一个很重要的构造函敎ͼ�StandardAnalyzer(String[] stopWords)�Q�可以对分析器定义一些��用词语，�q�不仅可以免除检索一些无用信息，而且�q�可以在��索中定义��止的政��L��、非法性的��索关键词�?/span>
IndexWriter
        IndexWriter的构造函数有三种接口�Q�针对目录Directory、文件File、文件�\径String三种情况�?br />例如IndexWriter(String path, Analyzer a, boolean create)�Q�path为文件�\径，a为分析器�Q�create标志是否重徏索引�Q�true�Q�徏立或者覆盖已存在的烦引，false�Q�扩展已存在的烦引。）
       一些重要的�Ҏ��Q?/span>
接口�??xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" /?>
备注
addDocument(Document doc)
索引��d��一个文�?o:p>
addIndexes(Directory[] dirs)
��目录中已存在烦引添加到�q�个索引
addIndexes(IndexReader[] readers)
��提供的索引��d��到这个烦�?o:p>
optimize()
合�ƈ索引�q�优�?o:p>
close()
关闭
　
       IndexWriter��Z��减少大量的io�l�护操作�Q�在每得��C��定量的烦引后建立新的��烦引文�Ӟ��W�者测试烦引批量的最��单位�ؓ10�Q�，然后再定期将它们整合��C��个烦引文件中�Q�因此在索引�l�束时必��进行wirter.optimize()�Q�以便将所有烦引合�q�优化�?br />org.apache.lucene.document
以下介绍两种主要的类�Q?br /> a�Q�org.apache.lucene.document.Document�Q?br />        Document文档�c�M��数据库中的一条记录，可以由好几个字段�Q�Field�Q�组成，�q�且字段可以套用不同的类型（详细见b�Q�。Document的几�U�接口：
接口�?o:p>
备注
add(Field field)
��d��一个字�D�（Field�Q�到Document�?o:p>
String get(String name)
从文档中获得一个字�D�对应的文本
Field getField(String name)
由字�D�名获得字段�?o:p>
Field[] getFields(String name)
由字�D�名获得字段值的�?o:p>

b�Q�org.apache.lucene.document.Field
        即上文所说的“字段”�Q�它是Document的片�D�section�?br />        Field的构造函敎ͼ�
       Field(String name, String string, boolean store, boolean index, boolean token)�?br />        Indexed�Q�如果字�D�|��Indexed的，表示�q�个字段是可��索的�?br />        Stored�Q�如果字�D�|��Stored的，表示�q�个字段的值可以从��索结果中得到�?br />        Tokenized�Q�如果一个字�D�|��Tokenized的，表示它是有经�q�Analyzer转变后成��Z��个tokens序列�Q�在�q�个转变�q�程tokenization中，Analyzer提取出需要进行烦引的文本�Q�而剔除一些冗余的词句�Q�例如：a�Q�the,they�{�，详见org.apache.lucene.analysis.StopAnalyzer.ENGLISH_STOP_WORDS和org.apache.lucene.analysis.standard.StandardAnalyzer(String[] stopWords)的API�Q�。Token是烦引时候的基本单元�Q�代表一个被索引的词�Q�例如一个英文单词，或者一个汉字。因此，所有包含中文的文本都必��L��Tokenized的�?br />     Field的几�U�接口：
Name
Stored
Indexed
Tokenized
use
Keyword(String name,
        String value)
Y
Y
N
date,url
Text(String name, Reader value)
N
Y
Y
short text fields:
title,subject
Text(String name, String value)
Y
Y
Y
longer text fields,
like “body”
UnIndexed(String name,
String value)
Y
N
N

UnStored(String name,
         String value)
N
Y
Y

Hits与Searcher
       Hits的主要��用接口：
接口�?o:p>
备注
Doc(int n)
�q�回�W�n个的文档的所有字�D?o:p>
length()
�q�回�q�个集中的可用个�?o:p>

3.2.       全文��索需求的实现
索引建立部分的代码：

private void createIndex(String indexFilePath) throws Exception{
        IndexWriter iwriter=getWriter(indexFilePath);
        Document doc=new Document();
        doc.add(Field.Keyword("name","jerry"));
        doc.add(Field.Text("sender","bluedavy@gmail.com"));
        doc.add(Field.Text("receiver","google@gmail.com"));
        doc.add(Field.Text("title","用于索引的标�?));
        doc.add(Field.UnIndexed("content","不徏立烦引的内容"));
        Document doc2=new Document();
        doc2.add(Field.Keyword("name","jerry.lin"));
        doc2.add(Field.Text("sender","bluedavy@hotmail.com"));
        doc2.add(Field.Text("receiver","msn@hotmail.com"));
        doc2.add(Field.Text("title","用于索引的第二个标题"));
        doc2.add(Field.Text("content","建立索引的内�?));
        iwriter.addDocument(doc);
        iwriter.addDocument(doc2);
        iwriter.optimize();
        iwriter.close();
    }

    private IndexWriter getWriter(String indexFilePath) throws Exception{
        boolean append=true;
        File file=new File(indexFilePath+File.separator+"segments");
        if(file.exists())
            append=false;
        return new IndexWriter(indexFilePath,analyzer,append);
    }

3.2.1.       对于某字�D늚�关键字的模糊查询

Query query=new WildcardQuery(new Term("sender","*davy*"));

        Searcher searcher=new IndexSearcher(indexFilePath);
        Hits hits=searcher.search(query);
        for (int i = 0; i < hits.length(); i++) {
            System.out.println(hits.doc(i).get("name"));
        }

3.2.2.       对于某字�D늚�关键字的语义查询

Query query=QueryParser.parse("索引","title",analyzer);

        Searcher searcher=new IndexSearcher(indexFilePath);
        Hits hits=searcher.search(query);
        for (int i = 0; i < hits.length(); i++) {
            System.out.println(hits.doc(i).get("name"));
        }

3.2.3.       对于多字�D늚�关键字的查询

Query query=MultiFieldQueryParser.parse("索引",new String[]{"title","content"},analyzer);

        Searcher searcher=new IndexSearcher(indexFilePath);
        Hits hits=searcher.search(query);
        for (int i = 0; i < hits.length(); i++) {
            System.out.println(hits.doc(i).get("name"));
        }

3.2.4.       复合查询(多种查询条�g的综合查�?

Query query=MultiFieldQueryParser.parse("索引",new String[]{"title","content"},analyzer);
        Query mquery=new WildcardQuery(new Term("sender","bluedavy*"));
        TermQuery tquery=new TermQuery(new Term("name","jerry"));

        BooleanQuery bquery=new BooleanQuery();
        bquery.add(query,true,false);
        bquery.add(mquery,true,false);
        bquery.add(tquery,true,false);

        Searcher searcher=new IndexSearcher(indexFilePath);
        Hits hits=searcher.search(bquery);
        for (int i = 0; i < hits.length(); i++) {
            System.out.println(hits.doc(i).get("name"));
        }

�? �ȝ��
�怿�大家通过上面的说明能知道Lucene的一个基本的使用�Ҏ��Q�在全文��索时��大家先采用语义时的搜索，先搜索出有意义的内容�Q�之后再�q�行模糊之类的搜索，^_^�Q�这个还是需要根据搜索的需求才能定了，Lucene�q�提供了很多其他更好用的�Ҏ��Q�这个就�{�待大家在��用的�q�程中自己去�q�一步的摸烦了，比如对于Lucene本��n提供的Query的更熟练的掌握，对于Filter、Sorter的��用，自己扩展实现Analyzer�Q�自己实现Query�{�等�Q�甚臛_��以去了解一些关于搜索引擎的技�?切词、烦引排�?etc)�{�等

Eric.Zhou 2007-01-28 10:38 发表评论

Lucene	数据�?/td>
索引数据源：doc(field1,field2...) doc(field1,field2...) \ indexer / _____________ \| Lucene Index\| -------------- / searcher \ �l�果输出�Q�Hits(doc(field1,field2) doc(field1...))	索引数据源：record(field1,field2...) record(field1..) \ SQL: insert/ _____________ \| DB Index \| ------------- / SQL: select \ �l�果输出�Q�results(record(field1,field2..) record(field1...))
Document�Q�一个需要进行烦引的“单元” 一个Document由多个字�D늻��?/td>	Record�Q�记录，包含多个字段
Field�Q�字�D?/td>	Field�Q�字�D?/td>
Hits�Q�查询结果集�Q�由匚w��的Document�l�成	RecordSet�Q�查询结果集�Q�由多个Record�l�成

接口�??xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" /?>	备注
addDocument(Document doc)	索引��d��一个文�?o:p>
addIndexes(Directory[] dirs)	��目录中已存在烦引添加到�q�个索引
addIndexes(IndexReader[] readers)	��提供的索引��d��到这个烦�?o:p>
optimize()	合�ƈ索引�q�优�?o:p>
close()	关闭

接口�?o:p>	备注
add(Field field)	��d��一个字�D�（Field�Q�到Document�?o:p>
String get(String name)	从文档中获得一个字�D�对应的文本
Field getField(String name)	由字�D�名获得字段�?o:p>
Field[] getFields(String name)	由字�D�名获得字段值的�?o:p>

Name	Stored	Indexed	Tokenized	use
Keyword(String name, String value)	Y	Y	N	date,url
Text(String name, Reader value)	N	Y	Y	short text fields: title,subject
Text(String name, String value)	Y	Y	Y	longer text fields, like “body”
UnIndexed(String name, String value)	Y	N	N
UnStored(String name, String value)	N	Y	Y

接口�?o:p>	备注
Doc(int n)	�q�回�W�n个的文档的所有字�D?o:p>
length()	�q�回�q�个集中的可用个�?o:p>