Bagaimana untuk menentukan sama ada pembolehubah kosong di Jawa

Preface

Java's StringUtil.isEmpty(str) dan "".equals(str) ialah kedua-dua kaedah yang digunakan untuk menentukan sama ada rentetan kosong, tetapi ia mempunyai beberapa senario penggunaan yang berbeza.

StringUtil.isEmpty()

StringUtil.isEmpty(str) biasanya digunakan untuk menentukan sama ada rentetan itu batal atau mempunyai panjang 0. Jika rentetan itu nol atau panjangnya 0 , ia kembali benar , jika tidak pulangkan palsu. Menggunakan pendekatan ini, anda boleh mengelakkan pengecualian penuding nol yang disebabkan oleh berbilang rentetan null.

"".equals()

"".equals(str) digunakan untuk menentukan sama ada rentetan itu ialah rentetan kosong (iaitu, panjangnya ialah 0). rentetan kosong, Ia mengembalikan benar, jika tidak ia mengembalikan palsu. Kaedah ini sesuai untuk situasi di mana anda hanya perlu menentukan sama ada rentetan ialah rentetan kosong.

Adalah disyorkan untuk menggunakan StringUtil.isEmpty(str) untuk menentukan nilai nol berbilang rentetan. Adalah disyorkan untuk menggunakan str.isEmpty() untuk menentukan sama ada rentetan ialah rentetan kosong. Dengan cara ini, anda boleh memilih kaedah yang lebih sesuai berdasarkan situasi sebenar, dengan itu meningkatkan kebolehbacaan dan kecekapan kod.

Tentukan sama ada berbilang rentetan kosong pada masa yang sama

public static boolean isAllEmpty(String... strs) {
    for (String str : strs) {
        if (StringUtil.isNotEmpty(str)) {
            return false;
        }
    }
    return true;
}

Dalam kaedah ini, kami menggunakan parameter berubah untuk menerima berbilang rentetan, dan kemudian gelung melalui rentetan ini, Selagi salah satu rentetan didapati tidak kosong, ia kembali palsu, menunjukkan bahawa tidak semuanya kosong. Jika tidak, benar dikembalikan selepas gelung berakhir, menunjukkan bahawa semua rentetan kosong.

Perlu diambil perhatian bahawa apabila menilai sama ada ia kosong, kaedah StringUtil.isNotEmpty(str) digunakan dan bukannya kaedah StringUtil.isEmpty(str). Ini kerana apabila menilai sama ada berbilang rentetan semuanya kosong, jika anda menggunakan kaedah StringUtil.isEmpty(str), selagi satu rentetan adalah batal atau rentetan kosong, benar akan dikembalikan dan rentetan lain tidak akan dinilai sama ada kosong. Oleh itu, adalah lebih tepat untuk menggunakan kaedah StringUtil.isNotEmpty(str) Ia hanya mengembalikan benar apabila rentetan itu tidak batal dan panjangnya bukan 0, yang boleh mengelakkan salah penilaian.

Menggunakan kaedah ini boleh menentukan dengan mudah sama ada berbilang rentetan kosong, mengelakkan pertindihan kod dan meningkatkan kebolehbacaan kod.

Apabila kita perlu menentukan sama ada berbilang rentetan semuanya kosong, kita boleh menggunakan parameter pembolehubah untuk menerima rentetan ini. Contohnya:

String str1 = "";
String str2 = null;
String str3 = "hello";
boolean result = isAllEmpty(str1, str2, str3);
System.out.println(result); // 输出false

Dalam contoh ini, kami mentakrifkan tiga rentetan str1, str2, str3, dengan str1 ialah rentetan kosong, str2 adalah nol dan str3 bukan kosong. Seterusnya, kami menggunakan kaedah isAllEmpty untuk menyemak sama ada ketiga-tiga rentetan itu kosong. Jika str3 tidak kosong, false akan dikembalikan apabila menggelung ke str3, menunjukkan bahawa tidak semuanya kosong.

Jika kita menetapkan str3 kepada null atau rentetan kosong, maka gelung tidak akan menemui sebarang rentetan yang tidak kosong sehingga akhir, dan akhirnya kembali benar, menunjukkan bahawa semua rentetan kosong. Contohnya:

String str1 = "";
String str2 = null;
String str3 = "";
boolean result = isAllEmpty(str1, str2, str3);
System.out.println(result); // 输出true

Dalam contoh ini, kami menetapkan kedua-dua str1 dan str2 kepada rentetan null atau kosong, dan hanya str3 juga kosong, jadi kaedah isAllEmpty akan kembali benar selepas gelung berakhir, menunjukkan bahawa semua rentetan adalah kosong.

Apabila kita perlu menentukan sama ada rentetan adalah nol atau mempunyai panjang 0, kita boleh menggunakan kaedah StringUtil.isEmpty(str). Contohnya:

String str = "";
if (StringUtil.isEmpty(str)) {
    System.out.println("字符串为空");
} else {
    System.out.println("字符串不为空");
}

