web-dev-qa-db-fra.com

Java équivalents de C # String.Format () et String.Join ()

Je sais que c'est une question de débutant, mais y a-t-il des équivalents aux opérations de chaîne de C # en Java?

Plus précisément, je parle de String.Format et String.Join.

c#javastring
108
Omar Kooheji

L'objet String Java String a une méthode format (à partir de 1,5), mais pas de méthode join.

Pour obtenir un tas de méthodes utiles de l'utilitaire String non encore incluses, vous pouvez utiliser org.Apache.commons.lang.StringUtils .

91
Grant Wagner

String.format . Quant à rejoindre, vous devez écrire le vôtre:

 static String join(Collection<?> s, String delimiter) {
     StringBuilder builder = new StringBuilder();
     Iterator<?> iter = s.iterator();
     while (iter.hasNext()) {
         builder.append(iter.next());
         if (!iter.hasNext()) {
           break;                  
         }
         builder.append(delimiter);
     }
     return builder.toString();
 }

Ce qui précède provient de http://snippets.dzone.com/posts/show/91

46
Allain Lalonde

Guava est livré avec la classe Joiner. .

import com.google.common.base.Joiner;

Joiner.on(separator).join(data);
38
Noel Yap

A partir de Java 8, join()] est maintenant disponible sous forme de deux méthodes de classe dans la classe String. Dans les deux cas, le premier argument est le délimiteur.

Vous pouvez passer individuel CharSequences comme arguments supplémentaires :

String joined = String.join(", ", "Antimony", "Arsenic", "Aluminum", "Selenium");
// "Antimony, Arsenic, Alumninum, Selenium"

Ou vous pouvez passer un Iterable<? extends CharSequence> :

List<String> strings = new LinkedList<String>();
strings.add("EX");
strings.add("TER");
strings.add("MIN");
strings.add("ATE");

String joined = String.join("-", strings);
// "EX-TER-MIN-ATE"

Java 8 ajoute également une nouvelle classe, StringJoiner , que vous pouvez utiliser comme ceci:

StringJoiner joiner = new StringJoiner("&");
joiner.add("x=9");
joiner.add("y=5667.7");
joiner.add("z=-33.0");

String joined = joiner.toString();
// "x=9&y=5667.7&z=-33.0"
29
qntm

TextUtils.join est disponible sur Android

17
Melllvar

Vous pouvez également utiliser des arguments variables pour les chaînes comme suit:

  String join (String delim, String ... data) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < data.length; i++) {
      sb.append(data[i]);
      if (i >= data.length-1) {break;}
      sb.append(delim);
    }
    return sb.toString();
  }
12
sgsweb

En ce qui concerne rejoindre, je pense que cela pourrait paraître un peu moins compliqué:

public String join (Collection<String> c) {
    StringBuilder sb=new StringBuilder();
    for(String s: c)
        sb.append(s);
    return sb.toString();
}

Je ne parviens pas à utiliser Java 5 autant que je le voudrais) (croyez-le ou non, j’utilise la version 1.0.x depuis quelque temps), alors je risque d’être un peu rouillé, mais je suis sûr que le concept est correct.

modifier addition: les ajouts de chaînes peuvent être lents, mais si vous travaillez sur du code d'interface graphique ou sur une routine de courte durée, peu importe si vous prenez .005 secondes ou .006, donc si vous aviez une collection appelée "joinMe" que vous souhaitez ajouter à une chaîne existante "cible", il ne serait pas horrible de simplement y insérer ceci:

for(String s : joinMe)
    target += s;

C'est tout à fait inefficace (et une mauvaise habitude), mais rien de ce que vous serez capable de percevoir à moins qu'il y ait des milliers de chaînes ou qu'il ne s'agisse pas d'une boucle énorme ou que votre code est vraiment critique en termes de performances.

Plus important encore, il est facile à retenir, court, rapide et très lisible. La performance n'est pas toujours le vainqueur automatique des choix de conception.

4
Bill K

