Bagaimana saya bisa mengecek apakah suatu string bukan nol dan tidak kosong?

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

Bagaimana dengan isEmpty () ?

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

Pastikan untuk menggunakan bagian-bagian &&dalam urutan ini, karena java tidak akan melanjutkan untuk mengevaluasi bagian kedua jika bagian pertama &&gagal, sehingga memastikan Anda tidak akan mendapatkan pengecualian penunjuk nol dari str.isEmpty()jika strnol.

Hati-hati, ini hanya tersedia sejak Java SE 1.6. Anda harus memeriksa str.length() == 0versi sebelumnya.

Untuk mengabaikan spasi putih juga:

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

(sejak Java 11 str.trim().isEmpty() dapat dikurangi str.isBlank()yang juga akan menguji ruang putih Unicode lainnya)

Dibungkus dalam fungsi praktis:

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

Menjadi:

if( !empty( str ) )

Gunakan org.apache.commons.lang.StringUtils

Saya suka menggunakan Apache commons-lang untuk hal-hal seperti ini, dan terutama kelas utilitas StringUtils :

import org.apache.commons.lang.StringUtils;

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

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

Cukup tambahkan Android di sini:

import android.text.TextUtils;

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

Untuk menambahkan ke @BJorn dan @SeanPatrickFloyd Cara Guava untuk melakukan ini adalah:

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

Commons Lang lebih mudah dibaca pada waktu-waktu tertentu tetapi saya perlahan-lahan lebih mengandalkan Guava dan kadang-kadang Commons Lang membingungkan ketika datang ke isBlank() (seperti apa spasi atau tidak).

Commons Lang versi Guava adalah isBlank:

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

Saya akan mengatakan kode yang tidak memungkinkan ""(kosong) DAN null mencurigakan dan berpotensi buggy karena mungkin tidak menangani semua kasus di mana tidak memungkinkan nullmasuk akal (meskipun untuk SQL saya bisa mengerti karena SQL / HQL aneh tentang '').

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

kalau tidak

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

atau

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

Catatan: Pemeriksaan kedua (alternatif pertama dan kedua) mengasumsikan str bukan nol. Tidak apa-apa hanya karena cek pertama melakukan itu (dan Java tidak melakukan pemeriksaan kedua jika yang pertama salah)!

PENTING: JANGAN gunakan == untuk persamaan string. == memeriksa pointer sama, bukan nilainya. Dua string dapat berada di alamat memori yang berbeda (dua contoh) tetapi memiliki nilai yang sama!

Hampir setiap perpustakaan yang saya kenal mendefinisikan kelas utilitas yang disebut StringUtils, StringUtilatau StringHelper, dan mereka biasanya menyertakan metode yang Anda cari.

Favorit pribadi saya adalah Apache Commons / Lang , di mana di kelas StringUtils , Anda mendapatkan keduanya

(Yang pertama memeriksa apakah sebuah string adalah nol atau kosong, yang kedua memeriksa apakah itu null, kosong atau hanya spasi putih)

Ada kelas utilitas serupa di Spring, Wicket dan banyak lib lainnya. Jika Anda tidak menggunakan perpustakaan eksternal, Anda mungkin ingin memperkenalkan kelas StringUtils di proyek Anda sendiri.

Update: bertahun-tahun telah berlalu, dan hari ini saya akan merekomendasikan menggunakan Jambu 's Strings.isNullOrEmpty(string)metode.

Ini bekerja untuk saya:

import com.google.common.base.Strings;

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

Mengembalikan nilai true jika string yang diberikan adalah null atau string yang kosong.

Pertimbangkan untuk menormalkan referensi string Anda dengan nullToEmpty. Jika ya, Anda dapat menggunakan String.isEmpty () alih-alih metode ini, dan Anda tidak akan memerlukan bentuk metode khusus null-safe seperti String.toUpperCase. Atau, jika Anda ingin menormalkan "ke arah lain," mengubah string kosong menjadi null, Anda dapat menggunakan emptyToNull.

Bagaimana tentang:

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

Gunakan metode Apache StringUtils isNotBlank seperti

StringUtils.isNotBlank(str)

Ini akan mengembalikan true hanya jika str tidak nol dan tidak kosong.

Anda harus menggunakan org.apache.commons.lang3.StringUtils.isNotBlank()atau org.apache.commons.lang3.StringUtils.isNotEmpty. Keputusan antara keduanya didasarkan pada apa yang sebenarnya ingin Anda periksa.

The isNotBlank () cek yang parameter input:

• bukan Null,
• bukan string kosong ("")
• bukan urutan karakter spasi putih ("")

The isNotEmpty () cek hanya bahwa parameter input

• bukan nol
• bukan String Kosong ("")

Mengembalikan nilai true atau false berdasarkan input

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

