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 AutoCompleteTextView, android tutorial.

Here are part of my codes, ignore the Badrul.class they will be changed later.

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.AutoCompleteTextView;
import android.widget.Toast;

public class Search extends Activity
{
    public void onCreate(Bundle savedInstanceSate)
    {
        final AutoCompleteTextView autoComplete;
        super.onCreate(savedInstanceSate);
        setContentView(R.layout.searchshop);

        autoComplete = (AutoCompleteTextView) findViewById(R.id.autoCompleteTextView1);
        ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, R.layout.list_item, shops);
        autoComplete.setAdapter(adapter); 
        autoComplete.setThreshold(1);
        autoComplete.setOnItemClickListener(new OnItemClickListener()
        {
        @Override
        public void onItemClick(AdapterView<?> arg0, View arg1, int position, long arg3) 
        {
            int index=999;
            for(int i=0;i<shops.length;i++)
            {
                if(autoComplete.getText().toString().trim().equals(shops[i]))
                {
                    index=i;
                    break;
                }
            }

                switch(index)
                {
                case 0:
                    startActivity(new Intent(Search.this, Adidas.class));
                    break;

                case 1:
                    startActivity(new Intent(Search.this, Affin.class));
                    break;
                case 2:
                    startActivity(new Intent(Search.this, AlamArt.class));
                    break;
                case 3:
                    startActivity(new Intent(Search.this, AlAmin.class));
                    break;
                case 4:
                    startActivity(new Intent(Search.this, Anakku.class));
                    break;
                case 5:
                    startActivity(new Intent(Search.this, Anggerik.class));
                    break;
                case 6:
                    startActivity(new Intent(Search.this, Asiari.class));
                    break;
                case 7:
                    startActivity(new Intent(Search.this, AsterSpring.class));
                    break;
                case 8:
                    startActivity(new Intent(Search.this, Audrey.class));
                    break;
                case 9:
                    startActivity(new Intent(Search.this, Badrul.class));
                    break;
                case 10:
                    startActivity(new Intent(Search.this, Badrul.class));
                    break;
                case 11:
                    startActivity(new Intent(Search.this, Badrul.class));
                    break;
                default:
                    Toast.makeText(Search.this, "Invalid Selection", Toast.LENGTH_SHORT).show();
                }
            }
            });

        }
static final String[] shops = new String[]
            {
                "Adidas", "Affin Bank ATM", "Alam Art Gallery", "Al Amin Kids", "Anakku", "Anggerik", "Asiari", 
                "Aster Spring", "Audrey", "Badrul Songket", "Bata"};
}

Answer 1

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 2

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.