Überprüfen Sie, ob eine Zeichenfolge nicht null und nicht leer ist

490

Wie kann ich überprüfen, ob eine Zeichenfolge nicht null und nicht leer ist?

public void doStuff(String str)
{
    if (str != null && str != "**here I want to check the 'str' is empty or not**")
    {
        /* handle empty string */
    }
    /* ... */
}
Bernhard Barker
quelle
8
Sie sollten wahrscheinlich PreparedStatementund so verwenden, anstatt eine SQL-Abfrage nach Zeichenfolgenverkettungsprimitiven zu erstellen. Vermeidet alle Arten von Injektionsschwachstellen, viel besser lesbar usw.
Polygenelubricants
2
Sie können eine Klasse erstellen, die nach Nullwerten oder Nullobjekten sucht. Das wird Ihnen helfen, die Wiederverwendbarkeit zu verbessern. Stackoverflow.com/a/16833309/1490962
Bhushankumar Lilapara

Antworten:

895

Was ist mit isEmpty () ?

if(str != null && !str.isEmpty())

Stellen Sie sicher, dass Sie die Teile von &&in dieser Reihenfolge verwenden, da Java den zweiten Teil nicht auswertet, wenn der erste Teil von &&fehlschlägt. Dadurch wird sichergestellt, dass Sie keine Nullzeigerausnahme von str.isEmpty()if erhalten, wenn strnull ist.

Achtung, es ist erst seit Java SE 1.6 verfügbar. Sie müssen str.length() == 0frühere Versionen überprüfen .


So ignorieren Sie auch Leerzeichen:

if(str != null && !str.trim().isEmpty())

(da Java 11 str.trim().isEmpty()reduziert werden kann, str.isBlank()wird auch auf andere Unicode-Leerzeichen getestet)

Eingewickelt in eine praktische Funktion:

public static boolean empty( final String s ) {
  // Null-safe, short-circuit evaluation.
  return s == null || s.trim().isEmpty();
}

Wird:

if( !empty( str ) )
Colin Hebert
quelle
80
Beachten Sie, dass isEmpty()anscheinend eine String-Instanz erforderlich ist (nicht statisch). Wenn Sie dies für eine Nullreferenz aufrufen, wird eine NullPointerException ausgelöst.
James P.
38
Oder wenn (str! = Null &&! Str.trim (). IsEmpty ()), um Leerzeichen zu ignorieren.
PapaFreud
if ((txt.getText (). length ()) == 0) // Element aus Layout holen
jruzafa
32
Ich würde empfehlen, TextUtils.isEmpty(String)zu überprüfen, ob die Zeichenfolge leer oder null ist. Schön kurz. Die TextUtils-Klasse ist Teil des Android SDK.
George Maisuradze
1
@ user1154390: Manchmal lohnt es sich, aus Gründen der Klarheit explizit true und false zu verwenden, aber wenn die Bedingung true für true und false für false zurückgibt, ist dies unnötig komplex. Einfach sagen (str != null && str.length() > 0).
ToolmakerSteve
213

Verwenden Sie org.apache.commons.lang.StringUtils

Ich verwende gerne Apache commons-lang für diese Art von Dingen, insbesondere für die Dienstprogrammklasse StringUtils :

import org.apache.commons.lang.StringUtils;

if (StringUtils.isNotBlank(str)) {
    ...
} 

if (StringUtils.isBlank(str)) {
    ...
} 
Romain Linsolas
quelle
17
Ist Apache commons-lang nicht ein Overkill, wenn Sie nur isEmpty verwenden können? Nur neugierig.
Zengr
17
@zengr - nein, weil Sie mit Sicherheit auch andere Dinge verwenden würden :)
Bozho
2
@zengr Wenn Sie nur isEmptyoder verwenden isBlank, ist es möglicherweise nicht sinnvoll, eine Bibliothek eines Drittanbieters einzuschließen . Sie können einfach Ihre eigene Dienstprogrammklasse erstellen, um eine solche Methode bereitzustellen. Wie Bozho erklärt, bietet das commons-langProjekt jedoch viele nützliche Methoden!
Romain Linsolas
13
Weil StringUtils.isNotBlank(str)auch die Nullprüfung.
Sdesciencelover
1
Wenn Sie Spring Framework verwenden, kann dies BEREITS in den Gläsern des Frameworks gebündelt werden.
Linuxunil
103

