Bir dizenin boş olup olmadığını nasıl kontrol edebilirim?

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

İsEmpty () ne olacak ?

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

&&Bu sırayla bölümlerini kullandığınızdan emin olun , çünkü java, ilk bölüm &&başarısız olursa ikinci bölümü değerlendirmeye devam etmez , bu nedenle null str.isEmpty()ise boş bir işaretçi istisnası stralmamanızı sağlar.

Dikkat edin, sadece Java SE 1.6'dan beri mevcuttur. str.length() == 0Önceki sürümleri kontrol etmelisiniz .

Boşluğu da yok saymak için:

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

(Java 11 str.trim().isEmpty(), str.isBlank()diğer Unicode beyaz alanlarını da test edecek şekilde azaltılabildiğinden )

Kullanışlı bir işlevle sarılmış:

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

Oluyor:

if( !empty( str ) )

kullanım Org.apache.commons.lang.StringUtils

Bu tür şeyler ve özellikle StringUtils yardımcı sınıf için Apache commons-lang kullanmayı seviyorum :

import org.apache.commons.lang.StringUtils;

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

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

Android'i buraya ekleyerek:

import android.text.TextUtils;

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

@BJorn ve @SeanPatrickFloyd'a eklemek için Bunu yapmanın Guava yolu:

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

Commons Lang zaman zaman daha okunabilir ama Guava'ya yavaşça daha fazla güveniyorum artı bazen Commons Lang söz konusu olduğunda kafa karıştırıcı oluyor isBlank()(beyaz boşlukta olan veya olmayan).

Guava'nın Commons Lang versiyonu isBlank:

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

Ben izin vermez ""(boş) VE null şüpheli ve potansiyel olarak buggy muhtemelen büyük olasılıkla izin vermeyen tüm durumlarda işlemez ki null(SQL için SQL / HQL hakkında garip olduğu gibi anlayabiliyorum ) kod koyacağız ''.

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

alternatif olarak

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

veya

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

Not: İkinci kontrol (birinci ve ikinci alternatifler) str'nin boş olmadığını varsayar. Sadece ilk kontrol bunu yapıyor çünkü Tamam (ve Java ilk yanlış olup olmadığını ikinci kontrol yapmaz)!

ÖNEMLİ: Dize eşitliği için == KULLANMAYIN. == işaretçinin değere eşit olup olmadığını denetler. İki dizgi farklı bellek adreslerinde (iki örnek) olabilir, ancak aynı değere sahiptir!

Bildiğim hemen hemen her kütüphane StringUtils, StringUtilveya adlı bir yardımcı sınıf tanımlar StringHelperve genellikle aradığınız yöntemi içerir.

Benim kişisel favorim Apache Commons / Lang içinde, StringUtils sınıfında elde edersiniz hem

(Birincisi bir dizenin boş veya boş olup olmadığını, ikincisinin boş, boş veya boşluk olup olmadığını kontrol eder)

İlkbahar, Wicket ve diğer birçok kütüphanede benzer yardımcı sınıflar vardır. Harici kitaplıklar kullanmazsanız, kendi projenize bir StringUtils sınıfı eklemek isteyebilirsiniz.

Güncelleme: Uzun yıllar geçti ve bu gün kullanıyorum tavsiye ederim Guava 'nın Strings.isNullOrEmpty(string)yöntemi.

Bu benim için çalışıyor:

import com.google.common.base.Strings;

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

Verilen dize null veya boş dize ise true değerini döndürür.

Dize referanslarınızı nullToEmpty ile normalleştirmeyi düşünün. Bunu yaparsanız, bu yöntem yerine String.isEmpty () kullanabilirsiniz ve String.toUpperCase gibi özel null-güvenli yöntemlere de ihtiyacınız yoktur. Veya, "diğer yönde" normalleştirmek isterseniz, boş dizeleri null değerine dönüştürmek istiyorsanız emptyToNull kullanabilirsiniz.

Nasıl olur:

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

Apache StringUtils 'isNotBlank yöntemini aşağıdaki gibi kullanın:

StringUtils.isNotBlank(str)

Yalnızca str boş değilse ve boş değilse true değerini döndürür.

Sen kullanmalısınız org.apache.commons.lang3.StringUtils.isNotBlank()veya org.apache.commons.lang3.StringUtils.isNotEmpty. Bu ikisi arasındaki karar, aslında ne kontrol etmek istediğinize dayanır.

İsNotBlank () giriş parametresi olup olmadığını kontrol eder:

• geçersiz değil,
• boş dize değil ("")
• boşluk karakterleri dizisi değil ("")

İsNotEmpty () giriş parametresidir sadece kontrol

• geçersiz değil
• Boş Dize ("") değil

Girdiye dayalı olarak doğru veya yanlış döndürür

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

