Re: switch using strings
Eric Sosman wrote:
1) Pre-compute the hashes of the Strings you care about, assign
those values to `static final int' constants, and then
switch (theString.hashCode()) {
ewwwww
case HASH_OF_ABC: ...
case HASH_OF_XYZ: ...
...
}
2) Pre-populate a Map<String,Integer>, look up the String in the
Map, and switch on the Integer value.
3) Like (2), but use an enum.
4) Use polymorphism: Write a class for each String value, use
Class.forName(theString) to load it, and call one of its
methods reflectively.
5) Combine (2/3) and (4): Pre-populate a Map<String,Handler>,
look up the String value, and call a method of the associated
Handler object. (Reflection not required.)
Dirk: Number 6 is the not-least-bad of the options.
1) and 2) are somewhat bad because they use int and Integer. These are not
self-documenting nor especially durable over time.
3) works for many cases where the universe of strings is relatively small.
4) works well only with 5): Map <String, Class <? extends Handler>>
5) Map <String, Handler> works really well in a lot of situations.
You have to be careful that the Handler instances either are thread-safe
(sometimes a pain to ensure) or used only locally to the object that owns the map.
The reflective version, Map <String, Class <? extends Handler>>, works best if
implementing classes have a no-arg constructor. Then the only reflection you
need is 'Handler handler = handlers.get( foo ).newInstance()' (with associated
try-catch).
Enums are great for the low-branch-width scenario that'd have a person
consider 'switch' statements.
Use the enum's 'valueOf()' method or a custom 'fromString()' (for example, to
allow case insensitivity) to arrive at the switch value.
You'll require tight control of the strings allowed to reach the decision
point, with the enum approach in particular.
--
Lew
Honi soit qui mal y pense.