public StopFilter(TokenStream input,
    String[] stopWords) 
{
             
    this(input, stopWords, false);
}

Construct a token stream filtering the given input.

 public StopFilter(TokenStream in,
    Set stopWords) 
{
    this(in, stopWords, false);
}

Constructs a filter which removes words from the input TokenStream that are named in the Set.

Also see:

makeStopSet(java.lang.String[])

 public StopFilter(TokenStream in,
    String[] stopWords,
    boolean ignoreCase) 
{
    super(in);
    this.stopWords = (CharArraySet)makeStopSet(stopWords, ignoreCase);
}

Constructs a filter which removes words from the input TokenStream that are named in the array of words.

 public StopFilter(TokenStream input,
    Set stopWords,
    boolean ignoreCase) 
{
    super(input);
    if (stopWords instanceof CharArraySet) {
      this.stopWords = (CharArraySet)stopWords;
    } else {
      this.stopWords = new CharArraySet(stopWords.size(), ignoreCase);
      this.stopWords.addAll(stopWords);
    }
}

Construct a token stream filtering the given input. If stopWords is an instance of CharArraySet (true if makeStopSet() was used to construct the set) it will be directly used and ignoreCase will be ignored since CharArraySet directly controls case sensitivity.

If stopWords is not an instance of CharArraySet , a new CharArraySet will be constructed and ignoreCase will be used to specify the case sensitivity of that set.

Parameters:

input -

stopWords - The set of Stop Words.

ignoreCase - -Ignore case when stopping.

 public boolean getEnablePositionIncrements() 
{
    return enablePositionIncrements;
}

 public static boolean getEnablePositionIncrementsDefault() 
{
    return ENABLE_POSITION_INCREMENTS_DEFAULT;
}

 public static final Set makeStopSet(String[] stopWords) 
{
    return makeStopSet(stopWords, false);
}

Builds a Set from an array of stop words, appropriate for passing into the StopFilter constructor. This permits this stopWords construction to be cached once when an Analyzer is constructed.

 public static final Set makeStopSet(String[] stopWords,
    boolean ignoreCase) 
{
    CharArraySet stopSet = new CharArraySet(stopWords.length, ignoreCase);
    stopSet.addAll(Arrays.asList(stopWords));
    return stopSet;
}

 public final Token next(Token result) throws IOException 
{
    // return the first non-stop word found
    int skippedPositions = 0;
    while((result = input.next(result)) != null) {
      if (!stopWords.contains(result.termBuffer(), 0, result.termLength)) {
        if (enablePositionIncrements) {
          result.setPositionIncrement(result.getPositionIncrement() + skippedPositions);
        }
        return result;
      }
      skippedPositions += result.getPositionIncrement();
    }
    // reached EOS -- return null
    return null;
}

Returns the next input Token whose termText() is not a stop word.

 public  void setEnablePositionIncrements(boolean enable) 
{
    this.enablePositionIncrements = enable;
}

Set to true to make this StopFilter enable position increments to result tokens.

When set, when a token is stopped (omitted), the position increment of the following token is incremented.

Default: see #setEnablePositionIncrementsDefault(boolean) .

 public static  void setEnablePositionIncrementsDefault(boolean defaultValue) 
{
    ENABLE_POSITION_INCREMENTS_DEFAULT = defaultValue;
}

Set the default position increments behavior of every StopFilter created from now on.

Note: behavior of a single StopFilter instance can be modified with #setEnablePositionIncrements(boolean) . This static method allows control over behavior of classes using StopFilters internally, for example StandardAnalyzer .

Default : false.