Comment puis-je coller une chaîne de caractères en Java?

depuis Java 1.5, String.format() peut être utilisé à gauche/droite pad une corde donnée.

public static String padRight(String s, int n) {
     return String.format("%1$-" + n + "s", s);  
}

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

...

public static void main(String args[]) throws Exception {
 System.out.println(padRight("Howto", 20) + "*");
 System.out.println(padLeft("Howto", 20) + "*");
}
/*
  output :
     Howto               *
                    Howto*
*/

Padding de 10 caractères:

String.format("%10s", "foo").replace(' ', '*');
String.format("%-10s", "bar").replace(' ', '*');
String.format("%10s", "longer than 10 chars").replace(' ', '*');

sortie:

  *******foo
  bar*******
  longer*than*10*chars

String password = "secret123";
String padded = String.format("%"+password.length()+"s", "").replace(' ', '*');

a la même longueur que la chaîne de mots de passe:

  secret123
  *********

dans Goyave , c'est facile:

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

quelque chose de simple:

la valeur doit être une chaîne. convertissez-le en chaîne, si ce n'est pas le cas. 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

pad à droite:

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"

regardez org.apache.commons.lang.StringUtils#rightPad(String str, int size, char padChar) .

mais l'algorithme est très simple (pad 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();
}

outre Apache Commons, voir aussi String.format qui devrait être capable de s'occuper de rembourrage simple (par exemple avec des espaces).

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

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

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

ça m'a pris un peu de temps à comprendre. La vraie clé est de lire cette documentation Formatter.

// 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
    "%1x",
    digest
);
// Replace the blank padding with 0s.
hex = hex.replace(" ","0");
System.out.println(hex);

je sais que ce fil est un peu vieux et la question originale était pour une solution facile, mais si c'est censé être vraiment rapide, vous devriez 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;
}

la solution de formatage n'est pas optimale. juste la construction de la chaîne de format crée 2 nouvelles chaînes.

la solution d'apache peut être améliorée en initialisant le sb avec la taille cible de sorte à remplacer en dessous de

StringBuffer padded = new StringBuffer(str); 

avec

StringBuffer padded = new StringBuffer(pad); 
padded.append(value);

empêcherait le tampon interne du sb de se développer.

Voici une autre façon de paver à 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-------";

vous pouvez réduire les frais généraux par appel en conservant les données de remplissage, plutôt que de les 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 faire de la longueur du résultat un paramètre de la méthode pad(...) . Dans ce cas, faire le réglage de l'caché rembourrage dans cette méthode, au lieu de dans le constructeur.

(indice: pour plus de crédit, Faites-le thread-safe! ;- )

vous pouvez utiliser les méthodes built in StringBuilder ajoute() et insert() , pour le rembourrage de longueurs de chaîne variables:

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());

Cela fonctionne:

"".format("%1$-" + 9 + "s", "XXX").replaceAll(" ", "0")

il remplira votre chaîne XXX jusqu'à 9 caractères avec un espace blanc. Après cela tous les espaces blancs seront remplacés par un 0. Vous pouvez changer l'espace blanc et le 0 à ce que vous voulez...

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 "";
}

laissez-moi vous donner une réponse pour quelques cas que vous devez donner gauche/droite padding (ou préfixe/chaîne de suffixe ou espaces) avant de vous concaténer à une autre chaîne et vous ne voulez pas tester la longueur ou toute condition if.

identique à la réponse sélectionnée, je préférerais le StringUtils D'Apache Commons mais en utilisant cette façon:

StringUtils.defaultString(StringUtils.leftPad(myString, 1))

expliquer:

• myString : la chaîne que j'entre, peut être nulle
• StringUtils.leftPad(myString, 1) : si string est null, cette déclaration retournerait aussi null
• puis utilisez defaultString pour donner une chaîne vide pour empêcher le concaténate null

Trouvé ceci sur Dzone

Pad avec zéros:

String.format("|%020d|", 93); // prints: |00000000000000000093|

java.util.Formatter fait un rembourrage à gauche et à droite. 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 de ce post 'le wiki de la communauté' car ce n'est pas quelque chose dont j'ai besoin.]

@ck 's et 's réponses de @Marlon Tarak 's sont les seuls à utiliser un char[] , qui pour les applications qui ont plusieurs appels à des méthodes de rembourrage par seconde est la meilleure approche. Cependant, ils ne tirent pas avantage de toute optimisation de la manipulation des réseaux et sont un peu écrasés à mon goût; cela peut être fait avec pas de boucles du tout .

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);
}

méthode D'essai Simple:

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 

utilisez cette fonction.

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

comment utiliser?

leftPadding(month, 2, '0');

sortie: 01 02 03 04 .. 11 12

Une solution simple sans aucune API seront 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();
}

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, n'a pas de limite

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, à la limite de tampon de longueur

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

Pad à Droite, limite à pavé de longueur

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

Tous chaîne l'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 flexible, similaire à ce que vous obtiendrez dans la commande PLSQL pad. En outre, Je ne veux pas inclure une grande lib pour une petite chose. Compte tenu de ces considérations, aucune de ces solutions n'était satisfaisante. Voici les solutions que j'ai trouvées, qui ont eu les meilleurs résultats de benchmarking, si quelqu'un pouvez 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;
    }
}

• notez qu'il s'appelle String.toCharArray() et le résultat peut être converti en Chaîne avec new String((char[])le résultat). La raison en est que, si vous appliquez plusieurs opérations, vous pouvez les faire toutes sur char[] et ne pas continuer à convertir entre les formats - dans les coulisses, la chaîne est stockée comme char[]. Si ces opérations étaient incluses dans la classe String elle-même, il aurait été deux fois plus efficace-vitesse et la mémoire Sage.

beaucoup de gens ont des techniques très intéressantes, mais j'aime garder cela simple donc je vais 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();
}

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())+"#");
    }
}

Comment est-ce

chaîne est "bonjour" et le rembourrage requis est de 15 avec " 0 "tampon de gauche

String ax="Hello";
while(ax.length() < 15) ax="0"+ax;