Comment puis-je tamponner une chaîne en Java?

Existe-t-il un moyen simple de comstackr Ssortingngs en Java?

Cela semble être quelque chose qui devrait se trouver dans une API de type SsortingngUtil, mais je ne trouve rien qui le fasse.

Apache SsortingngUtils dispose de plusieurs méthodes: leftPad , rightPad , center et repeat .

Mais veuillez noter que – comme d’autres l’ont mentionné et démontré dans cette réponse – Ssortingng.format() et les classes Formatter du JDK sont de meilleures options. Utilisez-les sur le code commons.

Depuis Java 1.5, Ssortingng.format() peut être utilisé pour Ssortingng.format() une chaîne donnée à gauche / à droite.

 public static Ssortingng padRight(Ssortingng s, int n) { return Ssortingng.format("%1$-" + n + "s", s); } public static Ssortingng padLeft(Ssortingng s, int n) { return Ssortingng.format("%1$" + n + "s", s); } ... public static void main(Ssortingng args[]) throws Exception { System.out.println(padRight("Howto", 20) + "*"); System.out.println(padLeft("Howto", 20) + "*"); } /* output : Howto * Howto* */ 

Rembourrage à 10 caractères:

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

sortie:

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

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

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

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

  secret123 ********* 

En goyave , c’est facile:

 Ssortingngs.padStart("ssortingng", 10, ' '); Ssortingngs.padEnd("ssortingng", 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.toSsortingng(123)

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

La sous-chaîne commence à partir de l’index de longueur de la longueur de la valeur jusqu’à la longueur de fin du remplissage:

 Ssortingng padded="00000000".subssortingng(value.length()) + value; // now padded is "00000123" 

Plus précis

pad à droite:

 Ssortingng padded = value + ("ABCDEFGH".subssortingng(value.length())); // now padded is "123DEFGH" 

pad gauche:

 Ssortingng padSsortingng = "ABCDEFGH"; Ssortingng padded = (padSsortingng.subssortingng(0, padSsortingng.length() - value.length())) + value; // now padded is "ABCDE123" 

Jetez un oeil à org.apache.commons.lang.SsortingngUtils#rightPad(Ssortingng str, int size, char padChar) .

Mais l’algorithme est très simple (pad jusqu’à la taille des caractères):

 public Ssortingng pad(Ssortingng str, int size, char padChar) { SsortingngBuffer padded = new SsortingngBuffer(str); while (padded.length() < size) { padded.append(padChar); } return padded.toString(); } 

Outre Apache Commons, voir également Ssortingng.format qui devrait pouvoir Ssortingng.format simple remplissage (par exemple avec des espaces).

 public static Ssortingng LPad(Ssortingng str, Integer length, char car) { return str + Ssortingng.format("%" + (length - str.length()) + "s", "") .replace(" ", Ssortingng.valueOf(car)); } public static Ssortingng RPad(Ssortingng str, Integer length, char car) { return Ssortingng.format("%" + (length - str.length()) + "s", "") .replace(" ", Ssortingng.valueOf(car)) + str; } LPad("Hi", 10, 'R') //gives "RRRRRRRRHi" RPad("Hi", 10, 'R') //gives "HiRRRRRRRR" RPad("Hi", 10, ' ') //gives "Hi " //etc... 

Cela m’a pris un peu de temps pour comprendre. La vraie clé est de lire cette documentation de 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. Ssortingng hex = Ssortingng.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); 

