Vous utilisez l'instruction switch avec une plage de valeurs dans chaque cas?

En Java, est-il possible d'écrire une instruction switch où chaque cas contient plus d'une valeur? Par exemple (bien que clairement le code suivant ne fonctionnera pas):

switch (num) {
    case 1 .. 5:
        System.out.println("testing case 1 to 5");
        break;
    case 6 .. 10:
        System.out.println("testing case 6 to 10");
        break;
}

Je pense que cela peut être fait en Objective C, y a-t-il une chose similaire en Java? Ou devrais - je utiliser simplement if, des else ifdéclarations à la place?

Java n'a rien de ce genre. Pourquoi ne pas faire ce qui suit?

public static boolean isBetween(int x, int lower, int upper) {
  return lower <= x && x <= upper;
}

if (isBetween(num, 1, 5)) {
  System.out.println("testing case 1 to 5");
} else if (isBetween(num, 6, 10)) {
  System.out.println("testing case 6 to 10");
}

Le plus proche de ce type de comportement avec des switchdéclarations est

switch (num) {
case 1:
case 2:
case 3:
case 4:
case 5:
     System.out.println("1 through 5");
     break;
case 6:
case 7:
case 8:
case 9:
case 10:
     System.out.println("6 through 10");
     break;
}

Utilisez des ifdéclarations.

une autre alternative consiste à utiliser l'opération mathématique en la divisant, par exemple:

switch ((int) num/10) {
    case 1:
        System.out.println("10-19");
        break;
    case 2:
        System.out.println("20-29");
        break;
    case 3:
        System.out.println("30-39");
        break;
    case 4:
        System.out.println("40-49");
        break;
    default:
        break;
}

Mais, comme vous pouvez le voir, cela ne peut être utilisé que lorsque la plage est fixe dans chaque cas.

Je ne pense pas que vous puissiez faire cela en Java. Le mieux est de simplement mettre le code dans le dernier cas de la plage.

switch (num) {
  case 1: case 2: case 3: case 4: case 5: 
     System.Out.Println("testing case 1 to 5");
     break;
  case 6: case 7: case 8: case 9: case 10:
     System.Out.Println("testing case 6 to 10");
     break;
  default:
     //
}

  case 1: case 2: case 3: case 4: case 5: 
         System.out.println("testing case 1 to 5");
         break;
  case 6: case 7: case 8: case 9: case 10:
         System.out.println("testing case 6 to 10");
         break;
  default:
         System.out.println("default"); 

Je sais que cet article est ancien mais je pense que cette réponse mérite une certaine reconnaissance. Il n'est pas nécessaire d'éviter l'instruction switch. Cela peut être fait en java mais via l'instruction switch, pas les cas. Il s'agit d'utiliser des opérateurs ternaires.

public class Solution {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = Integer.parseInt(sc.nextLine());

        switch ((1 <= num && num <= 5 ) ? 0 :
                (6 <= num && num <= 10) ? 1 : 2) {

            case 0:
                System.out.println("I'm between one and five inclusive.");
                break;
            case 1:
                System.out.println("I'm between 6 and 10 inclusive.");
                break;
            case 2:
                System.out.println("I'm not between one and five or 6 and 10 inclusive.");
                break;
        }
    }
}

Ou vous pouvez utiliser vos cas solo comme prévu et utiliser votre cas par défaut pour spécifier les instructions de plage comme:

switch(n) {
    case 1 : System.out.println("case 1"); break;
    case 4 : System.out.println("case 4"); break;
    case 99 : System.out.println("case 99"); break;
    default :
        if (n >= 10 && n <= 15)
            System.out.println("10-15 range"); 
        else if (n >= 100 && n <= 200)
            System.out.println("100-200 range");
        else
            System.out.println("Your default case");
        break;   
}

Essayez ceci si vous devez utiliser switch.

public static int range(int num){ 
    if ( 10 < num && num < 20)
        return 1;
    if ( 20 <= num && num < 30)
        return 2;
    return 3;
}

public static final int TEN_TWENTY = 1;
public static final int TWENTY_THIRTY = 2;

public static void main(String[]args){
    int a = 110;
    switch (range(a)){
        case TEN_TWENTY: 
            System.out.println("10-20"); 
            break;
        case TWENTY_THIRTY: 
            System.out.println("20-30"); 
            break;
        default: break;
    }
}

Non, vous ne pouvez pas faire ça. Le mieux que vous puissiez faire est que

case 1:
case 2:
case 3:
case 4:
case 5: 
  System.Out.Println("testing case 1 to 5");
break;

Il est possible de regrouper plusieurs conditions dans une même caseinstruction en utilisant le mécanisme de chute autorisé par les instructions switch, il est mentionné dans le tutoriel Java et entièrement spécifié dans la section §14.11. La déclaration switch de la spécification du langage Java .

