Using two values for one switch case statement
JavaSwitch StatementJava Problem Overview
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.
Java Solutions
Solution 1 - Java
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.
Solution 2 - Java
You can do the following to use multiple cases for one switch statement:
case "firstCase":
case "secondCase": {
// Run code here for both cases
}
Solution 3 - Java
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.
Solution 4 - Java
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);
}
}
Solution 5 - Java
Just do
case text1: case text4:
do stuff;
break;
Solution 6 - Java
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.
Solution 7 - Java
Fall through approach is the best one i feel.
case text1:
case text4: {
//Yada yada
break;
}
Solution 8 - Java
You can use:
case text1: case text4:
do stuff;
break;
Solution 9 - Java
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.
Solution 10 - Java
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.
Solution 11 - Java
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 ayield
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);
}
}
Solution 12 - Java
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
Solution 13 - Java
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";
};
Solution 14 - Java
Another variation?
switch (name) {
case ['text1', 'text2']:
// do something
break
case 'text3':
// do something
break
default:
// do something
break
}
Solution 15 - Java
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");
}