The gyst of it was that you shouldn’t use a List[T] for containment-lookup with a long list of elements, since the execution time will be proportional to the size of the list (and will require creation of an iterator.

Instead, use a Set[T], which has constant-time performance and doesn’t create a new iterator for every containment-lookup.

The ArrayList.contains() method will create an iterator and then walk the entire collection to find the value. Although the code looks nicer than the huge block of if/else statements, the performance won’t be any better. It’s fundamentally an O(n) algorithm.

Instead, create a HashSet[String].

The HashSet.contains method doesn’t create an iterator. And it doesn’t perform comparisons against every value in the collection. Instead of suffering through O(n) performance, you’ll enjoy O(1) performance. Hooray!

Here’s the code:

public static final Set[String] STREAM_ACTION_SET = new HashSet[String](11)
{
add(ACTION_CREATE_STREAM);
add(ACTION_DELETE_STREAM);
add(ACTION_RELEASE_STREAM);
add(ACTION_PUBLISH);
add(ACTION_PLAY);
add(ACTION_SEEK);
add(ACTION_PAUSE);
add(ACTION_PAUSE_RAW);
add(ACTION_CLOSE_STREAM);
add(ACTION_RECEIVE_VIDEO);
add(ACTION_RECEIVE_AUDIO);
}
};

// …

if (STREAM_ACTION_SET.contains(action)) {
// LARGE SETS ARE FASTER THAN LARGE LISTS
// FOR CHECKING VALUE CONTAINMENT!!!!!!
}

Enum naming always confuses me, since I tend to think of enums as collections. However, much like classes, enums are actually types, whereas their values (e.g. ACTION_CREATE_STREAM etc.) are equivalent to instances of that type.

Therefore, it is always best to use singular names rather than plural, as in the examples given by Sun in the introductory docs (http://java.sun.com/j2se/1.5.0/docs/guide/language/enums.html).

The enum should look like this:

public enum StreamActions {
ACTION_CREATE_STREAM(“string1″),
ACTION_DELETE_STREAM(“string2″),
ACTION_RELEASE_STREAM(“string3″),
ACTION_PUBLISH(“string4″),
ACTION_PLAY(“string5″),
ACTION_SEEK(“string6″),
ACTION_PAUSE(“string7″),
ACTION_PAUSE_RAW(“string8″),
ACTION_CLOSE_STREAM(“string9″),
ACTION_RECEIVE_VIDEO(“string10″),
ACTION_RECEIVE_AUDIO(“string11″);

protected String actionString;

StreamActions(String actionString) {
this.actionString = actionString;
}

public String getString() {
return actionString;
}
}

Your if statement can then be replaced with:

switch(action) {
case ACTION_CREATE_STREAM:
case ACTION_DELETE_STREAM:
case ACTION_RELEASE_STREAM:
case ACTION_PUBLISH:
case ACTION_PLAY:
case ACTION_SEEK:
case ACTION_PAUSE:
case ACTION_PAUSE_RAW:
case ACTION_CLOSE_STREAM:
case ACTION_RECEIVE_VIDEO:
case ACTION_RECEIVE_AUDIO:
//do something
}

However, I just had to go through some code on something weŕe working on and move everything back to the old form, because the code in question was so hot, that the implicit creation, use and destruction of a Java iterator in the ArrayList.contains(…) method was a performance bottleneck for us.

Now, like I said, 99 out of 100 times, the ArrayList method is better. But do measure