Using two values for one switch case statement

Question

In my code, the program does something depending on the text entered by the user. My code looks like:

switch (name) {
        case text1: {
            //blah
            break;
        }
        case text2: {
            //blah
            break;
        }
        case text3: {
            //blah
            break;
        }
        case text4: {
            //blah
            break;
        }

However, the code inside cases text1 and text4 is the same. I was therefore wondering if it would be possible for me to implement something like

case text1||text4: {
            //blah
            break;
        }

I know that the || operator won't work in the case statement but is there something similar I can use.

Snooze

Being a basic question makes it if anything more eligable for upvotes if its not a duplicate as its widely useful. And its something that didn't occure to me as possible but now that I realise it its blindingly obvious. So all in all a pretty awesome Q&A – Conductive

@RichardTingle - are you familiar with Duff's Device - en.wikipedia.org/wiki/Duff%27s_device – Eunuchoidism

"Why so many upvotes? Search for "java switch" in the internet and read one of the thousand explanations." <-- what do you think I was doing? – Ob

I literally searched for "multiple cases in one line java" and this Q&A was the first result. – Woodsman

@Christian Strempfer, because Fallthrough behavior is contrintuitive, easily not known by new developers, and multiple values in one case would be much more readable. – Accost

@Christian Strempfer, In my time I didn't know about fallthrough, while switch-case general behavior is obvious - no research needed. What an unpleasant surprise I've experienced when got a bug because of fallthrough. I thought that day "Why the heck case 9 is running when value is 8, it's mutually exclusive. When it's said case 9 - it mustn't be executed if value is not 9. Period. It's law of logic." How would you like if statements running without matching conditions. Moreover in some languages there is no fallthrough, or it is not default behavior (the best way imho). – Accost

@Luten: I doesn't matter if it's obvious or not. Searching the answer would have been faster than writing a question. – Rattan

@Christian Strempfer, Searching and receiving this answer in stack overflow's Q&A format instead of reading documentation is often faster. I think this question saves time (may be not for one who wrote it but definitely for those who found). That's why it receives upvotes. – Accost

The switch demo in the selected answer could be rephrased now that JDK-12 has integrated JEP-325. :) – Nobleminded

My fav approach is case text1, text4 -> { (referenced here) – Hageman

Answer 1

You can use have both CASE statements as follows.

  case text1: 
  case text4:{
            //blah
            break;
        }

SEE THIS EXAMPLE:The code example calculates the number of days in a particular month:

class SwitchDemo {
    public static void main(String[] args) {

        int month = 2;
        int year = 2000;
        int numDays = 0;

        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;
        }
        System.out.println("Number of Days = "
                           + numDays);
    }
}

This is the output from the code:

Number of Days = 29

FALLTHROUGH:

Another point of interest is the break statement. Each break statement terminates the enclosing switch statement. Control flow continues with the first statement following the switch block. The break statements are necessary because without them, statements in switch blocks fall through: All statements after the matching case label are executed in sequence, regardless of the expression of subsequent case labels, until a break statement is encountered.

EXAMPLE CODE:

public class SwitchFallThrough {

    public static void main(String[] args) {
        java.util.ArrayList<String> futureMonths =
            new java.util.ArrayList<String>();

        int month = 8;

        switch (month) {
            case 1:  futureMonths.add("January");
            case 2:  futureMonths.add("February");
            case 3:  futureMonths.add("March");
            case 4:  futureMonths.add("April");
            case 5:  futureMonths.add("May");
            case 6:  futureMonths.add("June");
            case 7:  futureMonths.add("July");
            case 8:  futureMonths.add("August");
            case 9:  futureMonths.add("September");
            case 10: futureMonths.add("October");
            case 11: futureMonths.add("November");
            case 12: futureMonths.add("December");
            default: break;
        }

        if (futureMonths.isEmpty()) {
            System.out.println("Invalid month number");
        } else {
            for (String monthName : futureMonths) {
               System.out.println(monthName);
            }
        }
    }
}

This is the output from the code:

August
September
October
November
December

Using Strings in switch Statements

In Java SE 7 and later, you can use a String object in the switch statement's expression. The following code example, , displays the number of the month based on the value of the String named month:

public class StringSwitchDemo {

