Comment puis-je ajouter un String en Java?

Est-il un moyen facile de tampon de Chaînes de caractères en Java?

Semble comme quelque chose qui devrait être dans certains StringUtil-comme l'API, mais je ne peux pas trouver quelque chose qui fait cela.

Sur la question de l'apache fonction de vs la chaîne de formatage, il y a peu de doute que l'apache fonction est plus clair et facile à lire. Emballage le formateur en fonction des noms n'est pas l'idéal.

InformationsquelleAutor pvgoddijn | 2008-12-23

167

Apache StringUtils a plusieurs méthodes: leftPad, remplissagedroite, center et repeat.

Mais s'il vous plaît noter que, comme d'autres l'ont mentionné et illustré dans cette réponse — String.format() et la Formatter les classes du JDK sont de meilleures options. Utiliser sur les communes de code.
- java.util.Formateur (et de la Chaîne.format()) est-ce que. Préférez toujours le JDK à une bibliothèque externe si la version du JDK fait le travail (ce qu'il fait).
- Pour plusieurs raisons, j'avais préfèrent maintenant la Goyave de Apache Commons; cette réponse montre comment le faire dans la Goyave.
- pourriez-vous faire une liste de vos raisons? L'Api de chercher à peu près la même.
- Pour un individu, de l'utilitaire, comme ces chaîne de remplissage aides, il ne fait pas vraiment de différence qui lib à utiliser. Cela dit, la Goyave est dans l'ensemble un plus moderne, plus propre et mieux documenté lib que ses homologues dans les différents Apache Commons projets (Communes Lang, Commons Collections, Commons IO, etc). Il est également construit par vraiment intelligent les gars (Kevin Bourrillion et al), dont beaucoup sont active à SO. Moi-même j'ai fini par remplacer les différents Apache Commons libs avec juste la Goyave il y a des années, et n'ont eu aucun regret.
- Quelques bonnes lecture complémentaire à cette question.
- StringUtils/Strings est toujours le meilleur choix de l'OMI, lorsque la taille du tampon est une variable d'exécution.
InformationsquelleAutor GaryF
583

Depuis Java 1.5, String.format() peut être utilisé à gauche/droite pad d'une chaîne donnée.
```
public static String padRight(String s, int n) {
     return String.format("%-" + n + "s", s);  
}

public static String padLeft(String s, int n) {
    return String.format("%" + n + "s", s);  
}

...

public static void main(String args[]) throws Exception {
 System.out.println(padRight("Howto", 20) + "*");
 System.out.println(padLeft("Howto", 20) + "*");
}
```
Et la sortie est:
```
Howto               *
               Howto*
```
- Que faire si vous avez besoin de lpad avec d'autres caractères (pas d'espaces) ? Est-il encore possible avec de la Ficelle.format ? Je ne suis pas en mesure de le faire fonctionner...
- Autant que je sache Chaîne.format() ne peuvent pas faire cela, mais il n'est pas trop difficile de code, voir rgagnon.com/javadetails/java-0448.html (2ème exemple)
- si vous faites allusion à l'rgagnon.com sachez que RealHowTo est l'auteur de rgagnon.com aussi, il serait en créditant lui-même...
- au moins sur mon JVM, le "#" ne fonctionne pas, le "-" est très bien. (Il suffit de supprimer le #). Cela peut être compatible avec le formateur de la documentation, je ne sais pas; il dit: "' # ' '\u0023' Exige la sortie d'utiliser une autre forme. La définition de la forme spécifiée par la conversion."
- Avec re6, "%1$#" est ok, mais avec jre7 "%1$#" throws java.util.FormatFlagsConversionMismatchException: Conversion = s, Flags = #. J'ai mis à jour cette réponse par enlever le "#".
- Merci pour la réponse impressionnante. J'ai un doute si, qu'est-ce que le 1$ pour? @leo a fait très semblable à la réponse qui n'utilise pas 1$ et apparemment, elle a le même effet. Fait-il une différence?
- Oh bien sûr, il est explicitement de la force de l'argument de l'ordre de la Chaîne.format, désolé pour la question stupide. :P Même alors, il sert pratiquement pas utiliser dans ce cas, je suppose.
- Notez que n doit être supérieure à 0.
- Je suggère de prendre le 1$ car il n'est pas nécessaire et les causes de la confusion dans d'autres exemples, c'est à dire que si vous formatez un modèle avec plusieurs paramètres.
- String.format("%5s", valueString) fonctionne tout aussi bien pour leftPad une chaîne d'une longueur de 5 par exemple. String.format("%5d", valueInt) serait garniture gauche d'un nombre à une longueur de 5. Comme d'autres l'ont souligné, la numérotation des arguments est facultatif.
- est supprimé.
InformationsquelleAutor RealHowTo
241

Rembourrage de 10 caractères:
```
String.format("%10s", "foo").replace(' ', '*');
String.format("%-10s", "bar").replace(' ', '*');
String.format("%10s", "longer than 10 chars").replace(' ', '*');
```
de sortie:
```
  *******foo
  bar*******
  longer*than*10*chars
```
Affichage '*' pour les caractères de mot de passe:
```
String password = "secret123";
String padded = String.format("%"+password.length()+"s", "").replace(' ', '*');
```
sortie a la même longueur que la chaîne de mot de passe:
```
  secret123
  *********
```
- Aussi longtemps que nous nous souvenons tous de ne pas passer dans une chaîne de caractères avec des espaces... 😀
- Je suis avec @aboveyou00--c'est un horrible solution pour les chaînes de caractères avec des espaces, y compris l'exemple fourni par leo. Une solution pour le rembourrage d'une chaîne de caractères sur la gauche ou la droite ne devrait pas modifier la chaîne d'entrée, tel qu'il apparaît dans la sortie, sauf si la chaîne d'entrée d'origine de rembourrage causes pour dépasser le spécifiée rembourrage longueur.
- Reconnaissez la question de l'espace. .replace(' ', '*') était plutôt destiné à montrer l'effet de rembourrage. Le mot de passe de cacher l'expression de ne pas avoir ce problème de toute façon... Pour une meilleure réponse sur la personnalisation de la gauche et droit de la chaîne de remplissage à l'aide de Java en natif fonctionnalité de voir mon autre réponse.
- Si la chaîne ne contient que des espaces simples et vous souhaitez le tapis avec des caractères différents, vous pouvez utiliser des regex pour remplacer avec un regard derrière/devant: String.format("%30s", "pad left").replaceAll("(?<=( |^)) ", "*") ou String.format("%-30s", "pad right").replaceAll(" (?=( |$))", "*")
InformationsquelleAutor leo

Dans Goyave, c'est facile:

Strings.padStart("string", 10, ' ');
Strings.padEnd("string", 10, ' ');

InformationsquelleAutor Garrett Hall

Quelque chose de simple:

La valeur doit être une chaîne de caractères. convertir en string, si elle ne l'est pas. Comme "" + 123 ou Integer.toString(123)

//let's assume value holds the String we want to pad
String value = "123";

Sous-chaîne de commencer à partir de la valeur de la longueur indice de char jusqu'à la fin de la longueur de collier:

String padded="00000000".substring(value.length()) + value;

//now padded is "00000123"

Plus précis

pavé droit:

String padded = value + ("ABCDEFGH".substring(value.length())); 

//now padded is "123DEFGH"

pad gauche:

String padString = "ABCDEFGH";
String padded = (padString.substring(0, padString.length() - value.length())) + value;

//now padded is "ABCDE123"

InformationsquelleAutor Shimon Doodkin

22

Ont un coup d'oeil à org.apache.commons.lang.StringUtils#rightPad(String str, int size, char padChar).

Mais l'algorithme est très simple (pavé de droite jusqu'à la taille des caractères):
```
public String pad(String str, int size, char padChar)
{
  StringBuffer padded = new StringBuffer(str);
  while (padded.length() < size)
  {
    padded.append(padChar);
  }
  return padded.toString();
}
```
- Notez qu'à partir de Java 1.5, il vaut la peine de l'utiliser StringBuilder au lieu de StringBuffer.
- Vous avez raison, il serait préférable d'utiliser si Java 5 est réglé.
InformationsquelleAutor Arne Burmeister
21

