Wie überprüfe ich, ob meine Zeichenfolge gleich null ist?

172

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 doSomethingtrotz 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 nulldieser Variablen zugewiesen in "null"! Also if (!myString.equals("null"))funktioniert.

römisch
quelle
2
nullhat keine Methoden, also auch nicht equals(). Wenn myStringja null, wie würden Sie jemals eine Methode dafür aufrufen? :)
BalusC
1
Darf ich vorschlagen, dass Sie System.out.println(myString)unmittelbar vor dem if-Block sehen, was da ist?
Michael Myers
1
Woher weißt du, dass "es gleich ist null"?
Richard JP Le Guen
6
nullDie dieser Variablen zugewiesene wurde in transformiert "null"- dies ist eine schreckliche Idee. Versuchen Sie, dieses Design nach Möglichkeit zu ändern.
Polygenschmierstoffe
8
Yuck - Ich glaube nicht, dass (! MyString.equals ("null")) die beste Lösung ist. Ich vermute, die meisten würden den Punkt, an dem die Zeichenfolge "null" myString zugewiesen wurde, als Fehler betrachten.
Bert F

Antworten:

231
if (myString != null && !myString.isEmpty()) {
  // doSomething
}

Als weiteren Kommentar sollten Sie diese equalsVertragsbedingung kennen:

Von Object.equals(Object):

Für jeden Nicht-Null - Referenzwert x, x.equals(null)sollte return false.

Der Weg zum Vergleichen nullist die Verwendung von x == nullund x != null.

Außerdem x.fieldund x.method()wirft NullPointerExceptionwenn x == null.

Polygenschmierstoffe
quelle
2
Aus Effizienzgründen sollten Sie eine Längenprüfung im Gegensatz zu einer gleichwertigen durchführen. Überprüfen Sie diesen Link hanuska.blogspot.com/2006/08/empty-string.html
CoolBeans
7
Ich würde sagen, Sie sollten dies tun, s.isEmpty()anstatt die s.length() == 0Lesbarkeit zu verbessern. Leistungsunterschiede sind vernachlässigbar. Ich stimme zu, dass s.equals("")das schrecklich ist.
polygenelubricants
6
Ich stimme der Lesbarkeit zu. Es hängt davon ab, ob wir Java 5 gegen Java 6 verwenden, da isEmpty () nur in Java 6 ist.
CoolBeans
@ CoolBeans: Guter Kommentar! Das hatte ich nicht bemerkt! Ich bin ein bisschen spät zur Java-Party =)
Polygenelubricants
26

Wenn myStringist null, dann rufen myString.equals(null)oder myString.equals("")mit einem fehlschlagen NullPointerException. Sie können keine Instanzmethoden für eine Nullvariable aufrufen.

Suchen Sie zuerst wie folgt nach null:

if (myString != null && !myString.equals("")) {
    //do something
}

Dies nutzt die Kurzschlussauswertung, um nicht zu versuchen, .equalsob myStringdie Nullprüfung fehlschlägt.

Michael Myers
quelle
+1 für Kurzschluss; Es ist wichtig, dass der Ausdruck funktioniert. Sie sollten jedoch wirklich .isEmpty()anstelle von verwenden .equals("").
polygenelubricants
1
Okay, ich wollte meinen Kommentar zu diesem Beitrag hinterlassen. lol. -> "Sie sollten aus Effizienzgründen eine Längenprüfung im Gegensatz zu gleich durchführen. Überprüfen Sie diesen Link hanuska.blogspot.com/2006/08/empty-string.html"
CoolBeans
@CoolBeans: Sicher, und mit Java 6 könnten Sie sogar tun myString.isEmpty(). Auf dieser Ebene übertrifft die Lesbarkeit jedoch die Optimierung, und die Leute sind möglicherweise eher an das Lesen gewöhnt myString.equals(""). (Oder möglicherweise auch nicht.)
Michael Myers
20

Apache Commons StringUtils.isNotEmptyist der beste Weg.

Kedar
quelle
13

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).

if (myString != null &&  !myString.isEmpty()){
    doSomething();
}

Übrigens würde ein Vergleich mit String-Literalen die Anweisung umkehren, um keine Nullprüfung durchführen zu müssen, d. H.

if ("some string to check".equals(myString)){
  doSomething();
} 

anstatt :

if (myString != null &&  myString.equals("some string to check")){
    doSomething();
}
corm
quelle
1
Guter Punkt, aber die letzten beiden Wenns sind nicht gleichwertig. Mit myString = "abc" ruft der mittlere nicht doSomething auf, der dritte jedoch.
Rimsky
@ Rimsky das ist behoben
pavi2410
7

