Verwenden von zwei Werten für eine switch case-Anweisung

In meinem Code macht das Programm etwas abhängig von dem vom Benutzer eingegebenen Text. Mein Code sieht aus wie:

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

Der Code in Fällen text1und text4ist jedoch der gleiche. Ich habe mich daher gefragt, ob es mir möglich sein würde, so etwas umzusetzen

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

Ich weiß, dass der ||Operator in der case-Anweisung nicht funktioniert, aber es gibt etwas Ähnliches, das ich verwenden kann.

Sie können beide CASEAnweisungen wie folgt verwenden.

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

SIEHE DIESES BEISPIEL: Das Codebeispiel berechnet die Anzahl der Tage in einem bestimmten Monat:

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

Dies ist die Ausgabe des Codes:

Number of Days = 29

DURCHFALLEN:

Ein weiterer interessanter Punkt ist die break-Anweisung. Jede break-Anweisung beendet die einschließende switch-Anweisung. Der Kontrollfluss wird mit der ersten Anweisung nach dem Schalterblock fortgesetzt. Die break-Anweisungen sind erforderlich, da ohne sie Anweisungen in switch-Blöcken fall through: Alle Anweisungen nach der übereinstimmenden case-Bezeichnung werden unabhängig vom Ausdruck nachfolgender case-Bezeichnungen nacheinander ausgeführt, bis eine break-Anweisung auftritt.

BEISPIELCODE:

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

Dies ist die Ausgabe des Codes:

August
September
October
November
December

Verwenden von Strings in switch-Anweisungen

In Java SE 7 und höher können Sie ein String-Objekt im Ausdruck der switch-Anweisung verwenden. Das folgende Codebeispiel zeigt die Nummer des Monats basierend auf dem Wert der Zeichenfolge mit dem Namen month an:

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

Die Ausgabe dieses Codes ist 8.

VON Java Docs

Sie können tun wie:

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

Die caseWerte sind nur codelose "goto" -Punkte, die denselben Einstiegspunkt haben können:

case text1:
case text4: 
    //blah
    break;

Beachten Sie, dass die geschweiften Klammern redundant sind.

Mach einfach

case text1: case text4: 
     do stuff;
     break;

Mit der Integration von JEP 325: Switch Expressions (Vorschau) in JDK-12-Builds für den frühen Zugriff kann die neue Form des Switch-Labels jetzt wie folgt verwendet werden:

case text1, text4 -> {
     //blah
} 

oder um die Demo aus einer der Antworten neu zu formulieren , so etwas wie: -

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

So können Sie es ausprobieren: Kompilieren Sie eine JDK12-Vorschaufunktion mit Maven

Die Klammern sind nicht erforderlich. Mach einfach

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

Wenn jemand neugierig ist, spricht man von einem Fallfall. Die Fähigkeit, dies zu tun, ist der Grund, warum break;es notwendig ist, Fallaussagen zu beenden. Weitere Informationen finden Sie im Wikipedia-Artikel http://en.wikipedia.org/wiki/Switch_statement .

Die fallthroughAntworten anderer sind gut.

Ein anderer Ansatz wäre jedoch, Methoden aus dem Inhalt Ihrer case-Anweisungen zu extrahieren und dann einfach die entsprechende Methode aus jedem Fall aufzurufen.

Im folgenden Beispiel verhalten sich Fall 'Text1' und Fall 'Text4' gleich:

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

Ich persönlich finde diese Art des Schreibens von Fallaussagen wartbarer und etwas lesbarer, insbesondere wenn die von Ihnen aufgerufenen Methoden gute beschreibende Namen haben.

Fall-through-Ansatz ist der beste, den ich fühle.

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

Sie können verwenden:

case text1: case text4: 
     do stuff;
     break;

Die Fallwerte sind nur codelose "goto" -Punkte, die denselben Einstiegspunkt haben können:

case text1:
case text4: {
// Mach etwas
kaputt;
}}

Beachten Sie, dass die geschweiften Klammern redundant sind.

JEP 354: Switch-Ausdrücke (Vorschau) in JDK-13 und JEP 361: Switch-Ausdrücke (Standard) in JDK-14 erweitern die switch-Anweisung, sodass sie als Ausdruck verwendet werden kann .

Jetzt kannst du:

• Variable direkt aus Schalterausdruck zuweisen ,
• Verwenden Sie eine neue Form der Schalterbezeichnung ( case L ->):

  Der Code rechts von der Schalterbezeichnung "case L ->" ist auf einen Ausdruck, einen Block oder (der Einfachheit halber) eine throw-Anweisung beschränkt.

• Verwenden Sie mehrere durch Kommas getrennte Konstanten pro Fall.
• und es gibt auch keine wertebrüche mehr :

  Um einen Wert aus einem switch-Ausdruck zu erhalten, wird die breakwith-value-Anweisung zugunsten einer yieldAnweisung gelöscht .

Die Demo aus einer der Antworten könnte also so aussehen:

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