Dalam contoh ini, kami mentakrifkan rentetan str kosong, dan kemudian menggunakan kaedah StringUtil.isEmpty(str) untuk menentukan sama ada rentetan itu kosong. Memandangkan panjang rentetan ialah 0, kaedah StringUtil.isEmpty(str) akan kembali benar, menunjukkan bahawa rentetan itu kosong. Bergantung pada nilai pulangan, kita boleh melakukan logik yang berbeza.

Contoh lain:

String str = null;
if (StringUtil.isEmpty(str)) {
    System.out.println("字符串为空");
} else {
    System.out.println("字符串不为空");
}

Dalam contoh ini, kami menetapkan rentetan str kepada null Pada masa ini, kaedah StringUtil.isEmpty(str) juga akan kembali benar, menunjukkan bahawa rentetan itu adalah. kosong. Pendekatan ini boleh mengelakkan Pengecualian Penunjuk Null kerana apabila kaedah StringUtil.isEmpty(str) dilaksanakan, walaupun rentetan itu adalah nol, Pengecualian Penunjuk Null tidak akan dilemparkan.

Perlu diambil perhatian bahawa kaedah ini hanya sesuai untuk situasi di mana anda perlu menentukan sama ada satu rentetan kosong Jika anda perlu menentukan sama ada berbilang rentetan kosong, anda perlu menggunakan parameter pembolehubah untuk menentukan. Sila rujuk contoh di atas untuk butiran.

Walaupun rentetan itu batal, pengecualian penuding nol tidak akan dilemparkan apabila kaedah StringUtil.isEmpty(str) dipanggil. Bilakah pengecualian penuding nol berlaku?

Pengecualian penuding nol biasanya berlaku apabila pembolehubah atau objek dengan nilai nol digunakan dalam atur cara. Contohnya:

String str = null;
int length = str.length(); // 抛出空指针异常

Dalam contoh ini, kami mencipta rentetan bernama str dan menetapkannya batal. Kemudian kita menggunakan kaedah str.length() untuk mendapatkan panjang rentetan Pada masa ini, pengecualian penuding nol akan dilemparkan, kerana apabila kita menggunakan kaedah objek str, kita sebenarnya menggunakan kaedah kosong. objek.

Contoh lain:

String[] strs = {"hello", "world", null};
for (String str : strs) {
    int length = str.length(); // 抛出空指针异常
}

Dalam contoh ini, kami telah mencipta str tatasusunan yang memegang rentetan di mana elemen ketiga mempunyai nilai null. Seterusnya, kami akan menggunakan gelung for untuk lelaran melalui tatasusunan, dan kemudian untuk setiap rentetan, panggil kaedah str.length() untuk mendapatkan panjangnya. Memandangkan elemen ketiga adalah nol, pengecualian penuding nol dilemparkan.

Perlu diambil perhatian bahawa walaupun kaedah StringUtil.isEmpty(str) boleh mengelakkan pengecualian penuding nol, dalam beberapa kes, kita mungkin perlu menentukan sama ada rentetan itu adalah nol. Pada masa ini, anda boleh menggunakan str == null untuk membuat pertimbangan. Contohnya:

String str = null;
if (str == null) {
    System.out.println("字符串为null");
} else if (StringUtil.isEmpty(str)) {
    System.out.println("字符串为空");
} else {
    System.out.println("字符串不为空");
}

在这个例子中，我们先使用str == null来判断该字符串是否为null，如果为null则输出"字符串为null"；否则使用StringUtil.isEmpty(str)方法来判断该字符串是否为空。通过这种方法，即可以预防出现空指针异常，又可以独立处理字符串为空和字符串为null的情况。

注意"“.equals(str)不要写成str.equals(”")，否则当str为null时，就会报错空指针异常。

两种判断，哪种性能更好？

就性能而言，使用StringUtil.isEmpty()相对更高效些。这是因为在判断一个字符串是否为空时，StringUtil.isEmpty()方法只需要进行一次判断，而使用"".equals()方法则需要进行两次判断，一次是判断字符串是否为null，另一次是判断字符串的长度是否为0。

虽然这个差距不大，但是在进行大量字符串判断的场景下，使用StringUtil.isEmpty()可以稍微提升一些性能。在实际开发中，更应该关注代码的可读性和易于维护性。虽然有一些性能差异，但它们微乎其微。

两种判断，哪种可读性和易于维护性都好

从可读性和易于维护性的角度来看，使用StringUtil.isEmpty()的方式更好一些，这是因为这个方法的意义更加清晰明了。使用"".equals()方法，虽然也可以达到同样的效果，但是需要写更多的代码来进行判断，不如直接调用一个专门的工具类方法更加简洁明了。

此外，如果后续需要修改判断条件，只需要在工具类方法中修改即可，而使用"".equals()方法则需要在多处修改，这样就增加了代码的维护难度。因此，在可读性和易于维护性方面，使用StringUtil.isEmpty()的方式更为优秀。

Atas ialah kandungan terperinci Bagaimana untuk menentukan sama ada pembolehubah kosong di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!