web-dev-qa-db-fra.com

Comment puis-je compléter une chaîne en Java?

Existe-t-il un moyen simple de patiner Strings en Java?

On dirait que quelque chose devrait être dans une API similaire à StringUtil, mais je ne trouve rien qui fasse cela.

373
pvgoddijn

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

Mais notez bien que - comme d’autres l’ont mentionné et démontré dans cette réponse - String.format() et les classes Formatter dans le JDK sont de meilleures options. Utilisez-les sur le code des biens communs.

159
GaryF

Depuis Java 1.5, String.format() peut être utilisé pour coller à gauche/droite 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 le résultat est:

Howto               *
               Howto*
567
RealHowTo

Rembourrage à 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

Afficher '*' pour les caractères du mot de passe:

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

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

  secret123
  *********
234
leo

En Guava , c'est facile:

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

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

La sous-chaîne commence à partir de l'index de caractère de longueur longueur jusqu'à la longueur finale de remplissage:

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

// now padded is "00000123"

Plus précis  

pad 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"
29
Shimon Doodkin

Jetez un coup d'œil à 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();
}
22
Arne Burmeister

Outre Apache Commons, consultez également String.format qui devrait pouvoir gérer un remplissage simple (par exemple, avec des espaces).

21
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...
16
Eduardo

Cela m'a pris un peu de temps pour comprendre… .. La vraie clé est de lire cette 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);
7
Nthalk

je sais que ce fil est un peu vieux et la question initiale était pour une solution facile mais si c'est supposé être très rapide, vous devriez utiliser un tableau de caractères.

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. la simple 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 afin de remplacer ci-dessous

StringBuffer padded = new StringBuffer(str); 

avec 

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

empêcherait le tampon interne du sb de croître.

6
ck.

Voici un autre moyen de vous déplacer à 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-------";
5
fawsha1

Vous pouvez réduire le temps système par appel en conservant les données de remplissage, au lieu 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);
    }

}

Vous pouvez également définir la longueur du résultat comme paramètre de la méthode pad(...). Dans ce cas, ajustez le remplissage caché dans cette méthode plutôt que dans le constructeur.

(Astuce: pour plus de crédit, assurez-vous de la sécurité des threads! ;-)

4
joel.neely
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 "";
}
2
Marlon Tarax

Trouvé ceci sur Dzone

Pad avec des zéros:

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

vous pouvez utiliser les méthodes intégrées StringBuilder append () et insert (), pour le remplissage 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());
2
ef_oren

Cela marche:

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

Il remplira votre String XXX jusqu’à 9 caractères avec un espace. Après cela, tous les espaces blancs seront remplacés par un 0. Vous pouvez modifier les espaces et le 0 comme vous le souhaitez ...

2
Sebastian S.

Laissons-moi laisser une réponse pour certains cas pour lesquels vous devez donner un remplissage à gauche/à droite (ou une chaîne de préfixe/suffixe) avant de concaténer une autre chaîne et vous ne voulez pas tester la longueur ou une condition if.

De même pour la réponse choisie, je préférerais la StringUtils d'Apache Commons, mais en utilisant cette méthode:

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

Explique:

  • myString: la chaîne que j'ai entrée, peut être null
  • StringUtils.leftPad(myString, 1): si la chaîne est null, cette instruction renvoie aussi null
  • puis utilisez defaultString pour donner une chaîne vide afin d'éviter la concaténation null
2
Osify

Les réponses de @ck et @Marlon Tarak sont les seules à utiliser un char[], qui est la meilleure approche pour les applications ayant plusieurs appels à des méthodes de remplissage par seconde. Cependant, ils ne tirent pas parti des optimisations de manipulation de tableaux et sont un peu écrasés à mon goût; cela peut être fait avec no 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 de test 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));
}

Les sorties:

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

Beaucoup de gens ont des techniques très intéressantes mais j'aime garder les choses simples alors 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();
}
1
Aelphaeis

Java.util.Formatter fera le remplissage gauche et droit. Pas besoin de dépendances tierces impaires (voudriez-vous les ajouter pour quelque chose d'aussi trivial).

[J'ai omis les détails et fait de ce post 'wiki de la communauté', car ce n'est pas quelque chose dont j'ai besoin.]

1

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

1
Samet öztoprak

Tout chaîne opération doit généralement être très efficace - surtout si vous travaillez avec de grands ensembles de données. Je voulais quelque chose qui soit rapide et flexible, semblable à ce que vous obtiendrez dans la commande plsql pad. En outre, je ne veux pas inclure une bibliothèque énorme pour une seule petite chose. Compte tenu de ces considérations, aucune de ces solutions n’était satisfaisante. C’est la solution que j’ai proposée, qui a eu les meilleurs résultats de benchmarking. Si quelqu'un peut l’améliorer, veuillez 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 est appelé avec String.toCharArray () et que le résultat peut être converti en String avec un nouveau résultat String ((char [])). La raison en est que si vous appliquez plusieurs opérations, vous pouvez toutes les exécuter sur char [] et ne pas poursuivre la conversion entre les formats. En coulisse, String est stocké sous la forme char []. Si ces opérations étaient incluses dans la classe String elle-même, l'efficacité aurait été deux fois plus grande - en termes de vitesse et de mémoire.
0
EarlB

Depuis Java 11, String.repeat (int) peut être utilisé pour coller à gauche/droite une chaîne donnée.

System.out.println("*".repeat(5)+"Apple");
System.out.println("Apple"+"*".repeat(5));

Sortie:

*****Apple
apple*****
0
Eko Setiawan

Java oneliners, pas de bibliothèque de fantaisie. 

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

Pad gauche, ne limite pas

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

Pad Bon, ne limite pas

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

Pad gauche, limite à la longueur du pad

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

Pad Droite, limiter à la longueur du pad

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

Une solution simple sans API sera la suivante:

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

Pourquoi ne pas utiliser la récursivité? La solution ci-dessous est compatible avec toutes les versions de JDK et aucune bibliothèque externe n'est requise:)

private static String addPadding(final String str, final int desiredLength, final String padBy) {
        String result = str;
        if (str.length() >= desiredLength) {
            return result;
        } else {
            result += padBy;
            return addPadding(result, desiredLength, padBy);
        }
    }

NOTE: Cette solution va ajouter le remplissage, avec un petit Tweak vous pouvez préfixer la valeur du pad.

0
Saikat Sengupta