Java instruction switch de multiples cas

Malheureusement, il n'est pas possible en Java. Vous devrez recourir à l'aide de if-else consolidés.

Peut-être pas aussi élégant que certaines réponses précédentes, mais si vous voulez atteindre le commutateur de cas avec quelques grandes plages, il vous suffit de combiner les plages pour un seul cas à l'avance:

//make a switch variable so as not to change the original value
int switchVariable = variable;

//combine range 1-100 to one single case in switch
if(1 <= variable && variable <=100)
    switchVariable = 1;
switch (switchVariable) 
{ 
    case 0:
        break; 
    case 1:
        //range 1-100
        doSomething(); 
        break;
    case 101: 
        doSomethingElse(); 
        break;
    etc.
} 

Un Objet Orienté option pour remplacer les trop grandes switch et if/else constructions est d'utiliser un Chain of Responsibility Pattern le modèle de la prise de décision.

Modèle chaîne de Responsabilité

Le modèle chaîne de responsabilité
permet la séparation de la source de
une demande de décider qui de la
potentiellement un grand nombre de gestionnaires d'
de la demande devraient action. L'
classe représentant la chaîne de rôle
les canaux de la demande à partir de la source
le long de la liste des maîtres-chiens jusqu'à ce qu'un
gestionnaire accepte la demande et
les mesures qu'il.

Voici un exemple de mise en œuvre qui est également de Type Coffre-fort à l'aide de médicaments Génériques.

import java.util.ArrayList;
import java.util.List;
/**
* Generic enabled Object Oriented Switch/Case construct
* @param <T> type to switch on
*/
public class Switch<T extends Comparable<T>>
{
private final List<Case<T>> cases;
public Switch()
{
this.cases = new ArrayList<Case<T>>();
}
/**
* Register the Cases with the Switch
* @param c case to register
*/
public void register(final Case<T> c) { this.cases.add(c); }
/**
* Run the switch logic on some input
* @param type input to Switch on
*/
public void evaluate(final T type)
{
for (final Case<T> c : this.cases)
{
if (c.of(type)) { break; }
}
}
/**
* Generic Case condition
* @param <T> type to accept
*/
public static interface Case<T extends Comparable<T>>
{
public boolean of(final T type);
}
public static abstract class AbstractCase<T extends Comparable<T>> implements Case<T>
{
protected final boolean breakOnCompletion;
protected AbstractCase()
{
this(true);
}
protected AbstractCase(final boolean breakOnCompletion)
{
this.breakOnCompletion = breakOnCompletion;
}
}
/**
* Example of standard "equals" case condition
* @param <T> type to accept
*/
public static abstract class EqualsCase<T extends Comparable<T>> extends AbstractCase<T>
{
private final T type;
public EqualsCase(final T type)
{
super();
this.type = type;
}
public EqualsCase(final T type, final boolean breakOnCompletion)
{
super(breakOnCompletion);
this.type = type;
}
}
/**
* Concrete example of an advanced Case conditional to match a Range of values
* @param <T> type of input
*/
public static abstract class InRangeCase<T extends Comparable<T>> extends AbstractCase<T>
{
private final static int GREATER_THAN = 1;
private final static int EQUALS = 0;
private final static int LESS_THAN = -1;
protected final T start;
protected final T end;
public InRangeCase(final T start, final T end)
{
this.start = start;
this.end = end;
}
public InRangeCase(final T start, final T end, final boolean breakOnCompletion)
{
super(breakOnCompletion);
this.start = start;
this.end = end;
}
private boolean inRange(final T type)
{
return (type.compareTo(this.start) == EQUALS || type.compareTo(this.start) == GREATER_THAN) &&
(type.compareTo(this.end) == EQUALS || type.compareTo(this.end) == LESS_THAN);
}
}
/**
* Show how to apply a Chain of Responsibility Pattern to implement a Switch/Case construct
*
* @param args command line arguments aren't used in this example
*/
public static void main(final String[] args)
{
final Switch<Integer> integerSwitch = new Switch<Integer>();
final Case<Integer> case1 = new EqualsCase<Integer>(1)
{
@Override
public boolean of(final Integer type)
{
if (super.type.equals(type))
{
System.out.format("Case %d, break = %s\n", type, super.breakOnCompletion);
return super.breakOnCompletion;
}
else
{
return false;
}
}
};
integerSwitch.register(case1);
//more instances for each matching pattern, granted this will get verbose with lots of options but is just
//and example of how to do standard "switch/case" logic with this pattern.
integerSwitch.evaluate(0);
integerSwitch.evaluate(1);
integerSwitch.evaluate(2);
final Switch<Integer> inRangeCaseSwitch = new Switch<Integer>();
final Case<Integer> rangeCase = new InRangeCase<Integer>(5, 100)
{
@Override
public boolean of(final Integer type)
{
if (super.inRange(type))
{
System.out.format("Case %s is between %s and %s, break = %s\n", type, this.start, this.end, super.breakOnCompletion);
return super.breakOnCompletion;
}
else
{
return false;
}
}
};
inRangeCaseSwitch.register(rangeCase);
//run some examples
inRangeCaseSwitch.evaluate(0);
inRangeCaseSwitch.evaluate(10);
inRangeCaseSwitch.evaluate(200);
//combining both types of Case implementations
integerSwitch.register(rangeCase);
integerSwitch.evaluate(1);
integerSwitch.evaluate(10);
}
}