Fügen Sie hier einfach Android hinzu:

import android.text.TextUtils;

if (!TextUtils.isEmpty(str)) {
...
}
Phreakhead
quelle
1
@staticx, Die StringUtils-Methode wurde in Lang Version 2.0 geändert. Die Zeichenfolge wird nicht mehr gekürzt. Diese Funktionalität ist in isBlank () verfügbar.
Nick
50

Hinzufügen zu @BJorn und @SeanPatrickFloyd Die Guava-Methode, um dies zu tun, ist:

Strings.nullToEmpty(str).isEmpty(); 
// or
Strings.isNullOrEmpty(str);

Commons Lang ist manchmal besser lesbar, aber ich habe mich langsam mehr auf Guava verlassen und manchmal ist Commons Lang verwirrend, wenn es darum geht isBlank()(wie in Leerzeichen oder nicht).

Guavas Version von Commons Lang isBlankwäre:

Strings.nullToEmpty(str).trim().isEmpty()

Ich werde sagen, dass Code, der nicht zulässt ""(leer) UND null verdächtig und möglicherweise fehlerhaft ist, da er wahrscheinlich nicht alle Fälle behandelt, in denen das nullNichtzulassen Sinn macht (obwohl ich für SQL verstehen kann, dass SQL / HQL seltsam ist '').

Adam Gent
quelle
zweite Guave auch. Guave folgt einer Konvention mehrerer statischer Klassen. Versuchen Sie für String Strings für statische Methoden wie isNullOrEmpty (str).
Thupten
34
str != null && str.length() != 0

Alternative

str != null && !str.equals("")

oder

str != null && !"".equals(str)

Hinweis: Bei der zweiten Prüfung (erste und zweite Alternative) wird davon ausgegangen, dass str nicht null ist. Es ist nur in Ordnung, weil die erste Prüfung dies tut (und Java die zweite Prüfung nicht durchführt, wenn die erste falsch ist)!

WICHTIG: Verwenden Sie == NICHT für die Zeichenfolgengleichheit. == prüft, ob der Zeiger gleich ist, nicht der Wert. Zwei Zeichenfolgen können sich in unterschiedlichen Speicheradressen befinden (zwei Instanzen), haben jedoch denselben Wert!

Helios
quelle
danke ... die str.length () hat bei mir funktioniert. Mein Fall war, dass ich die Werte aus dem Array erhalte, nachdem ich aus der Datenbank abgefragt habe. Selbst wenn die Daten leer waren, gab es bei der Str.Länge "1" Länge. Sehr seltsam, aber danke, dass du mir das gezeigt hast.
Arn-Arn
Das hat mit den Interna der Datenbank zu tun. Entweder handelt es sich um ein Zeichenfeld anstelle eines Varchar-Felds (daher werden Leerzeichen eingefügt), oder die Datenbank mag keine leeren Zeichenfolgen. Ich denke, das Beste ist, diese Werte nach / während der Abfrage vorzuverarbeiten (im Datenzugriff später in der App).
Helios
Ich denke, die Länge zu überprüfen ist besser als 'gleich', da es sich um eine O (1) -Operation handelt, da die Länge im Fall von String zwischengespeichert wird.
Bluelurker
26

Fast jede Bibliothek weiß ich , definiert eine Utility - Klasse genannt StringUtils, StringUtiloder StringHelper, und sie sind in der Regel die Methode die Sie suchen.

Mein persönlicher Favorit ist Apache Commons / Lang , wo Sie in der StringUtils- Klasse beide bekommen

  1. StringUtils.isEmpty (String) und die
  2. StringUtils.isBlank (String) -Methode

(Der erste prüft, ob eine Zeichenfolge null oder leer ist, der zweite prüft, ob sie null, leer oder nur Leerzeichen ist.)

Es gibt ähnliche Utility-Klassen in Spring, Wicket und vielen anderen Bibliotheken. Wenn Sie keine externen Bibliotheken verwenden, möchten Sie möglicherweise eine StringUtils-Klasse in Ihr eigenes Projekt einführen.


