Java switch statement multiple cases

Question

Just trying to figure out how to use many multiple cases for a Java switch statement  Here s an example of what I m trying to do   switch  variable        case 5  100          doSomething        break      versus having to do   switch  variable        case 5      case 6      etc      case 100          doSomething        break      Any ideas if this possible  or what a good alternative is

User · Answer

It is possible to handle this using Vavr library

import static io.vavr.API.*;
import static io.vavr.Predicates.*;

Match(variable).of(
    Case($(isIn(5, 6, ... , 100)), () -> doSomething()),
    Case($(), () -> handleCatchAllCase())
);

This is of course only slight improvement since all cases still need to be listed explicitly. But it is easy to define custom predicate:

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 is an expression so here it returns something like Runnable instance instead of invoking methods directly. After match is performed Runnable can be executed.

For further details please see official documentation.

User · Answer

Noncompliant Code Example  switch  i      case 1      doFirstThing        doSomething        break    case 2      doSomethingDifferent        break    case 3      Noncompliant  duplicates case 1 s implementation     doFirstThing        doSomething        break    default      doTheRest       if  a  gt   0  amp  amp  a  lt  10      doFirstThing       doTheThing      else if  a  gt   10  amp  amp  a  lt  20      doTheOtherThing      else if  a  gt   20  amp  amp  a  lt  50      doFirstThing      doTheThing        Noncompliant  duplicates first condition   else     doTheRest          Compliant Solution  switch  i      case 1    case 3      doFirstThing        doSomething        break    case 2      doSomethingDifferent        break    default      doTheRest       if   a  gt   0  amp  amp  a  lt  10      a  gt   20  amp  amp  a  lt  50       doFirstThing      doTheThing      else if  a  gt   10  amp  amp  a  lt  20      doTheOtherThing      else     doTheRest

User · Answer

This is possible with switch enhancements in Java 14  Following is a fairly intuitive example of how the same can be achieved  switch  month        case 1  3  5  7  8  10  12 - gt  System out println  quot this month has 31 days quot        case 4  6  9 - gt  System out println  quot this month has 30 days quot        case 2 - gt  System out println  quot February can have 28 or 29 days quot        default - gt  System out println  quot invalid month quot

User · Answer

One alternative instead of using hard-coded values could be using range mappings on the the switch statement instead   private static final int RANGE 5 100   1  private static final int RANGE 101 1000   2  private static final int RANGE 1001 10000   3   public boolean handleRanges int n        int rangeCode   getRangeCode n       switch  rangeCode            case RANGE 5 100     doSomething            case RANGE 101 1000     doSomething            case RANGE 1001 10000     doSomething            default     invalid range          private int getRangeCode int n        if  n  gt   5  amp  amp  n  lt   100            return RANGE 5 100        else if  n  gt   101  amp  amp  n  lt   1000            return RANGE 101 1000        else if  n  gt   1001  amp  amp  n  lt   10000            return RANGE 1001 10000             return -1

User · Answer

The second option is completely fine   I m not sure why a responder said it was not possible   This is fine  and I do this all the time   switch  variable        case 5      case 6      etc      case 100          doSomething        break

User · Answer

One Object Oriented option to replace excessively large switch and if else constructs is to use a Chain of Responsibility Pattern to model the decision making   Chain of Responsibility Pattern     The chain of responsibility pattern   allows the separation of the source of   a request from deciding which of the   potentially large number of handlers   for the request should action it  The   class representing the chain role   channels the requests from the source   along the list of handlers until a   handler accepts the request and   actions it    Here is an example implementation that is also Type Safe using Generics   import java util ArrayList  import java util List         Generic enabled Object Oriented Switch Case construct    param  lt T gt  type to switch on    public class Switch lt T extends Comparable lt T gt  gt        private final List lt Case lt T gt  gt  cases       public Switch                 this cases   new ArrayList lt Case lt T gt  gt                           Register the Cases with the Switch         param c case to register             public void register final Case lt T gt  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 lt T gt  c   this cases                        if  c of type     break                                    Generic Case condition         param  lt T gt  type to accept             public static interface Case lt T extends Comparable lt T gt  gt                public boolean of final T type              public static abstract class AbstractCase lt T extends Comparable lt T gt  gt  implements Case lt T gt                protected final boolean breakOnCompletion           protected AbstractCase                         this true                      protected AbstractCase final boolean breakOnCompletion                        this breakOnCompletion   breakOnCompletion                                  Example of standard  equals  case condition         param  lt T gt  type to accept             public static abstract class EqualsCase lt T extends Comparable lt T gt  gt  extends AbstractCase lt T gt                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  lt T gt  type of input             public static abstract class InRangeCase lt T extends Comparable lt T gt  gt  extends AbstractCase lt T gt                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   amp  amp                       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 lt Integer gt  integerSwitch   new Switch lt Integer gt             final Case lt Integer gt  case1   new EqualsCase lt Integer gt  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 lt Integer gt  inRangeCaseSwitch   new Switch lt Integer gt             final Case lt Integer gt  rangeCase   new InRangeCase lt Integer gt  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              This is just a quick straw man that I whipped up in a few minutes  a more sophisticated implementation might allow for some kind of Command Pattern to be injected into the Case implementations instances to make it more of a call back IoC style   Once nice thing about this approach is that Switch Case statements are all about side affects  this encapsulates the side effects in Classes so they can be managed  and re-used better  it ends up being more like Pattern Matching in a Functional language and that isn t a bad thing   I will post any updates or enhancements to this Gist on Github

