//在DirectoryReader中有一下函式。

public boolean isCurrent() throws CorruptIndexException, IOException { 
  return SegmentInfos.readCurrentVersion(directory) == segmentInfos.getVersion(); 
}

IndexWriter writer = new IndexWriter(FSDirectory.open(INDEX_DIR), new StandardAnalyzer(Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED); 
writer.setUseCompoundFile(false); 
indexDocs(writer, docDir);//docDir中只有兩篇文件

//文件一為：Students should be allowed to go out with their friends, but not allowed to drink beer.

//文件二為：My friend Jerry went to school to see his students but found them drunk which is not allowed.

writer.commit();//提交兩篇文件，形成_0段。

writer.deleteDocuments(new Term("contents", "school"));//刪除文件二 
writer.commit();//提交刪除，形成_0_1.del 
indexDocs(writer, docDir);//再次索引兩篇文件，Lucene不能判別文件與文件的不同，因而算兩篇新的文件。 
writer.commit();//提交兩篇文件，形成_1段 
writer.deleteDocuments(new Term("contents", "school"));//刪除第二次新增的文件二 
writer.close();//提交刪除，形成_1_1.del

IndexWriter.applyDeletes()

-> DocumentsWriter.applyDeletes(SegmentInfos)

     -> reader.deleteDocument(doc);

IndexWriter.commit()

-> IndexWriter.applyDeletes()

    -> IndexWriter$ReaderPool.release(SegmentReader)

         -> SegmentReader(IndexReader).commit()

             -> SegmentReader.doCommit(Map)

                  -> SegmentInfo.advanceDelGen()

                       -> if (delGen == NO) { 
                              delGen = YES; 
                           } else { 
                              delGen++; 
                           }

IndexWriter writer = new IndexWriter(FSDirectory.open(INDEX_DIR), new StandardAnalyzer(Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED); 
writer.setUseCompoundFile(false);

indexDocs(writer, docDir);//索引兩篇文件，一篇包含"school"，另一篇包含"beer" 
writer.commit();//提交兩篇文件到索引檔案，形成段(Segment) "_0" 
writer.deleteDocuments(new Term("contents", "school"));//刪除包含"school"的文件，其實是刪除了兩篇文件中的一篇。 
writer.commit();//提交刪除到索引檔案，形成"_0_1.del" 
writer.deleteDocuments(new Term("contents", "beer"));//刪除包含"beer"的文件，其實是刪除了兩篇文件中的另一篇。 
writer.commit();//提交刪除到索引檔案，形成"_0_2.del" 
indexDocs(writer, docDir);//索引兩篇文件，和上次的文件相同，但是Lucene無法區分，認為是另外兩篇文件。 
writer.commit();//提交兩篇文件到索引檔案，形成段"_1" 
writer.deleteDocuments(new Term("contents", "beer"));//刪除包含"beer"的文件，其中段"_0"已經無可刪除，段"_1"被刪除一篇。 
writer.close();//提交刪除到索引檔案，形成"_1_1.del"

形成的索引檔案如下：

      IndexWriter writer = new IndexWriter(FSDirectory.open(INDEX_DIR), new StandardAnalyzer(Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED); 
      writer.setUseCompoundFile(false);

    
      indexDocs(writer, docDir); 
      writer.flush();

//flush生成segment "_0"，並且flush函式中，flushDocStores設為false，也即下個段將同本段共享域和詞向量資訊，這時DocumentsWriter中的docStoreSegment= "_0"。

      indexDocs(writer, docDir); 
      writer.commit();

//commit生成segment "_1"，由於上次flushDocStores設為false，於是段"_1"的域以及詞向量資訊是儲存在"_0"中的，在這個時刻，段"_1"並不生成自己的"_1.fdx"和"_1.fdt"。然而在commit函式中，flushDocStores設為true，也即下個段將單獨使用新的段來儲存域和詞向量資訊。然而這時，DocumentsWriter中的docStoreSegment= "_1"，也即當段"_2"儲存其域和詞向量資訊的時候，是存在"_1.fdx"和"_1.fdt"中的，而段"_1"的域和詞向量資訊卻是存在"_0.fdt"和"_0.fdx"中的，這一點非常令人困惑。 如圖writer.commit的時候，_1.fdt和_1.fdx並沒有形成。

      indexDocs(writer, docDir); 
      writer.flush();

//段"_2"形成，由於上次flushDocStores設為true，其域和詞向量資訊是新建立一個段儲存的，卻是儲存在_1.fdt和_1.fdx中的，這時候才產生了此二檔案。

      indexDocs(writer, docDir); 
      writer.flush();

//段"_3"形成，由於上次flushDocStores設為false，其域和詞向量資訊是共享一個段儲存的，也是是儲存在_1.fdt和_1.fdx中的

      indexDocs(writer, docDir); 
      writer.commit();

//段"_4"形成，由於上次flushDocStores設為false，其域和詞向量資訊是共享一個段儲存的，也是是儲存在_1.fdt和_1.fdx中的。然而函式commit中flushDocStores設為true，也意味著下一個段將新建立一個段儲存域和詞向量資訊，此時DocumentsWriter中docStoreSegment= "_4"，也表明了雖然段"_4"的域和詞向量資訊儲存在了段"_1"中，將來的域和詞向量資訊卻要儲存在段"_4"中。此時"_4.fdx"和"_4.fdt"尚未產生。   

      indexDocs(writer, docDir); 
      writer.flush();

//段"_5"形成，由於上次flushDocStores設為true，其域和詞向量資訊是新建立一個段儲存的，卻是儲存在_4.fdt和_4.fdx中的，這時候才產生了此二檔案。

      indexDocs(writer, docDir); 
      writer.commit(); 
      writer.close();

//段"_6"形成，由於上次flushDocStores設為false，其域和詞向量資訊是共享一個段儲存的，也是是儲存在_4.fdt和_4.fdx中的

讀取此檔案格式參考SegmentInfos.read(Directory directory, String segmentFileName):

• int format = input.readInt();
• version = input.readLong(); // read version
• counter = input.readInt(); // read counter
• for (int i = input.readInt(); i > 0; i--) // read segmentInfos
  • add(new SegmentInfo(directory, format, input));
    • name = input.readString();
    • docCount = input.readInt();
    • delGen = input.readLong();
    • docStoreOffset = input.readInt();
    • docStoreSegment = input.readString();
    • docStoreIsCompoundFile = (1 == input.readByte());
    • hasSingleNormFile = (1 == input.readByte());
    • int numNormGen = input.readInt();
    • normGen = new long[numNormGen];
    • for(int j=0;j
    • normGen[j] = input.readLong();
  • isCompoundFile = input.readByte();
  • delCount = input.readInt();
  • hasProx = input.readByte() == 1;
  • diagnostics = input.readStringStringMap();

• userData = input.readStringStringMap();
• final long checksumNow = input.getChecksum();
• final long checksumThen = input.readLong();

public static final String ID_PAYLOAD_FIELD = "_ID";

public static final String ID_PAYLOAD_TERM = "_ID";

public static final Term ID_TERM = new Term(ID_PAYLOAD_TERM, ID_PAYLOAD_FIELD);

//宣告一個特殊的TokenStream，它只生成一個詞(Term)，就是那個特殊的詞，在特殊的域裡面。

static class SinglePayloadTokenStream extends TokenStream { 
    private Token token; 
    private boolean returnToken = false;

    SinglePayloadTokenStream(String idPayloadTerm) { 
        char[] term = idPayloadTerm.toCharArray(); 
        token = new Token(term, 0, term.length, 0, term.length); 
    }

    void setPayloadValue(byte[] value) { 
        token.setPayload(new Payload(value)); 
        returnToken = true; 
    }

    public Token next() throws IOException { 
        if (returnToken) { 
            returnToken = false; 
            return token; 
        } else { 
            return null; 
        } 
    } 
}

//對於每一篇文件，都讓它包含這個特殊的詞，在特殊的域裡面

SinglePayloadTokenStream singlePayloadTokenStream = new SinglePayloadTokenStream(ID_PAYLOAD_TERM); 
singlePayloadTokenStream.setPayloadValue(long2bytes(id)); 
doc.add(new Field(ID_PAYLOAD_FIELD, singlePayloadTokenStream));

long id = 0; 
TermPositions tp = reader.termPositions(ID_PAYLOAD_TERM); 
boolean ret = tp.skipTo(docID); 
tp.nextPosition(); 
int payloadlength = tp.getPayloadLength(); 
byte[] payloadBuffer = new byte[payloadlength]; 
tp.getPayload(payloadBuffer, 0); 
id = bytes2long(payloadBuffer); 
tp.close();

FieldInfos.read(IndexInput, String)

• int firstInt = input.readVInt();
• size = input.readVInt();
• for (int i = 0; i < size; i++)
  • String name = input.readString();
  • byte bits = input.readByte();
  • boolean isIndexed = (bits & IS_INDEXED) != 0;
  • boolean storeTermVector = (bits & STORE_TERMVECTOR) != 0;
  • boolean storePositionsWithTermVector = (bits & STORE_POSITIONS_WITH_TERMVECTOR) != 0;
  • boolean storeOffsetWithTermVector = (bits & STORE_OFFSET_WITH_TERMVECTOR) != 0;
  • boolean omitNorms = (bits & OMIT_NORMS) != 0;
  • boolean storePayloads = (bits & STORE_PAYLOADS) != 0;
  • boolean omitTermFreqAndPositions = (bits & OMIT_TERM_FREQ_AND_POSITIONS) != 0;

Document FieldsReader.doc(int n, FieldSelector fieldSelector)

• long position = indexStream.readLong();//indexStream points to ".fdx"
• fieldsStream.seek(position);//fieldsStream points to "fdt"
• int numFields = fieldsStream.readVInt();
• for (int i = 0; i < numFields; i++)
  • int fieldNumber = fieldsStream.readVInt();
  • byte bits = fieldsStream.readByte();
  • boolean compressed = (bits & FieldsWriter.FIELD_IS_COMPRESSED) != 0;
  • boolean tokenize = (bits & FieldsWriter.FIELD_IS_TOKENIZED) != 0;
  • boolean binary = (bits & FieldsWriter.FIELD_IS_BINARY) != 0;
  • if (binary)
    • int toRead = fieldsStream.readVInt();
    • final byte[] b = new byte[toRead];
    • fieldsStream.readBytes(b, 0, b.length);
    • if (compressed)
      • int toRead = fieldsStream.readVInt();
      • final byte[] b = new byte[toRead];
      • fieldsStream.readBytes(b, 0, b.length);
      • uncompress(b),
  • else
    • fieldsStream.readString()

TermVectorsReader.get(int docNum, String field, TermVectorMapper)

• int fieldNumber = fieldInfos.fieldNumber(field);//通過field名字得到field號
• seekTvx(docNum);//在tvx檔案中按docNum文件號找到相應文件的項
• long tvdPosition = tvx.readLong();//找到tvd檔案中相應文件的偏移量
• tvd.seek(tvdPosition);//在tvd檔案中按偏移量找到相應文件的項
• int fieldCount = tvd.readVInt();//此文件包含的域的個數。
• for (int i = 0; i < fieldCount; i++) //按域號查詢域
  • number = tvd.readVInt();
  • if (number == fieldNumber)
    • found = i;
• position = tvx.readLong();//在tvx中讀出此文件的第一個域在tvf中的偏移量
• for (int i = 1; i <= found; i++)
  • position += tvd.readVLong();//加上所要找的域在tvf中的偏移量
• tvf.seek(position);
• int numTerms = tvf.readVInt();
• byte bits = tvf.readByte();
• storePositions = (bits & STORE_POSITIONS_WITH_TERMVECTOR) != 0;
• storeOffsets = (bits & STORE_OFFSET_WITH_TERMVECTOR) != 0;
• for (int i = 0; i < numTerms; i++)
  • start = tvf.readVInt();
  • deltaLength = tvf.readVInt();
  • totalLength = start + deltaLength;
  • tvf.readBytes(byteBuffer, start, deltaLength);
  • term = new String(byteBuffer, 0, totalLength, "UTF-8");
  • if (storePositions)
    • positions = new int[freq];
    • int prevPosition = 0;
    • for (int j = 0; j < freq; j++)
      • positions[j] = prevPosition + tvf.readVInt();
      • prevPosition = positions[j];
  • if (storeOffsets)
    • offsets = new TermVectorOffsetInfo[freq];
    • int prevOffset = 0;
    • for (int j = 0; j < freq; j++)
    • int startOffset = prevOffset + tvf.readVInt();
    • int endOffset = startOffset + tvf.readVInt();
    • offsets[j] = new TermVectorOffsetInfo(startOffset, endOffset);
    • prevOffset = endOffset;