只是想弄清楚如何在Java switch语句中使用多个案例。这是我正在尝试做的一个例子：
switch (variable)
{
case 5..100:
doSomething();
break;
}
与必须做的：
switch (variable)
{
case 5:
case 6:
etc.
case 100:
doSomething();
break;
}
任何想法，如果这可能，或什么是一个好的选择？
可悲的是，这在Java中是不可能的。你将不得不求助于使用if-else语句。
替代方案，您可以使用如下：
if (variable >= 5 && variable <= 100) {
doSomething();
}
或以下代码也有效
switch (variable)
{
case 5:
case 6:
etc.
case 100:
doSomething();
break;
}
从上一个java-12版本开始，preview language feature中提供了同一案例标签中的多个常量
它可以在JDK功能版本中获得，以根据实际使用情况激发开发人员的反馈;这可能会导致它在未来的Java SE平台中成为永久性的。
看起来像：
switch(variable) {
case 1 -> doSomething();
case 2, 3, 4 -> doSomethingElse();
};
替代使用硬编码值的一种替代方法是在switch语句中使用范围映射：
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 >= 5 && n <= 100) {
return RANGE_5_100;
} else if (n >= 101 && n <= 1000) {
return RANGE_101_1000;
} else if (n >= 1001 && n <= 10000) {
return RANGE_1001_10000;
}
return -1;
}
第二种选择完全没问题。我不确定为什么响应者说不可能。这很好，我一直这样做：
switch (variable)
{
case 5:
case 6:
etc.
case 100:
doSomething();
break;
}
也许不像之前的一些答案那样优雅，但是如果你想要实现几个大范围的开关盒，只需事先将范围组合到一个案例中：
// 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.
}
public class SwitchTest {
public static void main(String[] args){
for(int i = 0;i<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;
}
}
}
}
日期：
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
替换过大的switch和if/else构造的一个面向对象的选项是使用Chain of Responsibility Pattern来模拟决策。
责任链模式
责任链模式允许将请求源分离，以决定请求中哪些潜在的大量处理程序应该对其执行操作。表示链角色的类沿着处理程序列表传递来自源的请求，直到处理程序接受请求并对其进行操作。
这是一个使用泛型的类型安全的示例实现。
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);
}
}
这只是一个快速的稻草人，我在几分钟内掀起，更复杂的实现可能允许某种Command Pattern被注入到Case实现实例中，使其更像是回调IoC风格。
关于这种方法的一个好处是Switch / Case语句都是关于副作用的，它将副作用封装在Classes中，这样它们可以被管理，并且可以更好地重复使用，最终更像是函数式语言中的模式匹配，这不是一件坏事。
我将在Github上发布此Gist的任何更新或增强功能。
基本上：
if (variable >= 5 && variable <= 100)
{
doSomething();
}
如果你真的需要使用开关，那将是因为你需要为某些范围做各种事情。在那种情况下，是的，你将会遇到混乱的代码，因为事情变得越来越复杂，只有遵循模式的东西才能很好地压缩。
切换的唯一原因是，如果您只是测试数字切换值，则可以节省输入变量名称。你不会打开100件事，他们也不会做同样的事情。这听起来更像是'if'块。
据this question说，这是完全可能的。
只需将包含相同逻辑的所有案例放在一起，并且不要将break放在它们后面。
switch (var) {
case (value1):
case (value2):
case (value3):
//the same logic that applies to value1, value2 and value3
break;
case (value4):
//another logic
break;
}
这是因为没有case的break将跳到另一个case直到break或return。
编辑：
回复评论，如果我们真的有95个具有相同逻辑的值，但是具有不同逻辑的案例数量较少，我们可以这样做：
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-else是你的选择。
//不符合规范的代码示例
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 >= 0 && a < 10) {
doFirstThing();
doTheThing();
}
else if (a >= 10 && a < 20) {
doTheOtherThing();
}
else if (a >= 20 && a < 50) {
doFirstThing();
doTheThing(); // Noncompliant; duplicates first condition
}
else {
doTheRest();
}
//合规解决方案
switch (i) {
case 1:
case 3:
doFirstThing();
doSomething();
break;
case 2:
doSomethingDifferent();
break;
default:
doTheRest();
}
if ((a >= 0 && a < 10) || (a >= 20 && a < 50)) {
doFirstThing();
doTheThing();
}
else if (a >= 10 && a < 20) {
doTheOtherThing();
}
else {
doTheRest();
}
可以使用Vavr库来处理这个问题
import static io.vavr.API.*;
import static io.vavr.Predicates.*;
Match(variable).of(
Case($(isIn(5, 6, ... , 100)), () -> doSomething()),
Case($(), () -> handleCatchAllCase())
);
这当然只是略有改进，因为所有案例仍然需要明确列出。但是定义自定义谓词很容易：
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())
);
匹配是一个表达式，因此它返回类似Runnable实例的内容，而不是直接调用方法。执行完比赛后，可以执行Runnable。
有关详细信息，请参阅official documentation。