User · Answer

public class SwitchTest       public static void main String   args           for int i   0 i lt 10 i                 switch i                   case 1  case 2  case 3  case 4    First case                     System out println  First case                        break                  case 8  case 9    Second case                     System out println  Second case                        break                  default    Default case                     System out println  Default case                        break                                    Out   Default case First case First case First case First case Default case Default case Default case Second case Second case   Src  http   docs oracle com javase tutorial java nutsandbolts switch html

User · Answer

According to this question  it s totally possible   Just put all cases that contain the same logic together  and don t put break behind them   switch  var        case  value1       case  value2       case  value3             the same logic that applies to value1  value2 and value3         break      case  value4             another logic         break      It s because case without break will jump to another case until break or return    EDIT   Replying the comment  if we really have 95 values with the same logic  but a way smaller number of cases with different logic  we can do   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      If you need finer control  if-else is the choice

User · Answer

for alternative you can use as below   if  variable  gt   5  amp  amp  variable  lt   100            doSomething             or the following code also works  switch  variable        case 5      case 6      etc      case 100          doSomething        break

User · Answer

Sadly  it s not possible in Java  You ll have to resort to using if-else statements

User · Answer

Maybe not as elegant as some previous answers  but if you want to achieve switch cases with few large ranges  just combine ranges to a single case beforehand      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  lt   variable  amp  amp  variable  lt  100      switchVariable   1  switch  switchVariable          case 0          break       case 1             range 1-100         doSomething             break      case 101           doSomethingElse             break      etc

User · Answer

Basically   if  variable  gt   5  amp  amp  variable  lt   100        doSomething        If you really needed to use a switch  it would be because you need to do various things for certain ranges  In that case  yes  you re going to have messy code  because things are getting complex and only things which follow patterns are going to compress well   The only reason for a switch is to save on typing the variable name if you re just testing for numeric switching values  You aren t going to switch on 100 things  and they aren t going to be all doing the same thing  That sounds more like an  if  chunk

User · Answer

JEP 354  Switch Expressions  Preview  in JDK-13 and JEP 361  Switch Expressions  Standard  in JDK-14 will extend the switch statement so it can be used as an expression    Now you can    directly assign variable from switch expression   use new form of switch label  case L - gt        The code to the right of a  case L -   switch label is restricted to be an expression  a block  or  for convenience  a throw statement   use multiple constants per case  separated by commas   and also there are no more value breaks      To yield a value from a switch expression  the break with value statement is dropped in favor of a yield statement     Switch expression example   public class SwitchExpression      public static void main String   args          int month   9        int year   2018        int numDays   switch  month            case 1  3  5  7  8  10  12 - gt  31          case 4  6  9  11 - gt  30          case 2 - gt              if  java time Year of year  isLeap                  System out println  Wow  It s leap year                 yield 29              else               yield 28                                default - gt              System out println  Invalid month               yield 0                           System out println  Number of Days       numDays

User · Answer

From the last java-12 release multiple constants in the same case label is available in preview language feature     It is available in a JDK feature release to provoke developer feedback based on real world use  this may lead to it becoming permanent in a future Java SE Platform    It looks like   switch variable        case 1 - gt  doSomething        case 2  3  4 - gt  doSomethingElse         See more JEP 325  Switch Expressions  Preview

[java] Java switch statement multiple cases

Examples related to java

Examples related to syntax

Examples related to switch-statement