Outre Apache Commons, voir aussi String.format qui doit être en mesure de prendre soin de simple remplissage (par exemple, avec des espaces).

InformationsquelleAutor Miserable Variable

public static String LPad(String str, Integer length, char car) {
  return (str + String.format("%" + length + "s", "").replace(" ", String.valueOf(car))).substring(0, length);
}

public static String RPad(String str, Integer length, char car) {
  return (String.format("%" + length + "s", "").replace(" ", String.valueOf(car)) + str).substring(str.length(), length + str.length());
}

LPad("Hi", 10, 'R') //gives "RRRRRRRRHi"
RPad("Hi", 10, 'R') //gives "HiRRRRRRRR"
RPad("Hi", 10, ' ') //gives "Hi        "
RPad("Hi", 1, ' ')  //gives "H"
//etc...

Attention: vous avez inversé les noms de fonctions; si vous l'exécutez, vous verrez.
de plus, si l'original str contient des espaces, cela ne fonctionne pas
Si je ne me trompe pas, le remplacer ne sont pas la cible de l'original str, donc c'est correct.
Par convention, vous ne devez pas utiliser une lettre majuscule pour les noms de fonction.
Est-il un manque conditionnelle sur le retour de la chaîne, c'est quand (length - str.length()) est 0? Le formateur jette un FormatFlagsConversionMismatchException quand %0s est la chaîne de format.

