web-dev-qa-db-de.com

Am besten überprüfen Sie, ob Zeichenfolge leer oder null ist

ich bin mir sicher, dass dies zuvor auf unterschiedliche Weise gefragt wurde - da isEmptyOrNull so häufig ist, wird es doch von den Leuten anders umgesetzt. aber ich habe unten neugierige abfragen hinsichtlich des besten verfügbaren ansatzes, der sowohl für den speicher als auch für die leistung gut ist. 

1) Im Folgenden werden nicht alle Leerzeichen berücksichtigt, wie bei einem leeren XML-Tag

return inputString==null || inputString.length()==0;

2) Darauf achtet man, aber Trimmen kann etwas Leistung + Gedächtnis fressen 

return inputString==null || inputString.trim().length()==0;

3) In Pattern Matcher konvertiert (wird nur aufgerufen, wenn die Zeichenfolge nicht null ist)

private static final Pattern p = Pattern.compile("\\s+");

return inputString==null || inputString.length()==0 || p.matcher(inputString).matches();

4) Noch etwas?

20
prash

Nützliche Methode von Apache Commons:

 org.Apache.commons.lang.StringUtils.isBlank(String str)

https://commons.Apache.org/proper/commons-lang/javadocs/api-2.6/org/Apache/commons/lang/StringUtils.html#isBlank(Java.lang.String)

19
puczo

Um festzustellen, ob eine Zeichenfolge null oder leer ist, können Sie Folgendes verwenden, ohne externe Abhängigkeiten von Ihrem Projekt zu berücksichtigen, und trotzdem Ihren Code einfach und sauber zu halten:

if(myString==null || myString.isEmpty()){
    //do something
}

oder wenn auch Leerzeichen erkannt werden sollen:

if(myString==null || myString.trim().isEmpty()){
    //do something
}

sie können diese leicht in Utility-Methoden einbinden, um sie übersichtlicher zu gestalten, da es sich um sehr häufig durchzuführende Überprüfungen handelt:

public final class StringUtils{

    private StringUtils() { }   

    public static bool isNullOrEmpty(string s){
        if(s==null || s.isEmpty()){
            return true;
        }
        return false;
    }

    public static bool isNullOrWhiteSpace(string s){
        if(s==null || s.trim().isEmpty()){
            return true;
        }
        return false;
    }
}

und dann rufen Sie diese Methoden über:

if(StringUtils.isNullOrEmpty(myString)){...}

und

if(StringUtils.isNullOrWhiteSpace(myString)){...}

17
GregH

Nur um die Position von Java 8 zu zeigen, um Nullwerte zu entfernen.

String s = Optional.ofNullable(myString).orElse("");
if (s.trim().isEmpty()) {
    ...
}

Ist sinnvoll, wenn Sie Optional<String> verwenden können.

12
Joop Eggen

Dieser von Google Guava könnte "null und leerer String" gleichzeitig auschecken.

Strings.isNullOrEmpty("Your string.");

Fügen Sie eine Abhängigkeit mit Maven hinzu

<dependency>
  <groupId>com.google.guava</groupId>
  <artifactId>guava</artifactId>
  <version>20.0</version>
</dependency>

mit Gradle

dependencies {
  compile 'com.google.guava:guava:20.0'
}
7
mavis.chen
Optional.ofNullable(label)
.map(String::trim)
.map(string -> !label.isEmpty)
.orElse(false)

OR

TextUtils.isNotBlank(label);

die letzte Lösung prüft, ob nicht null und schneidet die Zeichenkette gleichzeitig ab

2
haneenCo

Apache Commons Lang hat die StringUtils.isEmpty(String str)-Methode, die true zurückgibt, wenn das Argument leer oder null ist

2

In den meisten Fällen würde StringUtils.isBlank(str) aus der Apache-Commons-Bibliothek das Problem lösen. Wenn es jedoch Fälle gibt, in denen die zu überprüfende Eingabezeichenfolge einen Nullwert in Anführungszeichen hat, können solche Fälle nicht geprüft werden.

Nehmen Sie ein Beispiel, bei dem ich ein Eingabeobjekt habe, das mit String.valueOf(obj) API in eine Zeichenfolge konvertiert wurde. Falls die Objektreferenz null ist, gibt String.valueOf "null" anstelle von null zurück.

Wenn Sie versuchen, die StringUtils.isBlank("null")-API fehlerhaft zu verwenden, müssen Sie möglicherweise nach solchen Anwendungsfällen suchen, um sicherzustellen, dass Ihre Validierung korrekt ist.

1

Ich habe noch keine nativen Lösungen gesehen. Hier ist eine:

return str == null || str.chars().allMatch(Character::isWhitespace);

Verwenden Sie grundsätzlich die native Funktion Character.isWhitespace (). Von dort aus können Sie verschiedene Optimierungsstufen erreichen, je nachdem, wie wichtig dies ist (ich kann Ihnen versichern, dass in 99,99999% der Anwendungsfälle keine weitere Optimierung erforderlich ist):

return str == null || str.length() == 0 || str.chars().allMatch(Character::isWhitespace);

Oder um wirklich optimal zu sein (aber hässlich):

int len;
if (str == null || (len = str.length()) == 0) return true;
for (int i = 0; i < len; i++) {
  if (!Character.isWhitespace(str.charAt(i))) return false;
}
return true;

Eine Sache, die ich gerne mache:

Optional<String> notBlank(String s) {
  return s == null || s.chars().allMatch(Character::isWhitepace))
    ? Optional.empty()
    : Optional.of(s);
}

...

notBlank(myStr).orElse("some default")
0
gzak

Einfach und klar:

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

Wenn Sie mehr als eine Zeichenfolge in derselben Validierung testen müssen, können Sie Folgendes tun:

import Java.util.Optional;
import Java.util.function.Predicate;
import Java.util.stream.Stream;

public class StringHelper {

  public static Boolean hasBlank(String ... strings) {

    Predicate<String> isBlank = s -> s == null || s.trim().isEmpty();

    return Optional
      .ofNullable(strings)
      .map(Stream::of)
      .map(stream -> stream.anyMatch(isBlank))
      .orElse(false);
  }

}

Sie können dies also wie StringHelper.hasBlank("Hello", null, "", " ") oder StringHelper.hasBlank("Hello") in einer generischen Form verwenden.

0
rsa

Sie können die optionale und die Apache-Commons-Stringutils-Bibliothek verwenden

Optional.ofNullable(StringUtils.noEmpty(string1)).orElse(string2);

hier wird geprüft, ob string1 nicht null und nicht leer ist. Andernfalls wird string2 zurückgegeben

0
Deepak Pandey

springframework library Überprüfe, ob der angegebene String leer ist.

f(StringUtils.isEmpty("")) {
    //.... String is blank or null
}
0
gifpif