web-dev-qa-db-fra.com

Quelle est la bonne approche pour concaténer une chaîne nulle en Java?

Je sais que ce qui suit:

String s = null;
System.out.println("s: " + s);

affichera: s: null.

Comment puis-je le faire sortir simplement s: ​?

Dans mon cas, cela est important car je dois concaténer String à partir de 4 valeurs, s1, s2, s3, s4, où chacune de ces valeurs peut ou non avoir une valeur de null.

Je pose cette question car je ne veux pas vérifier toutes les combinaisons de s1 à s4 (c'est-à-dire vérifier si ces variables sont null) ou remplacez "null" avec emptyString à la fin, car je pense qu'il peut y avoir de meilleures façons de le faire.

javastringconcat
33
syntagma

La solution la plus concise est la suivante:

System.out.println("s: " + (s == null ? "" : s));

ou peut-être créer ou utiliser une méthode d'assistance statique pour faire de même; par exemple.

System.out.println("s: " + denull(s));

Cependant, cette question a "l'odeur" d'une application qui surexploite/abuse de null. Il est préférable d'utiliser/renvoyer un null uniquement s'il a une signification spécifique distincte (et doit être distincte) de la signification des valeurs non nulles.

Par exemple:

  • Si ces valeurs nulles proviennent d'attributs String qui ont été initialisés par défaut à null, envisagez de les initialiser explicitement à "" au lieu.
  • N'utilisez pas null pour désigner des tableaux ou des collections vides.
  • Ne retournez pas null quand il serait préférable de lever une exception.
  • Pensez à utiliser le Null Object Pattern .

Maintenant, évidemment, il y a des contre-exemples à tout cela, et parfois vous devez faire face à une API préexistante qui vous donne des valeurs nulles ... pour une raison quelconque. Cependant, d'après mon expérience, il vaut mieux éviter d'utiliser null ... la plupart du temps.

Donc, dans votre cas, la meilleure approche peut être:

String s = "";  /* instead of null */
System.out.println("s: " + s);
41
Stephen C

Vous pouvez utiliser ce qui suit avec Java 8:

String s1 = "a";
String s2 = null;
String s3 = "c";
String s4 = "d";
String concat = Stream.of(s1, s2, s3, s4)
        .filter(s -> s != null)
        .collect(Collectors.joining());

donne

abc

Quelques points à noter:

  • Vous pouvez transformer des structures de données (listes, etc.) directement en Stream<String>.
  • Vous pouvez également donner un délimiteur lors de la jonction des chaînes.
23
skiwi
String s = null;
System.out.println("s: " + (s != null ? s : ""));

Mais ce que vous demandez vraiment est un opérateur de coalescence nul .

18
David Ehrmann

Vous pouvez utiliser la méthode Apache Commons StringUtils.defaultString(String) , ou vous pouvez même écrire votre propre méthode qui ne serait qu'une ligne, si vous n'utilisez aucune bibliothèque tierce.

private static String nullToEmptyString(String str) {
    return str == null ? "" : str;
}

puis utilisez-le dans votre sysout comme suit:

System.out.println("s: " + nullToEmptyString(s));
9
Rohit Jain

Une autre approche consiste à utiliser Java.util.Objects.toString() qui a été ajouté dans Java 7:

String s = null;
System.out.println("s: " + Objects.toString(s, ""));

Cela fonctionne pour n'importe quel objet, pas seulement pour les chaînes, et bien sûr, vous pouvez fournir une autre valeur par défaut au lieu de simplement la chaîne vide.

7
Stuart Marks

Vous pouvez déclarer votre propre méthode pour concatenation:

public static String concat(String... s) 
{//Use varArgs to pass any number of arguments
    if (s!=null) {
       StringBuilder sb = new StringBuilder();
       for(int i=0; i<s.length; i++) {
          sb.append(s[i] == null ? "" : s[i]);
       }
       return sb.toString();
    }
    else {
        return "";
    }
}
7
CoderCroc

Essaye ça

String s = s == null ? "" : s;
System.out.println("s: " + s);

Une variable chaîne (ici, s) est appelée null quand aucun objet n'est affecté à la variable. Initialisez donc la variale avec une chaîne vide qui est ""; Ensuite, vous pouvez concaténer des chaînes.

Si votre variable s peut être nulle ou non nulle, utilisez l'opérateur conditionnel avant de l'utiliser à nouveau. La variable s n'est alors plus nulle.

Ceci est un exemple de code:

    String s1 = "Some Not NULL Text 1 ";
    String s2 = null;
    String s3 = "Some Not NULL Text 2 ";

    s1 = s1 == null ? "" : s1;
    s2 = s2 == null ? "" : s2;
    s3 = s3 == null ? "" : s3;

    System.out.println("s: " + s1 + s2 + s3);

Exemple de sortie:

s: Some Not NULL Text 1 Some Not NULL Text 2

4
user3717646

Deux méthodes me viennent à l'esprit, la première n'utilise pas la concaténation mais est la plus sûre:

public static void substituteNullAndPrint(String format, String nullString, Object... params){
    String[] stringParams = new String[params.length()];
    for(int i=0; i<params.length(); i++){
        if(params[i] == null){
            stringParams[i] = nullString;
        }else{
            stringParams[i] = params[i].toSTring();
        }
    }

    String formattedString = String.format(format, stringParams);
    System.out.println(formattedString);
}

USAGE:
substituteNullAndPrint("s: %s,%s", "", s1, s2);

La seconde utilise la concaténation mais requiert que votre chaîne réelle ne contienne jamais "null", donc elle ne peut être utilisable que pour des cas très simples (Quoi qu'il en soit, même si votre chaîne n'est jamais "null", je ne l'utiliserais jamais):

public static void substituteNullAndPrint(String str){
    str.replace("null", "");
    System.out.println(str);
}

USAGE:
substituteNullAndPrint("s: " + s1);

REMARQUES:

-Les deux utilisent une méthode d'utilité externe car je suis contre l'inclusion de beaucoup de conditionnels.

-Ce n'est pas testé et je pourrais confondre la syntaxe c # avec Java

1
Fabio Marcolini