Update: Viele Jahre sind vergangen, und heutzutage würde ich die Verwendung der Guava - Strings.isNullOrEmpty(string)Methode empfehlen .

Sean Patrick Floyd
quelle
Ich möchte fragen, warum Sie dies jetzt empfehlen? Ich würde gerne wissen, ob es einen Unterschied zwischen Strings.isNullOrEmpty (String) und StringUtils.isEmpty (String) gibt
Vicangel
Die Methoden von @vicangel Apache Commons sind voller Annahmen und Dinge, nach denen ich nicht gefragt habe. Mit Guava bekomme ich genau das, wonach ich gefragt habe und nichts mehr oder weniger
Sean Patrick Floyd
24

Das funktioniert bei mir:

import com.google.common.base.Strings;

if (!Strings.isNullOrEmpty(myString)) {
       return myString;
}

Gibt true zurück, wenn die angegebene Zeichenfolge null oder die leere Zeichenfolge ist.

Erwägen Sie, Ihre Zeichenfolgenreferenzen mit nullToEmpty zu normalisieren. In diesem Fall können Sie anstelle dieser Methode String.isEmpty () verwenden, und Sie benötigen auch keine speziellen nullsicheren Methodenformen wie String.toUpperCase. Wenn Sie "in die andere Richtung" normalisieren und leere Zeichenfolgen in Null konvertieren möchten, können Sie emptyToNull verwenden.

Javatar
quelle
2
<dependency> <groupId> com.google.guava </ groupId> <artifactId> guava </ifactId> <version> 12.0 </ version> </ dependency>
Junchen Liu
11

Wie wäre es mit:

if(str!= null && str.length() != 0 )
Codaddict
quelle
löst eine NullPointerException aus, wenn str NULL ist.
Mindwin
13
@ Mindwin Das stimmt nicht. Der Code rechts von &&if str == null wird nicht ausgeführt , wodurch eine NullPointerException verhindert wird. (Quelle: Ich habe es gerade versucht)
Zach Lysobey
Ich stehe korrigiert. Löscht den Kommentar nicht aus Scham, damit Zach und GI Joe keine Antworten aus dem Nichts erhalten. Lolz. ABER es ist schön zu wissen, dass dieses Überspringen logische Fehler verursachen kann, wenn Sie etwas anderes tun als nur Dinge zu testen und bei den übersprungenen Methodenaufrufen einen Booleschen Wert zurückzugeben.
Mindwin
2
@Mindwin Es ist schön zu wissen, wie die Sprache, die Sie verwenden, tatsächlich funktioniert. Wenn Sie die Kurzschlussbewertung nicht verstehen, verwenden Sie sie entweder nicht oder lernen Sie sie besser kennen.
Marquis von Lorne
7

Verwenden Sie die isNotBlank-Methode von Apache StringUtils wie

StringUtils.isNotBlank(str)

Es wird nur dann true zurückgegeben, wenn der str nicht null und nicht leer ist.

Ein Nullzeiger
quelle
Wenn str hier null ist, gibt die Aussage true zurück
Alexandr
Das stimmt, mein schlechtes !! Stattdessen würde StringUtils.isNotEmpty (str) von apache-commons den Job erledigen.
Ein
6

Sie sollten org.apache.commons.lang3.StringUtils.isNotBlank()oder verwenden org.apache.commons.lang3.StringUtils.isNotEmpty. Die Entscheidung zwischen diesen beiden basiert auf dem, wonach Sie tatsächlich suchen möchten.

Die isNotBlank () überprüft , dass der Eingangsparameter ist:

  • nicht null,
  • nicht die leere Zeichenfolge ("")
  • keine Folge von Leerzeichen ("")

Die isNotEmpty () überprüft nur , dass der Eingangsparameter ist

  • nicht null
  • nicht die leere Zeichenfolge ("")
gprasant
quelle
6

Gibt basierend auf der Eingabe true oder false zurück

Predicate<String> p = (s)-> ( s != null && !s.isEmpty());
p.test(string);
Koustubh Mokashi
quelle
5