Tüm kütüphaneyi dahil etmek istemiyorsanız; sadece ondan istediğiniz kodu ekleyin. Bunu kendiniz sürdürmeniz gerekecek; ama oldukça basit bir fonksiyon. Burada commons.apache.org adresinden kopyalanır.

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

Biraz çok geç, ama burada işlevsel bir kontrol tarzı:

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

'Da yeni bir yöntem var Java-11: String#isBlank

Dize boşsa veya yalnızca beyaz boşluk kod noktaları içeriyorsa true değerini, aksi takdirde false değerini döndürür.

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

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

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

Bu, Optionaldizenin boş veya boş olup olmadığını kontrol etmek için ile birleştirilebilir

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

Dize # ISBLANK

test, aynı koşulda boş bir dize ve null değerine eşittir:

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

NullPointerExceptionStr null olursa atar , çünkü Object.equals()arg ise false değerini döndürür null.

diğer yapı str.equals("")korkunç olanı fırlatacaktı NullPointerException. Bazıları equals(), çağrılırken nesne olarak bir String değişmezi kullanarak kötü formu düşünebilir , ancak bu işi yapar.

Ayrıca bu yanıtı da kontrol edin: https://stackoverflow.com/a/531825/1532705

Basit çözüm:

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

Seanizer yukarıda belirtildiği gibi, Apache StringUtils bunun için harika, guava dahil etmek eğer şunları yapmalısınız;

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

Ayrıca, sonuç kümenizdeki sütunlara dizin yerine ada göre de başvurmanızı öneririm, bu kodunuzun bakımını daha kolay hale getirir.

Ben tam bir if deyimi yerine, aynı anda birkaç dizeleri kontrol etmek için kendi yarar işlevi yaptım if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty). Bu işlev:

public class StringUtils{

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

        return true;
    }   

}

bu yüzden yazabilirim:

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

Java 8 kullanıyorsanız ve daha İşlevsel Programlama yaklaşımına sahip olmak istiyorsanız Function, denetimi yöneten bir tanım tanımlayabilir ve sonra yeniden ve apply()gerektiğinde yeniden kullanabilirsiniz .

Uygulamada gelince, sen tanımlayabilirsiniz Functionolarak

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

Ardından, apply()yöntemi şu şekilde çağırarak kullanabilirsiniz :

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

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

İsterseniz , boş Functionolup olmadığını kontrol eden Stringve daha sonra ile olumsuzlayan bir tanımlayabilirsiniz !.

Bu durumda, aşağıdaki Functiongibi görünecektir:

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

Ardından, apply()yöntemi şu şekilde çağırarak kullanabilirsiniz :

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

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

İle Java 8 İsteğe Yapabileceğiniz:

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

Bu ifadede, Stringboşluklardan oluşan leri de ele alacaksınız .

StringUtils.isEmpty () kullanabilirsiniz, dize null veya boşsa true ile sonuçlanır.

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

sonuçlanacak

str1 boş veya değer yok

str2 boş veya değer yok

Guava veya Apache Commons'ı gerçek ihtiyacınıza göre tavsiye ederim. Örnek kodumdaki farklı davranışları kontrol edin:

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

Sonuç:
Apache:
a boş
b boş
c c boş
Google:
b NullOrEmpty
c boş NullOrEmpty

Spring Boot kullanıyorsanız aşağıdaki kod İşi yapacak

StringUtils.hasLength(str)

Tamlık için : Zaten Spring çerçevesini kullanıyorsanız , StringUtils yöntemi sağlar

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

Döndürür: String boş değilse ve uzunluğu varsa true

yanı sıra yöntem

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

Döndürür: String boş değilse, uzunluğu 0'dan büyükse ve yalnızca boşluk içermiyorsa true

Basitçe, beyaz alanı da göz ardı etmek için:

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

Spring framework kullanıyorsanız, o zaman yöntemi kullanabilirsiniz:

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

Bu yöntem, herhangi bir Object'i null ve boş String ile karşılaştırarak argüman olarak kabul eder. Sonuç olarak, bu yöntem null olmayan bir String olmayan nesne için asla true değerini döndürmez.

Dizede null değerinin işlenmesinin en iyi yolu,

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

Kısacası,

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

Bir nesnedeki tüm dize niteliklerinin boş olup olmadığını kontrol etmek için (java yansıma api yaklaşımını izleyen tüm alan adlarında! = Null kullanmak yerine

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

Tüm String alanı değerleri boşsa bu yöntem true değerini döndürür, String özniteliklerinde herhangi bir değer varsa false değerini döndürür

"Boş" (dize olarak) boş olarak kabul edilmelidir kontrol etmeniz gereken bir durumla karşılaştım. Ayrıca beyaz boşluk ve gerçek null değerinin doğru olması gerekir. Sonunda aşağıdaki işleve karar verdim ...

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

Yöntem parametrelerinizi doğrulamanız gerektiğinde aşağıdaki basit yöntemi kullanabilirsiniz

public class StringUtils {

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

}

Misal:

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