Je sais que ce sujet est assez ancien et que la question initiale était une solution facile, mais si elle est supposée être très rapide, vous devriez utiliser un tableau de caractères.

 public static Ssortingng pad(Ssortingng 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 construction de la chaîne de format crée 2 nouvelles chaînes.

la solution apache peut être améliorée en initialisant le sb avec la taille de la cible afin de la remplacer ci-dessous

 SsortingngBuffer padded = new SsortingngBuffer(str); 

avec

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

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

Voici une autre façon de mettre à droite:

 // put the number of spaces, or any character you like, in your paddedSsortingng Ssortingng paddedSsortingng = "--------------------"; Ssortingng mySsortingngToBePadded = "I like donuts"; mySsortingngToBePadded = mySsortingngToBePadded + paddedSsortingng.subssortingng(mySsortingngToBePadded.length()); //result: mySsortingngToBePadded = "I like donuts-------"; 

Vous pouvez réduire la surcharge par appel en conservant les données de remplissage plutôt que de les reconstruire à chaque fois:

 public class RightPadder { private int length; private Ssortingng padding; public RightPadder(int length, Ssortingng pad) { this.length = length; SsortingngBuilder sb = new SsortingngBuilder(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); } } 

En alternative, vous pouvez 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, rendez-le aussi sûr que possible! 😉

vous pouvez utiliser les méthodes append () et insert () de SsortingngBuilder pour le remplissage de longueurs de chaîne variables:

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

Par exemple:

 private static final Ssortingng MAX_STRING = " "; //20 spaces Set set= new HashSet(); set.add(new SsortingngBuilder("12345678")); set.add(new SsortingngBuilder("123456789")); set.add(new SsortingngBuilder("1234567811")); set.add(new SsortingngBuilder("12345678123")); set.add(new SsortingngBuilder("1234567812234")); set.add(new SsortingngBuilder("1234567812222")); set.add(new SsortingngBuilder("12345678122334")); for(SsortingngBuilder padMe: set) padMe.append(MAX_STRING, padMe.length(), MAX_STRING.length()); 

Cela marche:

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

Il remplira votre chaîne XXX jusqu’à 9 caractères avec un espace. Après cela, tous les espaces blancs seront remplacés par un 0. Vous pouvez changer les espaces et les 0 comme vous voulez …

 public static Ssortingng padLeft(Ssortingng in, int size, char padChar) { if (in.length() <= size) { char[] temp = new char[size]; /* Llenado Array con el padChar*/ for(int i =0;i 

Laissez-moi une réponse pour certains cas où vous devez donner un remplissage gauche / droit (ou une chaîne de préfixe / suffixe ou des espaces) 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 sélectionnée, je préférerais les SsortingngUtils d’Apache Commons mais en utilisant cette méthode:

 SsortingngUtils.defaultSsortingng(SsortingngUtils.leftPad(mySsortingng, 1)) 

Explique:

  • mySsortingng : la chaîne que je saisis peut être nulle
  • SsortingngUtils.leftPad(mySsortingng, 1) : si ssortingng est null, cette instruction renverrait également null
  • utilisez ensuite defaultSsortingng pour donner une chaîne vide pour éviter la concaténation de null

J’ai trouvé ça sur Dzone

Pad avec des zéros:

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

java.util.Formatter fera un remplissage gauche et droit. Pas besoin de dépendances tierces bizarres (voudriez-vous les append pour quelque chose d’aussi sortingvial).

[J’ai omis les détails et rendu ce post ‘wiki communautaire’ car ce n’est pas quelque chose dont j’ai besoin.]

Les réponses de @ck ‘s et de @Marlon Tarak sont les seules à utiliser un char[] , ce qui est la meilleure approche pour les applications qui ont plusieurs appels aux méthodes de remplissage par seconde. Cependant, ils ne tirent aucun avantage des optimisations de manipulation de la masortingce et sont un peu écrasés à mon goût. Cela peut être fait sans boucles du tout .

 public static Ssortingng pad(Ssortingng 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 Ssortingng(out); } 

Méthode de test simple:

 public static void main(Ssortingng... 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 

Une solution simple sans API sera la suivante:

 public Ssortingng pad(Ssortingng 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(); } 

Oneliners Java, pas de bibliothèque sophistiquée.

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

Pad gauche, ne limite pas

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

Pad Right, ne limite pas

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

Pad Left, limite à la longueur du pad

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

Pad droite, limite à la longueur du pad

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

Toutes les opérations sur les chaînes doivent généralement être très efficaces , 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 énorme lib pour une petite chose. Avec ces considérations, aucune de ces solutions n’était satisfaisante. Ce sont les solutions que j’ai trouvées, qui ont eu les meilleurs résultats de benchmarking, si quelqu’un peut l’améliorer, ajoutez votre commentaire.

 public static char[] lpad(char[] pSsortingngChar, int pTotalLength, char pPad) { if (pSsortingngChar.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 Ssortingng.toCharArray () et que le résultat peut être converti en Ssortingng avec le nouveau résultat Ssortingng ((char [])). La raison en est que si vous appliquez plusieurs opérations, vous pouvez les faire toutes sur char [] et ne pas continuer à convertir entre formats - en coulisses, Ssortingng est stocké sous la forme de char []. Si ces opérations étaient incluses dans la classe Ssortingng elle-même, cela aurait été deux fois plus efficace - en termes de vitesse et de mémoire.

Utilisez cette fonction.

 private Ssortingng leftPadding(Ssortingng 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

Beaucoup de gens ont des techniques très intéressantes mais j’aime garder les choses simples alors je vais avec ça:

 public static Ssortingng padRight(Ssortingng s, int n, char padding){ SsortingngBuilder builder = new SsortingngBuilder(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(Ssortingng[] args) { Ssortingng s = "123" ; System.out.println("#"+(" " + s).subssortingng(s.length())+"#"); } } 

Comment est-ce

La chaîne est “hello” et le remplissage requirejs est de 15 avec le pad gauche “0”

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