In this example of a custom Analyzer, we will assume we are
indexing text in English. Our PorterStemAnalyzer will perform
Porter stemming on its input. As stated by its creator, the
Porter stemming algorithm (or "Porter stemmer") is a process for removing the
more common morphological and inflexional endings from words in English. Its main
function is to be part of a term normalization process that is usually done
when setting up Information Retrieval systems.

This Analyzer will use an implementation of the Porter stemming
algorithm provided by Lucene's PorterStemFilter class.

The tokenStream(Reader) method is the core of the
PorterStemAnalyzer. It lower-cases input, eliminates stop words,
and uses the PorterStemFilter to remove common morphological and
inflexional endings. This class includes only a small set of stop words for
English. When using Lucene in a production system for indexing and searching
text in English, I suggest that you use a more complete list of stop words,
such as this one.

To use our new PorterStemAnalyzer class, we need to modify a
single line of our LuceneIndexExample class shown above, to
instantiate PorterStemAnalyzer instead of
StandardAnalyzer:

Old line:

Analyzer analyzer = new StandardAnalyzer();

New line:

Analyzer analyzer = new PorterStemAnalyzer();

The rest of the code remains unchanged. Anything indexed after this change
will pass through the Porter stemmer. The process of text indexing with
PorterStemAnalyzer is depicted in Figure 1.

Figure 1: The indexing process with PorterStemAnalyzer.

Because different Analyzers process their text input
differently, note again that changing the Analyzer for an existing
index is dangerous. It will result in erroneous search results later, in the
same way that using a different Analyzer for both indexing and
searching will produce invalid results.

Lucene offers four different types of fields from which a developer can
choose: Keyword, UnIndexed, UnStored,
and Text. Which field type you should use depends on how you want
to use that field and its values.

Keyword fields are not tokenized, but are indexed and stored
in the index verbatim. This field is suitable for fields whose original value
should be preserved in its entirety, such as URLs, dates, personal names,
Social Security numbers, telephone numbers, etc.

UnIndexed fields are neither tokenized nor indexed, but their
value is stored in the index word for word. This field is suitable for fields
that you need to display with search results, but whose values you will never
search directly. Because this type of field is not indexed, searches against
it are slow. Since the original value of a field of this type is stored in the
index, this type is not suitable for storing fields with very large values, if
index size is an issue.

UnStored fields are the opposite of UnIndexed fields.
Fields of this type are tokenized and indexed, but are not stored in the index.
This field is suitable for indexing large amounts of text that does not need to
be retrieved in its original form, such as the bodies of Web pages, or any
other type of text document.

Text fields are tokenized, indexed, and stored in the index.
This implies that fields of this type can be searched, but be cautious about
the size of the field stored as Text field.

If you look back at the LuceneIndexExample class, you will see
that I used a Text field:

document.add(Field.Text("fieldname", text));

If we wanted to change the type of field "fieldname," we would call one of
the other methods of class Field:

document.add(Field.Keyword("fieldname", text));

or

document.add(Field.UnIndexed("fieldname", text));

or

document.add(Field.UnStored("fieldname", text));

Although the Field.Text, Field.Keyword, Field.UnIndexed, and
Field.UnStored calls may at first look like calls to constructors, they are
really just calls to different Field class methods. Table 1
summarizes the different field types.

In this article, we have learned about adding basic text indexing
capabilities to your applications using IndexWriter and its associated
classes. We have also developed a custom Analyzer that can
perform Porter stemming on its input. Finally, we have looked at different
field types and learned what each of them can be used for. In the next article
of this Lucene series, we shall look at indexing in more depth, and address
issues such as performance and multi-threading.