Java instruction switch pour gérer les deux variables?

Je suis à la recherche d'un moyen de gérer les deux chaînes à l'aide d'un commutateur unique, je pense que c'est impossible dans Java.

Voici le pseudo-code le genre de chose que je veux réaliser avec un seul interrupteur.

    int s1Value = 0;
    int s2Value = 0;
    String s1 = "a";
    String s2 = "g";
    switch (s1 || s2) {
         case "a": s1value = 0; s2value = 0; break;
         case "b": s1value = 1; s2value = 1; break;
         case "c": s1value = 2; s2value = 2; break;
         case "d": s1value = 3; s2value = 3; break;
         case "e": s1value = 4; s2value = 4; break;
         case "f": s1value = 5; s2value = 5; break;
         case "g": s1value = 6; s2value = 6; break;
    }

s1 et s2 ne sont pas String !
Je pense que vous ne comprenez pas la changer la syntaxe..
Je copie et collé à la mauvaise partie 🙂 Édité...
Quelles sont les valeurs que peut s1 et s2 prendre ?
Vous êtes en attribuant la même valeur pour les deux variables, dans tous les cas.. pourquoi ne pas simplement attribuer un, et faire s2value égal à s1value?

OriginalL'auteur Ciphor | 2013-03-05

8

À l'aide d'un simple commutateur selon votre condition n'est pas possible.
C'est aussi proche que vous allez obtenir à l'aide de Java.
```
    switch (s1)  {
        case "a":  doAC(); break;
        case "b":  doBD(); break;
        default:
            switch(s2) {
                case "c":  doAC(); break;
                case "d":  doBD(); break;
            }
   }        
```
Voir qui était ce que j'étais en évitant, comme je l'ai peut ainsi juste deux interrupteurs séparés, un pour chaque Corde :/
Deux interrupteurs séparés pour provoque des bugs dans votre code, car doAC() ou doBD() sera appelée deux fois. Vous avez besoin d'utiliser imbriqués les commutateurs comme je l'ai indiqué.
Si il n'est pas possible comme tu le dis, je vais avoir à rêve du jour où je peux utiliser une expression booléenne que l'instruction switch 🙂
Aussi oui, je vois que maintenant, merci pour cette remarque!
Pas besoin d'en rêver. Vue jcp.org

OriginalL'auteur Java42
4

La seule façon de le faire avec un seul interrupteur est d'abord de fusionner les deux valeurs, trouver celui avec la plus haute priorité, et l'application de la passer à la suite. Dans votre exemple, le minimum de s1 et s2, et de la commutation sur le résultat.

Depuis "a" à "g" en sont un exemple, vous aurez besoin d'avoir une certaine façon de classer les vraies valeurs de la première.

OriginalL'auteur Emerson Farrugia

Avez-vous envisagé de ne pas utiliser la commutateur déclaration, mais plutôt en utilisant des tables?

public class MyClass {
    private static final Map<String, Integer> valuesMap;

    static {
         Map<String,Integer> aMap = new HashMap<>();
         aMap.put("a", 0);
         aMap.put("b", 1);
              ..... rest .....
         valuesMap = Collections.unmodifiableMap(aMap);
    }

    public void foo()
    {
       int s1Value = 0;
       int s2Value = 0;

       String s1 = "a";
       String s2 = "g";
       if( valuesMap.containsKey(s1) )
       {
          s1Value = valuesMap.get(s1);
          s2Value = s1Value;
       }
       else if( valuesMap.contansKey(s2) )
       {
          s1Value = valuesMap(s2);
          s2Value = s1Value;
       }
    }
}

Si vous avez besoin d'un autre ensemble de valeurs de la s2Value ensuite, vous pouvez construire une deuxième carte à tirer de ceux de.

Depuis que vous avez voulu utiliser un commutateur je prends ça pour dire que le des candidats possibles et les valeurs est un fixe, connu au temps de développement de liste, à l'aide d'un statiquement initialisé la carte comme cela ne devrait pas être un problème.

OriginalL'auteur Jere

1

Vous pouvez faire ce que vous voulez sans l'aide d'un interrupteur, il suffit d'écrire que:
```
s1value = s1.charAt(0)-'a'; //returns 0 if s1value="a", 1 if s1value="b", etc.
```
Ce que je ne comprends pas complètement de ce que tu veux dire avec
```
(s1 || s2)
```
Voulez-vous faire quelque chose comme cela?
```
  int s1Value = 0;
  int s2Value = 0;

  String s1 = "g";
  String s2 = "a";

  char s1char = s1.charAt(0);
  char s2char = s2.charAt(0);
  int myChar = Math.max(s1char, s2char);
  s1Value = s2Value = myChar - 'a';
```
Mise à JOUR

Dans les commentaires, vous avez écrit:

s1="g" et s2="g" avant d'entrer dans le commutateur, puis le seul cas qui procédera à l'évaluation de vrai, c'est le cas "g" et donc, à la fois s1Value et s2Value deviendra 6 et puis la sortie de l'interrupteur.

Donc, je pense que vous êtes en train de dire que s1 et s2 sont initialisés avec la même valeur, donc:
```
  int s1Value = 0;
  int s2Value = 0;

  String s1 = "g";
  String s2 = "g";

  char s1char = s1.charAt(0);
  s1Value = s2Value = s1char - 'a'; //s1Value = s2Value = 6
```
Cela devrait faire ce que vous voulez

Mise à JOUR 2

avec s1="a" et s2="d" nous considérons le cas "a", avec s1="c" et s2="b" nous considérons le cas "b"

Essayez ceci:
```
  int s1Value = 0;
  int s2Value = 0;

  String s1 = "g";
  String s2 = "a";

  char s1char = s1.charAt(0);
  char s2char = s2.charAt(0);
  int myChar = Math.min(s1char, s2char);
  s1Value = s2Value = myChar - 'a';
```
Il devrait faire l'affaire, d'essai et laissez-moi savoir si cela fonctionne

Rien à voir avec de la traversée de la Chaîne, je veux simplement vérifier dans chaque cas si s1 OU s2 est vrai et puis effectuer certaines déclarations si elle est.
s1 et s2 ne peut pas être vrai ou faux, , car ils sont des Chaînes de caractères et non des booléens, donc, fondamentalement, vous ne pouvez pas vérifier si une chaîne est vrai ou faux. Dites-moi, lorsque votre chaîne être vrai, et quand doit-il être faux?
Bien cas "g" c'est comme dire que si(s1.equals("g") || s2.equals("g")) dans mon pseudo.
donc votre "ou" dans le commutateur est en ce sens que les deux chaîne doit contenir la même valeur?
Non, c'est une logique OU si l'une des Chaînes est "g" l'affaire "g" sera exécuté?

OriginalL'auteur BackSlash

Vous devez vous connecter pour publier un commentaire.