public MultiReader(IndexReader[] subReaders) 
{
  
    initialize(subReaders, true);
}

Construct a MultiReader aggregating the named set of (sub)readers. Directory locking for delete, undeleteAll, and setNorm operations is left to the subreaders.

Note that all subreaders are closed if this Multireader is closed.

Parameters:

subReaders - set of (sub)readers

Throws:

IOException -

 public MultiReader(IndexReader[] subReaders,
    boolean closeSubReaders) 
{
    initialize(subReaders, closeSubReaders);
}

Construct a MultiReader aggregating the named set of (sub)readers. Directory locking for delete, undeleteAll, and setNorm operations is left to the subreaders.

Parameters:

closeSubReaders - indicates whether the subreaders should be closed when this MultiReader is closed

subReaders - set of (sub)readers

Throws:

IOException -

 protected synchronized  void doClose() throws IOException 
{
    for (int i = 0; i <  subReaders.length; i++) {
      if (decrefOnClose[i]) {
        subReaders[i].decRef();
      } else {
        subReaders[i].close();
      }
    }
}

 protected  void doCommit() throws IOException 
{
    for (int i = 0; i <  subReaders.length; i++)
      subReaders[i].commit();
}

 protected  void doDelete(int n) throws IOException, CorruptIndexException 
{
    numDocs = -1;                             // invalidate cache
    int i = readerIndex(n);                   // find segment num
    subReaders[i].deleteDocument(n - starts[i]);      // dispatch to segment reader
    hasDeletions = true;
}

 protected  void doSetNorm(int n,
    String field,
    byte value) throws IOException, CorruptIndexException 
{
    synchronized (normsCache) {
      normsCache.remove(field);                         // clear cache
    }
    int i = readerIndex(n);                           // find segment num
    subReaders[i].setNorm(n-starts[i], field, value); // dispatch
}

 protected  void doUndeleteAll() throws IOException, CorruptIndexException 
{
    for (int i = 0; i <  subReaders.length; i++)
      subReaders[i].undeleteAll();
    hasDeletions = false;
    numDocs = -1;                                 // invalidate cache
}

 public int docFreq(Term t) throws IOException 
{
    ensureOpen();
    int total = 0;          // sum freqs in segments
    for (int i = 0; i <  subReaders.length; i++)
      total += subReaders[i].docFreq(t);
    return total;
}

 public Document document(int n,
    FieldSelector fieldSelector) throws IOException, CorruptIndexException 
{
    ensureOpen();
    int i = readerIndex(n);                          // find segment num
    return subReaders[i].document(n - starts[i], fieldSelector);    // dispatch to segment reader
}

 public Collection getFieldNames(IndexReader.FieldOption fieldNames) 
{
    ensureOpen();
    return MultiSegmentReader.getFieldNames(fieldNames, this.subReaders);
}

 IndexReader[] getSubReaders() 
{
    return subReaders;
}

 public TermFreqVector getTermFreqVector(int n,
    String field) throws IOException 
{
    ensureOpen();
    int i = readerIndex(n);        // find segment num
    return subReaders[i].getTermFreqVector(n - starts[i], field);
}

 public  void getTermFreqVector(int docNumber,
    TermVectorMapper mapper) throws IOException 
{
    ensureOpen();
    int i = readerIndex(docNumber);        // find segment num
    subReaders[i].getTermFreqVector(docNumber - starts[i], mapper);
}

 public  void getTermFreqVector(int docNumber,
    String field,
    TermVectorMapper mapper) throws IOException 
{
    ensureOpen();
    int i = readerIndex(docNumber);        // find segment num
    subReaders[i].getTermFreqVector(docNumber - starts[i], field, mapper);
}

 public TermFreqVector[] getTermFreqVectors(int n) throws IOException 
{
    ensureOpen();
    int i = readerIndex(n);        // find segment num
    return subReaders[i].getTermFreqVectors(n - starts[i]); // dispatch to segment
}

 public long getVersion() 
{
    throw new UnsupportedOperationException("MultiReader does not support this method.");
}

Not implemented.

 public boolean hasDeletions() 
{
    // Don't call ensureOpen() here (it could affect performance)
    return hasDeletions;
}

 public boolean hasNorms(String field) throws IOException 
{
    ensureOpen();
    for (int i = 0; i <  subReaders.length; i++) {
      if (subReaders[i].hasNorms(field)) return true;
    }
    return false;
}

 public boolean isCurrent() throws IOException, CorruptIndexException 
{
    for (int i = 0; i <  subReaders.length; i++) {
      if (!subReaders[i].isCurrent()) {
        return false;
      }
    }
    // all subreaders are up to date
    return true;
}