Jika Anda tidak ingin menyertakan seluruh perpustakaan; cukup sertakan kode yang Anda inginkan darinya. Anda harus memeliharanya sendiri; tapi itu fungsi yang cukup lurus ke depan. Ini disalin dari 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;
}

Ini agak terlambat, tetapi di sini ada gaya fungsional untuk memeriksa:

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

Ada metode baru di java-11: String#isBlank

Mengembalikan nilai true jika string kosong atau hanya berisi codepoint ruang putih, jika tidak palsu.

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

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

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

Ini dapat digabungkan dengan Optionaluntuk memeriksa apakah string nol atau kosong

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

String # isBlank

test sama dengan string kosong dan null dalam kondisi yang sama:

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

Tidak melempar NullPointerExceptionjika str adalah null, karena Object.equals()mengembalikan false jika arg adalah null.

konstruk lainnya str.equals("")akan melempar yang ditakuti NullPointerException. Beberapa orang mungkin menganggap bentuk buruk menggunakan String literal sebagai objek yang equals()disebut tetapi melakukan pekerjaan.

Periksa juga jawaban ini: https://stackoverflow.com/a/531825/1532705

Solusi sederhana:

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

Seperti kata seanizer di atas, Apache StringUtils sangat bagus untuk ini, jika Anda memasukkan jambu biji, Anda harus melakukan hal berikut;

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

Bolehkah saya juga merekomendasikan agar Anda merujuk ke kolom di hasil yang Anda atur dengan nama daripada dengan indeks, ini akan membuat kode Anda lebih mudah dipelihara.

Saya telah membuat fungsi utilitas saya sendiri untuk memeriksa beberapa string sekaligus, daripada memiliki pernyataan if penuh if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty). Ini fungsinya:

public class StringUtils{

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

        return true;
    }   

}

jadi saya bisa menulis:

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

Jika Anda menggunakan Java 8 dan ingin memiliki pendekatan Pemrograman yang Lebih Fungsional, Anda dapat menentukan Functionyang mengelola kontrol dan kemudian Anda dapat menggunakannya kembali dan apply()kapan pun diperlukan.

Datang untuk berlatih, Anda dapat mendefinisikan Functionsebagai

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

Kemudian, Anda dapat menggunakannya hanya dengan memanggil apply()metode sebagai:

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

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

Jika Anda mau, Anda dapat menentukan Functionyang memeriksa apakah Stringkosong dan kemudian meniadakannya !.

Dalam hal ini, Functionakan terlihat seperti:

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

Kemudian, Anda dapat menggunakannya hanya dengan memanggil apply()metode sebagai:

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

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

Dengan Java 8 Opsional Anda dapat melakukan:

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

Dalam ungkapan ini, Anda akan menangani Strings yang terdiri dari spasi juga.

Anda dapat menggunakan StringUtils.isEmpty (), Ini akan menghasilkan true jika string tersebut null atau kosong.

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

akan menghasilkan

str1 adalah nol atau kosong

str2 adalah nol atau kosong

Saya akan menyarankan Guava atau Apache Commons sesuai dengan kebutuhan Anda yang sebenarnya. Periksa berbagai perilaku dalam kode contoh saya:

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

Hasil:
Apache:
a kosong
b kosong
c kosong
Google:
b adalah NullOrEmpty
c adalah NullOrEmpty

Jika Anda menggunakan Spring Boot maka kode di bawah ini akan melakukan Pekerjaan

StringUtils.hasLength(str)

Untuk kelengkapan: Jika Anda sudah menggunakan kerangka Spring , StringUtils menyediakan metode

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

Pengembalian: true jika String tidak nol dan memiliki panjang

serta metodenya

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

Pengembalian: true jika String tidak nol, panjangnya lebih besar dari 0, dan tidak mengandung spasi saja

Cukup, untuk mengabaikan ruang putih juga:

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

Jika Anda menggunakan kerangka kerja Spring maka Anda dapat menggunakan metode:

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

Metode ini menerima Objek apa pun sebagai argumen, membandingkannya dengan null dan String kosong. Sebagai akibatnya, metode ini tidak akan pernah mengembalikan true untuk objek non-null non-null

Cara yang lebih baik untuk menangani null dalam string adalah,

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

Pendeknya,

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

Untuk memeriksa apakah semua atribut string dalam objek kosong (Alih-alih menggunakan! = Null pada semua nama bidang mengikuti pendekatan api refleksi java

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

Metode ini akan mengembalikan true jika semua nilai bidang String kosong, Ini akan mengembalikan false jika ada satu nilai hadir dalam atribut String

Saya telah mengalami situasi di mana saya harus memeriksa bahwa "null" (sebagai string) harus dianggap kosong. Juga ruang putih dan nol aktual harus mengembalikan true. Saya akhirnya menetapkan fungsi berikut ...

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

Jika Anda perlu memvalidasi parameter metode Anda, Anda dapat menggunakan ikuti metode sederhana

public class StringUtils {

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

}

Contoh:

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