String .contains VS Set .contains VS Regex String.matches()

Question

I have two sets of strings which are not very long (200~500 words) in two files which looks like this:

File1          File2

this           window
that           good
word           work
java           fine
book           home

All unique words.

Now First read the strings from file (line-by-line) and store them in:

1. Set<String> set1 Set<String> set2: That may looks like this: [this, that, word, java, book] and [window, good, work, fine, home]

Or

2. String str1 String str2: That may looks like this: str1: thisthatwordjava and str2: windowgoodworkfinehome OR can be str1: this,that,word,java (separated by comma).

Now there are three ways to check the word home in which Set or String will be present:

1. To use set1/2.contains("home")
2. To use str1/2.contains("home")
3. To use str1/2.matches("home")

All of the above will work fine, but which one the BEST one

Note: The purpose of this question is because the frequency of checking for string is very high.

Answer 1

Don't Make Performance Assumptions

What makes you think that String.contains will have "better performance"?

It won't, except for very simple cases, that is if:

• your list of strings is short,
• the strings to compare are short,
• you want to do a one-time lookup.

For all other cases, the Set approach will scale and work better. Sure you'll have a memory overhead for the Set as opposed to a single string, but the O(1) lookups will remain constant even if you want to store millions of strings and compare long strings.

The Right Data-Structure and Algorithm for the Right Job

Use the safer and more robust design, especially as here it's not a difficult solution to implement. And as you mention that you will check frequently, then a set approach is definitely better for you.

Also, String.contain will be unsafe, as if your both have matching strings and substrings your lookups will fail. As kennytm said in a comment, if we use your example, and you have the "java" string in your list, looking up "ava" will match it, which you apparently don't want.

Pick the Right Set

You may not want to use the simple HashSet or to tweak its settings though. For instance, you could consider a Guava ImmutableSet, if your set will be created only once but checked very often.

Examples

Here's what I'd do, assuming you want an immutable set (as you say you read the list of strings from a file). This is off-hand and without verification so forgive the lack of ceremonies.

Using Java 8 + Guava

import com.google.common.collect.ImmutableSet;
import com.google.common.io.Files;
import com.google.common.base.Splitter;

final Set<String> lookupTable = ImmutableSet.copyOf(
  Splitter.on(',')
    .trimResults()
    .omitEmptyStrings()
    .split(Files.asCharSource(new File("YOUR_FILE_PATH"), Charsets.UTF_8).read())
);

Season to taste with correct path, correct charset, and with or without trimming if you want to allow spaces and an empty string.

Using Only Java 8

If you don't want to use Guava and only vanilla Java, then simply do something like this in Java 8 (again, apologies, untested):

final Set<String> lookupTable =
    Files.lines(Paths.get("YOUR_FILE_PATH"))
      .map(line -> line.split(",+"))
      .map(Arrays::stream)
      .collect(toSet());

Using Java < 8

If you have Java < 8, then use the usual FileInputStream to read the file, then String.split[] or StringTokenizer to extract an array, and finally add the array entries into a Set.

Answer 2

I guess you read the line(s) of the file into a String anyway, so splitting it and storing the substrings in a set isn't more optimal if you plan only one query.

Answer 3

If you want to know something about performence differences. Simply measure it. Here is a test setting for you.

final int WORDS = 10000;
final int SEARCHES = 1000000;

Set<String> strSet = new TreeSet<String>();
String strStr = "";
int[] searches = new int[SEARCHES];
Random randomGenerator = new Random();

// filling set and string
for(int i = 0; i < WORDS; i++){
    strSet.add(String.valueOf(i));
    strStr += "," + String.valueOf(i);
}

// creating searches
for(int i = 0; i < SEARCHES; i++)
    searches[i] = randomGenerator.nextInt(WORDS);

// measure set
long startTime = System.currentTimeMillis();
for(int i = 0; i < SEARCHES; i++)
    strSet.contains(String.valueOf(searches[i]));
System.out.println("set result " + (System.currentTimeMillis() - startTime));

// measure string
startTime = System.currentTimeMillis();
for(int i = 0; i < SEARCHES; i++)
    strStr.contains(String.valueOf(searches[i]));
System.out.println("string result " + (System.currentTimeMillis() - startTime));

For me the output is a meaningful proof that you should stay with a Set

set result 350
string result 14197

Answer 4

Set should take more memory space but less execution time if given the word without comas (which can be done with a simple split)

but what i really think is the best way is the experimental proof System.currentTimeMillis()