Voici une réponse assez simple. Utilisation += puisque c'est moins de code et laissez l'optimiseur le convertir en StringBuilder pour vous. En utilisant cette méthode, vous n'avez pas à effectuer de vérification "dernier" dans votre boucle (amélioration des performances) et vous n'avez pas à vous soucier de supprimer des délimiteurs à la fin.

        Iterator<String> iter = args.iterator();
        output += iter.hasNext() ? iter.next() : "";
        while (iter.hasNext()) {
            output += "," + iter.next();
        }
4
Jess

Je ne voulais pas importer une bibliothèque Apache entière pour ajouter une fonction de jointure simple, alors voici mon hack.

    public String join(String delim, List<String> destinations) {
        StringBuilder sb = new StringBuilder();
        int delimLength = delim.length();

        for (String s: destinations) {
            sb.append(s);
            sb.append(delim);
        }

        // we have appended the delimiter to the end 
        // in the previous for-loop. Let's now remove it.
        if (sb.length() >= delimLength) {
            return sb.substring(0, sb.length() - delimLength);
        } else {
            return sb.toString();
        }
    }
2
Martin Konecny

Si vous souhaitez joindre (concaténer) plusieurs chaînes en une, vous devez utiliser un StringBuilder. C'est bien mieux que d'utiliser

for(String s : joinMe)
    target += s;

Il y a également une légère victoire sur les performances de StringBuffer, car StringBuilder n'utilise pas la synchronisation.

Pour une méthode d’utilité générale telle que celle-ci, elle sera (éventuellement) appelée plusieurs fois dans de nombreuses situations. Vous devez donc la rendre efficace et ne pas allouer de nombreux objets transitoires. Nous avons défini de nombreuses applications Java différentes) et nous constatons presque toujours que la concaténation de chaînes et les allocations string/char [] prennent beaucoup de temps et de mémoire.

Notre méthode de collection réutilisable -> string calcule d'abord la taille du résultat requis, puis crée un StringBuilder avec cette taille initiale; Cela évite les doublons/copies inutiles du caractère interne [] utilisé lors de l'ajout de chaînes.

1
djb

J'ai écrit propre:

public static String join(Collection<String> col, String delim) {
    StringBuilder sb = new StringBuilder();
    Iterator<String> iter = col.iterator();
    if (iter.hasNext())
        sb.append(iter.next().toString());
    while (iter.hasNext()) {
        sb.append(delim);
        sb.append(iter.next().toString());
    }
    return sb.toString();
}

mais Collection n'est pas supporté par JSP, donc pour la fonction de balise, j'ai écrit:

public static String join(List<?> list, String delim) {
    int len = list.size();
    if (len == 0)
        return "";
    StringBuilder sb = new StringBuilder(list.get(0).toString());
    for (int i = 1; i < len; i++) {
        sb.append(delim);
        sb.append(list.get(i).toString());
    }
    return sb.toString();
}

et mis à .tld fichier:

<?xml version="1.0" encoding="UTF-8"?>
<taglib version="2.1" xmlns="http://Java.Sun.com/xml/ns/javaee"
    <function>
        <name>join</name>
        <function-class>com.core.util.ReportUtil</function-class>
        <function-signature>Java.lang.String join(Java.util.List, Java.lang.String)</function-signature>
    </function>
</taglib>

et l'utiliser dans les fichiers JSP en tant que:

<%@taglib prefix="funnyFmt" uri="tag:com.core.util,2013:funnyFmt"%>
${funnyFmt:join(books, ", ")}
1
gavenkoa

StringUtils est une classe très utile dans la bibliothèque Apache Commons Lang.

0
Vishal

Je vois beaucoup d'implémentations trop complexes de String.Join ici. Si vous n'avez pas Java 1.8 et que vous ne voulez pas importer une nouvelle bibliothèque, la mise en œuvre ci-dessous devrait suffire.

public String join(Collection<String> col, String delim) {
    StringBuilder sb = new StringBuilder();
    for ( String s : col ) {
        if ( sb.length() != 0 ) sb.append(delim);
        sb.append(s);
    }
    return sb.toString();
}
0
Brandon Dutton

Il y a MessageFormat.format() qui fonctionne comme le String.Format() de C #.

0
MrSnowflake