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

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.

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.

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.

Apache Commons StringUtils.isNotEmptyist der beste Weg.

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

ARBEITEN !!!!

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

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

if (myString != null) {
    doSomething
}

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

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

Versuchen,

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

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

        // your magic here

 }

Ü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

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.

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.

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

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.

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

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

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.

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

Ich bevorzuge:

if(!StringUtils.isBlank(myString)) { // checks if myString is whitespace, empty, or null
    // do something
}

Lesen Sie StringUtils.isBlank () vs String.isEmpty () .

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.

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.

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
}

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

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

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

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

Eine Ausnahme kann auch helfen:

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

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.

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