    public static int getMonthNumber(String month) {

        int monthNumber = 0;

        if (month == null) {
            return monthNumber;
        }

        switch (month.toLowerCase()) {
            case "january":
                monthNumber = 1;
                break;
            case "february":
                monthNumber = 2;
                break;
            case "march":
                monthNumber = 3;
                break;
            case "april":
                monthNumber = 4;
                break;
            case "may":
                monthNumber = 5;
                break;
            case "june":
                monthNumber = 6;
                break;
            case "july":
                monthNumber = 7;
                break;
            case "august":
                monthNumber = 8;
                break;
            case "september":
                monthNumber = 9;
                break;
            case "october":
                monthNumber = 10;
                break;
            case "november":
                monthNumber = 11;
                break;
            case "december":
                monthNumber = 12;
                break;
            default: 
                monthNumber = 0;
                break;
        }

        return monthNumber;
    }

    public static void main(String[] args) {

        String month = "August";

        int returnedMonthNumber =
            StringSwitchDemo.getMonthNumber(month);

        if (returnedMonthNumber == 0) {
            System.out.println("Invalid month");
        } else {
            System.out.println(returnedMonthNumber);
        }
    }
}

The output from this code is 8.

FROM Java Docs

Gemmule

It's worth to mention that this language feature is called fallthrough. Cases without break are basically appended with next case block which is visually below, hence fall through. – Mesial

@EmperorOrionii i updated my answer as you are suggested.Thanks – Gemmule

@Gemmule Perhaps they really really agreed with Kobor42. In all fairness I agree with Kobor42 (not enough to stop this being an awesome answer though) and now that its edited awesome answer+ – Conductive

@Kobor42 first learn how to talk in public sites.Any how your suggestion is help ful.Thanks – Gemmule

I know how to talk on public sites. blog.stackoverflow.com/2012/08/… – Platinocyanide

@Platinocyanide How about: Why have you used that formatting? Putting cases horisontally makes the code less readable and is generally considered bad practice [Reference optional but desired]. I have always felt that switch statements are a particularly readable format but presented this way they lose all that. – Conductive

Let me add another remarok on readability: In my opinion for case's using numbers is not nice. It isn't explaining the situation which you choose. Please take a look at my edit, and accept it if you agree. – Platinocyanide

@Platinocyanide Often true, but for months the 1==january, 2==feburary is sufficiently ingrained that just using the number is fine – Conductive

@RichardTingle You ask for my reference? Here: google.com/search?q=switch+case+best+practice I can't see your formatting anywhere... – Platinocyanide

@Platinocyanide Just so we're clear; I agree with you, my formatting is your formatting. My point was about the way you were saying it not what you were saying (although most of the comments from then seem to have been deleted) – Conductive

@RichardTingle i flagged his comment.The so team deleted – Gemmule

The switch demo could be rephrased now that JDK-12 has integrated JEP-325. :) – Nobleminded

same in javascript – Olivia

Answer 2

You can do the following to use multiple cases for one switch statement:

case "firstCase":
case "secondCase": {
    // Run code here for both cases
}

Donatelli

for OP: read this also Java switch cases: with or without braces? – Donatelli

@Xiddoc To answer OP, I used text1 as "firstCase" and text4 as "secondCase" , read the question case text1||text4: { //blah break; }, your edit passed but I orignal answer was simple for OP – Donatelli

My bad, I filed another edit to undo the case rename. – Slapstick

Answer 3

Summary: separate by commas

switch (name) {
    case text1 , text4  -> doX() ;
    case text2          -> doY() ;
    case text3          -> doZ() ;
}

Switch Expressions

With the integration of JEP 361: Switch Expressions in Java 14 and later, one can make use of the new form of the switch label using a comma between multiple values.

case text1, text4 -> {
     //blah
} 

or to rephrase the demo from one of the answers, something like :-

public class RephraseDemo {

    public static void main(String[] args) {
        int month = 9;
        int year = 2018;
        int numDays = 0;

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

            }
        }
        System.out.println("Number of Days = " + numDays);
    }
}

Nobleminded

People always mix up arrow labels and switch expressions. Sure they were introduced in the same JEP, but they are orthogonal features. – Thelmathem

Answer 4

The case values are just codeless "goto" points that can share the same entry point:

case text1:
case text4: 
    //blah
    break;

Note that the braces are redundant.

Ynes

Answer 5

Just do

case text1: case text4: 
     do stuff;
     break;

Slang

Answer 6

The brackets are unnecessary. Just do

case text1:
case text4:
  doSomethingHere();
  break;
case text2:
  doSomethingElse()
  break;

