Java switch语句多种情况

Question

只是想弄清楚如何在 Java switch 语句中使用多种情况。这是我想做的一个例子：

switch (variable)
{
    case 5..100:
        doSomething();
    break;
}

与必须做的事情相比：

switch (variable)
{
    case 5:
    case 6:
    etc.
    case 100:
        doSomething();
    break;
}

如果可能的话有什么想法，或者什么是好的替代方案？

Answer 1

第二种选择完全没问题。我不知道为什么回复者说这是不可能的。这很好，我一直这样做：

switch (variable)
{
    case 5:
    case 6:
    etc.
    case 100:
        doSomething();
    break;
}

Answer 2

遗憾的是，这在 Java 中是不可能的。您必须求助于使用 if-else 语句。

Answer 3

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

Answer 4

也许不像以前的一些答案那么优雅，但是如果您想实现具有几个大范围的开关案例，只需预先将范围组合到单个案例中即可：

// 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.
} 

Answer 5

这可以通过 Java 14 中的开关增强功能实现。以下是一个相当直观的示例，说明如何实现相同的目标。

switch (month) {
    case 1, 3, 5, 7, 8, 10, 12 -> System.out.println("this month has 31 days");
    case 4, 6, 9 -> System.out.println("this month has 30 days");
    case 2 -> System.out.println("February can have 28 or 29 days");
    default -> System.out.println("invalid month");
}

Answer 6

替换过大的 switch 和 if/else 构造的一种面向对象选项是使用责任链模式来对决策进行建模。

责任链模式

责任链模式
允许分离源
决定哪一个的请求
潜在大量处理程序
对于请求应该采取行动。这
代表链角色的类
渠道来自源的请求
沿着处理程序列表直到
处理程序接受请求并
采取行动。

这是一个使用泛型也是类型安全的示例实现。

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

    }
}

这只是我在几分钟内快速完成的稻草人，更复杂的实现可能允许将某种命令模式注入到Case实现实例中使其更像回调 IoC 风格。

这种方法的好处是 Switch/Case 语句都是关于副作用的，这将副作用封装在类中，以便可以更好地管理和重用它们，它最终更像是函数式语言中的模式匹配，这并不是一件坏事。

我将发布对此的任何更新或增强要点。

Answer 7

根据这个问题，这是完全有可能的。

只需将包含相同逻辑的所有 case 放在一起，不要将 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;
}

这是因为没有 break 的 case 会跳转到另一个 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 就是选择。

Answer 8

JDK-13 和 JEP 354：切换表达式（预览版） a href="https://openjdk.java.net/jeps/361" rel="noreferrer">JEP 361：JDK-14 中的 Switch 表达式（标准） 将扩展switch 语句，因此它可以用作表达式。

现在您可以：

• 直接从 switch 表达式 分配变量，
• 使用新形式的 switch 标签 (case L ->)：

  <块引用>

  “case L ->”右侧的代码switch 标签仅限于表达式、块或（为方便起见）抛出语句。

• 每个案例使用多个常量，用逗号分隔，
• 并且也没有更多的值中断：

  <块引用>

  要从 switch 表达式中生成值，需要删除 break with value 语句，而代之以 yield 语句。

开关表达式示例：

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);
  }
}

Answer 9

从最新的 java-12 版本开始，预览语言功能中提供了同一 case 标签中的多个常量

它在 JDK 功能版本中可用，以激发开发人员根据实际使用情况提供反馈；这可能会导致它在未来的 Java SE 平台中永久存在。

它看起来像：

switch(variable) {
    case 1 -> doSomething();
    case 2, 3, 4 -> doSomethingElse();
};

查看更多JEP 325：切换表达式（预览版）

Answer 10

基本上：

if (variable >= 5 && variable <= 100)
{
    doSomething();
}

如果您确实需要使用开关，那是因为您需要在某些范围内执行各种操作。在这种情况下，是的，您将得到混乱的代码，因为事情变得越来越复杂，只有遵循模式的东西才能很好地压缩。

使用开关的唯一原因是，如果您只是测试数字开关值，则可以节省键入变量名称的时间。你不会打开 100 个东西，它们也不会都做同样的事情。这听起来更像是一个“如果”块。

Answer 11

// 不合规代码示例

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();
}

Answer 12

可以使用 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())
);

Match 是一个表达式，因此这里它返回类似 Runnable 实例的内容，而不是直接调用方法。匹配完成后，可以执行Runnable。

有关更多详细信息，请参阅官方文档。

Answer 13

不使用硬编码值的一种替代方法是在 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;
}

Answer 14

作为替代方案，您可以使用如下所示：

if (variable >= 5 && variable <= 100) {
        doSomething();

    }

或者以下代码也适用

switch (variable)
{
    case 5:
    case 6:
    etc.
    case 100:
        doSomething();
    break;
}

Answer 15

JEP 427：switch 的模式匹配（第三个预览版） 作为 Java 19 中的预览功能，并允许您使用所谓的“受保护的模式”解决问题：

Integer variable = new Random().nextInt(200);
switch (variable) {
     case Integer v when v >= 5 && v <= 100
             -> System.out.println("in my range");
     default -> System.out.println("out of range");
}

热启用 Java 中的预览功能，请参阅 这个SO问题。

到 Java 20 或 21，此语法可能会作为标准功能提供。

Answer 16

我找到了这个问题的解决方案...我们可以在java中的switch case中使用多个条件..但它需要多个switch case..

public class MultiCSwitchTest {
public static void main(String[] args) {
    int i = 209;
    int a = 0;
    switch (a = (i>=1 && i<=100) ? 1 : a){    
    case 1:
        System.out.println ("The Number is Between 1 to 100 ==> " + i);
        break;
    default:
        switch (a = (i>100 && i<=200) ? 2 : a) {
            case 2:
                System.out.println("This Number is Between 101 to 200 ==> " + i);
                break;
        
            default:
                switch (a = (i>200 && i<=300) ? 3 : a) {
                    case 3:
                        System.out.println("This Number is Between 201 to 300 ==> " + i);
                        break;
                
                    default:
                        // You can make as many conditions as you want;
                        break;
                }
        }
        
    }
}
}