it-swarm.com.de

Verwendung 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 so aus:

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

Der Code in den Fällen text1 und text4 ist jedoch derselbe. Ich habe mich deshalb gefragt, ob es mir möglich wäre, so etwas umzusetzen

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

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

244
Ankush

Sie können beide Anweisungen CASE 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 umschließende switch-Anweisung. Der Steuerungsfluss wird mit der ersten Anweisung fortgesetzt, die auf den Schaltblock folgt. Die break-Anweisungen sind notwendig, da ohne sie Anweisungen in switch-Blöcken fall through: Alle Anweisungen nach der übereinstimmenden case-Bezeichnung werden nacheinander ausgeführt, unabhängig vom Ausdruck nachfolgender case-Bezeichnungen, bis eine break-Anweisung auftritt.

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

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 von diesem Code ist 8.

FROM Java Docs

476
PSR

du kannst machen wie:

case text1:
case text4: {
            //blah
            break;
}
37
Grijesh Chauhan

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

case text1:
case text4: 
    //blah
    break;

Beachten Sie, dass die Klammern redundant sind.

25
Bohemian

Mach einfach

case text1: case text4: 
     do stuff;
     break;
20
kaljak

Mit der Integration von JEP 325: Switch Expressions (Preview) in JDK-12-Builds mit frühem Zugriff kann die neue Form der Switch-Bezeichnung nun wie folgt verwendet werden:

case text1, text4 -> {
     //blah
} 

oder um die Demo von eine der Antworten umzuformulieren, 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);
    }
}

Hier ist, wie Sie es ausprobieren können - Kompilieren Sie eine JDK12-Vorschau-Funktion mit Maven

6
Naman

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 Fallthrough. Die Fähigkeit, dies zu tun, ist der Grund, warum break; erforderlich ist, um case-Anweisungen zu beenden. Weitere Informationen finden Sie im Wikipedia-Artikel http://en.wikipedia.org/wiki/Switch_statement .

6
scottmrogowski

Die fallthrough Antworten von anderen 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 Groß- und Kleinschreibung 'text1' und 'text4' gleich:

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

Ich persönlich finde diesen Schreibstil für case-Anweisungen leichter zu pflegen und etwas besser lesbar, insbesondere wenn die von Ihnen aufgerufenen Methoden aussagekräftige Namen haben.

5
Colin D

Fall Through Approach ist das Beste, was ich fühle.

case text1:
case text4: {
        //Yada yada
        break;
} 
4
Ankur Sharma

Sie können verwenden:

case text1: case text4: 
     do stuff;
     break;
3
Joseph DSCS

Die case-Werte sind nur codefreie "goto" -Punkte, die denselben Einstiegspunkt haben können:

falltext1:
case text4: {
//Etwas tun
brechen;
}

Beachten Sie, dass die Klammern redundant sind.

3
David_DD