Wenn Sie nicht die gesamte Bibliothek einschließen möchten; Fügen Sie einfach den gewünschten Code hinzu. Sie müssen es selbst warten; aber es ist eine ziemlich einfache Funktion. Hier wird es von commons.apache.org kopiert

    /**
 * <p>Checks if a String is whitespace, empty ("") or null.</p>
 *
 * <pre>
 * StringUtils.isBlank(null)      = true
 * StringUtils.isBlank("")        = true
 * StringUtils.isBlank(" ")       = true
 * StringUtils.isBlank("bob")     = false
 * StringUtils.isBlank("  bob  ") = false
 * </pre>
 *
 * @param str  the String to check, may be null
 * @return <code>true</code> if the String is null, empty or whitespace
 * @since 2.0
 */
public static boolean isBlank(String str) {
    int strLen;
    if (str == null || (strLen = str.length()) == 0) {
        return true;
    }
    for (int i = 0; i < strLen; i++) {
        if ((Character.isWhitespace(str.charAt(i)) == false)) {
            return false;
        }
    }
    return true;
}
Tom
quelle
5

Es ist etwas zu spät, aber hier ist ein funktionaler Überprüfungsstil:

Optional.ofNullable(str)
    .filter(s -> !(s.trim().isEmpty()))
    .ifPresent(result -> {
       // your query setup goes here
    });
Pilot
quelle
1
Ich würde empfehlen, eine Map für das Trimmen zu verwenden, z. B.: Optional.ofNullable (str) .map (String :: trim) .filter (String :: isEmpty) .ifPresent (this :: setStringMethod);
Bachph
5

Es gibt eine neue Methode in :: String#isBlank

Gibt true zurück, wenn die Zeichenfolge leer ist oder nur Leerzeichen-Codepunkte enthält, andernfalls false.

jshell> "".isBlank()
$7 ==> true

jshell> " ".isBlank()
$8 ==> true

jshell> " ! ".isBlank()
$9 ==> false

Dies kann kombiniert werden Optional, um zu überprüfen, ob die Zeichenfolge null oder leer ist

boolean isNullOrEmpty = Optional.ofNullable(str).map(String::isBlank).orElse(true);

String # isBlank

Anton Balaniuc
quelle
3

Test entspricht einer leeren Zeichenfolge und null in derselben Bedingung:

if(!"".equals(str) && str != null) {
    // do stuff.
}

Wirft nicht, NullPointerExceptionwenn str null ist, da Object.equals()false zurückgegeben wird, wenn arg ist null.

das andere Konstrukt str.equals("")würde die gefürchteten werfen NullPointerException. Einige mögen eine schlechte Form in Betracht ziehen, indem sie ein String-Literal als das Objekt verwenden, auf das equals()es aufgerufen wird, aber es erledigt den Job.

Überprüfen Sie auch diese Antwort: https://stackoverflow.com/a/531825/1532705

Mindwin
quelle
1
so wurde noch nie Code erreicht str != null. !"".equals(str)mache schon den Job
amdev
3

Einfache Lösung:

private boolean stringNotEmptyOrNull(String st) {
    return st != null && !st.isEmpty();
}
Shweta
quelle
2

Wie oben erwähnt, ist Apache StringUtils dafür fantastisch. Wenn Sie Guave einschließen, sollten Sie Folgendes tun:

public List<Employee> findEmployees(String str, int dep) {
 Preconditions.checkState(StringUtils.isNotBlank(str), "Invalid input, input is blank or null");
 /** code here **/
}

Darf ich auch empfehlen, dass Sie die Spalten in Ihrer Ergebnismenge nicht nach Index, sondern nach Namen referenzieren. Dadurch wird die Verwaltung Ihres Codes erheblich vereinfacht.

BjörnS
quelle
Es ist jedoch nicht erforderlich, Apache Commons von Guave zu verwenden, es gibt auch eine Strings-Klasse in Guave: guava-libraries.googlecode.com/svn/trunk/javadoc/com/google/…
Sean Patrick Floyd
Ich habe einige Guava-Beispiele für Java-Anfänger hinzugefügt, die auf dieser Frage landen: stackoverflow.com/a/13146903/318174 .
Adam Gent
2

