java交换机案例的最大实现？

Question

我使用的是一个开关箱，它将有100多个箱被使用。有限制吗

案例的使用是为了我的安卓教程AutoCompleteTextView的建议

这是我的部分代码，忽略Badrul。课程内容将在以后更改

import 安卓.app.Activity;
import 安卓.content.Intent;
import 安卓.os.Bundle;
import 安卓.view.View;
import 安卓.widget.AdapterView;
import 安卓.widget.AdapterView.OnItemClickListener;
import 安卓.widget.ArrayAdapter;
import 安卓.widget.AutoCompleteTextView;
import 安卓.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

在实施开关时，可以对性能进行许多优化，否则必须列出所有开关，直到匹配为止

我在这里要做的是，为第一个字符设置一组主要的开关，然后在其中嵌套开关，因此如果选择z，则不必首先循环检查每个名称

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

        }
break;

case B://do the same
}

另一种方法是将switch语句分解为大小相等的较小语句。由于字节码的编译方式（参考Java性能调优-shirazi），这会更快

Answer 2

对最大方法长度有一个限制：Maximum size of a method in java?

否则，作为一个示例，一个switch包含1000个形式的案例

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

似乎有效。生成的字节码使用^{}指令，这意味着它甚至不应该是低效的

当然，除非它是自动生成的代码，否则这将是不受欢迎的

考虑其他选择，例如：

• 值的映射/数组（如果您的案例只是返回或生成某种值）
• 将运行必要代码的对象的映射/数组（取决于具体条件，这样可能会得到更少的代码）

编辑：

看看您的代码，似乎因为您的所有case语句都运行完全相同类型的代码，所以您只需要一个由index访问的Class[]，类似于：

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

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

当然，如果有一种方法以其他方式生成这些类会更好，比如说，如果您有Adidas和Affin对象，并且在它们上运行getClass()，或者如果您有它们的名称列表并且可以使用^{}

Answer 3

或者你可以看看战略模式。例如：

如果现在看起来像这样：

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

您可以使用以下策略模式重构它：

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

快乐编码！ 戴夫

Answer 4

一种可能的方法是将代码移动/重新建模为责任链模式，因为这些开关语句不是简单的返回，需要对它们进行一些处理，等等

我相信您也没有番石榴系列的用例（换句话说，您有一个描述一个的用例，而不是两个（多个）用例的通用处理

Answer 5

开关可以很好地处理byte、short、char和int。因此您有int值+默认值的限制。从here

但我建议更多地考虑建筑。最好组织一些接口“执行者”，并实现一些执行者（可以作为内部类）。然后，您只需要有一个数组（映射），其中包含此执行者的条件和实例。其思想是将数据与算法分离

你也可以试着找到其他的模式

Answer 6

在您达到Java施加的任何限制之前，代码将变得不可管理

你考虑过重构代码吗？根据switch语句的设计目的，您可以：

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

因此，在您的情况下，最好将静态Map索引值定义为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();
      }
    }
    ...
  }

这使得onItemClick()中的代码更易于阅读。您可以更进一步，定义一个私有的startActivity()方法，该方法获取要使用的索引并包含所有switch语句替换代码