Bagaimana cara memeriksa apakah string saya sama dengan nol?

Saya ingin melakukan beberapa tindakan HANYA JIKA string saya memiliki nilai yang bermakna. Jadi, saya mencoba ini.

if (!myString.equals("")) {
doSomething
}

dan ini

if (!myString.equals(null)) {
doSomething
}

dan ini

if ( (!myString.equals("")) && (!myString.equals(null))) {
doSomething
}

dan ini

if ( (!myString.equals("")) && (myString!=null)) {
doSomething
}

dan ini

if ( myString.length()>0) {
doSomething
}

Dan dalam semua kasus, program saya doSomethingterlepas dari fakta bahwa string saya KOSONG. Itu sama dengan null. Jadi, apa yang salah dengan itu?

TAMBAH:

Saya menemukan alasan masalahnya. Variabel dinyatakan sebagai string dan, sebagai konsekuensinya, nullditugaskan untuk variabel ini ditransformasikan menjadi "null"! Jadi, if (!myString.equals("null"))berhasil.

if (myString != null && !myString.isEmpty()) {
  // doSomething
}

Sebagai komentar lebih lanjut, Anda harus mengetahui istilah ini dalam equalskontrak:

Dari Object.equals(Object):

Untuk nilai referensi yang bukan nol x, x.equals(null)harus return false.

Cara untuk membandingkan dengan nullmenggunakan x == nulldan x != null.

Apalagi, x.fielddan x.method()melempar NullPointerExceptionjika x == null.

Jika myStringadalah null, kemudian memanggil myString.equals(null)atau myString.equals("")akan gagal dengan NullPointerException. Anda tidak dapat memanggil metode instance apa pun pada variabel nol.

Periksa null terlebih dahulu seperti ini:

if (myString != null && !myString.equals("")) {
    //do something
}

Ini menggunakan evaluasi hubung singkat untuk tidak mencoba .equalsjika myStringgagal pemeriksaan nol.

Apache commons StringUtils.isNotEmptyadalah cara terbaik untuk melakukannya.

Jika myString sebenarnya nol, maka setiap panggilan ke referensi akan gagal dengan Null Pointer Exception (NPE). Sejak java 6, gunakan #isEmpty alih-alih panjang cek (dalam hal apapun JANGAN PERNAH membuat String kosong baru dengan centang).

if (myString != null &&  !myString.isEmpty()){
    doSomething();
}

Kebetulan jika membandingkan dengan String literal seperti yang Anda lakukan, akan membalikkan pernyataan agar tidak harus memiliki cek nol, yaitu,

if ("some string to check".equals(myString)){
  doSomething();
} 

dari pada :

if (myString != null &&  myString.equals("some string to check")){
    doSomething();
}

BEKERJA !!!!

if (myString != null && !myString.isEmpty()) {
    return true;
}
else {
    return false;
}

Anda perlu memeriksa bahwa myStringobjeknya adalah null:

if (myString != null) {
    doSomething
}

Jika string Anda nol, panggilan seperti ini akan menghasilkan NullReferenceException:

myString.equals (null)

Tapi bagaimanapun, saya pikir metode seperti ini yang Anda inginkan:

public static class StringUtils
{
    public static bool isNullOrEmpty(String myString)
    {
         return myString == null || "".equals(myString);
    }
}

Kemudian dalam kode Anda, Anda dapat melakukan hal-hal seperti ini:

if (!StringUtils.isNullOrEmpty(myString))
{
    doSomething();
}

Saya akan mendorong menggunakan utilitas yang ada, atau membuat metode Anda sendiri:

public static boolean isEmpty(String string) {
    return string == null || string.length() == 0;
}

Kemudian gunakan saja saat Anda membutuhkannya:

if (! StringUtils.isEmpty(string)) {
  // do something
}

Seperti disebutkan di atas, || dan && operator hubungan pendek. Itu berarti segera setelah mereka dapat menentukan nilai mereka berhenti. Jadi jika (string == null) benar, bagian panjang tidak perlu dievaluasi, karena ekspresi selalu benar. Demikian juga dengan &&, di mana jika sisi kiri salah, ekspresi selalu salah dan tidak perlu dievaluasi lebih lanjut.

Sebagai catatan tambahan, menggunakan panjang umumnya merupakan ide yang lebih baik daripada menggunakan .equals. Performanya sedikit lebih baik (tidak banyak), dan tidak memerlukan pembuatan objek (walaupun kebanyakan kompiler mungkin mengoptimalkan ini).

Mencoba,

myString!=null && myString.length()>0

 if (myString != null && myString.length() > 0) {

        // your magic here

 }

Kebetulan, jika Anda melakukan banyak manipulasi string, ada kelas Spring yang hebat dengan segala macam metode yang berguna:

http://static.springsource.org/spring/docs/2.5.x/api/org/springframework/util/StringUtils.html

