Comment formater une liste de chaînes de caractères dans

J'ai une liste de chaînes de caractères que je veux format de chacun d'eux de la même manière. par exemple, myListOfStrings = str1, str2, str3, et mon format (%s)
Je veux avoir quelque chose comme ceci:

String.format(" (%s) ", myListOfStrings)

Sortie

(str1)  (str2)  (str3)

Est-il un moyen élégant de faire cela? ou dois-je utiliser un générateur de chaîne et de faire une boucle foreach sur toutes les chaînes?

Êtes-vous à l'aide de Java 8?
Eh bien, StringBuilder semble évident , pouvez-vous fournir un exemple de code (à l'aide de SB), afin de mieux comprendre ce que tu veux dire , s'il vous plaît.
Vous pouvez utiliser StringBuilder(si vous ne voulez pas thread-safe) ou d'utiliser une mémoire tampon de chaîne
ne pouvez-vous pas avoir une classe wrapper pour votre liste?

OriginalL'auteur user844541 | 2015-05-25

7

Vous pouvez le faire avec Java 8:
```
import static java.util.stream.Collectors.joining;

public static void main(String[] args) throws Exception {

    final List<String> strings = Arrays.asList("a", "b", "c");

    final String joined = strings.stream()
            .collect(joining(") (", "(", ")"));

    System.out.println(joined);
}
```
Ou:
```
final String joined = strings.stream()
        .map(item -> "(" + item + ")")
        .collect(joining(" "));
```
Que celle que vous préférez est une question de préférence personnelle.

La première rejoint les éléments sur ) ( qui donne:

a) (b) (c

Puis vous utilisez le préfixe et le suffixe arguments pour joining avec préfixe ( et le suffixe avec ), de produire le bon résultat.

La seconde alternative transforme chaque élément de ( + item + ) puis se joint à eux sur " ".

La première pourrait également être un peu plus vite, car il ne nécessite la création d' un StringBuilder exemple - pour le rejoindre et le pré/suffixe. La deuxième solution nécessite la création d' n + 1 StringBuilder cas, un pour chaque élément et un pour le rejoindre sur " ".

OriginalL'auteur Boris the Spider
2

si vous voulez une solution en ligne, vous pouvez utiliser l'un de la StringUtils.rejoindre méthodes de Apache Commons Lang.
```
String result = "(" + StringUtils.join(myListOfStrings, ") (") + ")";
```
OriginalL'auteur Sharon Ben Asher

Vous pouvez essayer ceci:

List<String> list = new ArrayList<String>();
list.add("str1");
list.add("str2");
list.add("str3");

for(String s : list) {
  System.out.println(String.format(" (%s) ", s));
}

OriginalL'auteur Krishanthy Mohanachandran

0
```
String strOut = "";
for(int i=0; i< myListOfStrings.size(); i++){
    strOut = strOut +"("+myListOfStrings.get(i)+")";
}
```
Pourriez vous s'il vous plaît modifier votre réponse à donner une explication de pourquoi ce code répond à la question? Code-seules réponses sont découragé, parce qu'ils n'enseignent pas la solution.

OriginalL'auteur G.B.Krishna
0

Boris L'Araignée de réponse est ce que je voudrais aller avec, mais dans le cas où vous n'êtes pas à l'aide de java 8, mais peut-être que vous êtes à l'aide de Goyave vous pouvez faire quelque chose comme cela, mais c'est un peu verbeux:
```
Joiner.on("").join(Collections2.transform(myListOfStrings, new Function<String, String>() {

        @Override
        public String apply(String input) {
            return String.format(" (%s) ", input);
        }
    }));
```
Ceci est similaire à mon deuxième alternative qui est de moins en moins efficace. Aussi, il ne semble pas que l'OP veut la sortie à pré/sufffixed avec des espaces - vous devriez vous joindre sur un espace que j'ai fait dans mon code.

OriginalL'auteur Kajo
0

À l'aide de Java8 nouveau forEach méthode d'itération sur les collections:
```
public static String format(List<String> list) {
    StringBuilder sb = new StringBuilder();
    list.forEach(x -> sb.append(String.format(" (%s) ", x)));
    return sb.toString();
} 
```
Essayer ici: https://ideone.com/52EKRH

Eugh - je n'aime pas cela du tout. Il mélange la mise en forme avec la sortie est une manière très moche. Elle devrait aussi probablement nous printf, plutôt que les deux format et print. Ou utiliser un map puis un print. De toute façon, je pense que ce n'est pas une bonne approche.
sur le printf, encore), il est beaucoup plus lisible que du stream/map/collecter et de l'assemblage des formes
avez-vous jamais utiliser un enregistreur à tous?
La journalisation si, pour des fins de débogage pas de la logique métier.
Votre nouveau code est beaucoup mieux, mais je pense que si vous avez un StringBuilder puis utilisation - passez le format entièrement et de ses frais généraux...

OriginalL'auteur guido

Vous devez vous connecter pour publier un commentaire.