InformationsquelleAutor Eduardo

Ce qui m'a pris un peu de temps à comprendre.
La vraie clé est de lire que Formateur de la documentation.

//Get your data from wherever.
final byte[] data = getData();
//Get the digest engine.
final MessageDigest md5= MessageDigest.getInstance("MD5");
//Send your data through it.
md5.update(data);
//Parse the data as a positive BigInteger.
final BigInteger digest = new BigInteger(1,md5.digest());
//Pad the digest with blanks, 32 wide.
String hex = String.format(
    //See: http://download.oracle.com/javase/1.5.0/docs/api/java/util/Formatter.html
    //Format: %[argument_index$][flags][width]conversion
    //Conversion: 'x', 'X'  integral    The result is formatted as a hexadecimal integer
    "%1$32x",
    digest
);
//Replace the blank padding with 0s.
hex = hex.replace(" ","0");
System.out.println(hex);

Pourquoi faire à la fin si compliqué? Vous pourriez avoir tout fait Chaîne hex = String.format("%032x", digest), et qu'elle avait exactement les mêmes résultats, sans inutile replace() et d'avoir à utiliser l' $ pour accéder à des variables spécifiques (il n'y a qu'un seul, après tout.)
juste point de. Quelqu'un à l'origine demandé pour le rembourrage des valeurs hexadécimales dans une autre question, j'ai vu que j'avais un lien vers le module de formatage de la documentation. C'est compliqué pour l'exhaustivité.

InformationsquelleAutor Nthalk

6

je sais que ce fil est une sorte de vieux et de la question d'origine était une solution de facilité, mais si c'est censé être vraiment rapide, vous devez utiliser un tableau de char.
```
public static String pad(String str, int size, char padChar)
{
    if (str.length() < size)
    {
        char[] temp = new char[size];
        int i = 0;

        while (i < str.length())
        {
            temp[i] = str.charAt(i);
            i++;
        }

        while (i < size)
        {
            temp[i] = padChar;
            i++;
        }

        str = new String(temp);
    }

    return str;
}
```
le formateur solution n'est pas optimale. juste la construction de la chaîne de format crée 2 nouvelles chaînes.

apache solution peut être améliorée par l'initialisation de la sb avec la taille de la cible afin de remplacer ci-dessous
```
StringBuffer padded = new StringBuffer(str); 
```
avec
```
StringBuffer padded = new StringBuffer(pad); 
padded.append(value);
```
permettrait d'éviter le sb de la mémoire tampon interne de plus en plus.
- Si le StringBuffer ne peut pas être accédé par plusieurs threads à la fois (ce qui dans ce cas est vrai), vous devez utiliser un StringBuilder (en JDK1.5+) pour éviter la surcharge de la synchronisation.
InformationsquelleAutor ck.

Ici est une autre façon de pad à droite:

//put the number of spaces, or any character you like, in your paddedString

String paddedString = "--------------------";

String myStringToBePadded = "I like donuts";