Setiap kali saya harus berurusan dengan string (hampir setiap waktu) saya berhenti dan bertanya-tanya di mana sebenarnya cara tercepat untuk memeriksa string kosong. Tentu saja string.Length == 0 centang harus menjadi yang tercepat karena Panjang adalah properti dan tidak boleh ada pemrosesan selain mengambil nilai properti. Tapi kemudian saya bertanya pada diri sendiri, mengapa ada String. Seharusnya lebih cepat memeriksa String. Jauh dari panjang, kataku pada diri sendiri. Yah aku akhirnya memutuskan untuk mengujinya. Saya membuat kode aplikasi Konsol Windows kecil yang memberi tahu saya berapa lama waktu yang dibutuhkan untuk melakukan pemeriksaan tertentu untuk 10 juta replikasi. Saya memeriksa 3 string berbeda: string NULL, string Kosong, dan string "". Saya menggunakan 5 metode berbeda: String.IsNullOrEmpty (), str == null, str == null || str == String.Empty, str == null || str == "", str == null || str.

String.IsNullOrEmpty()
NULL = 62 milliseconds
Empty = 46 milliseconds
"" = 46 milliseconds

str == null
NULL = 31 milliseconds
Empty = 46 milliseconds
"" = 31 milliseconds

str == null || str == String.Empty
NULL = 46 milliseconds
Empty = 62 milliseconds
"" = 359 milliseconds

str == null || str == ""
NULL = 46 milliseconds
Empty = 343 milliseconds
"" = 78 milliseconds

str == null || str.length == 0
NULL = 31 milliseconds
Empty = 63 milliseconds
"" = 62 milliseconds

Menurut hasil ini, pemeriksaan rata-rata str == nulladalah yang tercepat, tetapi mungkin tidak selalu menghasilkan apa yang kami cari. if str = String.Emptyatau str = "", itu menghasilkan false. Maka Anda memiliki 2 yang terikat di tempat kedua: String.IsNullOrEmpty()dan str == null || str.length == 0. Karena String.IsNullOrEmpty()terlihat lebih bagus dan lebih mudah (dan lebih cepat) untuk menulis, saya akan merekomendasikan menggunakannya daripada solusi lain.

Saya akan melakukan sesuatu seperti ini:

( myString != null && myString.length() > 0 )
    ? doSomething() : System.out.println("Non valid String");

• Menguji cek nol apakah myString berisi instance String.
• length () mengembalikan panjangnya dan sama dengan equals ("").
• Memeriksa apakah myString adalah null terlebih dahulu akan menghindari NullPointerException.

Saya telah menggunakan StringUtil.isBlank(string)

Ini menguji apakah string kosong: null, emtpy, atau hanya spasi putih.

Jadi yang ini adalah yang terbaik sejauh ini

Berikut adalah metode orignal dari dokumen

/**
    * Tests if a string is blank: null, emtpy, or only whitespace (" ", \r\n, \t, etc)
    * @param string string to test
    * @return if string is blank
    */
    public static boolean isBlank(String string) {
        if (string == null || string.length() == 0)
            return true;

        int l = string.length();
        for (int i = 0; i < l; i++) {
            if (!StringUtil.isWhitespace(string.codePointAt(i)))
                return false;
        }
        return true;
    } 

Ini seharusnya bekerja:

if (myString != null && !myString.equals(""))
    doSomething
}

Jika tidak, maka myString kemungkinan memiliki nilai yang tidak Anda harapkan. Coba cetak seperti ini:

System.out.println("+" + myString + "+");

Menggunakan simbol '+' untuk mengelilingi string akan menunjukkan kepada Anda jika ada spasi kosong di sana yang tidak Anda perhitungkan.

if(str.isEmpty() || str==null){ do whatever you want }

