Jak mogę sprawdzić, czy łańcuch nie jest pusty i nie jest pusty?

public void doStuff(String str)
{
    if (str != null && str != "**here I want to check the 'str' is empty or not**")
    {
        /* handle empty string */
    }
    /* ... */
}

Co z isEmpty () ?

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

Pamiętaj, aby użyć części &&w tej kolejności, ponieważ Java nie będzie oceniać drugiej części, jeśli pierwsza część się &&nie powiedzie, zapewniając w ten sposób, że nie otrzymasz wyjątku wskaźnika zerowego od str.isEmpty()if strjest null.

Uwaga, jest dostępna tylko od wersji Java SE 1.6. Musisz sprawdzić str.length() == 0poprzednie wersje.

Aby zignorować również białe znaki:

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

(ponieważ Java 11 str.trim().isEmpty()może zostać zredukowana, do str.isBlank()której będzie również testowane inne białe znaki Unicode)

Zawinięty w przydatną funkcję:

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

Staje się:

if( !empty( str ) )

Użyj org.apache.commons.lang.StringUtils

Lubię używać Apache commons-lang do tego rodzaju rzeczy, a zwłaszcza klasy narzędzi StringUtils :

import org.apache.commons.lang.StringUtils;

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

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

Właśnie dodałem tutaj Androida:

import android.text.TextUtils;

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

Aby dodać do @BJorn i @SeanPatrickFloyd Sposób Guava to zrobić:

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

Commons Lang jest czasami bardziej czytelny, ale powoli polegam bardziej na Guava, a czasem Commons Lang jest mylący, jeśli chodzi o isBlank()(jak w tym, co jest spacją, czy nie).

Wersja Commons Lang autorstwa Guava to isBlank:

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

Powiem, że kod, który nie pozwala ""(pusty) ORAZ null jest podejrzany i potencjalnie błędny, ponieważ prawdopodobnie nie obsługuje wszystkich przypadków, w których niedozwolone nullma sens (chociaż w przypadku SQL rozumiem, że SQL / HQL jest dziwny '').

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

alternatywnie

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

lub

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

Uwaga: Druga kontrola (pierwsza i druga alternatywa) zakłada, że ​​str nie jest zerowy. Jest w porządku tylko dlatego, że robi to pierwsza kontrola (a Java nie wykonuje drugiej kontroli, jeśli pierwsza jest fałszywa)!

WAŻNE: NIE używaj == dla równości łańcuchów. == sprawdza, czy wskaźnik jest równy, a nie wartość. Dwa ciągi znaków mogą znajdować się w różnych adresach pamięci (dwa wystąpienia), ale mają tę samą wartość!

Niemal każda biblioteka wiem definiuje klasę użytkową nazwie StringUtils, StringUtilalbo StringHelper, i zazwyczaj obejmują sposób, którego szukasz.

Moim ulubionym jest Apache Commons / Lang , gdzie w klasie StringUtils dostajesz oba

(Pierwszy sprawdza, czy łańcuch jest pusty, czy drugi, czy jest pusty, czy zawiera tylko białe znaki)

Istnieją podobne klasy narzędzi w Spring, Wicket i wiele innych bibliotek. Jeśli nie korzystasz z bibliotek zewnętrznych, możesz chcieć wprowadzić klasę StringUtils we własnym projekcie.

Aktualizacja: wiele lat minęło, a te dni, polecam za pomocą Guava „s Strings.isNullOrEmpty(string)metody.

To działa dla mnie:

import com.google.common.base.Strings;

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

Zwraca true, jeśli podany ciąg ma wartość NULL lub jest łańcuchem pustym.

Rozważ normalizację odwołań do ciągu za pomocą nullToEmpty. Jeśli to zrobisz, możesz użyć String.isEmpty () zamiast tej metody i nie będziesz potrzebować specjalnych form bezpiecznych dla wartości zerowych, takich jak String.toUpperCase. Lub, jeśli chcesz znormalizować „w innym kierunku”, konwertując puste ciągi na null, możesz użyć emptyToNull.

Co powiesz na:

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

Użyj metody isNotBlank Apache StringUtils jak

StringUtils.isNotBlank(str)

Zwróci true tylko wtedy, gdy str nie ma wartości null i nie jest puste.

Powinieneś użyć org.apache.commons.lang3.StringUtils.isNotBlank()lub org.apache.commons.lang3.StringUtils.isNotEmpty. Decyzja między tymi dwoma opiera się na tym, co naprawdę chcesz sprawdzić.

W isNotBlank () sprawdza, czy parametr wejściowy wynosi:

• Nie jest zerem,
• nie pusty ciąg („”)
• nie sekwencja białych znaków („”)

IsNotEmpty () sprawdza tylko, że parametr wejściowy jest

• Nie jest zerem
• nie pusty ciąg („”)

Zwraca wartość true lub false na podstawie danych wejściowych

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

