Comment déterminer si une variable est vide en Java

Avant-propos

StringUtil.isEmpty(str) et "".equals(str) de Java sont deux méthodes utilisées pour déterminer si une chaîne est vide, mais elles ont des scénarios d'utilisation différents.

StringUtil.isEmpty()

StringUtil.isEmpty(str) est généralement utilisé pour déterminer si une chaîne est nulle ou a une longueur de 0. Si la chaîne est nulle ou a une longueur de 0, elle renvoie vrai, sinon elle renvoie faux. En utilisant cette approche, vous pouvez éviter les exceptions de pointeur nul provoquées par plusieurs chaînes nulles.

"".equals()

"".equals(str) est utilisé pour déterminer si la chaîne est une chaîne vide (c'est-à-dire que la longueur est 0). Si la chaîne est une chaîne vide, elle renvoie vrai, sinon, il renvoie faux. Cette méthode convient aux situations où il vous suffit de déterminer si une chaîne est une chaîne vide.

Il est recommandé d'utiliser StringUtil.isEmpty(str) pour juger de la valeur nulle de plusieurs chaînes. Il est recommandé d'utiliser str.isEmpty() pour déterminer si une chaîne est une chaîne vide. De cette façon, vous pouvez choisir une méthode plus appropriée en fonction de la situation réelle, améliorant ainsi la lisibilité et l'efficacité du code.

Déterminez si plusieurs chaînes sont vides en même temps

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

Dans cette méthode, nous utilisons des paramètres variables pour recevoir plusieurs chaînes, puis parcourons ces chaînes, tant qu'il s'avère que l'une des chaînes n'est pas Si c'est le cas vide, il renvoie false, indiquant qu'il n'est pas tout vide. Sinon, true est renvoyé une fois la boucle terminée, indiquant que toutes les chaînes sont vides.

Il convient de noter que pour juger s'il est vide, la méthode StringUtil.isNotEmpty(str) est utilisée à la place de la méthode StringUtil.isEmpty(str). En effet, lorsque vous jugez si plusieurs chaînes sont toutes vides, si vous utilisez la méthode StringUtil.isEmpty(str), tant qu'une chaîne est nulle ou vide, true sera renvoyé et les autres chaînes ne seront pas jugées. c'est vide. Par conséquent, il est plus précis d'utiliser la méthode StringUtil.isNotEmpty(str) Elle ne renvoie vrai que lorsque la chaîne n'est pas nulle et que la longueur n'est pas 0, ce qui peut éviter une erreur de jugement.

L'utilisation de cette méthode peut facilement déterminer si plusieurs chaînes sont vides, éviter la duplication de code et améliorer la lisibilité du code.

Lorsque nous devons déterminer si plusieurs chaînes sont toutes vides, nous pouvons utiliser des paramètres variables pour recevoir ces chaînes. Par exemple :

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

Dans cet exemple, nous définissons trois chaînes str1, str2, str3, où str1 est la chaîne vide, str2 est nulle et str3 n'est pas vide. Ensuite, nous utilisons la méthode isAllEmpty pour vérifier si les trois chaînes sont vides. Si str3 n'est pas vide, false sera renvoyé lors d'une boucle vers str3, indiquant que tout n'est pas vide.

Si nous définissons str3 sur null ou une chaîne vide, alors la boucle ne trouvera aucune chaîne qui ne soit vide jusqu'à la fin, et retournera finalement true, indiquant que toutes les chaînes sont vides. Par exemple :

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

Dans cet exemple, nous définissons str1 et str2 sur une chaîne nulle ou vide, et seul str3 est également vide, donc la méthode isAllEmpty retournera true une fois la boucle terminée, indiquant que toutes les chaînes sont vides.

Lorsque nous devons déterminer si une chaîne est nulle ou a une longueur de 0, nous pouvons utiliser la méthode StringUtil.isEmpty(str). Par exemple :

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

Dans cet exemple, nous définissons une chaîne vide str, puis utilisons la méthode StringUtil.isEmpty(str) pour déterminer si la chaîne est vide. Puisque la longueur de la chaîne est 0, la méthode StringUtil.isEmpty(str) renverra true, indiquant que la chaîne est vide. En fonction de la valeur de retour, nous pouvons effectuer une logique différente.

Un autre exemple :

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

Dans cet exemple, nous définissons la chaîne str sur null. À ce moment, la méthode StringUtil.isEmpty(str) retournera également true, indiquant que la chaîne est vide. Cette approche peut éviter les exceptions de pointeur nul, car lorsque la méthode StringUtil.isEmpty(str) est exécutée, même si la chaîne est nulle, une exception de pointeur nul ne sera pas levée.

Il convient de noter que cette méthode ne convient qu'aux situations où vous devez déterminer si une seule chaîne est vide. Si vous devez déterminer si plusieurs chaînes sont vides, vous devez utiliser des paramètres variables pour déterminer. reportez-vous à l’exemple ci-dessus.

Même si la chaîne est nulle, une exception de pointeur nul ne sera pas levée lorsque la méthode StringUtil.isEmpty(str) est appelée. Quand une exception de pointeur nul se produit-elle ?

Une exception de pointeur nul se produit généralement lorsqu'une variable ou un objet avec une valeur nulle est utilisé dans un programme. Par exemple :

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

Dans cet exemple, nous créons une chaîne nommée str et lui attribuons null. Ensuite, nous utilisons la méthode str.length() pour obtenir la longueur de la chaîne. À ce stade, une exception de pointeur nul sera levée, car lorsque nous utilisons la méthode de l'objet str, nous utilisons en fait la méthode d'un objet vide. objet.

Un autre exemple :

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

Dans cet exemple, nous avons créé un tableau strs contenant des chaînes où la valeur du troisième élément est nulle. Ensuite, nous utiliserons une boucle for pour parcourir le tableau, puis pour chaque chaîne, appellerons la méthode str.length() pour obtenir sa longueur. Puisque le troisième élément est nul, une exception de pointeur nul est levée.

Il convient de noter que bien que la méthode StringUtil.isEmpty(str) puisse éviter les exceptions de pointeur nul, dans certains cas, nous devrons peut-être déterminer si la chaîne est nulle. À ce stade, vous pouvez utiliser str == null pour porter un jugement. Par exemple :

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()的方式更为优秀。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!