Oke ini adalah cara kerja tipe data di Jawa. (Anda harus memaafkan bahasa Inggris saya, saya mungkin tidak menggunakan kosakata yang tepat. Anda harus membedakan keduanya. Jenis data dasar dan tipe data normal. Tipe data dasar cukup banyak membentuk semua yang ada. Misalnya, ada semua angka, char, boolean, dll. Tipe data normal atau tipe data kompleks adalah yang lainnya. String adalah array karakter, oleh karena itu tipe data kompleks.

Setiap variabel yang Anda buat sebenarnya adalah penunjuk pada nilai di memori Anda. Sebagai contoh:

String s = new String("This is just a test");

variabel "s" TIDAK mengandung String. Itu adalah sebuah pointer. Pointer ini menunjuk pada variabel di memori Anda. Ketika Anda menelepon System.out.println(anyObject), toString()metode objek itu disebut. Jika tidak menimpa toStringdari Object, itu akan mencetak pointer. Sebagai contoh:

public class Foo{
    public static void main(String[] args) {
        Foo f = new Foo();
        System.out.println(f);
    }
}

>>>>
>>>>
>>>>Foo@330bedb4

Segala sesuatu di belakang "@" adalah penunjuk. Ini hanya berfungsi untuk tipe data yang kompleks. Tipe data primitif secara LANGSUNG disimpan dalam penunjuknya. Jadi sebenarnya tidak ada pointer dan nilainya disimpan secara langsung.

Sebagai contoh:

int i = 123;

saya TIDAK menyimpan pointer dalam hal ini. saya akan menyimpan nilai integer 123 (dalam byte ofc).

Oke jadi ayo kembali ke ==operator. Itu selalu membandingkan pointer dan bukan konten yang disimpan pada posisi pointer di memori.

Contoh:

String s1 = new String("Hallo");
String s2 = new String("Hallo");

System.out.println(s1 == s2);

>>>>> false

String kedua ini memiliki pointer yang berbeda. Namun String.equals (String other) membandingkan konten. Anda dapat membandingkan tipe data primitif dengan operator '==' karena pointer dari dua objek berbeda dengan konten yang sama adalah sama.

Null akan berarti bahwa pointernya kosong. Tipe data primitif kosong secara default adalah 0 (untuk angka). Null untuk objek kompleks bagaimanapun berarti, objek itu tidak ada.

Salam pembuka

Bagi saya pemeriksaan terbaik jika string memiliki konten yang bermakna di Jawa adalah yang ini:

string != null && !string.trim().isEmpty()

Pertama Anda memeriksa apakah string nullharus dihindari NullPointerExceptiondan kemudian Anda memotong semua karakter spasi untuk menghindari memeriksa string yang hanya memiliki spasi putih dan akhirnya Anda memeriksa apakah string yang dipangkas tidak kosong, yaitu memiliki panjang 0.

Saya punya masalah ini di android dan saya menggunakan cara ini (Bekerja untuk saya):

String test = null;
if(test == "null"){
// Do work
}

Tetapi dalam kode java saya menggunakan:

String test = null;
if(test == null){
// Do work
}

Dan:

private Integer compareDateStrings(BeanToDoTask arg0, BeanToDoTask arg1, String strProperty) {
    String strDate0 = BeanUtils.getProperty(arg0, strProperty);_logger.debug("strDate0 = " + strDate0);
    String strDate1 = BeanUtils.getProperty(arg1, strProperty);_logger.debug("strDate1 = " + strDate1);
    return compareDateStrings(strDate0, strDate1);
}

private Integer compareDateStrings(String strDate0, String strDate1) {
    int cmp = 0;
    if (isEmpty(strDate0)) {
        if (isNotEmpty(strDate1)) {
            cmp = -1;
        } else {
            cmp = 0;
        }
    } else if (isEmpty(strDate1)) {
        cmp = 1;
    } else {
        cmp = strDate0.compareTo(strDate1);
    }
    return cmp;
}

private boolean isEmpty(String str) {
    return str == null || str.isEmpty();
}
private boolean isNotEmpty(String str) {
    return !isEmpty(str);
}

Saya lebih suka menggunakan:

if(!StringUtils.isBlank(myString)) { // checks if myString is whitespace, empty, or null
    // do something
}

Baca StringUtils.isBlank () vs String.isEmpty () .

Di Android Anda dapat memeriksa ini dengan metode utilitas isEmptydari TextUtils,

public static boolean isEmpty(CharSequence str) {
    return str == null || str.length() == 0;
}

isEmpty(CharSequence str)Metode memeriksa kedua kondisi, untuk nulldan panjang.

Saya selalu menggunakan seperti ini:

if (mystr != null && !mystr.isEmpty()){
  //DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}else {
  //DO WHATEVER YOU WANT OR LEAVE IT EMPTY
}

atau Anda dapat menyalin ini ke proyek Anda:

private boolean isEmptyOrNull(String mystr){
    if (mystr != null && !mystr.isEmpty()){ return true; }
    else { return false; }
}

dan sebut saja seperti:

boolean b = isEmptyOrNull(yourString);

itu akan mengembalikan true jika kosong atau nol.
b=truejika kosong atau nol

atau Anda dapat menggunakan coba tangkap dan tangkap saat itu nol.

Saya pikir myString bukan string tetapi array string. Inilah yang perlu Anda lakukan:

String myNewString = join(myString, "")
if (!myNewString.equals(""))
{
    //Do something
}

Anda dapat memeriksa string sama dengan nol menggunakan ini:

String Test = null;
(Test+"").compareTo("null")

Jika hasilnya 0 maka (Uji + "") = "null".

Saya mencoba sebagian besar contoh yang diberikan di atas untuk sebuah null di aplikasi android yang sedang saya bangun dan semuanya gagal. Jadi saya datang dengan solusi yang bekerja kapan saja untuk saya.

String test = null+"";
If(!test.equals("null"){
       //go ahead string is not null

}

Jadi cukup gabungkan string kosong seperti yang saya lakukan di atas dan uji terhadap "null" dan itu berfungsi dengan baik. Bahkan tidak terkecuali dilempar

Pengecualian juga dapat membantu:

try {
   //define your myString
}
catch (Exception e) {
   //in that case, you may affect "" to myString
   myString="";
}

Jika Anda bekerja di Android maka Anda dapat menggunakan kelas TextUtils sederhana. Periksa kode berikut:

if(!TextUtils.isEmpty(myString)){
 //do something
}

Ini adalah penggunaan kode yang sederhana. Jawaban bisa diulang. Tetapi sederhana untuk memiliki cek tunggal dan sederhana untuk Anda.

Anda harus memeriksa dengan nol if(str != null).