C'est un simple homme de paille que je fouettée, en quelques minutes, une version plus sophistiquée de la mise en œuvre pourrait permettre une sorte de Command Pattern à être injectés dans le Case implémentations cas pour la rendre plus d'un appel de retour Cio style.

Une fois la bonne chose à propos de cette approche est que le Commutateur de Cas, les états sont tous sur les effets secondaires, cela résume les effets secondaires dans les Classes de sorte qu'ils peuvent être gérés, et ré-utilisés mieux, il finit par n'être plus comme le Modèle Correspondant dans un langage Fonctionnel et qui n'est pas une mauvaise chose.

Je vais poster des mises à jour ou des améliorations de ce Gist sur Github.

Selon cette question, il est tout à fait possible.

Il suffit de mettre tous cas qui contiennent la même logique d'ensemble, et ne pas mettre break derrière eux.

switch (var) {
case (value1):
case (value2):
case (value3):
//the same logic that applies to value1, value2 and value3
break;
case (value4):
//another logic
break;
}

C'est parce que case sans break de passer à un autre case jusqu'à break ou return.

EDIT:

Répondre au commentaire, si vraiment nous avons 95 les valeurs avec la même logique, mais d'une manière plus petit nombre de cas, avec une logique différente, nous pouvons faire:

switch (var) {
case (96):
case (97):
case (98):
case (99):
case (100):
//your logic, opposite to what you put in default.
break;
default: 
//your logic for 1 to 95. we enter default if nothing above is met. 
break;
}

Si vous avez besoin d'un contrôle plus précis, if-else est le choix.

Il est possible de gérer cela à l'aide de Vavr bibliothèque

import static io.vavr.API.*;
import static io.vavr.Predicates.*;
Match(variable).of(
Case($(isIn(5, 6, ... , 100)), () -> doSomething()),
Case($(), () -> handleCatchAllCase())
);

Bien sûr ce n'est qu'une légère amélioration depuis tous les cas, doivent être indiqués explicitement. Mais il est facile de définir un prédicat:

public static <T extends Comparable<T>> Predicate<T> isInRange(T lower, T upper) {
return x -> x.compareTo(lower) >= 0 && x.compareTo(upper) <= 0;
}
Match(variable).of(
Case($(isInRange(5, 100)), () -> doSomething()),
Case($(), () -> handleCatchAllCase())
);

Match est une expression donc, ici, il renvoie à quelque chose comme Runnable exemple au lieu d'invoquer des méthodes directement. Après match est effectuée Runnable peut être exécutée.

Pour plus de détails, veuillez voir la documentation officielle.

À partir de la dernière java-12 la libération de plusieurs constantes dans le même cas l'étiquette est disponible dans aperçu de fonctionnalité

Il est disponible dans un JDK version de fonctionnalités pour provoquer développeur rétroaction basée sur l'utilisation du monde réel; cela peut devenir permanente dans un avenir Java SE Platform.

Il ressemble:

switch(variable) {
case 1 -> doSomething();
case 2, 3, 4 -> doSomethingElse();
};

Voir plus JEP 325: Commutateur Expressions (Extrait)