Switch cases maximum implementation?

Question

I am using a single switch cases which will have more than 100 cases statement to be used. Are there any limit ?

The usage of cases are for the suggestions of my Aut

Answer 1

When implementing switches many optimisations can be made for performance, otherwise you have to list through all the switches till it matches.

What I would do here, is have a main set of switches for the first character then nested switches inside, therefore if the choice was z it doesn't have to loop check every name first

switch(FIRSTCHAR){
case A: switch(index){
        case 0: ..... break;
        etc

        }
break;

case B://do the same
}

Another way is to break your switch statement up into smaller equal sized statements. This is faster due the way the bytecode is compiled (ref Java performance tuning - shirazi)

Answer 2

The code will become unmanageable before you hit any limit that Java imposes.

Have you considered refactoring the code? Depending on what the switch statement is designed to achieve you could either:

• Use a map to provide different results
• Create a hierarchy of simple objects that give the behaviour you require for each case

So in your case, you would be better off defining a static Map of index values to Classes:

public class MyClass
{
    private static final Map<Integer, Class> LOOKUP = 
      new HashMap<Integer, Class>(...);
    static
    {
      LOOKUP.put(0, Adidas.class);
      LOOKUP.put(1, Affin.class);
      ...
    }

    public void onItemClick(...)
    {
      ...
      // Replace switch statement with:
      if (LOOKUP.containsKey(index))
      {
        startActivity(new Intent(Search.this, LOOKUP.get(index)));
      }
      else
      { 
        Toast.makeText(Search.this, 
                       "Invalid Selection", 
                       Toast.LENGTH_SHORT).show();
      }
    }
    ...
  }

This makes the code in onItemClick() easier to read. You could go one step further and define a private startActivity() method that takes the index to be used and contains all the switch statement replacement code.

Answer 3

There is a limit imposed on the maximum method length: Maximum size of a method in java?

Otherwise, as an example, a switch with 1000 cases of the form

casen: System.out.println(n); break;

seems to work. The generated bytecode uses a tableswitch instruction, which means it shouldn't even be inefficient.

Of course, unless it's automatically generated code, this will be frowned upon.

Think of alternatives, such as:

• a map/array of values (if your cases just return or produce a value of some kind);
• a map/array of objects that will run the necessary code (depending on the exact conditions, you might end up with less code this way).

Edit:

Looking at your code, it seems, since all your case statements run the exact same type of code, all you need is a Class[] accessed by index, something like:

Class[] myArray = new Class[...];
myArray[0] = Adidas.class;
//...

//instead of the switch
startActivity(new Intent(Search.this, myArray[index])); 

And of course, it would be prettier if there were a way to produce those classes some other way, say if you had Adidas and Affin objects, and you ran getClass() on them, or if you had a list of their names and could use Class.forName.

Answer 4

I don't know exactly what your startActivity() method do, don't even know how the Intent object is implemented, but I think an alternative way to solve your issue could be:

• Define a super-class or interface called Shop (for example);
• Inherit all your classes like Adidas or Affin from it;
• Call the specific implementation of startActivity() method for each class;

For example:

public interface Shop
{
    void startActivity(Intent i);
}

Then, for each class...

public class Adidas implements Shop
{
    public Adidas(){
        // ...
    }

    public void startActivity(Intent i)
    {
        // specific implementation
    }
}

Finally, in your client code

Shop[] shops = new Shop[]{ new Adidas(), new Affin(), ... };

for (Shop shop : shops)
{
   shop.startActivity(new Intent(Search.this));
}

Answer 5

One possibel appraoch is to move/remodel that code to "Chain of Responsibility patter given that those switch statements are not simple return, some processing is involved on them and so on.

I believe you dont have use case of Guava Ranges too (In other words you are having each case a descret one, not a common processing on two (more than one) case.

Answer 6

Or you can have a look at the strategy pattern. For example:

If it looks like this now:

switch (calculation type)
{
   case: Fibonacci { ... }
   case: Pithagoras { ... }
   ...
   case 104 : { ... }
}

You can refactor it using the strategy pattern maybe like this:

CalculationStrategy strategy = strategyFactor.getStrategy(calculation type);
strategy.doCalculation;

Happy coding! Dave