ARBEITEN !!!!

if (myString != null && !myString.isEmpty()) {
    return true;
}
else {
    return false;
}
Salman Nazir
quelle
6

Sie müssen überprüfen, ob das myStringObjekt null:

if (myString != null) {
    doSomething
}
Wirbelwind
quelle
5

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:

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

Dann können Sie in Ihrem Code Folgendes tun:

if (!StringUtils.isNullOrEmpty(myString))
{
    doSomething();
}
Andy White
quelle
5

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

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

Dann benutzen Sie es einfach, wenn Sie es brauchen:

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

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).

Matt
quelle
4

Versuchen,

myString!=null && myString.length()>0
Prahler
quelle
Dies ist nicht möglich, wenn myString null ist
hsmit
4
Dies ist so ziemlich möglich, wenn myString null ist. Sie sollten wissen, dass, wenn der linke Teil des && fehlschlägt, der rechte Ausdruck überhaupt nicht ausgewertet wird.
Bragboy
4

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.

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 str == nullist die Überprüfung im Durchschnitt die schnellste, liefert jedoch möglicherweise nicht immer das, wonach wir suchen. if str = String.Emptyoder str = ""es führt zu false. Dann haben Sie 2, die an zweiter Stelle gebunden sind: String.IsNullOrEmpty()und str == null || str.length == 0. Da String.IsNullOrEmpty()es besser aussieht und einfacher (und schneller) zu schreiben ist, würde ich empfehlen, es gegenüber der anderen Lösung zu verwenden.

ldsant
quelle
3

Ich würde so etwas machen:

( myString != null && myString.length() > 0 )
    ? doSomething() : System.out.println("Non valid String");
  • Beim Testen auf Null wird geprüft, ob myString eine Instanz von String enthält.
  • length () gibt die Länge zurück und entspricht equals ("").
  • Wenn Sie zuerst überprüfen, ob myString null ist, wird eine NullPointerException vermieden.
James P.
quelle
3

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

/**
    * Tests if a string is blank: null, emtpy, or only whitespace (" ", \r\n, \t, etc)
    * @param string string to test
    * @return if string is blank
    */
    public static boolean isBlank(String string) {
        if (string == null || string.length() == 0)
            return true;

        int l = string.length();
        for (int i = 0; i < l; i++) {
            if (!StringUtil.isWhitespace(string.codePointAt(i)))
                return false;
        }
        return true;
    } 
Max
quelle
2

Das sollte funktionieren:

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

Wenn nicht, hat myString wahrscheinlich einen Wert, den Sie nicht erwarten. Versuchen Sie es wie folgt auszudrucken:

System.out.println("+" + myString + "+");

Wenn Sie die Zeichenfolge mit den Symbolen '+' umgeben, wird angezeigt, ob sich dort zusätzliche Leerzeichen befinden, die Sie nicht berücksichtigen.

elduff
quelle
2

if(str.isEmpty() || str==null){ do whatever you want }

Moe
quelle
3
isEmpty ist umgekehrt. Wenn Sie die Methode für ein Null-Objekt aufrufen, erhalten Sie NPE
Brian
Wenn die Zeichenfolge null ist, erhalten Sie eine Nullzeigerausnahme, noch bevor Sie überprüfen, ob sie null ist. Dieser Code sollte niemals verwendet werden!
Gil.fernandes
2

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:

String s = new String("This is just a test");

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 die toString()Methode dieses Objekts aufgerufen. Wenn es nicht toStringvon Object überschrieben wurde , wird der Zeiger gedruckt. Beispielsweise:

public class Foo{
    public static void main(String[] args) {
        Foo f = new Foo();
        System.out.println(f);
    }
}

>>>>
>>>>
>>>>Foo@330bedb4

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:

int i = 123;

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:

String s1 = new String("Hallo");
String s2 = new String("Hallo");

System.out.println(s1 == s2);

>>>>> false

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

Luecx
quelle
2

Für mich ist die beste Überprüfung, ob eine Zeichenfolge in Java einen aussagekräftigen Inhalt hat, folgende:

string != null && !string.trim().isEmpty()

Zuerst überprüfen Sie, ob die Zeichenfolge vermieden werden soll null, NullPointerExceptionund 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.

gil.fernandes
quelle
1

Ich hatte dieses Problem in Android und ich benutze diese Weise (Arbeit für mich):

String test = null;
if(test == "null"){
// Do work
}

Aber im Java-Code verwende ich:

