Verwenden Sie in Java eine Zeichenfolge im Groß- und Kleinschreibung

Folgendes muss ich ändern ifist zu a switch–case beim Suchen nach a Stringum die zyklomatische Komplexität zu verbessern.

String value = some methodx;
if ("apple".equals(value)) {
    method1;
}

if ("carrot".equals(value)) {
    method2;
}

if ("mango".equals(value)) {
    method3;
}

if ("orange".equals(value)) {
    method4;
}

Aber ich bin mir nicht sicher, welchen Wert ich bekommen werde.

Java (vor Version 7) unterstützt Strings in switch/case nicht. Aber Sie können das gewünschte Ergebnis erzielen, indem Sie eine Aufzählung verwenden.

private enum Fruit {
    apple, carrot, mango, orange;
}

String value; // assume input
Fruit fruit = Fruit.valueOf(value); // surround with try/catch

switch(fruit) {
    case apple:
        method1;
        break;
    case carrot:
        method2;
        break;
    // etc...
}

Lernen Sie zu verwenden else.

Seit value niemals gleich zwei ungleichen Zeichenfolgen auf einmal sein wird, gibt es nur 5 mögliche Ergebnisse — eines für jeden Wert, der Ihnen wichtig ist, plus eines für “keine der oben genannten”. Da Ihr Code jedoch die nicht bestandenen Tests nicht eliminiert, hat er 16 “mögliche” Pfade (2 ^ die Anzahl der Tests), von denen die meisten niemals befolgt werden.

Mit elsedie einzigen Pfade, die existieren, sind die 5, die tatsächlich passieren können.

String value = some methodx;
if ("apple".equals(value )) {
    method1;
}
else if ("carrot".equals(value )) {
    method2;
}
else if ("mango".equals(value )) {
    method3;
}
else if ("orance".equals(value )) {
    method4;
}

Oder beginnen Sie mit der Verwendung von JDK 7, das die Möglichkeit bietet, Zeichenfolgen in a zu verwenden switch Aussage. Natürlich wird Java nur kompilieren switch In ein if/else sowieso wie konstruieren…

Jeder benutzt mindestens Java7 jetzt rechts? Hier ist die Antwort auf das ursprüngliche Problem:

String myString = getFruitString();

switch (myString) {

    case "apple":
        method1();
        break;

    case "carrot":
        method2();
        break;

    case "mango":
        method3();
        break;

    case "orange":
        method4();
        break;
}

Anmerkungen

• Die case-Anweisungen sind äquivalent zu using String.equals.
• Wie üblich wird beim String-Matching zwischen Groß- und Kleinschreibung unterschieden.
• Laut dem Dokumenteist dies im Allgemeinen schneller als die Verwendung von chained if–else Aussagen (wie in cHaos Antwort).

Verwenden Sie eine Karte, um die zyklomatische Komplexität zu reduzieren:

Map<String,Callable<Object>> map = new HashMap < > ( ) ;
map . put ( "apple" , new Callable<Object> () { public Object call ( method1 ( ) ; return null ; } ) ;
...
map . get ( x ) . call ( ) ;

oder Polymorphismus

Nur um die Antwort von Emory konkret zu machen, der ausführbare Code ist der folgende:

  Map<String,Callable<USer>> map = new HashMap<String,Callable<User>>();
  map.put( "test" , new Callable<User> () { public User call (){ return fillUser("test" ); }} ) ;
  map.put( "admin" , new Callable<Utente> () { public Utente call (){  return fillUser("admin" ); }} ) ;

wobei der Benutzer ein POJO ist, und dann

  User user = map.get(USERNAME).call();

Endlich, das genannt Methode steht irgendwo:

 private User fillUser(String x){        
        User user = new User();
        // set something in User
        return user;
}

Java unterstützt keine Groß-/Kleinschreibung mit String. Ich denke dieser Link kann dir helfen. 🙂

Hier ist ein möglicher Weg vor 1.7, den ich nicht empfehlen kann:

public class PoorSwitch
{
    final static public int poorHash (String s) {
        long l = 0L;
        for (char c: s.toCharArray ()) {
            l = 97*l + c;
        }
        return (int) l;
    }

    public static void main (String args[])
    {
        String param = "foo";
        if (args.length == 1)
        {
            param = args[0];
        }
        // uncomment these lines, to evaluate your hash
        // test ("foo");
        // test ("bar");
        switch (poorHash (param)) {
            // this doesn't work, since you need a literal constant
            // so we have to evaluate our hash beforehand:
            // case poorHash ("foo"): {
            case 970596: {
                System.out.println ("Foo!");
                break;
            }
            // case poorHash ("bar"): {
            case 931605: {
                System.out.println ("Bar!");
                break;
            }
            default: {
                System.out.println ("unknown\t" + param);
                break;
            }
        }
    }

    public static void test (String s)
    {
        System.out.println ("Hash:\t " + s + " =\t" + poorHash (s));
    }
}

Vielleicht könnte man mit einem solchen Trick in einem generierten Code arbeiten. Sonst kann ich es nicht empfehlen. Nicht so sehr, dass mir die Möglichkeit einer Hash-Kollision Sorgen bereitet, aber wenn etwas verwechselt wird (Ausschneiden und Einfügen), ist es schwierig, den Fehler zu finden. 931605 ist keine gute Dokumentation.

Nehmen Sie es einfach als Proof of Concept, als Neugier.