If anyone is curious, this is called a case fallthrough. The ability to do this is the reason why break; is necessary to end case statements. For more information, see the wikipedia article http://en.wikipedia.org/wiki/Switch_statement.

Beech

Answer 7

Fall through approach is the best one i feel.

case text1:
case text4: {
        //Yada yada
        break;
} 

Yeseniayeshiva

Answer 8

You can use:

case text1: case text4: 
     do stuff;
     break;

Garrote

Answer 9

The case values are just codeless "goto" points that can share the same entry point:

case text1:
case text4: {
//Do something
break;
}

Note that the braces are redundant.

Altagraciaaltaic

Answer 10

The fallthrough answers by others are good ones.

However another approach would be extract methods out of the contents of your case statements and then just call the appropriate method from each case.

In the example below, both case 'text1' and case 'text4' behave the same:

switch (name) {
        case text1: {
            method1();
            break;
        }
        case text2: {
            method2();
            break;
        }
        case text3: {
            method3();
            break;
        }
        case text4: {
            method1();
            break;
        }

I personally find this style of writing case statements more maintainable and slightly more readable, especially when the methods you call have good descriptive names.

Unanswerable

It is not more maintainable if text1 and text4 will ALMOST CERTAINLY do the same thing, regardless of a future change. If they should always be linked, making a change in the case for text1 (meaning changing which method it calls) would require a change in text4. In this case it is obviously not more maintainable. It depends on the situation. – Buck

I will say that this method should probably be combined with the other way anyway, since switch statements are not (IMHO) the prettiest programming structure. – Buck

Answer 11

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 ->):

  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.

So the demo from one of the answers might look like this:

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 -> 31;
        case 4, 6, 9, 11 -> 30;
        case 2 -> {
          if (java.time.Year.of(year).isLeap()) {
            System.out.println("Wow! It's leap year!");
            yield 29;
          } else {
            yield 28;
          }
        }
        default -> {
          System.out.println("Invalid month.");
          yield 0;
        }
      };
      System.out.println("Number of Days = " + numDays);
  }
}

Kermanshah

This Answer repeats another posted a couple of years prior. – Hairtail

Answer 12

Java 12 and above

switch (name) {
    case text1, text4 -> // do something ;
    case text2, text3, text 5 -> // do something else ;
    default -> // default case ;
}

You can also assign a value through the switch case expression :

String text = switch (name) {
    case text1, text4 -> "hello" ;
    case text2, text3, text5 -> "world" ;
    default -> "goodbye";
};

"yield" keyword

It allows you to return a value by the switch case expression

String text = switch (name) {
    case text1, text4 ->
        yield "hello";
    case text2, text3, text5 ->
        yield "world";
    default ->
        yield "goodbye";
};

Grubman

Answer 13

A more beautiful way to handle that

if (["Joe", "Peterson", "Bond" ].indexOf(name) > -1)

    //Do something

else if (["Joe", "Peterson", "Bond" ].indexOf(name) > -1)

    //Do other  ...

You can do that for multiple values with the same result

Theft

Answer 14

if you just add a : then every case will run the same code block until you get to the first break. so in this case 123, 456 have the same execution. Be sure to include the break and if you add code for 123 and 456 with no break then both code blocks will be ran. this may or may not be the case for Java but in JavaScript you open {} whenever you have scoped variables that you need to define inside the case otherwise they leak/break through to the other cases.

    case '123':
    case '456': //some code
         break;
    case '789' {
    /// some code
         break;
}  
 default break;

Dalt

Answer 15

Another variation?

  switch (name) {
    case ['text1', 'text2']:
      // do something
      break
    case 'text3':
      // do something
      break
    default:
      // do something
      break
  }

Nitrate

Answer 16

If you are using and enum you can just sparate them with comma and you ready to go...

switch (xyzEnum) {
        case x, y -> {
            //Do stuff
        }
        case x -> {
            //Do stuff
        }
    }

Castra

Answer 17

you can also do this

let date = new Date().getDay();
switch (date) {
  case 0: console.log("domingo"); break;
  case 1: console.log("segunda"); break;
  case 2: console.log("terça"); break;
  case 3: console.log("quarta"); break;
  case 4: console.log("quinta"); break;
  case 5: console.log("sexta"); break;
  case 6: console.log("sábado"); break;
  default: console.log("dia inválido");
}

Tight

Welcome to Stack Overflow! Please edit your answer to provide more information as to how the code you've provided works, what you have changed, etc. Code-only answers might solve the problem of the original asker but they don't help future readers understand the solution. – Asternal