Checks recursively if all subreaders are up to date.

 public boolean isDeleted(int n) 
{
    // Don't call ensureOpen() here (it could affect performance)
    int i = readerIndex(n);                           // find segment num
    return subReaders[i].isDeleted(n - starts[i]);    // dispatch to segment reader
}

 public boolean isOptimized() 
{
    return false;
}

 public int maxDoc() 
{
    // Don't call ensureOpen() here (it could affect performance)
    return maxDoc;
}

 public synchronized byte[] norms(String field) throws IOException 
{
    ensureOpen();
    byte[] bytes = (byte[])normsCache.get(field);
    if (bytes != null)
      return bytes;          // cache hit
    if (!hasNorms(field))
      return fakeNorms();
    bytes = new byte[maxDoc()];
    for (int i = 0; i <  subReaders.length; i++)
      subReaders[i].norms(field, bytes, starts[i]);
    normsCache.put(field, bytes);      // update cache
    return bytes;
}

 public synchronized  void norms(String field,
    byte[] result,
    int offset) throws IOException 
{
    ensureOpen();
    byte[] bytes = (byte[])normsCache.get(field);
    if (bytes==null && !hasNorms(field)) bytes=fakeNorms();
    if (bytes != null)                            // cache hit
      System.arraycopy(bytes, 0, result, offset, maxDoc());
    for (int i = 0; i <  subReaders.length; i++)      // read from segments
      subReaders[i].norms(field, result, offset + starts[i]);
}

 public synchronized int numDocs() 
{
    // Don't call ensureOpen() here (it could affect performance)
    if (numDocs == -1) {        // check cache
      int n = 0;                // cache miss--recompute
      for (int i = 0; i <  subReaders.length; i++)
        n += subReaders[i].numDocs();      // sum from readers
      numDocs = n;
    }
    return numDocs;
}

 public IndexReader reopen() throws IOException, CorruptIndexException 
{
    ensureOpen();
    boolean reopened = false;
    IndexReader[] newSubReaders = new IndexReader[subReaders.length];
    boolean[] newDecrefOnClose = new boolean[subReaders.length];
    boolean success = false;
    try {
      for (int i = 0; i <  subReaders.length; i++) {
        newSubReaders[i] = subReaders[i].reopen();
        // if at least one of the subreaders was updated we remember that
        // and return a new MultiReader
        if (newSubReaders[i] != subReaders[i]) {
          reopened = true;
          // this is a new subreader instance, so on close() we don't
          // decRef but close it 
          newDecrefOnClose[i] = false;
        }
      }
      if (reopened) {
        for (int i = 0; i <  subReaders.length; i++) {
          if (newSubReaders[i] == subReaders[i]) {
            newSubReaders[i].incRef();
            newDecrefOnClose[i] = true;
          }
        }
        MultiReader mr = new MultiReader(newSubReaders);
        mr.decrefOnClose = newDecrefOnClose;
        success = true;
        return mr;
      } else {
        success = true;
        return this;
      }
    } finally {
      if (!success && reopened) {
        for (int i = 0; i <  newSubReaders.length; i++) {
          if (newSubReaders[i] != null) {
            try {
              if (newDecrefOnClose[i]) {
                newSubReaders[i].decRef();
              } else {
                newSubReaders[i].close();
              }
            } catch (IOException ignore) {
              // keep going - we want to clean up as much as possible
            }
          }
        }
      }
    }
}

Tries to reopen the subreaders.
If one or more subreaders could be re-opened (i. e. subReader.reopen() returned a new instance != subReader), then a new MultiReader instance is returned, otherwise this instance is returned.

A re-opened instance might share one or more subreaders with the old instance. Index modification operations result in undefined behavior when performed before the old instance is closed. (see IndexReader#reopen() ).

If subreaders are shared, then the reference count of those readers is increased to ensure that the subreaders remain open until the last referring reader is closed.

 public TermDocs termDocs() throws IOException 
{
    ensureOpen();
    return new MultiTermDocs(subReaders, starts);
}

 public TermPositions termPositions() throws IOException 
{
    ensureOpen();
    return new MultiTermPositions(subReaders, starts);
}

 public TermEnum terms() throws IOException 
{
    ensureOpen();
    return new MultiTermEnum(subReaders, starts, null);
}

 public TermEnum terms(Term term) throws IOException 
{
    ensureOpen();
    return new MultiTermEnum(subReaders, starts, term);
}