Ich möchte NUR eine Aktion ausführen, wenn meine Zeichenfolge einen aussagekräftigen Wert hat. Also habe ich es versucht.
if (!myString.equals("")) {
doSomething
}
und das
if (!myString.equals(null)) {
doSomething
}
und das
if ( (!myString.equals("")) && (!myString.equals(null))) {
doSomething
}
und das
if ( (!myString.equals("")) && (myString!=null)) {
doSomething
}
und das
if ( myString.length()>0) {
doSomething
}
Und in jedem Fall mein Programm doSomething
trotz der Tatsache, dass meine Zeichenfolge leer ist. Es ist gleich null
. Also, was ist daran falsch?
HINZUGEFÜGT:
Ich habe den Grund des Problems gefunden. Die Variable wurde als String deklariert und infolgedessen null
dieser Variablen zugewiesen in "null"
! Also if (!myString.equals("null"))
funktioniert.
null
hat keine Methoden, also auch nichtequals()
. WennmyString
janull
, wie würden Sie jemals eine Methode dafür aufrufen? :)System.out.println(myString)
unmittelbar vor dem if-Block sehen, was da ist?null
"?null
Die dieser Variablen zugewiesene wurde in transformiert"null"
- dies ist eine schreckliche Idee. Versuchen Sie, dieses Design nach Möglichkeit zu ändern.Antworten:
Als weiteren Kommentar sollten Sie diese
equals
Vertragsbedingung kennen:Von
Object.equals(Object)
:Der Weg zum Vergleichen
null
ist die Verwendung vonx == null
undx != null
.Außerdem
x.field
undx.method()
wirftNullPointerException
wennx == null
.quelle
s.isEmpty()
anstatt dies.length() == 0
Lesbarkeit zu verbessern. Leistungsunterschiede sind vernachlässigbar. Ich stimme zu, dasss.equals("")
das schrecklich ist.Wenn
myString
istnull
, dann rufenmyString.equals(null)
odermyString.equals("")
mit einem fehlschlagenNullPointerException
. Sie können keine Instanzmethoden für eine Nullvariable aufrufen.Suchen Sie zuerst wie folgt nach null:
Dies nutzt die Kurzschlussauswertung, um nicht zu versuchen,
.equals
obmyString
die Nullprüfung fehlschlägt.quelle
.isEmpty()
anstelle von verwenden.equals("")
.myString.isEmpty()
. Auf dieser Ebene übertrifft die Lesbarkeit jedoch die Optimierung, und die Leute sind möglicherweise eher an das Lesen gewöhntmyString.equals("")
. (Oder möglicherweise auch nicht.)Apache Commons
StringUtils.isNotEmpty
ist der beste Weg.quelle
Wenn myString tatsächlich null ist, schlägt jeder Aufruf der Referenz mit einer Null-Zeiger-Ausnahme (NPE) fehl. Verwenden Sie seit Java 6 #isEmpty anstelle der Längenprüfung (erstellen Sie auf keinen Fall eine neue leere Zeichenfolge mit der Prüfung).
Übrigens würde ein Vergleich mit String-Literalen die Anweisung umkehren, um keine Nullprüfung durchführen zu müssen, d. H.
anstatt :
quelle
ARBEITEN !!!!
quelle
Sie müssen überprüfen, ob das
myString
Objektnull
:quelle
Wenn Ihre Zeichenfolge null ist, sollten Aufrufe wie diese eine NullReferenceException auslösen:
myString.equals (null)
Aber ich denke, eine Methode wie diese ist genau das, was Sie wollen:
Dann können Sie in Ihrem Code Folgendes tun:
quelle
Ich würde empfehlen, ein vorhandenes Dienstprogramm zu verwenden oder eine eigene Methode zu erstellen:
Dann benutzen Sie es einfach, wenn Sie es brauchen:
Wie oben erwähnt, ist das || und && Betreiber Kurzschluss. Das heißt, sobald sie ihren Wert bestimmen können, hören sie auf. Wenn also (string == null) wahr ist, muss der Längenanteil nicht ausgewertet werden, da der Ausdruck immer wahr wäre. Ebenso bei &&, wenn die linke Seite falsch ist, ist der Ausdruck immer falsch und muss nicht weiter ausgewertet werden.
Als zusätzliche Anmerkung 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 möglicherweise optimieren).
quelle
Versuchen,
quelle
Übrigens, wenn Sie viel mit Strings arbeiten, gibt es eine großartige Spring-Klasse mit allen möglichen nützlichen Methoden:
http://static.springsource.org/spring/docs/2.5.x/api/org/springframework/util/StringUtils.html
quelle
Jedes Mal, wenn ich mich mit Strings beschäftigen muss (fast jedes Mal), halte ich inne und frage mich, welcher Weg wirklich der schnellste ist, um nach einem leeren String zu suchen. Natürlich sollte die Prüfung string.Length == 0 die schnellste sein, da Length eine Eigenschaft ist und keine andere Verarbeitung als das Abrufen des Werts der Eigenschaft erfolgen sollte. Aber dann frage ich mich, warum gibt es einen String.Empty? Es sollte schneller sein, nach String.Empty zu suchen als nach Länge, sage ich mir. Nun, ich habe mich schließlich entschlossen, es auszuprobieren. Ich habe eine kleine Windows-Konsolen-App codiert, die mir sagt, wie lange es dauert, eine bestimmte Prüfung für 10 Millionen Wiederholungen durchzuführen. Ich habe 3 verschiedene Zeichenfolgen überprüft: eine NULL-Zeichenfolge, eine leere Zeichenfolge und eine "" Zeichenfolge. Ich habe 5 verschiedene Methoden verwendet: String.IsNullOrEmpty (), str == null, str == null || str == String.Empty, str == null || str == "", str == null || str.
Nach diesen Ergebnissen
str == null
ist die Überprüfung im Durchschnitt die schnellste, liefert jedoch möglicherweise nicht immer das, wonach wir suchen.if str = String.Empty
oderstr = ""
es führt zu false. Dann haben Sie 2, die an zweiter Stelle gebunden sind:String.IsNullOrEmpty()
undstr == null || str.length == 0
. DaString.IsNullOrEmpty()
es besser aussieht und einfacher (und schneller) zu schreiben ist, würde ich empfehlen, es gegenüber der anderen Lösung zu verwenden.quelle
Ich würde so etwas machen:
quelle
Ich habe benutzt
StringUtil.isBlank(string)
Es wird getestet, ob eine Zeichenfolge leer ist: null, emtpy oder nur Leerzeichen.
Dieser ist also der bisher beste
Hier ist die ursprüngliche Methode aus den Dokumenten
quelle
Das sollte funktionieren:
Wenn nicht, hat myString wahrscheinlich einen Wert, den Sie nicht erwarten. Versuchen Sie es wie folgt auszudrucken:
Wenn Sie die Zeichenfolge mit den Symbolen '+' umgeben, wird angezeigt, ob sich dort zusätzliche Leerzeichen befinden, die Sie nicht berücksichtigen.
quelle
if(str.isEmpty() || str==null){ do whatever you want }
quelle
Okay, so funktionieren Datentypen in Java. (Sie müssen mein Englisch entschuldigen, ich verwende wahrscheinlich nicht das richtige Vokabular. Sie müssen zwischen zwei davon unterscheiden. Die Basisdatentypen und die normalen Datentypen. Basisdatentypen machen so ziemlich alles aus, was existiert. Zum Beispiel dort sind alle Zahlen, Zeichen, Boolesche Werte usw. Die normalen Datentypen oder komplexen Datentypen sind alles andere. Ein String ist ein Array von Zeichen, daher ein komplexer Datentyp.
Jede Variable, die Sie erstellen, ist tatsächlich ein Zeiger auf den Wert in Ihrem Speicher. Beispielsweise:
Die Variable "s" enthält KEINEN String. Es ist ein Zeiger. Dieser Zeiger zeigt auf die Variable in Ihrem Speicher. Wenn Sie aufrufen
System.out.println(anyObject)
, wird dietoString()
Methode dieses Objekts aufgerufen. Wenn es nichttoString
von Object überschrieben wurde , wird der Zeiger gedruckt. Beispielsweise:Alles hinter dem "@" ist der Zeiger. Dies funktioniert nur für komplexe Datentypen. Primitive Datentypen werden DIREKT in ihrem Zeiger gespeichert. Es gibt also eigentlich keinen Zeiger und die Werte werden direkt gespeichert.
Beispielsweise:
Ich speichere in diesem Fall keinen Zeiger. Ich werde den ganzzahligen Wert 123 (in Byte ofc) speichern.
Okay, kommen wir zurück zum
==
Operator. Es vergleicht immer den Zeiger und nicht den Inhalt, der an der Position des Zeigers im Speicher gespeichert ist.Beispiel:
Diese beiden Zeichenfolgen haben einen unterschiedlichen Zeiger. String.equals (String other) vergleicht jedoch den Inhalt. Sie können primitive Datentypen mit dem Operator '==' vergleichen, da der Zeiger zweier verschiedener Objekte mit demselben Inhalt gleich ist.
Null würde bedeuten, dass der Zeiger leer ist. Ein leerer primitiver Datentyp ist standardmäßig 0 (für Zahlen). Null für ein komplexes Objekt bedeutet jedoch, dass dieses Objekt nicht existiert.
Schöne Grüße
quelle
Für mich ist die beste Überprüfung, ob eine Zeichenfolge in Java einen aussagekräftigen Inhalt hat, folgende:
Zuerst überprüfen Sie, ob die Zeichenfolge vermieden werden soll
null
,NullPointerException
und dann schneiden Sie alle Leerzeichen, um zu vermeiden, dass Zeichenfolgen überprüft werden, die nur Leerzeichen enthalten, und schließlich, ob die zugeschnittene Zeichenfolge nicht leer ist, dh die Länge 0 hat.quelle
Ich hatte dieses Problem in Android und ich benutze diese Weise (Arbeit für mich):
Aber im Java-Code verwende ich:
Und :
quelle
Ich bevorzuge:
Lesen Sie StringUtils.isBlank () vs String.isEmpty () .
quelle
In Android können Sie dies mit der Dienstprogrammmethode
isEmpty
von überprüfenTextUtils
,isEmpty(CharSequence str)
Methode Überprüfen Sie sowohl Bedingungnull
als auch Länge.quelle
Ich benutze immer so:
oder Sie können dies in Ihr Projekt kopieren:
und nenne es einfach wie:
es wird true zurückgeben, wenn es leer oder null ist.
b=true
wenn leer oder null istoder Sie können try catch and catch verwenden, wenn es null ist.
quelle
Ich denke, dass myString kein String ist, sondern ein Array von Strings. Folgendes müssen Sie tun:
quelle
Sie können die Zeichenfolge null wie folgt überprüfen:
Wenn das Ergebnis 0 ist, ist (Test + "") = "null".
quelle
Ich habe die meisten der oben angegebenen Beispiele für eine Null in einer Android-App ausprobiert, die ich erstellt habe, und alles ist fehlgeschlagen. Also habe ich eine Lösung gefunden, die für mich jederzeit funktioniert.
Verketten Sie also einfach eine leere Zeichenfolge wie oben beschrieben und testen Sie sie gegen "null", und es funktioniert einwandfrei. In der Tat wird keine Ausnahme geworfen
quelle
Eine Ausnahme kann auch helfen:
quelle
Wenn Sie in Android arbeiten, können Sie die einfache TextUtils-Klasse verwenden. Überprüfen Sie den folgenden Code:
Dies ist eine einfache Verwendung von Code. Die Antwort kann wiederholt werden. Aber es ist einfach, einen einzigen und einfachen Scheck für Sie zu haben.
quelle
Sie müssen mit null prüfen
if(str != null).
quelle