String test = null;
if(test == null){
// Do work
}

Und :

private Integer compareDateStrings(BeanToDoTask arg0, BeanToDoTask arg1, String strProperty) {
    String strDate0 = BeanUtils.getProperty(arg0, strProperty);_logger.debug("strDate0 = " + strDate0);
    String strDate1 = BeanUtils.getProperty(arg1, strProperty);_logger.debug("strDate1 = " + strDate1);
    return compareDateStrings(strDate0, strDate1);
}

private Integer compareDateStrings(String strDate0, String strDate1) {
    int cmp = 0;
    if (isEmpty(strDate0)) {
        if (isNotEmpty(strDate1)) {
            cmp = -1;
        } else {
            cmp = 0;
        }
    } else if (isEmpty(strDate1)) {
        cmp = 1;
    } else {
        cmp = strDate0.compareTo(strDate1);
    }
    return cmp;
}

private boolean isEmpty(String str) {
    return str == null || str.isEmpty();
}
private boolean isNotEmpty(String str) {
    return !isEmpty(str);
}
AA
quelle
1

In Android können Sie dies mit der Dienstprogrammmethode isEmptyvon überprüfen TextUtils,

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

isEmpty(CharSequence str)Methode Überprüfen Sie sowohl Bedingung nullals auch Länge.

NSK
quelle
1

Ich benutze immer so:

if (mystr != null && !mystr.isEmpty()){
  //DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}else {
  //DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}

oder Sie können dies in Ihr Projekt kopieren:

private boolean isEmptyOrNull(String mystr){
    if (mystr != null && !mystr.isEmpty()){ return true; }
    else { return false; }
}

und nenne es einfach wie:

boolean b = isEmptyOrNull(yourString);

es wird true zurückgeben, wenn es leer oder null ist.
b=truewenn leer oder null ist

oder Sie können try catch and catch verwenden, wenn es null ist.

Web.11
quelle
0

Ich denke, dass myString kein String ist, sondern ein Array von Strings. Folgendes müssen Sie tun:

String myNewString = join(myString, "")
if (!myNewString.equals(""))
{
    //Do something
}
imitieren
quelle
Mein Code ist für die Verarbeitung. Die Verarbeitung ist eine Java-basierte Programmiersprache. Weitere Informationen zu join: process.org/reference/join_.html .
Mimit
0

Sie können die Zeichenfolge null wie folgt überprüfen:

String Test = null;
(Test+"").compareTo("null")

Wenn das Ergebnis 0 ist, ist (Test + "") = "null".

Harrouchi Taher
quelle
Dies schafft nur eine unnötige Zeichenfolge
svarog
0

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.

String test = null+"";
If(!test.equals("null"){
       //go ahead string is not null

}

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

leeCoder
quelle
1
Nein, das ist eine absolut schreckliche Lösung. Die obigen Antworten funktionieren.
Konrad Rudolph
@KonradRudolph Ich habe oben einige dieser Lösungen ausprobiert, bevor ich zu meinem Schluss kam. Ich habe versucht, diese Lösung in einem Recyclerview-Adapter zu verwenden, und es gab mir nicht das richtige Ergebnis, bis ich diese Antwort fand.
LeeCoder
Ich kann mit Sicherheit sagen, dass dies bedeutet, dass etwas anderes mit Ihrem Code nicht stimmt und Sie lediglich die Symptome beheben, nicht die Fehlerquelle. Verstehen Sie das nicht falsch, aber dies ist ein typischer Fall der Frachtkultprogrammierung .
Konrad Rudolph
0

Eine Ausnahme kann auch helfen:

try {
   //define your myString
}
catch (Exception e) {
   //in that case, you may affect "" to myString
   myString="";
}
Herimanitra Ranaivoson
quelle
0

Wenn Sie in Android arbeiten, können Sie die einfache TextUtils-Klasse verwenden. Überprüfen Sie den folgenden Code:

if(!TextUtils.isEmpty(myString)){
 //do something
}

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.

Manmohan Soni
quelle
-5

Sie müssen mit null prüfen if(str != null).

rawa rawandze
quelle
5
Ihre Lösung wurde vor Jahren von anderen Benutzern veröffentlicht ... Was bringt es, sie zu wiederholen?
TDG
1
Ich sehe keine der Antworten bestätigt, deshalb antworte ich ihm
Rawa Rawandze
6
Richtig, er hat die Antworten seit 2010 nicht bestätigt, also wiederholen Sie einfach eine vorherige Antwort und er wird Ihre Antwort bestätigen ...
TDG