Wie prüfe ich, ob meine Zeichenfolge gleich Null ist?

Question

Ich möchte eine Aktion NUR dann durchführen, wenn meine Zeichenfolge einen sinnvollen Wert hat. Also, ich habe dies versucht.

if (!myString.equals("")) {
doSomething
}

und dies

if (!myString.equals(null)) {
doSomething
}

und dies

if ( (!myString.equals("")) && (!myString.equals(null))) {
doSomething
}

und dies

if ( (!myString.equals("")) && (myString!=null)) {
doSomething
}

und dies

if ( myString.length()>0) {
doSomething
}

Und in allen Fällen ist mein Programm doSomething trotz der Tatsache, dass mein String leer ist. Sie ist gleichbedeutend mit null . Was ist also falsch daran?

HINZUFÜGEN:

Ich habe die Ursache des Problems gefunden. Die Variable wurde als Zeichenkette deklariert und als Folge davon, null die dieser Variable zugewiesen wurde, wurde transformiert in "null" ! So, if (!myString.equals("null")) funktioniert.

Answer 1

Sie müssen überprüfen, ob die myString Objekt ist null :

if (myString != null) {
    doSomething
}

Answer 2

Wenn Ihre Zeichenfolge null ist, sollten Aufrufe wie dieser eine NullReferenceException auslösen:

myString.equals(null)

Aber wie auch immer, ich denke, eine solche Methode ist das, was Sie wollen:

public static class StringUtils
{
    public static bool isNullOrEmpty(String myString)
    {
         return myString == null || "".equals(myString);
    }
}

In Ihrem Code können Sie dann Dinge wie diese tun:

if (!StringUtils.isNullOrEmpty(myString))
{
    doSomething();
}

Answer 3

Ich würde empfehlen, ein vorhandenes Dienstprogramm zu verwenden oder eine eigene Methode zu entwickeln:

public static boolean isEmpty(String string) {
    return string == null || string.length() == 0;
}

Verwenden Sie es dann einfach, wenn Sie es brauchen:

if (! StringUtils.isEmpty(string)) {
  // do something
}

Wie bereits erwähnt, sind die Operatoren || und && Kurzschlüsse. Das heißt, sobald sie ihren Wert bestimmen können, hören sie auf. Wenn also (string == null) wahr ist, muss der Längenteil nicht ausgewertet werden, da der Ausdruck immer wahr wäre. Ähnlich verhält es sich mit &&: Wenn die linke Seite falsch ist, ist der Ausdruck immer falsch und muss nicht weiter ausgewertet werden.

Außerdem ist die Verwendung von Länge im Allgemeinen eine bessere Idee als die Verwendung von .equals. Die Leistung ist etwas besser (nicht viel), und erfordert keine Objekterstellung (obwohl die meisten Compiler dies optimieren könnten).

Answer 4

Jedes Mal, wenn ich mit Strings zu tun habe (fast jedes Mal), halte ich inne und frage mich, welcher Weg wirklich der schnellste ist, um auf eine leere Zeichenfolge zu prüfen. Natürlich sollte die Prüfung von string.Length == 0 am schnellsten sein, da Length eine Eigenschaft ist und es keine andere Verarbeitung als die Abfrage des Eigenschaftswertes geben sollte. Aber dann frage ich mich, warum gibt es einen String.Empty? Es sollte schneller sein, auf String.Empty zu prüfen als auf Length, sage ich mir. Nun, ich habe endlich beschlossen, es auszuprobieren. Ich habe eine kleine Windows-Konsolenanwendung programmiert, die mir sagt, wie lange es dauert, eine bestimmte Prüfung für 10 Millionen Wiederholungen durchzuführen. Ich habe 3 verschiedene Strings geprüft: einen NULL-String, einen leeren String und einen ""-String. Ich habe 5 verschiedene Methoden verwendet: String.IsNullOrEmpty(), str == null, str == null || str == String.Empty, str == null || str == "", str == null || str.length == 0. Unten sind die Ergebnisse:

String.IsNullOrEmpty()
NULL = 62 milliseconds
Empty = 46 milliseconds
"" = 46 milliseconds

str == null
NULL = 31 milliseconds
Empty = 46 milliseconds
"" = 31 milliseconds

str == null || str == String.Empty
NULL = 46 milliseconds
Empty = 62 milliseconds
"" = 359 milliseconds

str == null || str == ""
NULL = 46 milliseconds
Empty = 343 milliseconds
"" = 78 milliseconds

str == null || str.length == 0
NULL = 31 milliseconds
Empty = 63 milliseconds
"" = 62 milliseconds

Nach diesen Ergebnissen wird im Durchschnitt die Kontrolle für str == null ist am schnellsten, führt aber nicht immer zu dem, was wir suchen. if str = String.Empty o str = "" ist das Ergebnis falsch. Dann haben Sie 2, die an zweiter Stelle stehen: String.IsNullOrEmpty() y str == null || str.length == 0 . Seit String.IsNullOrEmpty() schöner aussieht und einfacher (und schneller) zu schreiben ist, würde ich empfehlen, sie der anderen Lösung vorzuziehen.

Answer 5

Versuchen Sie es,

myString!=null && myString.length()>0