web-dev-qa-db-fra.com

Équivalent Java de c # String.IsNullOrEmpty () et String.IsNullOrWhiteSpace ()

En travaillant dans c #, j'ai trouvé très utiles deux méthodes statiques de la classe String: 

je ne trouve pas de substitut valide en Java. Existe-t-il quelque chose de similaire? 

En fait, j'ai traduit les deux méthodes de cette manière: 

public static boolean isNullOrEmpty(String a) {
return a == null || a.isEmpty();
} 

public static boolean isNullOrWhiteSpace(String a) {
return a == null || (a.length() > 0 && a.trim().length() <= 0);
}

Est-ce la meilleure façon de traduire ces méthodes en Java? Quel est le meilleur moyen de traduire ces deux méthodes en Java?

c#javastring
33
aleroot

Je préférerais ne pas utiliser String.trim pour vérifier l'existence d'espaces. Il fait plus de travail que nécessaire, car il vérifie les deux extrémités de la chaîne (même si aucun espace n'a été trouvé à l'autre extrémité) ET il renvoie un nouvel objet String. Donc, je préférerais implémenter une méthode pour vérifier les espaces uniquement.

Donc, ma suggestion (si vous vous implémentez vous-même) serait la suivante:

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

public static boolean isNullOrWhitespace(String s) {
    return s == null || isWhitespace(s);

}
private static boolean isWhitespace(String s) {
    int length = s.length();
    if (length > 0) {
        for (int i = 0; i < length; i++) {
            if (!Character.isWhitespace(s.charAt(i))) {
                return false;
            }
        }
        return true;
    }
    return false;
}

Ou bien en prenant exemple sur l'implémentation de String.trim, vous pouvez utiliser la comparaison de caractères plutôt que Character.isWhitespace ():

// checking for whitespace like String.trim() does
private static boolean isWhitespace(String s) {
    int length = s.length();
    if (length > 0) {
        for (int i = 0; i < length; i++) {
            if (s.charAt(i) > ' ') {
                return false;
            }
        }
        return true;
    }
    return false;
}

Enfin, je considérerais de vérifier les deux extrémités de la chaîne à chaque itération, en passant à l’intérieur. Cela minimiserait le nombre d'itérations nécessaires pour obtenir la réponse, que l'espace soit au début ou à la fin de la chaîne.

private static boolean isWhitespace(String s) {
    int length = s.length();
    if (length > 0) {
        for (int start = 0, middle = length / 2, end = length - 1; start <= middle; start++, end--) {
            if (s.charAt(start) > ' ' || s.charAt(end) > ' ') {
                return false;
            }
        }
        return true;
    }
    return false;
}
21
sudocode

Vous pouvez toujours voir l'implémentation de c # à travers le réflecteur .net ou un autre décompilateur:

public static bool IsNullOrEmpty(string value)
{
  if (value != null)
    return value.Length == 0;
  else
    return true;
}

et

public static bool IsNullOrWhiteSpace(string value)
{
  if (value == null)
    return true;
  for (int index = 0; index < value.Length; ++index)
  {
    if (!char.IsWhiteSpace(value[index]))
      return false;
  }
  return true;
}
12
Marcin Deptuła

tu peux essayer comme ça

import org.Apache.commons.lang.StringUtils;

public class CheckEmptyStringExample 
{  
  public static void main(String[] args)
  {
     String string1 = "";
     String string2 = "\t\r\n";
     String string3 = " ";
     String string4 = null;
     String string5 = "Hi"; 
     System.out.println("\nString one is empty? " + StringUtils.isBlank(string1));
     System.out.println("String one is not empty? " + StringUtils.isNotBlank(string1));
     System.out.println("\nString two is empty? " +  StringUtils.isBlank(string2));
     System.out.println("String two is not empty?" + StringUtils.isNotBlank(string2));
     System.out.println("\nString three is empty?" + StringUtils.isBlank(string3));
     System.out.println("String three is not empty?" + StringUtils.isNotBlank(string3));
     System.out.println("\nString four is empty?" +  StringUtils.isBlank(string4));
     System.out.println("String four is not empty?" + StringUtils.isNotBlank(string4));
     System.out.println("\nString five is empty?" + StringUtils.isBlank(string5));
     System.out.println("String five is not empty?" + StringUtils.isNotBlank(string5)); 
  }
}
9
Enigma State

Examinez la classe StringUtils dans Apache commons lang.

6
Qwerky

Si vous importez com.google.common.base.Strings, vous avez Strings.isNullOrEmpty()

isNullOrEmpty(@Nullable String string)
4
C oneil

Apache.commons.lang.StringUtils est la réponse.

isBlank ()

est vide()

1
Bhushan

Apache Commons Lang possède un ensemble varié d’utilitaires pour les chaînes: http://commons.Apache.org/lang/api-release/org/Apache/commons/lang3/StringUtils.html

Bien sûr, votre implémentation peut suffire si vous ne voulez pas vous soucier des dépendances.

1
Viruzzo

Cela devrait être beaucoup plus simple et facile à comprendre.

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

public static boolean isNullOrWhitespace(String s) {
    return isNullOrEmpty(s) ? true : isNullOrEmpty(s.trim());
}
0
Dragon Warrior

Dans JDK11 , la classe String a une méthode isBlank qui:

Renvoie true si la chaîne est vide ou ne contient que des espaces blancs codepoints, sinon faux.

Bien qu'il ne vérifie pas la nullité, il est certainement plus proche du string.IsNullOrWhiteSpace de C #. 

Vous pouvez maintenant faire:

var isNullOrWhiteSpace = str == null || str.isBlank();

ou créez une méthode d'assistance:

public static boolean isNullOrWhitespace(String s) { return s == null || str.isBlank(); }
0
Aomine