亚洲自拍偷拍网址,fc2人成共享视频在线观看,99久久精品免费看国产小宝寻花

晓宇 — Fri, 30 May 2008 06:47:00 GMT

在搜索引擎中�Q�切词语是一个重要的部分�Q�其中包括专有名词的提取、词的分剌Ӏ�词的格式化�{�等�?br /> TokenStream �c�d��乎是所有这些类的基�c?br /> 有两个需要被子类实现的方法Token next() �?nbsp;close()
首先来看analysis包，�q�个包主要是提供一些简单的词汇化处�?br /> �?span style="color: #339966">Tokenizer�l�尾的类是将要处理的字符串进行分割成Token��，而根据分割的依据的又产生了以下几个Tokenizer�c?br /> 首先Tokenizer�c�L��所�?span style="color: #000000">以Tokenizer�l�尾的类的基�c?br /> 然后是CharTokenizer�Q�所有的�?span style="color: #339966">Tokenizer�l�尾的类都是从这个类�l�承�?br /> �q�个�c�M��有一个抽象方�?br /> protected abstract boolean isTokenChar(char c);
另外一个需要被子类覆写的方�?br />   protected char normalize(char c) {}�Q?/span>
是对单个字符�q�行处理的方法譬如说��英文字母全部�{化�ؓ��写

�q�有一个变�?br /> protected Reader input;
�q�个��d��器是�q�些�c�L��处理的数据的   数据�?br /> 输入一个Reader �Q��生一个Token��?/span>

�q�个�Ҏ(gu��)��是是否进行切分的依据�Q�依�ơ读取char��，然后用这个方法对每个char�q�行��，如果�q�回false则将预先存储�?br /> 词汇�~�冲��Z��的char数组作�ؓ一个Token�q�回
LetterTokenizer �Q?/span>
      protected boolean isTokenChar(char c) {
              return Character.isLetter(c);
      }
WhitespaceTokenizer�Q?/span>
      protected boolean isTokenChar(char c) {
             return !Character.isWhitespace(c);
     }
LowerCaseTokenizer extends LetterTokenizer�Q?/span>
protected char normalize(char c) {
      return Character.toLowerCase(c);
   }
   在构造函��C��调用super(in);�q�行�?nbsp;LetterTokenizer同样的操作，但是在词汇化之前所有的词都转化为小写了

然后是以Filter�l�尾的类�Q�这个类��主要是对已�l�词汇化的Token��进行进一步的处理
输入是Token��?, 输出仍然是Token��?br /> TokenFilter extends TokenStream 是所有这些类的父�c?br /> protected TokenStream input;
在TokenFilter 中有一个TokenStream 变量�Q�是Filter�cȝ��处理的数据源�Q�而Filter�cȝ��又是�l�承了TokenStream �cȝ��
有一个public final Token next()�Ҏ(gu��)��,�q�个�Ҏ(gu��)��以TokenStream.next()产生的Token��?为处理源�Q��生的仍然是Token��?br /> 只不�q�中间有一些处理的�q�程
LowerCaseFilter�Q�将所有的Token��的转化为小�?br />      t.termText = t.termText.toLowerCase();
StopFilter�Q�过滤掉一些停止词�Q�这些停止词由构造函数指�?/span>
     for (Token token = input.next(); token != null; token = input.next())
      if (!stopWords.contains(token.termText))
        return token;

比较一下Tokenizer�cȝ��和Filter�cȝ��Q�可以知�?br /> Tokenizer�cȝ��主要是对输入的Reader��，实际上是字符��按照一定的规则�q�行分割�Q��生出Token��?br /> 其输入是字符串的Reader��Ş式，输出是Token��?br />
Filter�cȝ��主要是对输入的Token��进行更�q�一步的处理�Q�如去除停止词，转化为小�?br /> 主要��Z��些格式化操作�?br /> �׃��Filter�cȝ��的输入输出相同，所以可以嵌套几个不同的Filter�c�，以达到预期的处理目的�?br /> 前一个Filter�cȝ��输出作�ؓ后一个Filter�cȝ��输入
而Tokenizer�cȝ��׃��输入输出不同�Q�所以不能嵌�?br />

晓宇 2008-05-30 14:47 发表评论

关于IndexWriter中的3个性能参数

晓宇 — Thu, 15 May 2008 11:27:00 GMT

�?font size="2">IndexWriter中有3个重要的性能参数
mergeFactor           默认�?0
minMergeDocs      默认�?0
maxMergeDocs     默认为Integer.maxValue

maxMergeDocs     一个段中所能包含的最大的doc敎ͼ�辑ֈ��q�个数目即不再将�D�进行合�q?一般不改变�q�个�?br /> minMergeDocs      是指在RAMDirectory中保存的Doc的个敎ͼ�辑ֈ�minMergeDocs 个即要合�q�到��盘上去�Q�在��盘上新��Z��个段�Q?br /> mergeFactor           合�ƈ因子�Q�是控制��盘上的�D늚�合�ƈ的，每次在硬盘上新徏一个段之后��x��?br />                                  targetMergeDocs*=mergeFactor�Q�一开�?font size="2">targetMergeDocs=minMergeDocs�Q?nbsp;如果��盘上的doc数目大于�{�于                            targetMergeDocs则将��盘上最后徏立的mergeFactor个段�q�行合�ƈ成一个段

拉K��认的参数举例�Q?br /> 如果��盘上面已经�?个段每个�D�分别存储了10个Document,共（90个DOC�Q�，�q�时候如果程序再向硬盘合�q�一个新的段�Q�含10个DOC�Q�，合�ƈ完之�?font size="2">targetMergeDocs=10*10 �E�序��查已�l�合�q�的最后（按照创徏的时间先后顺序）mergeFactor个段的document的��d��100是否大于�{�于targetMergeDocs�Q�这里是100�Q�刚好满��求）于是�E�序又将��盘上面的后10个段合�ƈ��Z��个新的段�?br />
另外一个例子：
doc数目            �D�|��?br /> 1000---------------9�?br /> 100-----------------9�?br /> 10   ----------------9�?br /> �q�时如果再象��盘中新��Z��个新的包含了10个doc的段
    doc数目            �D�|��?br /> (1) 1000----------------9�?br />
(2) 100-----------------9�?br />
(3)   10  ----------------9�?br />
(4)    10 ----------------1�?br /> �q�时�?3)(4)首先合�ƈ成一个新的段(3-4)包含100个doc
然后(2)(3-4)和�ƈ成一个新�D�（2-3-4�Q�包�?000个doc
然后(1)(2-3-4)合�ƈ成一个新的段包含10000个doc
最后合�q�成一个段

private final void maybeMergeSegments() throws IOException {
    long targetMergeDocs = minMergeDocs;
    while (targetMergeDocs <= maxMergeDocs) {
      // find segments smaller than current target size
      int minSegment = segmentInfos.size();
      int mergeDocs = 0;
      while (--minSegment >= 0) {
        SegmentInfo si = segmentInfos.info(minSegment);
        if (si.docCount >= targetMergeDocs)
          break;
        mergeDocs += si.docCount;
      }

      if (mergeDocs >= targetMergeDocs)          // found a merge to do
        mergeSegments(minSegment+1);
      else
        break;

      targetMergeDocs *= mergeFactor;        // increase target size
      System.out.println("- -- - -targetMergeDocs:"+targetMergeDocs);
      try {Thread.sleep(5000);} catch(Exception e) {};
    }
  }

晓宇 2008-05-15 19:27 发表评论

晓宇 — Mon, 21 Apr 2008 09:52:00 GMT

segments文�g的格式： �Q�段的信息）
int: =-1    查看文�g是否是Lucene合法的文件格�?br /> long:        版本��P��每更��C��ơ该文�g��会��版本号�?
int:         用来命名新段
int:         �D늚�数目
String + int �D늚�信息 String是段的名�U?nbsp; int是段中所含的doc数目
String + int 同上

.fnm的文件格式：   �Q�Field的信息）
int:               Field的个敎ͼ�最��ؓ1�Q�最��有一个Field("",false)�Q�在初始化的时候写�?暂时不知道原�?; 名称为空字符�Ԍ��未烦引，        �?nbsp;              �?nbsp;          量化。readVInt()��d��
String: byte      String�?nbsp;Field的名�U?nbsp; byte指示该Field 是否被烦引，是否向量�?�Q�值有�Q?1�Q?0�Q?1�Q�第一�?代表被烦引，�W�二个代表被向量�?br /> String: byte Field 同上

.fdx的文件格式：主要是提供对.fdt中存储的document的随卌��?br /> long : �W�一个document�?fdt文�g中的位置
long: �W�二个document�?fdt文�g中的位置

.fdt的文件格式： .fdt文�g存储了一�p�d��document的信�?br /> VInt: 该document中的isStored属性�ؓtrue的域的个�?br /> (VInt:) 如果该field的isStored属性�ؓtrue则得到该field的fieldNumber�Q�暂时不知道�q�个fieldNumber是怎么产生的，有什么用�Q�初步估计是按照field创徏的顺序��生的�Q�每�ơ再上一个field的fieldNumber基础上加1�?br /> byte: 如果该field的isTokenized属性�ؓtrue写入1否则写入false�?br /> String: 该field的stringValue()倹{�?br /> 一个document�l�束�Q�下面的数据��会开始一个新的document�Q�每个新的document的开始点的文件位�|�都会在.fdx中有记蝲�Q�便于随卌��?/span>

晓宇 2008-04-21 17:52 发表评论

org.apache.lucene.index.SegmentInfos

晓宇 — Fri, 18 Apr 2008 09:02:00 GMT

final class SegmentInfos extends Vector
可以看出该类实际上是一个Vector   以及��装了对该Vevtor的一些操�?br /> 实际上封装的是对segments文�g的一些读写操�?br /> 先来看下segments文�g的格�?br />
segments文�g的格式：
int: =-1       文�g是否是Lucene合法的文件格式正常情况下�?-1
long:           版本��P��每更��C��ơ该文�g��会��版本号�?
int:               用来命名新段
int:                �D늚�数目
String + int �D늚�信息 String是段的名�U?nbsp; int是段中所含的doc数目
String + int 同上

所以用Lucene的API�Q�我们可以简单的打印出其segments的所有信�?br />

try {
   //DataInputStream fis = new DataInputStream(new FileInputStream("C:\\sf\\snow\\segments"));
   FSDirectory dir=FSDirectory.getDirectory("C:/sf/snow", false);
    InputStream input = dir.openFile("segments");
   System.out.println("Format:"+input.readInt());             //得到文�g标志�Q�是否�ؓ正常的segments文�g
   System.out.println("version:"+input.readLong());        //得到版本�?br />    System.out.println("name:"+input.readInt());                //得到用来重命名新�D늚�int�Q�暂时不知道有什么用
   int n=input.readInt();                                                          //�D늚�数目
   System.out.println("SegmentNum:"+n);
   for(int i=0;i     System.out.println("segment "+i+" - name:"+input.readString()+" num:"+input.readInt());
   }
  } catch (Exception e) {

}
当然,该类提供了更为复杂的讉K��和更新segments文�g的方�?br /> final void read(Directory directory) ��所有的�D�信息保存在本vector�?br /> final void write(Directory directory) 跟新该segment文�g的内容，主要是�ؓ了添加段�Q?br /> 主要是更�?版本�?�D늚�数目�Q�跟新完�q�些后即可往segment文�g后添加新�D늚�信息�?br />

晓宇 2008-04-18 17:02 发表评论

org.apache.lucene.index.SegmentInfo

晓宇 — Fri, 18 Apr 2008 08:45:00 GMT

segment(�D?的信�?br /> 该类比较��单，贴出其全部代�?/p>

import org.apache.lucene.store.Directory;

final class SegmentInfo {
public String name;        //在烦引目录中唯一的名�U?nbsp;
public int docCount;      // 该段中doc的数�?br /> public Directory dir;      // 该段所存在的Dirrectory

public SegmentInfo(String name, int docCount, Directory dir) {
    this.name = name;
    this.docCount = docCount;
    this.dir = dir;
}
}

晓宇 2008-04-18 16:45 发表评论

org.apache.lucene.store.RAMInputStream

晓宇 — Fri, 18 Apr 2008 03:45:00 GMT

该类是从RAMFile中读数据用的
最重要的一个方法：
该方法存在着从RAMFile的多个byte[1024]中读取数据的情况�Q�所以应该在循环中进行处�?br />
public void readInternal(byte[] dest, int destOffset, int len) {
    int remainder = len;
    int start = pointer;
    while (remainder != 0) {
      int bufferNumber = start/BUFFER_SIZE; // buffer的序�?br />       int bufferOffset = start%BUFFER_SIZE; //    buffer偏移�?br />       int bytesInBuffer = BUFFER_SIZE - bufferOffset;// 在当前buffer中剩下的字节�?br />       //如果�~�冲��Z��剩余的字节大于len�Q�则��d��len长度的字节，如果不够则读出剩余的字节�?
      // bytesToCopy表示实际��d��的字节数
      int bytesToCopy = bytesInBuffer >= remainder ? remainder : bytesInBuffer;
      byte[] buffer = (byte[])file.buffers.elementAt(bufferNumber);
      System.arraycopy(buffer, bufferOffset, dest, destOffset, bytesToCopy);
      destOffset += bytesToCopy;       //增加已经复制的byte数据长度 �?nbsp; dest中的偏移�?br />       start += bytesToCopy;                 //RAMFile文�g指针�Q�用来确定bufferNumber 和bytesInBuffer   相当于内存中的分��?br />       remainder -= bytesToCopy;       //剩余的还未复制的字节�?br />     }
    pointer += len;//文�g指针位置
}

晓宇 2008-04-18 11:45 发表评论

org.apache.lucene.store.RAMOutputStream

晓宇 — Fri, 18 Apr 2008 03:38:00 GMT

�q�是OutputStream的一个子�c�，其输��备是内存�Q�准��来说是RAMFile�Q�即��数据写入到RAMFile的Vector中去�?br /> 该类有一个最重要的方法，现在把它整个贴出�?/p>

public void flushBuffer(byte[] src, int len) {
    int bufferNumber = pointer/BUFFER_SIZE;   //buffer序列�Q�即当前所写Buffer在RAMFile中的Vector中的序列�?br />     int bufferOffset = pointer%BUFFER_SIZE;   //偏移量，卛_��前所写字节在当前Buffer中的偏移量�?br />     int bytesInBuffer = BUFFER_SIZE - bufferOffset; //当前Buffer的剩余可写字节数
   //bytesToCopy是实际写入的字节敎ͼ�如果当前Bufer的剩余字节数大于需要写的字节的��L��则写入所有字�?br />    //否则�Q�将当前Buffer写满卛_��Q�剩余的字节��写入下一个Buffer
    int bytesToCopy = bytesInBuffer >= len ? len : bytesInBuffer;

if (bufferNumber == file.buffers.size())
file.buffers.addElement(new byte[BUFFER_SIZE]); //在RAMFile中添加新的byte[1024]元素

byte[] buffer = (byte[])file.buffers.elementAt(bufferNumber);
System.arraycopy(src, 0, buffer, bufferOffset, bytesToCopy);

    if (bytesToCopy < len) {     // not all in one buffer,
      int srcOffset = bytesToCopy;
      bytesToCopy = len - bytesToCopy;    // remaining bytes 剩余的未写入的字节数
      bufferNumber++;                         //��buffer数增�?
      if (bufferNumber == file.buffers.size())
        file.buffers.addElement(new byte[BUFFER_SIZE]);
      buffer = (byte[])file.buffers.elementAt(bufferNumber); //剩余字节写入下一个Buffer
      System.arraycopy(src, srcOffset, buffer, 0, bytesToCopy);
    }
    pointer += len;
    if (pointer > file.length)
      file.length = pointer;        //�U�M��文�g指针          在原有的基础上加上实际写入的字节��L��

file.lastModified = System.currentTimeMillis(); //修改文�g的最后修�Ҏ(gu��)��间�ؓ当前旉��
}

从指定的字节数组复制指定长度的字节到RAMFile中去。由于RAMFile中Vector的元素是byte[1024]所以可能存在做一�ơ该操作
要操作两个Vector元素的情��c��即先将当前byte[1024]数组填满�Q�再新徏一个元素装载剩余的字节�?br />
另外�q�有一个writeTo(OutputStream out)�Ҏ(gu��)��Q�将RAMFile中的数据输出到另一个输出流

晓宇 2008-04-18 11:38 发表评论

org.apache.lucene.store.RAMFile

晓宇 — Fri, 18 Apr 2008 03:23:00 GMT

�q�个�c�L��较简�?br /> import java.util.Vector;
class RAMFile {
Vector buffers = new Vector();
long length;
long lastModified = System.currentTimeMillis();
}

可以理解��Z��个存储在内存中的文�g�Q�buffers是存储数据的容器�Q�length是容器中数据的�ȝ��字节�?br /> lastModified 是最后修�Ҏ(gu��)��间�?br />
在实际��用过�E�中容器buffers存放的对象是一个byte[1024]数组�?br />

晓宇 2008-04-18 11:23 发表评论

org.apache.lucene.store.OutputStream

晓宇 — Wed, 16 Apr 2008 13:24:00 GMT

OutputStream
�q�是一个Abstract�c�，是Lucene自己的一个文件输出流的基�c?br /> BUFFER_SIZE = 1024 �~�冲�?大小�?1024bit
bufferStart = 0 文�g位置指针
bufferPosition = 0 内存�~�冲区指�?br />
public final void writeByte(byte b) throws IOException {
    if (bufferPosition >= BUFFER_SIZE)
      flush();
    buffer[bufferPosition++] = b;
}
几乎所有的写入函数都要调用�q�个函数�Q�如果缓冲区的当前容量已�l�等于他的最大容量，则将�~�冲��Z��的数据写入文件�?br />
public final void writeBytes(byte[] b, int length) throws IOException
扚w��写byte�q�入内存�~�冲

public final void writeInt(int i) throws IOException
写入整�Ş数据

public final void writeLong(long i) throws IOException
写入长整型数据，即结合移位运��调用两�ơwriteInt(int i)

另外�Q�最值得注意的是在该�c�M��有两个最�Ҏ(gu��)��的函�?br /> writeVInt�Q�int i�Q?/   writeVLong(long i),
先说
writeVInt(int i )   {
while ((i & ~0x7F) != 0) {
      writeByte((byte)((i & 0x7f) | 0x80));
      i >>>= 7;
    }
    writeByte((byte)i);
}
~0x7F==~(0111 1111)==(1000 0000)==0x80
((i & ~0x7F) != 0) �q�一句判断i是否大于0x80�Q�如果不是则说明该int只有一个字节的有效数据�Q�其他字节都�?�Q�直接�{化�ؓByte写入�?br /> 如果大于0x80�?br /> (i & 0x7f) | 0x80
i&0x7f 只对�?位进行处理，|0x80��第8位置1�Q�与前面�?个bit构成一个字节，�|?的原因是说明该字节�ƈ不是一个完整的整�Ş敎ͼ�需要与其他的字节合��h��才能构成一个整形数字�?br /> �q�个��法相当于将一�?2bit的整形数字按照每7位编码成一个字节进行存储，��按照整形数的大��存�?-5个字节�?/span>
writeVLong(long i)�Ҏ(gu��)��大致与其相同�?br />
final void writeChars(String s, int start, int length)
��字�W�串转化成UTF-8�~�码的格式进行存储�?br /> 附：

UNICODE�?UTF-8�~�码
U-00000000 - U-0000007F: 0xxxxxxx
U-00000080 - U-000007FF: 110xxxxx 10xxxxxx
U-00000800 - U-0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx

可见对于�?0x00-0x7F范围内的UNICODE��|��最大有效数位：7位）�Q�将会编码成单字节的�Q�会大大节约存储�I�间�?br /> 对于�?nbsp; 0x80-0x7FF范围内的UNICODE�Q�最大有效数位：11位）�Q�会�~�码成双字节的。先存储原字节低5位的��C��Q�且��最高位和次高位都置1�Q�再�ơ高位置0�Q�writeByte((byte)(0xC0 | (code >> 6)));�Q�。然后存储后6位的字节�Q�将前两位置10�Q�writeByte((byte)(0x80 | (code & 0x3F)));�Q?br /> 对于其他的UNICODE值则
writeByte((byte)(0xE0 | (code >>> 12))); 4�?br /> writeByte((byte)(0x80 | ((code >> 6) & 0x3F))); 5�?br /> writeByte((byte)(0x80 | (code & 0x3F))); 3- 5�?br />
final void writeString(String s) throws IOException
该函数首先用s.length()判断该String��d��有多��个字符
然后首先调用writeVInt写入�q�个字符长度
再调用writeChars(s,s.length())写入字符

在inputStream中的readString()�Ҏ(gu��)��则与其相反，首先用readVInt()�Ҏ(gu��)��d��字符长度len 然后��d��len长度的字�W?br />
protected final void flush() throws IOException
该方法调用另外一个方法flushBuffer��缓冲区中的数据输出�Q�然后清�I�缓冲区�Q?br />
abstract void flushBuffer(byte[] b, int len) throws IOException
可见flushBuffer�Ҏ(gu��)��是abstract的，即需要其子类对该�Ҏ(gu��)��q�行覆写�Q�以定位该输出流的输出方式�?br />
final long getFilePointer() throws IOException
得到文�g指针的位�|�，卛_��到输出流已经输出的字节数�?br />
public void seek(long pos) throws IOException
输出�~�冲区的内容�Q�然后将文�g指针定位到l(f��)ong所指示的文件位�|��?br />
abstract long length() throws IOException
�q�回文�g中已有的字节数。需要子�c�d��现�?br />

晓宇 2008-04-16 21:24 发表评论

org.apache.lucene.store.FSDirectory

晓宇 — Thu, 10 Apr 2008 13:35:00 GMT

FSDirectory�l�承了abstract�c�Directory
在该�c�M��既有该类的一些初始化操作�Q�又有对FSDirectory对象本��n的一些操作，�q�是��Z��么把其构造函数设�|��ؓ�U�有的一部分原因

static final Hashtable DIRECTORIES = new Hashtable();
每新��Z��个FSDirectory都会��其加入到该Hashtable中来。名�U�是FSDirectory对应的File   值是该FSDirectory�?br /> 注意�Q�final对象�q��是不可更改的

static final String LOCK_DIR =
    System.getProperty("org.apache.lucene.lockdir",
      System.getProperty("java.io.tmpdir"));
首先看用��h��否注册了"org.apache.lucene.lockdir"属性，如果没有则用JAVA虚拟机固有的"java.io.tmpdir"属�?br /> �q�个属性是一个�\径，代表lucene的锁文�g锁放的位�|��?br />
static final boolean DISABLE_LOCKS =
      Boolean.getBoolean("disableLuceneLocks") || Constants.JAVA_1_1;
如果用户注册�?disableLuceneLocks"属性且为false�Q?span style="color: red">或�?/span>JAVA的版本是1.1则无法��用锁�?br />
static FSDirectory getDirectory(String path, boolean create)
static FSDirectory getDirectory(File file, boolean create)
从得��C��个指定�\径或者文件的FSDirectory如果在则取出�Q�如果不存在则用其私有的构造函数构造一�?br /> 该类�q�有3个非static的类变量
private File directory = null;      索引目录
private int refCount;                   锁目�?br /> private File lockDir;                    索引目录数目
实际上，初始化一个FSDirectory只需要初始化�q?个变量即�?br /> 如果create的��gؓtrue 则：如果索引目录是已�l�存在的目录�Q�则会遍历该目录然后删除每一个文�Ӟ��如果锁目录是已存在的也会用list�q�回所有的文�g然后调用file.delete() 删除�?如果目录不存在则创徏一个新的�?br />
注意�Q�list()�Ҏ(gu��)��   会先用文件名�q�行排序然后�q�回�Q�a.txt会比b.txt先返回）    且delete�Ҏ(gu��)��删除文�g�Ҏ(gu��)��Q�只能删除空文�g夏V��如果失败则跛_��E�序�Q�不会删除在该文件夹之后�q�回的文件。（如果有aa.txt , ab/b.txt , b.txt �Q?则删除时候由于a文�g多w��I�删除失败，则b.txt�׃��前面删除��p�|跛_��E�序�Q�也不会被删�?但是aa.txt被正常删除）

private FSDirectory(File path, boolean create) throws IOException
�U�有的构造函�?br />
private synchronized void create() throws IOException
创徏新的directory /lockDir目录�Q�当目录已存在时��x��I��目录�Q�不存在卛_��建新的目录�?br />
final String[] list() throws IOException
以字�W�串文�g名的形式�q�回索引目录的所有文�?br />
final boolean fileExists(String name) throws IOException
在烦引目录是否存在指定文件名的文�?br />
final long fileModified(String name) throws IOException
static final long fileModified(File directory, String name)
�q�回该文件的最后修�Ҏ(gu��)��_��directory参数为相对�\径，�W�一个函数的相对路径为烦引目�?br />
void touchFile(String name) throws IOException
��该文�g的最后修�Ҏ(gu��)��间设�|��ؓ当前旉��

final long fileLength(String name) throws IOException
�q�回该文件的长度

final void deleteFile(String name) throws IOException
删除该文�?br />
final synchronized void renameFile(String from, String to) throws IOException
重命名该文�g
该方法会首先��新的文件名命名的文件是否已�l�存在如果存在即删除该文�Ӟ��然后再将文�g重新命名为新的文件名�?br /> doug cutting在该�Ҏ(gu��)��的注释上写到�Q?br /> 1.删除操作和重命名的操作不是原子的�?br /> 2.重命名操作在有些虚拟��Z��面不能正��的工作�Q�如果重命名��p�|则会采用手动copy的方法。��用输入输出流��旧的文件的内容写入到新的文件中去，然后删除旧的文�g�?br /> 注意�Q�该�Ҏ(gu��)��必须是同步的�?br />
final OutputStream createFile(String name) throws IOException
用指定的文�g名创��Z��个新的可写的�I�文�?nbsp; 实际上返回的是FSOutputStream,注意�q�里的OutputStream�q�不是java的基��c�R��而是doug cutting自己写的一个文仉��卌��问类。同理FSInputStream和InputStream也是Lucene自己的类�?br />
final InputStream openFile(String name) throws IOException
从一个存在的文�g打开一个输入流

getLockPrefix()
在FSDirectory中还�?br /> private static MessageDigest DIGESTER;�q�个静态变量是提供加密功能�?br /> DIGESTER=MessageDigest.getInstance("MD5"),-----MD5加密��法
或者可以DIGESTER=MessageDigest.getInstance("SHA"),-----SHA加密��法
用于寚w��目录�?nbsp; 文�g名的加密
用法如下�Q?br /> digest = DIGESTER.digest(dirName.getBytes()); dirName是需要被加密的字�W�串�Q�这里是索引文�g的目录名�Q?br /> 在FSContext中，其应用在 getLockPrefix() 该方法是为某个烦引目录创建其对应的锁目录文�g名�?br /> 首先�q�回�l�过加密后的byte[] 数组digest�Q�然后将digest按照�?个bit转化��Z��?6�q�制的字�W�，存进一个StringBuffer�?br /> 其�{化类��g��Base64�~�码方式�Q�不�q�要��单得多�?br />
�Ҏ(gu��)��
Lockl makeLock�Q�String name�Q?br /> 是从Directory中扩展而来的，该方法返回一个Lock对象�Q�该对象��会在介�l�完Lucene的输入输出流之后介绍�?br /> 该方法比较简单，首先是调用了getLockPrefix() �Ҏ(gu��)��Q�返回文仉��的部分对象名�Q�然后在该名�U�后面加上锁的特征名
譬如说读写锁事务�?
其名�U�类��g��下：
lucene-12c90c2c381bc7acbc4846b4ce97593b-write.lock
lucene-12c90c2c381bc7acbc4846b4ce97593b-commit.lock
�q�两�U�锁机制��会在后面介�l?br /> 最后通过一个匿名的内部�c�返回一个经�q�重载的Lock对象�Q�该内部�c�M��的方法有锁的创徏�Q�得刎ͼ�释放�Q�以及检��，另外�q�有一个toString()�Ҏ(gu��)��q�回锁的名称�?br />

在FSDirectory�c�M��有OutputStream和InputStream的实现类�Q�这两个虚类只是定义了一些操作，�q�没有定义输入或者输出的讑֤��?br /> Lucene在输入输出的设计上，��会由子�c�d��义输入输出的讑֤��?br /> FSOutputStream
在FSOutputStream中有一�?RandomAccess File=new RandomAccessFile(path, "rw");
在对该输出流的操作将用调用该file的相应方法实�?br /> 最重要�?br /> public final void flushBuffer(byte[] b, int size) throws IOException {
    file.write(b, 0, size);
}
flushBuffer的调用将会将byte中的0--size范围的数据写入到文�gpath中去�?br />

FSInputStream
最重要�?br /> protected final void readInternal(byte[] b, int offset, int len)
       throws IOException {
    synchronized (file) {
      long position = getFilePointer();     //得到该当前文件指�?br />       if (position != file.position) {
        file.seek(position);
        file.position = position;
      }
      int total = 0;
      do {

   //从文件中��d��指定长度的字节到字节数组
   // 在其基类InputStream中的refill()�Ҏ(gu��)�� 会调用 readInternal(buffer, 0, bufferLength);首先从文件中��d��字节到缓冲数�l��?br /> // 在InputStream中每�ơ读取操作都会调用readInternal�Ҏ(gu��)��Q�或者通过refill()�Ҏ(gu��)��间接调用该方法�?br />         int i = file.read(b, offset+total, len-total);       //��文件中的数据读到缓冲区
        if (i == -1)
          throw new IOException("read past EOF");
        file.position += i;
        total += i;
      } while (total < len);
    }
}

晓宇 2008-04-10 21:35 发表评论

org.apache.lucene.document.DateField

晓宇 — Thu, 10 Apr 2008 11:26:00 GMT

该类提供了日期和字符串之间的�怺�转化�Q�实际上�?long型和String型的�怺�转化�Q��{化时用到了一个不常用�?br /> Long.toString(long,int);�Ҏ(gu��)��。是按指定的方式对long型进行�{�?br /> �W�一个参数是要�{化的long,�W�二个参数是转化时候的基数�Q�如果基数是10��q��当于�Ҏ(gu��)��Long.toString(long);
�q�里使用的参数是最大��|��?6== 10个数�?26个英文字母。这栯��{化出来的字符串长度比较短�Q�占用比较少的空��_��
另外�Q�在转化�Ӟ��l�一了�{化后的字�W�串长度�Q�如果不��?位（日期的long转化后最高�ؓ9位，1970之后的日期可正确转换�Q�，
�l�一长度后的字符串可以通过比较字符串来比较日期的大��?br />

日期转化成的字符串类��g��
0fev8eza3
本来应该是fev8eza3 采取了不��?位补0的方法�?br />
private static int DATE_LEN = Long.toString(1000L*365*24*60*60*1000,
Character.MAX_RADIX).length();
计算��Z��1970�q�开始后1000�q�的旉��转化为字�W�串后的长度�Q�所有�{化后的时间都不应��过�q�个长度�Q�如果不��_��在前面补0

可以通过字符串�{化�ؓ日期的函数计��出能表�C�的最大日期�ؓ
stringToTime("zzzzzzzzz");
打印出来�?Fri Apr 22 19:04:28 CST 5188
所以该函数能�{化的日期范围�?1970-1-1~~5188-4-22

日期转化为字�W�串
public static String timeToString(long time)

字符串�{化�ؓ日期
public static long stringToTime(String s)

实际�?函数 LongToString(long i,int radix) 相当�?nbsp; 先将i转化为radix�q�制的整敎ͼ�然后再用函数
LongToString(i)转化为字�W�串。所以radix的值应该在2--36之间如果不是则按�?0�q�制计算�?br />

晓宇 2008-04-10 19:26 发表评论

org.apache.lucene.document.Document

晓宇 — Tue, 08 Apr 2008 12:27:00 GMT

Document是一些Field的集合，每个Field有一个名字和文本��|��当中的某些Field可能会随着Documnet被存储。这��P��每个Document应该臛_��包含一个可以唯一标示它的被存储的Field

//Field集合
List fields = new Vector();
//增强因子�Q�作用于该Document的所有Field
private float boost = 1.0f;
//向Document中添加Field
public final void add(Field field) {
fields.add(field);
}
//删除指定名称的第一个Field
public final void removeField(String name)
//删除所有拥有指定名�U�的Field
public final void removeFields(String name)
//得到指定名称的第一个Field
public final Field getField(String name)
//以数�l�的形式�q�回指定名称的所有Field
public final Field[] getFields(String name)
//得到所有Field的一个枚�?br /> public final Enumeration fields()

该类也重载了toString()�Ҏ(gu��)��
打印出所有Field的信�?br />

晓宇 2008-04-08 20:27 发表评论

晓宇 — Tue, 08 Apr 2008 12:07:00 GMT

package org.apache.lucene.document;
Field
是Document的一部分�Q�每个Field有两个部分组�?名字-�?�?名字是String �?可以是String �?Reader�Q�如果是KeyWord�c�d��的Field�Q�那么值将不会被进一步处理，像URL�Q�Date�{�等。Field被存储在Index中，以便于能以Hits的�Ş式返回原有的Document
Field�? 个Boolean形的标识
private boolean isStored = false;     被存�?nbsp;
private boolean isIndexed = true;    被烦�?br /> private boolean isTokenized = true 被分�?br /> 通过调整�q?个boolean的��|��可以��定该Field的类�?br /> Keyword     true, true, false           一般存�?URL DATE �{�关键字
UnIndexed   true, false, false          一般是随HITS查询�l�果一赯��回的信息
Text              true, true, true
UnStored      false, true, true

另外�Q�还有一个重载的toString�Ҏ(gu��)�� 可以打印��Field的类�?br />
float boost = 1.0f;    增强因子�Q�用于排序的评分�Q�作用于拥有该域(field)的所有文�?document)

晓宇 2008-04-08 20:07 发表评论