myStringToBePadded = myStringToBePadded + paddedString.substring(myStringToBePadded.length());

//result:
myStringToBePadded = "I like donuts-------";

InformationsquelleAutor fawsha1

4

Vous pouvez réduire le nombre d'appels généraux en conservant les données de remplissage, plutôt que de reconstruire à chaque fois:
```
public class RightPadder {

    private int length;
    private String padding;

    public RightPadder(int length, String pad) {
        this.length = length;
        StringBuilder sb = new StringBuilder(pad);
        while (sb.length() < length) {
            sb.append(sb);
        }
        padding = sb.toString();
   }

    public String pad(String s) {
        return (s.length() < length ? s + padding : s).substring(0, length);
    }

}
```
Comme alternative, vous pouvez rendre le résultat de longueur d'un paramètre à la pad(...) méthode. Dans ce cas, faire le réglage de l'caché rembourrage dans cette méthode, au lieu de dans le constructeur.

(Astuce: Pour un crédit supplémentaire, faire thread-safe! 😉
- C'est thread-safe, sauf pour dangereux publication (faites votre champs de finale, comme une question de cours). Je pense que la performance pourrait être améliorée en faisant une sous-chaîne avant le + qui devrait être remplacé par concat (étrangement).
InformationsquelleAutor joel.neely
3

Trouvé ceci sur Dzone

Pad avec des zéros:
```
String.format("|%020d|", 93); //prints: |00000000000000000093|
```
- Cela devrait être la réponse, simple et concis, pas besoin d'installer les bibliothèques externes.
InformationsquelleAutor OJVM

vous pouvez utiliser le construit en StringBuilder append() et l'insert() les méthodes, les
pour le rembourrage de la variable longueur de chaîne:

AbstractStringBuilder append(CharSequence s, int start, int end) ;

Par Exemple:

private static final String  MAX_STRING = "                    "; //20 spaces

    Set<StringBuilder> set= new HashSet<StringBuilder>();
    set.add(new StringBuilder("12345678"));
    set.add(new StringBuilder("123456789"));
    set.add(new StringBuilder("1234567811"));
    set.add(new StringBuilder("12345678123"));
    set.add(new StringBuilder("1234567812234"));
    set.add(new StringBuilder("1234567812222"));
    set.add(new StringBuilder("12345678122334"));

    for(StringBuilder padMe: set)
        padMe.append(MAX_STRING, padMe.length(), MAX_STRING.length());

InformationsquelleAutor ef_oren

2

Cela fonctionne:
```
"".format("%1$-" + 9 + "s", "XXX").replaceAll(" ", "0")
```
Il remplira votre Chaîne XXX jusqu'à 9 Caractères avec un espace. Après que tous les Espaces sera remplacé par un 0. Vous pouvez modifier l'espace et le 0 pour tout ce que vous voulez...
- Vous devez appeler la static méthode String.format(…) au lieu d'abuser d'une chaîne vide. Sauver quatre caractères dans le code source n'est sûrement pas la peine de la perte de lisibilité.
InformationsquelleAutor Sebastian S.

public static String padLeft(String in, int size, char padChar) {                
    if (in.length() <= size) {
        char[] temp = new char[size];
        /* Llenado Array con el padChar*/
        for(int i =0;i<size;i++){
            temp[i]= padChar;
        }
        int posIniTemp = size-in.length();
        for(int i=0;i<in.length();i++){
            temp[posIniTemp]=in.charAt(i);
            posIniTemp++;
        }            
        return new String(temp);
    }
    return "";
}

InformationsquelleAutor Marlon Tarax

2

Me laisser une réponse à certains des cas que vous avez besoin pour donner à gauche/droite de rembourrage (ou préfixe/suffixe ou des espaces) avant de concaténer à l'autre de la chaîne et vous ne voulez pas tester la longueur ou de tout si la condition.

Le même à la réponse choisie, je préfère le StringUtils de Apache Commons, mais à l'aide de cette façon:
```
StringUtils.defaultString(StringUtils.leftPad(myString, 1))
```
Expliquer:
- myString: la chaîne I de l'entrée, peut être null
- StringUtils.leftPad(myString, 1): si la chaîne est nulle, cette déclaration serait de retour null trop
- ensuite utiliser defaultString de donner une chaîne vide pour éviter concaténer null
InformationsquelleAutor Osify

@ck's et @Marlon Tarakreponses sont les seuls à utiliser un char[], qui pour les applications qui ont plusieurs appels à rembourrage méthodes par seconde est la meilleure approche. Cependant, ils ne prennent pas avantage de n'importe quel tableau de manipulation et optimisations sont un peu écrasées à mon goût, ce qui peut être fait avec pas de boucles à tous les.

public static String pad(String source, char fill, int length, boolean right){
    if(source.length() > length) return source;
    char[] out = new char[length];
    if(right){
        System.arraycopy(source.toCharArray(), 0, out, 0, source.length());
        Arrays.fill(out, source.length(), length, fill);
    }else{
        int sourceOffset = length - source.length();
        System.arraycopy(source.toCharArray(), 0, out, sourceOffset, source.length());
        Arrays.fill(out, 0, sourceOffset, fill);
    }
    return new String(out);
}

Simple méthode de test:

public static void main(String... args){
    System.out.println("012345678901234567890123456789");
    System.out.println(pad("cats", ' ', 30, true));
    System.out.println(pad("cats", ' ', 30, false));
    System.out.println(pad("cats", ' ', 20, false));
    System.out.println(pad("cats", '$', 30, true));
    System.out.println(pad("too long for your own good, buddy", '#', 30, true));
}

Sorties:

012345678901234567890123456789
cats                          
                          cats
                cats
cats$$$$$$$$$$$$$$$$$$$$$$$$$$
too long for your own good, buddy

Vous pouvez utiliser getChars pour le String copier son contenu directement dans la out tableau, au lieu d'appeler source.toCharArray(), suivie par System.arraycopy. J'irais même jusqu'à envisager de simplifier la mise en œuvre de char[] out = new char[length]; Arrays.fill(out, 0, length, fill); source.getChars(0, source.length(), out, right? 0: length - source.length()); return new String(out);; tout cela ressemble à fill permettrait de faire plus de travail, il permet en fait de la JVM pour éliminer le défaut à zéro de remplissage.

InformationsquelleAutor ndm13

1

java.util.Formatter fera à gauche et à droite de rembourrage. Pas besoin de bizarre tiers des dépendances (voudriez-vous ajouter quelque chose de tellement banal).

[J'ai laissé de côté les détails et fait ce post 'wiki de la communauté", car il n'est pas quelque chose que j'ai besoin d'.]
- Je suis en désaccord. Dans tout grand projet Java vous sera généralement faire beaucoup de manipulation de Chaîne, que l'augmentation de la lisibilité et éviter les erreurs vaut bien à l'aide d'Apache Commons Lang. Vous le savez tous un code comme someString.subString(someString.indexOf(startCharacter), someString.lastIndexOf(endCharacter)), qui peuvent être facilement évitée avec StringUtils.
InformationsquelleAutor

Utiliser cette fonction.

private String leftPadding(String word, int length, char ch) {
   return (length > word.length()) ? leftPadding(ch + word, length, ch) : word;
}

comment l'utiliser?

leftPadding(month, 2, '0');

de sortie:
01 02 03 04 .. 11 12

InformationsquelleAutor Samet öztoprak

Beaucoup de gens ont quelque chose de très intéressant techniques, mais j'aime garder les choses simples je pars donc avec ceci :

public static String padRight(String s, int n, char padding){
    StringBuilder builder = new StringBuilder(s.length() + n);
    builder.append(s);
    for(int i = 0; i < n; i++){
        builder.append(padding);
    }
    return builder.toString();
}

public static String padLeft(String s, int n,  char padding) {
    StringBuilder builder = new StringBuilder(s.length() + n);
    for(int i = 0; i < n; i++){
        builder.append(Character.toString(padding));
    }
    return builder.append(s).toString();
}

public static String pad(String s, int n, char padding){
    StringBuilder pad = new StringBuilder(s.length() + n * 2);
    StringBuilder value = new StringBuilder(n);
    for(int i = 0; i < n; i++){
        pad.append(padding);
    }
    return value.append(pad).append(s).append(pad).toString();
}

C'est très inefficace, vous devez utiliser un StringBuilder
Puisque vous connaissez déjà la longueur, vous devez dire à la StringBuilder pour allouer beaucoup d'espace lors de l'instanciation.
intéressant que vous mentionniez que parce que je viens de dire à quelqu'un d'autre à ce sujet aujourd'hui lol.

InformationsquelleAutor Aelphaeis

1

Depuis Java 11, Chaîne.répéter(int) peut être utilisé à gauche/droite pad d'une chaîne donnée.
```
System.out.println("*".repeat(5)+"apple");
System.out.println("apple"+"*".repeat(5));
```
De sortie:
```
*****apple
apple*****
```
- Meilleure réponse pour java 11!
InformationsquelleAutor Eko Setiawan

Une solution simple sans aucune API sera comme suit:

public String pad(String num, int len){
    if(len-num.length() <=0) return num;
    StringBuffer sb = new StringBuffer();
    for(i=0; i<(len-num.length()); i++){
        sb.append("0");
    }
    sb.append(num);
    return sb.toString();
}

InformationsquelleAutor Shashank Shekhar

Java oneliners, pas de fantaisie, de la bibliothèque.

//6 characters padding example
String pad = "******";
//testcases for 0, 4, 8 characters
String input = "" | "abcd" | "abcdefgh"

Pad Gauche, ne se limite pas

result = pad.substring(Math.min(input.length(),pad.length())) + input;
results: "******" | "**abcd" | "abcdefgh"

Pavé Droit, n'a pas de limite

result = input + pad.substring(Math.min(input.length(),pad.length()));
results: "******" | "abcd**" | "abcdefgh"

Pad Gauche, limite pad longueur

result = (pad + input).substring(input.length(), input.length() + pad.length());
results: "******" | "**abcd" | "cdefgh"

Pad à Droite, limite à la pad longueur

result = (input + pad).substring(0, pad.length());
results: "******" | "abcd**" | "abcdef"

InformationsquelleAutor leo

0

Tous chaîne opération a généralement besoin d'être très efficace - surtout si vous travaillez avec de grands ensembles de données. Je voulais quelque chose de rapide et souple, similaire à ce que vous obtenez en plsql pavé de commande. Aussi, je ne veux pas d'inclure un énorme lib pour juste une petite chose. Avec ces considérations, aucune de ces solutions ont été satisfaisants. C'est la solutions je suis venu avec, qui avait le meilleur bench-marking résultats, si quelqu'un peut l'améliorer, s'il vous plaît ajouter votre commentaire.
```
public static char[] lpad(char[] pStringChar, int pTotalLength, char pPad) {
    if (pStringChar.length < pTotalLength) {
        char[] retChar = new char[pTotalLength];
        int padIdx = pTotalLength - pStringChar.length;
        Arrays.fill(retChar, 0, padIdx, pPad);
        System.arraycopy(pStringChar, 0, retChar, padIdx, pStringChar.length);
        return retChar;
    } else {
        return pStringChar;
    }
}
```
- remarque il est appelé avec de la Ficelle.toCharArray() et le résultat peut être converti en Chaîne avec new String((char[])le résultat). La raison pour cela est si vous appliquez plusieurs activités que vous pouvez faire tous les char[] et de ne pas garder sur la conversion entre les formats les coulisses de, la Chaîne est stockée en tant que char[]. Si ces opérations ont été inclus dans la Chaîne de la classe elle-même, il aurait été deux fois plus efficace - de la vitesse et de la mémoire sage.
InformationsquelleAutor EarlB

-1

Une solution simple serait:

package nl;
public class Padder {
    public static void main(String[] args) {
        String s = "123" ;
        System.out.println("#"+("     " + s).substring(s.length())+"#");
    }
}

InformationsquelleAutor Hans Andeweg

-2

Comment est-ce

Chaîne "bonjour" et requis le rembourrage est de 15 "0" à gauche pad
```
String ax="Hello";
while(ax.length() < 15) ax="0"+ax;
```
- J'ai aimé celui-ci. 🙂
- cela génère jusqu'à 15 nouvelles chaînes.
- Oui, mais ceci.
InformationsquelleAutor Satwant

Vous devez vous connecter pour publier un commentaire.