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 */
    }
    /* ... */
}

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

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

Fügen Sie hier einfach Android hinzu:

import android.text.TextUtils;

if (!TextUtils.isEmpty(str)) {
...
}

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

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!

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

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

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.

Wie wäre es mit:

if(str!= null && str.length() != 0 )

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.

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 ("")

Gibt basierend auf der Eingabe true oder false zurück

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

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

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

Es gibt eine neue Methode in Java-11:: 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

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

Einfache Lösung:

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

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.

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
}

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

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.

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

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

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

StringUtils.hasLength(str)

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

Um auch Leerzeichen zu ignorieren:

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

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.

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

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

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

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