L'extrait de code suivant est tiré d'un exemple du didacticiel, il calcule le nombre de jours de chaque mois (numérotés du mois 1 au mois 12):

switch (month) {
    case 1: case 3: case 5:
    case 7: case 8: case 10:
    case 12:
        numDays = 31;
        break;
    case 4: case 6:
    case 9: case 11:
        numDays = 30;
        break;
    case 2:
        if (((year % 4 == 0) && 
             !(year % 100 == 0))
             || (year % 400 == 0))
            numDays = 29;
        else
            numDays = 28;
        break;
    default:
        System.out.println("Invalid month.");
        break;
}

Comme vous pouvez le voir, pour couvrir une plage de valeurs dans une seule caseinstruction, la seule alternative est de lister chacune des valeurs possibles individuellement, l'une après l'autre. Comme exemple supplémentaire, voici comment implémenter le pseudocode dans la question:

switch(num) {
    case 1: case 2: case 3: case 4: case 5:
        System.out.println("testing case 1 to 5");
        break;
    case 6: case 7: case 8: case 9: case 10:
        System.out.println("testing case 6 to 10");
        break;
}

Vous pouvez utiliser un enumpour représenter vos plages,

public static enum IntRange {
  ONE_TO_FIVE, SIX_TO_TEN;
  public boolean isInRange(int v) {
    switch (this) {
    case ONE_TO_FIVE:
      return (v >= 1 && v <= 5);
    case SIX_TO_TEN:
      return (v >= 6 && v <= 10);
    }
    return false;
  }

  public static IntRange getValue(int v) {
    if (v >= 1 && v <= 5) {
      return ONE_TO_FIVE;
    } else if (v >= 6 && v <= 10) {
      return SIX_TO_TEN;
    }
    return null;
  }
}

Il est pris en charge à partir de Java 12. Consultez JEP 354 . Pas de possibilité de «gamme» ici, mais peut être utile non plus.

switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> System.out.println(6);//number of letters
    case TUESDAY                -> System.out.println(7);
    case THURSDAY, SATURDAY     -> System.out.println(8);
    case WEDNESDAY              -> System.out.println(9);
}

Vous devriez également pouvoir l'implémenter sur ints. Notez que votre instruction switch doit être exhaustive (en utilisant un defaultmot clé ou en utilisant toutes les valeurs possibles dans les instructions case).

Voici une manière magnifique et minimaliste d'aller

(num > 1 && num < 5) ? first_case_method() 
                     : System.out.println("testing case 1 to 5")
                     : (num > 5 && num < 7)  ? System.out.println("testing case 5 to 7") 
                     : (num > 7 && num < 8)  ? System.out.println("testing case 7 to 8") 
                     : (num > 8 && num < 9)  ? System.out.println("testing case 8 to 9") 
                     : ... 
                     : System.out.println("default");

La réponse de @missingfaktor est en effet correcte mais un peu trop compliquée. Le code est plus détaillé (au moins pour des intervalles continus) qu'il pourrait l'être, et nécessite des surcharges / casts et / ou un paramétrage pour long, float, Integer, etc.

if (num < 1)
    System.Out.Println("invalid case: " + num); // you should verify that anyway
else if (num <= 5)
    System.Out.Println("1 to 5");
else if (num <= 10)
    System.Out.Println("6 to 10");
else if (num <= 42)
    System.Out.Println("11 to 42");
else    
    System.Out.Println("43 to +infinity");

Utilisez une NavigableMapimplémentation, comme TreeMap.

/* Setup */
NavigableMap<Integer, Optional<String>> messages = new TreeMap<>();
messages.put(Integer.MIN_VALUE, Optional.empty());
messages.put(1, Optional.of("testing case 1 to 5"));
messages.put(6, Optional.of("testing case 6 to 10"));
messages.put(11, Optional.empty());

/* Use */
messages.floorEntry(3).getValue().ifPresent(System.out::println);

Pour numéro d'entrée dans la plage 0..100

int n1 = 75; // input value
String res; int n=0; 
int[] a ={0,20,35,55,70,85,101};

for(; n1>=a[n]; n++);
switch(6-n+1) {
  case 1: res="A"; break;
  case 2: res="B"; break;
  case 3: res="C"; break;
  case 4: res="D"; break;
  case 5: res="E"; break;
  default:res="F";
}
System.out.println(res);

Ce type de comportement n'est pas pris en charge en Java. Cependant, si vous avez un grand projet qui en a besoin, envisagez de mélanger du code Groovy dans votre projet. Le code Groovy est compilé en code octet et peut être exécuté avec JVM. L'entreprise pour laquelle je travaille utilise Groovy pour écrire des classes de service et Java pour tout écrire.