it-swarm.com.de

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

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

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. So stellen Sie sicher, dass Sie keine Ausnahme von Nullzeiger von str.isEmpty() erhalten, wenn str null ist.

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


Whitespace ebenfalls ignorieren:

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

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

In einer praktischen Funktion verpackt:

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

Wird:

if( !empty( str ) )
838
Colin Hebert

Verwenden Sie org.Apache.commons.lang.StringUtils

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

import org.Apache.commons.lang.StringUtils;

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

if (StringUtils.isBlank(str)) {
    ...
} 
193
Romain Linsolas

Hinzufügen von Android hier:

import Android.text.TextUtils;

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

Hinzufügen zu @BJorn und @SeanPatrickFloyd Der Guava-Weg, 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 um isBlank() geht (wie bei Whitespace oder nicht).

Guavas Version von Commons Lang isBlank wäre:

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

Ich werde sagen, dass Code, der "" (empty)UNDnull nicht erlaubt, verdächtig und potenziell fehlerhaft ist, da er wahrscheinlich nicht alle Fälle behandelt, in denen null nicht zulässig ist (obwohl für SQL ich verstehen kann wie SQL/HQL ist '') komisch.

42
Adam Gent
str != null && str.length() != 0

alternative

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

oder

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

Anmerkung: Bei der zweiten Prüfung (erste und zweite Alternative) wird davon ausgegangen, dass str nicht null ist. Das ist nur dann in Ordnung, weil die erste Prüfung das tut (und Java prüft nicht, ob die erste falsch ist).

WICHTIG: Verwenden Sie NICHT == für die Gleichheit von Zeichenfolgen. == 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!

33
helios

Das funktioniert für mich:

import com.google.common.base.Strings;

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

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

Erwägen Sie, Ihre Zeichenkettenreferenzen mit nullToEmpty zu normalisieren. Wenn du Sie können jedoch anstelle dieser Methode String.isEmpty () verwenden. benötigen spezielle nullsichere Formen von Methoden wie String.toUpperCase entweder. Oder, wenn Sie "in die andere Richtung" normalisieren möchten. Wenn Sie leere Zeichenfolgen in Null konvertieren, können Sie emptyToNull verwenden.

24
Javatar

Nahezu jede Bibliothek, die ich kenne, definiert eine Dienstprogrammklasse namens StringUtils, StringUtil oder StringHelper, und diese enthalten normalerweise die von Ihnen gesuchte Methode.

Mein persönlicher Favorit ist Apache Commons/Lang , wobei in der Klasse StringUtils beide angezeigt werden 

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

(Die erste prüft, ob eine Zeichenfolge null oder leer ist, die 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ügen </ S>


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

23

Wie wäre es mit:

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

Verwenden Sie die isNotBlank-Methode von Apache StringUtils 

StringUtils.isNotBlank(str)

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

7
A Null Pointer

Sie sollten org.Apache.commons.lang3.StringUtils.isNotBlank() oder org.Apache.commons.lang3.StringUtils.isNotEmpty verwenden. Die Entscheidung zwischen diesen beiden basiert auf dem, worauf Sie eigentlich prüfen möchten. 

Das isNotBlank () prüft, ob der Eingabeparameter der folgende ist: 

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

Das isNotEmpty () überprüft nur, ob der Eingabeparameter ist 

  • nicht null
  • nicht der leere String ("")
6
gprasant

Wenn Sie nicht die gesamte Bibliothek aufnehmen möchten; Fügen Sie einfach den gewünschten Code hinzu. Sie müssen es selbst aufrechterhalten. aber es ist eine ziemlich geradlinige 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;
}
5
Tom

Es ist etwas zu spät, aber es gibt einen funktionalen Prüfstil:

Optional.ofNullable(str)
    .filter(s -> !(s.trim().isEmpty()))
    .ifPresent(result -> {
       // your query setup goes here
    });
5
pilot

Gibt basierend auf der Eingabe true oder false zurück

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

Es gibt eine neue Methode in Java-11 : String#isBlank

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

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

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

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

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

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

String # isBlank

4
Anton Balaniuc

test entspricht einer leeren Zeichenfolge und null in derselben Bedingung:

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

Gibt NullPointerException nicht aus, wenn str null ist, da Object.equals() false zurückgibt, wenn arg null ist.

das andere Konstrukt str.equals("") würde die gefürchtete NullPointerException werfen. Einige betrachten möglicherweise ein schlechtes Formular, das ein String-Literal als Objekt verwendet, auf das equals() aufgerufen wird, aber es erledigt den Job. 

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

3
Mindwin

Einfache Lösung: 

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

Wie Seanizer oben gesagt hat, ist Apache StringUtils fantastisch. Wenn Sie Guava einbeziehen, 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 **/
}

Ich kann auch empfehlen, dass Sie sich auf die Spalten in der Ergebnismenge nach Name und nicht auf Index beziehen. Dadurch wird die Code-Verwaltung wesentlich einfacher.

2
BjornS

Ich habe meine eigene Utility-Funktion erstellt, um mehrere Strings gleichzeitig zu überprüfen, anstatt eine if-Anweisung voller if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty) zu haben. 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
}
2
W.K.S

Wenn Sie Java 8 verwenden und einen funktionaleren Programmieransatz verwenden möchten, können Sie ein Function definieren, das die Steuerung verwaltet, und Sie können es und apply() immer wieder verwenden.

In der Praxis können Sie Function als definieren 

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

Dann können Sie es verwenden, indem Sie einfach die apply()-Methode 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 Function definieren, das überprüft, ob das String leer ist, und es mit ! negieren.

In diesem Fall sieht Function folgendermaßen aus:

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

Dann können Sie es verwenden, indem Sie einfach die apply()-Methode aufrufen:

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

String notEmptyString = "StackOverflow";
!isEmpty.apply(notEmptyString); // this will return true
1
araknoid

Sie können StringUtils.isEmpty () verwenden. Es wird true zurückgegeben, 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

1
Vivek Vermani

Ich würde Guava oder Apache Commons entsprechend Ihren tatsächlichen Bedürfnissen beraten. Überprüfen Sie die unterschiedlichen 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

1
BlondCode

Wenn Sie Spring Boot verwenden, erledigt der folgende Code den Job

StringUtils.hasLength(str)
1
Avinash

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

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

Kehrt zurück: true, wenn der String nicht null ist und Länge hat

sowie die Methode

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

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

0
l00tr

So prüfen Sie, ob alle Zeichenfolgenattribute in einem Objekt leer sind (Verwenden Sie stattdessen! = Null für alle Feldnamen nach dem Ansatz der Java-Reflektions-API) 

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 in den String-Attributen Werte enthalten sind 

0
Lokeshkumar R

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

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

Zusamenfassend,

str.length()>0 && !str.equalsIgnoreCase("null")

Einfach auch Leerzeichen ignorieren:

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

Wenn Sie Spring Framework verwenden, können Sie die 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. Folglich wird diese Methode für ein Nicht-Nicht-String-Objekt niemals true zurückgeben.

0
Taras Melnyk

Ich bin auf eine Situation gestoßen, in der ich überprüfen muss, dass "null" (als Zeichenfolge) als leer betrachtet werden muss. Auch Leerzeichen und ein tatsächliches 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()));
}
0
Dave

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 String, das auch aus Leerzeichen besteht.

0
Stas