Ich habe meine eigene Utility-Funktion erstellt, um mehrere Zeichenfolgen gleichzeitig zu überprüfen, anstatt eine if-Anweisung voller zu haben if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty). Dies ist die Funktion:

public class StringUtils{

    public static boolean areSet(String... strings)
    {
        for(String s : strings)
            if(s == null || s.isEmpty)
                return false;

        return true;
    }   

}

so kann ich einfach schreiben:

if(!StringUtils.areSet(firstName,lastName,address)
{
    //do something
}
WKS
quelle
2
Wäre schöner, die Signatur zu verwenden: areSet(String... strings)kann dann ohne die Array-Erstellung aufgerufen werden:if(!StringUtils.areSet(firstName, lastName, address))
Weston
2

Wenn Sie Java 8 verwenden und einen funktionaleren Programmieransatz wünschen, können Sie einen definieren Function, der das Steuerelement verwaltet, und ihn dann wiederverwenden undapply()Wenn .

Wenn Sie zum Üben kommen, können Sie das Functionals definieren

Function<String, Boolean> isNotEmpty = s -> s != null && !"".equals(s)

Anschließend können Sie es verwenden, indem Sie die apply()Methode einfach wie folgt aufrufen :

String emptyString = "";
isNotEmpty.apply(emptyString); // this will return false

String notEmptyString = "StackOverflow";
isNotEmpty.apply(notEmptyString); // this will return true

Wenn Sie möchten, können Sie ein definieren Function, das prüft, ob das Stringleer ist, und es dann mit negieren !.

In diesem Fall Functionsieht das folgendermaßen aus:

Function<String, Boolean> isEmpty = s -> s == null || "".equals(s)

Anschließend können Sie es verwenden, indem Sie die apply()Methode einfach wie folgt aufrufen :

String emptyString = "";
!isEmpty.apply(emptyString); // this will return false

String notEmptyString = "StackOverflow";
!isEmpty.apply(notEmptyString); // this will return true
Araknoid
quelle
So mache ich das gerne, wenn ich mir Sorgen über Leistungskosten oder Nebenwirkungen mache und keine Importe zur Hand habe.
david.pfx
2

Mit Java 8 Optional können Sie Folgendes tun:

public Boolean isStringCorrect(String str) {
    return Optional.ofNullable(str)
            .map(String::trim)
            .map(string -> !str.isEmpty())
            .orElse(false);
}

In diesem Ausdruck behandeln Sie Strings, die ebenfalls aus Leerzeichen bestehen.

Johnny
quelle
1

Sie können StringUtils.isEmpty () verwenden. Es wird true ausgegeben, wenn der String entweder null oder leer ist.

 String str1 = "";
 String str2 = null;

 if(StringUtils.isEmpty(str)){
     System.out.println("str1 is null or empty");
 }

 if(StringUtils.isEmpty(str2)){
     System.out.println("str2 is null or empty");
 }

wird darin enden, dass

str1 ist null oder leer

str2 ist null oder leer

Vivek Vermani
quelle
Oder verwenden Sie einfachisNotBlank
Brian
1

Ich würde Guava oder Apache Commons je nach Ihrem tatsächlichen Bedarf empfehlen. Überprüfen Sie die verschiedenen Verhaltensweisen in meinem Beispielcode:

import com.google.common.base.Strings;
import org.apache.commons.lang.StringUtils;

/**
 * Created by hu0983 on 2016.01.13..
 */
public class StringNotEmptyTesting {
  public static void main(String[] args){
        String a = "  ";
        String b = "";
        String c=null;

    System.out.println("Apache:");
    if(!StringUtils.isNotBlank(a)){
        System.out.println(" a is blank");
    }
    if(!StringUtils.isNotBlank(b)){
        System.out.println(" b is blank");
    }
    if(!StringUtils.isNotBlank(c)){
        System.out.println(" c is blank");
    }
    System.out.println("Google:");

    if(Strings.isNullOrEmpty(Strings.emptyToNull(a))){
        System.out.println(" a is NullOrEmpty");
    }
    if(Strings.isNullOrEmpty(b)){
        System.out.println(" b is NullOrEmpty");
    }
    if(Strings.isNullOrEmpty(c)){
        System.out.println(" c is NullOrEmpty");
    }
  }
}

Ergebnis:
Apache:
a ist leer
b ist leer
c ist leer
Google:
b ist NullOrEmpty
c ist NullOrEmpty

BlondCode
quelle
1

Wenn Sie Spring Boot verwenden, führt der folgende Code den Job aus

StringUtils.hasLength(str)
Avinash
quelle
0

Der Vollständigkeit halber : Wenn Sie bereits das Spring-Framework verwenden , stellen die StringUtils die Methode bereit

org.springframework.util.StringUtils.hasLength(String str)

Rückgabe: true, wenn der String nicht null ist und eine Länge hat

sowie die Methode

org.springframework.util.StringUtils.hasText(String str)

Rückgabe: true, wenn der String nicht null ist, seine Länge größer als 0 ist und nicht nur Leerzeichen enthält

l00tr
quelle
Wir können die StringUtils.isEmpty (param) -Methode verwenden.
Supun Dharmarathne
0

Um auch Leerzeichen zu ignorieren:

if (str == null || str.trim().length() == 0) {
    // str is empty
} else {
    // str is not empty
}
simhumileco
quelle
0

Wenn Sie Spring Framework verwenden, können Sie folgende Methode verwenden:

org.springframework.util.StringUtils.isEmpty(@Nullable Object str);

Diese Methode akzeptiert jedes Objekt als Argument und vergleicht es mit null und dem leeren String. Infolgedessen gibt diese Methode für ein Nicht-Null-Nicht-String-Objekt niemals true zurück.

Taras Melnyk
quelle
1
Beachten Sie, dass in der Dokumentation für StringUtils"Hauptsächlich für den internen Gebrauch innerhalb des Frameworks; betrachten Sie Apaches Commons Lang für eine umfassendere Suite von String-Dienstprogrammen" angegeben wird.
Fredrik Jonsén
0

Der bessere Weg, um mit Null in der Zeichenfolge umzugehen, ist:

str!=null && !str.equalsIgnoreCase("null") && !str.isEmpty()

Zusamenfassend,

str.length()>0 && !str.equalsIgnoreCase("null")
Bhanu Prakash Pasupula
quelle
0

So überprüfen Sie, ob alle Zeichenfolgenattribute in einem Objekt leer sind (anstatt! = Null für alle Feldnamen nach dem Java Reflection API-Ansatz zu verwenden

private String name1;
private String name2;
private String name3;

public boolean isEmpty()  {

    for (Field field : this.getClass().getDeclaredFields()) {
        try {
            field.setAccessible(true);
            if (field.get(this) != null) {
                return false;
            }
        } catch (Exception e) {
            System.out.println("Exception occurred in processing");
        }
    }
    return true;
}

Diese Methode würde true zurückgeben, wenn alle String-Feldwerte leer sind. Sie würde false zurückgeben, wenn ein Wert in den String-Attributen vorhanden ist

Lokeshkumar R.
quelle
0

Ich bin auf eine Situation gestoßen, in der ich überprüfen muss, ob "null" (als Zeichenfolge) als leer angesehen werden muss. Auch Leerzeichen und eine tatsächliche Null müssen true zurückgeben. Ich habe mich endlich für folgende Funktion entschieden ...

public boolean isEmpty(String testString) {
  return ((null==testString) || "".equals((""+testString).trim()) || "null".equals((""+testString).toLowerCase()));
}
Dave
quelle
0

Wenn Sie Ihre Methodenparameter validieren müssen, können Sie die folgende einfache Methode verwenden

public class StringUtils {

    static boolean anyEmptyString(String ... strings) {
        return Stream.of(strings).anyMatch(s -> s == null || s.isEmpty());
    }

}

Beispiel:

public String concatenate(String firstName, String lastName) {
    if(StringUtils.anyBlankString(firstName, lastName)) {
        throw new IllegalArgumentException("Empty field found");
    }
    return firstName + " " + lastName;
}
Marco Montel
quelle