HomeSearch

Java String Switch Example

Use switch statements on Strings. Benchmark expressions, HashMap and String switches.
String switch. A string has a value (like "cat"). In a switch statement we can select that value and match it. Java supports string switches.Switch
In a string switch, case is important. Lowercase and uppercase letters are not equal. As for performance, a string switch is usually less fast than a HashMap or expression.
Simple example. Here we introduce a logical method that matches the names of moths. I am not a moth expert, but these names are interesting.

Return: The isMoth method returns true if a moth name is detected, and false otherwise.

Return

Default: When no string is matched in the isMoth method, we reach the default case, where false is returned.

Java program that uses string switch public class Program { static boolean isMoth(String value) { // Switch on a string. // ... Match names of some moths. switch (value) { case "Atlas Moth": case "Beet Armyworm": case "Indian Meal Moth": case "Ash Pug": case "Latticed Heath": case "Ribald Wave": case "The Streak": return true; default: return false; } } public static void main(String[] args) { // Test the isMoth method. System.out.println(isMoth("Atlas Moth")); System.out.println(isMoth("atlas moth")); // Case matters. System.out.println(isMoth("Chiloe")); } } Output true false false
Benchmark, string switch. Let us consider the performance of string switches. Here we have two methods, both of which return the same values.

Version 1: IsMoth uses a switch statement to detect the names of moths. It is the same as the first example.

Version 2: IsMothOr uses an expression with string equality and logical ors. It could be written as an if-statement.

If

Version 3: This version of the code uses a HashMap and its containsKey method. The values are added at the start of main.

Result: We find that the expression-based isMothOr performed better than the string switch and the HashMap.

Java program that times string switch, expression, HashMap import java.util.HashMap; public class Program { static boolean isMoth(String value) { switch (value) { case "Atlas Moth": case "Beet Armyworm": case "Indian Meal Moth": case "Ash Pug": case "Latticed Heath": case "Ribald Wave": case "The Streak": return true; default: return false; } } static boolean isMothOr(String value) { return value == "Atlas Moth" || value == "Beet Armyworm" || value == "Indian Meal Moth" || value == "Ash Pug" || value == "Latticed Heath" || value == "Ribald Wave" || value == "The Streak"; } public static void main(String[] args) throws Exception { // Initialize HashMap. HashMap<String, Boolean> hash = new HashMap<>(); hash.put("Atlas Moth", true); hash.put("Beet Armyworm", true); hash.put("Indian Meal Moth", true); hash.put("Ash Pug", true); hash.put("Latticed Heath", true); hash.put("Ribald Wave", true); hash.put("The Streak", true); String[] tests = { "Ribald Wave", "Java", "Beet Armyworm", "Python" }; int max = 100000000; long t1 = System.currentTimeMillis(); // Version 1: switch. for (int i = 0; i < max; i++) { int count = 0; for (String test : tests) { if (isMoth(test)) { count++; } } if (count != 2) { throw new Exception(); } } long t2 = System.currentTimeMillis(); // Version 2: or-expression. for (int i = 0; i < max; i++) { int count = 0; for (String test : tests) { if (isMothOr(test)) { count++; } } if (count != 2) { throw new Exception(); } } long t3 = System.currentTimeMillis(); // Version 3: use HashMap. for (int i = 0; i < max; i++) { int count = 0; for (String test : tests) { if (hash.containsKey(test)) { count++; } } if (count != 2) { throw new Exception(); } } long t4 = System.currentTimeMillis(); // Results. System.out.println(t2 - t1); System.out.println(t3 - t2); System.out.println(t4 - t3); } } Output 1236 ms Switch 801 ms Or 2147 ms HashMap
Some comments. For small groups of strings, an expression (with logical ors) is fastest. But when more data are present, we should optimize with a HashMap.

Switch: The string switch is convenient, but in my test it was slower than either the expressions or the HashMap.

Warning: This benchmark has flaws, but isMothOr seems better. Benchmarks are optimized by the JIT compiler, so they can be misleading.

A review. String switches are easy to write in Java. Sadly they do not appear to have a performance edge—expressions and HashMap lookups (with containsKey) tend to be faster.
Home
Dot Net Perls
© 2007-2020 Sam Allen. Every person is special and unique. Send bug reports to info@dotnetperls.com.