Jeśli nie chcesz uwzględniać całej biblioteki; po prostu dołącz żądany kod. Będziesz musiał sam to utrzymać; ale jest to dość prosta funkcja. Tutaj jest kopiowany z commons.apache.org

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

Jest trochę za późno, ale oto funkcjonalny styl sprawdzania:

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

Istnieje nowa metoda w java-11: String#isBlank

Zwraca true, jeśli łańcuch jest pusty lub zawiera tylko białe znaki kodowe, w przeciwnym razie false.

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

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

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

Można to połączyć z, Optionalaby sprawdzić, czy ciąg znaków jest pusty lub pusty

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

Ciąg # isBlank

test jest równy pustemu ciągowi i zeru w tym samym warunku:

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

Nie wyrzuca, NullPointerExceptionjeśli str ma wartość null, ponieważ Object.equals()zwraca false, jeśli argument ma wartość null.

drugi konstrukt str.equals("")rzuciłby przerażenie NullPointerException. Niektórzy mogą rozważyć złą formę, używając dosłownego ciągu jako obiektu, który equals()zostanie wywołany, ale spełnia swoją rolę.

Sprawdź również tę odpowiedź: https://stackoverflow.com/a/531825/1532705

Proste rozwiązanie:

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

Jak powiedział powyżej seanizer, Apache StringUtils jest do tego fantastyczny, jeśli chcesz włączyć guawę, wykonaj następujące czynności;

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

Czy mogę również polecić odwoływanie się do kolumn w zestawie wyników według nazwy, a nie indeksu, co znacznie ułatwi obsługę kodu.

Stworzyłem własną funkcję narzędziową do sprawdzania kilku ciągów naraz, zamiast mieć pełną instrukcję if if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty). To jest funkcja:

public class StringUtils{

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

        return true;
    }   

}

więc mogę po prostu napisać:

if(!StringUtils.areSet(firstName,lastName,address)
{
    //do something
}

Jeśli używasz Java 8 i chcesz mieć bardziej funkcjonalne podejście do programowania, możesz zdefiniować, Functionktóry zarządza kontrolą, a następnie możesz użyć go ponownie iapply() kiedy zajdzie taka potrzeba.

Idąc do praktyki, możesz zdefiniować Functionjako

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

Następnie możesz go użyć, po prostu wywołując apply()metodę jako:

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

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

Jeśli wolisz, możesz zdefiniować, Functionktóry sprawdza, czy Stringjest pusty, a następnie zanegować za pomocą! .

W takim przypadku Functionbędzie wyglądać następująco:

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

Następnie możesz go użyć, po prostu wywołując apply()metodę jako:

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

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

Za pomocą Java 8 Optional możesz:

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

W tym wyrażeniu poradzisz sobie również z Stringliterami spacji.

Możesz użyć StringUtils.isEmpty (). Wynik będzie prawdziwy, jeśli łańcuch będzie zerowy lub pusty.

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

spowoduje

str1 jest zerowy lub pusty

str2 ma wartość NULL lub jest puste

Poradziłbym Guava lub Apache Commons zgodnie z twoją rzeczywistą potrzebą. Sprawdź różne zachowania w moim przykładowym kodzie:

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

Wynik:
Apache:
a jest puste
b jest puste
c jest puste
Google:
b to NullOrEmpty
c to NullOrEmpty

Jeśli używasz Spring Boot, poniższy kod wykona zadanie

StringUtils.hasLength(str)

Dla kompletności: jeśli już korzystasz ze struktury Spring , StringUtils udostępnia metodę

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

Zwraca: true, jeśli Łańcuch nie jest pusty i ma długość

jak również metoda

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

Zwraca: true, jeśli Łańcuch nie jest pusty, jego długość jest większa od 0 i nie zawiera tylko białych znaków

Po prostu, aby zignorować również białe znaki:

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

Jeśli używasz platformy Spring, możesz użyć metody:

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

Ta metoda przyjmuje dowolny obiekt jako argument, porównując go do wartości null i pustego ciągu. W rezultacie ta metoda nigdy nie zwróci wartości true dla niepustego obiektu innego niż String.

Lepszym sposobem obsługi wartości null w ciągu jest

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

W skrócie,

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

Aby sprawdzić, czy wszystkie atrybuty łańcucha w obiekcie są puste (Zamiast używać! = Null dla wszystkich nazw pól po podejściu API do Java odbicie

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

Ta metoda zwróciłaby wartość true, jeśli wszystkie wartości pola String są puste, Zwróciłaby wartość false, jeśli w atrybutach String występuje jedna wartość

Zetknąłem się z sytuacją, w której muszę sprawdzić, czy „null” (jako ciąg znaków) należy uznać za pusty. Również biała spacja i rzeczywista wartość null muszą zwracać wartość true. W końcu zdecydowałem się na następującą funkcję ...

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

W przypadku konieczności zweryfikowania parametrów metody można użyć prostej metody

public class StringUtils {

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

}

Przykład:

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