web-dev-qa-db-fra.com

Java: joindre un tableau de primitives avec un séparateur

Supposons que j'ai un tableau:

int[] arr = new int[] {1, 2, 3, 4, 5, 6, 7};

Et je dois joindre ses éléments en utilisant un séparateur, par exemple, " - ". Ainsi, le résultat devrait être une chaîne comme celle-ci:

"1 - 2 - 3 - 4 - 5 - 6 - 7"

Comment pourrais-je faire ça?

PS: oui, je connais les posts de this et this , mais ses solutions ne fonctionneront pas avec un tableau de primitives.

javaarraysjoinseparator
20
spirit

Voici ce que je suis venu avec. Il y a plusieurs façons de le faire et cela dépend des outils que vous utilisez.

Utiliser StringUtils et ArrayUtils de Common Lang :

int[] arr = new int[] {1, 2, 3, 4, 5, 6, 7};
String result = StringUtils.join(ArrayUtils.toObject(arr), " - ");

Vous ne pouvez pas simplement utiliser StringUtils.join(arr, " - "); car StringUtils ne possède pas cette version surchargée de la méthode. Cependant, il a la méthode StringUtils.join(int[], char).

Fonctionne sur toutes les versions de Java, à partir de 1.2.

Utilisation de flux Java 8:

Quelque chose comme ça:

int[] arr = new int[] {1, 2, 3, 4, 5, 6, 7};
String result = Arrays.stream(arr)
        .mapToObj(String::valueOf)
        .collect(Collectors.joining(" - "));

En fait, il existe de nombreuses variantes pour obtenir le résultat en utilisant des flux.

La méthode String.join() de Java 8 ne fonctionne qu'avec les chaînes, de sorte que vous devez toujours convertir int[] en String[] pour l'utiliser.

String[] sarr = Arrays.stream(arr).mapToObj(String::valueOf).toArray(String[]::new);
String result = String.join(" - ", sarr);

Si vous êtes bloqué avec Java 7 ou une version antérieure sans bibliothèque, vous pouvez écrire votre propre méthode utilitaire:

public static String myJoin(int[] arr, String separator) {
    if (null == arr || 0 == arr.length) return "";

    StringBuilder sb = new StringBuilder(256);
    sb.append(arr[0]);

    //if (arr.length == 1) return sb.toString();

    for (int i = 1; i < arr.length; i++) sb.append(separator).append(arr[i]);

    return sb.toString();
}

Que vous pouvez faire:

int[] arr = new int[] {1, 2, 3, 4, 5, 6, 7};
String result = myJoin(arr, " - ");
48
spirit

En Java 8+, vous pouvez utiliser IntStream et StringJoiner . Quelque chose comme,

int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7 };
StringJoiner sj = new StringJoiner(" - ");
IntStream.of(arr).forEach(x -> sj.add(String.valueOf(x)));
System.out.println(sj.toString());

La sortie est (comme demandé)

1 - 2 - 3 - 4 - 5 - 6 - 7
8
Elliott Frisch

Vous pouvez utiliser la goyave pour joindre des éléments. Vous trouverez d'autres exemples et documents sur ce site. https://github.com/google/guava/wiki/StringsExplained

Joiner.on("-")
      .join(texts);

Pour être plus précis, vous devriez d’abord enrouler votre tableau dans une List avec Arrays.asList() ou Guava's primitive-friendly équivalents.

Joiner.on("-")
      .join(Arrays.asList(1, 2, 3, 4, 5, 6, 7));

Joiner.on("-")
      .join(Ints.asList(arr));
4
RMachnik

Je suis sûr qu'il existe un moyen de faire cela en Kotlin/Scala ou dans d'autres langages JVM, mais vous pouvez toujours garder les choses simples pour un petit ensemble de valeurs comme celles que vous avez ci-dessus:

int i, arrLen = arr.length;
 StringBuilder tmp = new StringBuilder();
 for (i=0; i<arrLen-1; i++)
    tmp.append(arr[i] +" - ");
 tmp.append(arr[arrLen-1]);

 System.out.println( tmp.toString() );
2
engAnt

La solution Java 8 ressemblerait à ceci:

Stream.of(1,2,3,4).map(String::valueOf).collect(Collectors.joining("-"))
1
user2935131

J'ai cherché un moyen de joindre des primitives dans un flux sans d'abord instancier des chaînes pour chacune d'entre elles. J'y suis venu mais il faut quand même les boxer.

LongStream.range(0, 500).boxed().collect(Collector.of(StringBuilder::new, (sb, v) -> {
    if (sb.length() != 0)
        sb.append(',');
    sb.append(v.longValue());
}, (a, b) -> a.length() == 0 ? b : b.length() != 0 ? a.append(',').append(b) : a, StringBuilder::toString));
1
bourne2program
int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7 };

IntStream.of(arr).mapToObj(i -> String.valueOf(i)).collect(Collectors.joining(",")) ;
0
Lin W