La méthode la plus sophistiquée pour créer des chaînes séparées par des virgules à partir d'une collection, d'un tableau ou d'une liste ?

Question

Au cours de mon travail avec les bases de données, j'ai remarqué que j'écrivais des chaînes de requête et que dans ces chaînes, je devais mettre plusieurs restrictions dans la clause where d'une liste, d'un tableau ou d'une collection. Cela devrait ressembler à ceci :

select * from customer 
where customer.id in (34, 26, ..., 2);

Vous pouvez simplifier cette question en la ramenant à une collection de chaînes de caractères et en voulant créer une liste séparée par des virgules de ces chaînes en une seule chaîne.

L'approche que j'ai utilisée jusqu'à présent est à peu près la même :

String result = "";
boolean first = true;
for(String string : collectionOfStrings) {
    if(first) {
        result+=string;
        first=false;
    } else {
        result+=","+string;
    }
}

Mais comme vous pouvez le constater, c'est très laid. Vous ne pouvez pas voir ce qui se passe au premier coup d'œil, en particulier lorsque les chaînes construites (comme toute requête SQL) deviennent compliquées.

Quelle est votre méthode (plus) élégante ?

Answer 1

Utiliser le Google Guava API 's join méthode :

Joiner.on(",").join(collectionOfStrings);

Answer 2

Note : Cette réponse était bonne lorsqu'elle a été écrite il y a 11 ans, mais il existe aujourd'hui de bien meilleures options pour faire cela plus proprement en une seule ligne, que ce soit en utilisant uniquement les classes intégrées de Java ou en utilisant une bibliothèque d'utilitaires. Voir les autres réponses ci-dessous.

---

Les chaînes étant immuables, vous pouvez utiliser la classe StringBuilder si vous avez l'intention de modifier la chaîne dans le code.

La classe StringBuilder peut être considérée comme un objet String mutable qui alloue plus de mémoire lorsque son contenu est modifié.

La proposition initiale de la question peut être rédigée de manière encore plus claire et plus efficace, en prenant soin des éléments suivants virgule de fin redondante :

    StringBuilder result = new StringBuilder();
    for(String string : collectionOfStrings) {
        result.append(string);
        result.append(",");
    }
    return result.length() > 0 ? result.substring(0, result.length() - 1): "";

Answer 3

Je viens de regarder un code qui faisait cela aujourd'hui. Il s'agit d'une variante de la réponse d'AviewAnew.

collectionOfStrings = /* source string collection */;
String csList = StringUtils.join(collectionOfStrings.toArray(), ",");

En StringUtils ( <-- commons.lang 2.x, ou lien commons.lang 3.x ) que nous avons utilisé est celui de Apache Commons .

Answer 4

La façon dont j'écris cette boucle est la suivante :

StringBuilder buff = new StringBuilder();
String sep = "";
for (String str : strs) {
    buff.append(sep);
    buff.append(str);
    sep = ",";
}
return buff.toString();

Ne vous préoccupez pas de la performance de sep. Une mission est très rapide. Hotspot a tendance à supprimer la première itération d'une boucle de toute façon (car il doit souvent faire face à des bizarreries telles que les contrôles null et mono/bimorphic inlining).

Si vous l'utilisez beaucoup (plus d'une fois), placez-la dans une méthode partagée.

Il y a une autre question sur stackoverflow qui traite de l'insertion d'une liste d'identifiants dans une instruction SQL.

Answer 5

J'ai trouvé l'idiome de l'itérateur élégant, parce qu'il a un test pour plus d'éléments (test null/empty omis pour des raisons de brièveté) :

public static String convert(List<String> list) {
    String res = "";
    for (Iterator<String> iterator = list.iterator(); iterator.hasNext();) {
        res += iterator.next() + (iterator.hasNext() ? "," : "");
    }
    return res;
}