sentencia switch

hola quisiera saber si en una sentencia switch
puedo hacer esto:

Switch (expresion[contador]

case: ("+" or " * " or "/") and ( "1" or "2")
{
haga algo
}

donde expresion es una cadena string y contador un ciclo para ir recorriendo la cadena.

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de ezamudio

no

En Java 7 creo que ya podrás usar cadenas en switch, pero hoy en día solamente con tipos numéricos. Y de todas maneras no se puede lo de expresión y contador.

En qué lenguaje es válido eso?

En java se "podría" hacer

En java se "podría" hacer algo como esto:

String [] expression = // un arreglo con expresiones de algun lado
int contador = n;//
switch( expression[contador].charAt(0) ) {
   case '+':
   case '*':
   case '/':
        switch( expresion[contador].charAt(1)) {
              case '1':
              case '2':
                 System.out.println("Fue ('+' or ' * ' or '/') and ( '1' or '2') ");
          }
}

Pero no quiere decir que sea buena idea. Lo que se está haciendo ahí es revisar si el primer caracter es el simbolo y si el segundo es 1 o 2

Esto mismo se puede hacer con una expresion regular

Así:

/^[+*/][12]$/

Y se lee exactamente como lo necesitas:

El primer caracter es + o * o / y el segundo es o 1 o 2

Aquí te va un ejemplo completo usando ambas, el switch y la expresion regular.

class A {
    public static void main( String ... args ) {

        String [] expression =  args ;// un arreglo con expresiones de algun lado
        for( int contador = 0 ; contador < expression.length ; contador++ ) {
            switch( expression[contador].charAt(0) ) {
                case '+':
                case '*':
                case '/':
                    switch( expression[contador].charAt(1)) {
                        case '1':
                        case '2':
                            System.out.println("Fue [+*/][12] ");
                            break;
                       default: System.out.println("Era + * o / pero no 1 o 2");
                    }
                    break;
                default: System.out.println("Errr!!");
            }
            // O se puede usar una expresion regular:
            if( expression[contador].matches("[+*/][12]") ) {
              System.out.println("Si cumplio");
            } else {
              System.out.println("No cumplio");
           }
        }
    }
}

Sale así:

$java A +1
Fue [+*/][12]
Si cumplio
$java A *1
Fue [+*/][12]
Si cumplio
$java A "/1"
Fue [+*/][12]
Si cumplio
$java A +2
Fue [+*/][12]
Si cumplio
$java A +3
Era + * o / pero no 1 o 2
No cumplio
$java A *3
Era + * o / pero no 1 o 2
No cumplio

La ventaja de la expresion regular es que puedes fácilmente ( cuando ya las dominas ) modificarla y por ejemplo ignorar los espacios en blanco:

[+*/]\s*[12]

Eso dice lo mismo que lo anterior, pero además dice que puede haber 0 o más espacios en blanco.

Lo siguiente sigue funcionando con esa regexp  + 1 y  *        2

P.D. Si necesitas evaluar expresiones aritméticas, un simple switch no te va a bastar. Tienes que hacer algo más complejo ( aunque no tanto )

Este es el primer link que encontré:

http://www.ibm.com/developerworks/library/j-w3eval/index.html