Méthode pour concaténer 2 Chaînes de caractères en Java

J'ai une méthode en Java qui sert à concaténer 2 Chaînes. Actuellement, il fonctionne correctement, mais je pense que ça peut être mieux écrit.

public static String concat(String str1, String str2) {
  String rVal = null;
  if (str1 != null || str2 != null) {
    rVal = "";
    if (str1 != null) {
      rVal += str1;
    }
    if (str2 != null) {
      rVal += str2;
    }      
  }    
  return rVal;
}

Voici certaines des exigences:

Si les deux str1 et str2 sont nulles, la méthode renvoie null
Si ch1 ou ch2 est null, il suffit de retourner le pas de Chaîne null
Si str1 et str2 ne sont pas null, il va enchaîner
Jamais, il ajoute "null" à la suite

Quelqu'un peut-il le faire avec moins de code?

Si je l'appelle str1.concat(str2), il va lancer une exception NullPointerException lors de str1 est null.
Ne pourriez-vous utiliser StringBuilder?
Je ne suis pas sûr que les poignées de l'null cas très bien.
Cette question a vraiment 7 votes? Vraiment? Juste pour être en mesure de ré-écrire la même chose avec un opérateur ternaire?

OriginalL'auteur Ryan | 2010-03-17

13

Sûr:
```
public static String concat(String str1, String str2) {
  return str1 == null ? str2
      : str2 == null ? str1
      : str1 + str2;
}
```
Noter que cela prend en charge les "nulles" cas dans la première condition: si str1 est null, alors vous voulez retourner la valeur null (si str2 est nul) ou str2 (si str2 n'est pas null) - qui sont tous deux gérés par juste retour str2.

Conditionnels imbriqués les opérateurs? Sérieusement?
Certains peuvent le lire, certains ne le peuvent pas. Il est en effet plus déroutant pour les débutants. J'aurais préféré les mettre en une seule ligne avec des parenthèses. Quelque chose comme return (str1 == null) ? str2 : ((str2 == null) ? str1 : (str1 + str2));
Absolument - je trouver un pattern très utile lorsque vous voulez tester plusieurs conditions avec une préférence.
- Je trouver les parenthèses ajouter de la confusion alors que les sauts de ligne montrent la structure logique plus clairement. C'est une question de préférence personnelle truc bien.
urks s'il vous Plaît ajouter la version sans opérateur conditionnel pour l'exhaustivité et de la beauté. Parfois, plus le code est moins de confusion!

OriginalL'auteur Jon Skeet

À l'aide de simples if clauses:

public static String concat(String str1, String str2) {
    if(str1==null) return str2;
    if(str2==null) return str1;
    return str1 + str2;
}

Ou, si vous avez une profonde et un amour passionné pour les parenthèses:

public static String concat(String str1, String str2) {
    if(str1==null)
    { 
        return str2;
    }
    if(str2==null) 
    {
        return str1;
    }
    return str1 + str2;
}

Vous n'aimez pas imbriquée à conditions - je n'aime pas if déclarations sans accolades 🙂
il y avait ceux qui, au premier abord, mais la compacité de l'OMI est mieux dans ce cas simple.
Moins de code est plus lisible

OriginalL'auteur Michael Borgwardt

1
```
import org.apache.commons.lang.StringUtils;

StringUtils.join([str1, str2]);
```
Rejoint les éléments du tableau en une seule Chaîne de caractères contenant la liste des éléments.

Aucun séparateur est ajouté à la rejoint la Chaîne. Des objets Null ou une chaîne vide dans le tableau sont représentées par des chaînes vides.
```
 StringUtils.join(null)            = null
 StringUtils.join([])              = ""
 StringUtils.join([null])          = ""
 StringUtils.join(["a", "b", "c"]) = "abc"
 StringUtils.join([null, "", "a"]) = "a"
```
C'est proche, mais un simple null vérification est nécessaire dans le cas où les deux str1 et str2 sont tous deux nuls.

OriginalL'auteur nishu
0

Tout le monde semble avoir manqué la condition 1, où si les deux chaînes sont nulles, elle renvoie null. La version la plus simple à lire (OMI) devient alors:
```
public static String concat(String str1, String str2) {  
    if(str1==null && str2==null) return null;  
    if(str1==null) return str2;  
    if(str2==null) return str1;  
    return str1 + str2;  
}
```
Je retire ce que...la première réponse par Jon n'a...
Jon et Michael solutions serait de retourner la valeur null sur la première condition (retour de l'autre de la Chaîne, qui est nulle) si les deux chaînes sont nulles. La vôtre, tout en ajoute une supplémentaire inutile de test de la condition.

OriginalL'auteur Striker

public class ConcatTest extends TestCase {

    //1. If both str1 and str2 are null, the method returns null
    public void testBothNull() throws Exception {
        assertNull(concat(null, null));
    }

    //2. If either str1 or str2 is null, it will just return the not null
    //String
    public void testOneNull() throws Exception {
        assertEquals("a", concat(null, "a"));
        assertEquals("b", concat("b", null));
    }

    //3. If str1 and str2 are not null, it will concatenate them
    public void testNonNull() throws Exception {
        assertEquals("ab", concat("a", "b"));
    }

    //4. It never adds "null" to the result (not really testable)

    public static String concat(String a, String b) {
        if (a == null && b == null)
            return null;
        return denulled(a) + denulled(b);
    }

    private static String denulled(String s) {
        return s == null ? "" : s;
    }

}

OriginalL'auteur Carl Manaster

Vous devez vous connecter pour publier un commentaire.