Comment formater une chaîne Java avec un zéro non significatif?

Voici la chaîne, par exemple:

"Apple"

et je voudrais ajouter zéro pour remplir 8 caractères:

"000Apple"

Comment puis-je le faire?

Au cas où vous deviez le faire sans l'aide d'une bibliothèque:

("00000000" + "Apple").substring("Apple".length())

(Fonctionne, tant que votre chaîne ne dépasse pas 8 caractères.)

public class LeadingZerosExample {
    public static void main(String[] args) {
       int number = 1500;

       // String format below will add leading zeros (the %0 syntax) 
       // to the number above. 
       // The length of the formatted string will be 7 characters.

       String formatted = String.format("%07d", number);

       System.out.println("Number with leading zeros: " + formatted);
    }
}

 StringUtils.leftPad(yourString, 8, '0');

Cela vient de commons-lang . Voir javadoc

C'est ce qu'il demandait vraiment je crois:

String.format("%0"+ (8 - "Apple".length() )+"d%s",0 ,"Apple"); 

production:

000Apple

Vous pouvez utiliser la méthode String.format telle qu'utilisée dans une autre réponse pour générer une chaîne de 0,

String.format("%0"+length+"d",0)

Cela peut être appliqué à votre problème en ajustant dynamiquement le nombre de 0 non significatifs dans une chaîne de format:

public String leadingZeros(String s, int length) {
     if (s.length() >= length) return s;
     else return String.format("%0" + (length-s.length()) + "d%s", 0, s);
}

C'est toujours une solution compliquée, mais a l'avantage que vous pouvez spécifier la longueur totale de la chaîne résultante en utilisant un argument entier.

Utilisation de la Stringsclasse utilitaire de Guava :

Strings.padStart("Apple", 8, '0');

Vous pouvez utiliser ceci:

org.apache.commons.lang.StringUtils.leftPad("Apple", 8, "0")

J'ai été dans une situation similaire et j'ai utilisé ceci; C'est assez concis et vous n'avez pas à vous occuper de la longueur ou d'une autre bibliothèque.

String str = String.format("%8s","Apple");
str = str.replace(' ','0');

Simple et soigné. Le format de chaîne renvoie " Apple"donc après avoir remplacé l'espace par des zéros, il donne le résultat souhaité.

String input = "Apple";
StringBuffer buf = new StringBuffer(input);

while (buf.length() < 8) {
  buf.insert(0, '0');
}

String output = buf.toString();

Utilisez Apache Commons StringUtils.leftPad (ou regardez le code pour créer votre propre fonction).

public class PaddingLeft {
    public static void main(String[] args) {
        String input = "Apple";
        String result = "00000000" + input;
        int length = result.length();
        result = result.substring(length - 8, length);
        System.out.println(result);
    }
}

Vous devrez peut-être prendre soin de l'Edgecase. C'est une méthode générique.

public class Test {
    public static void main(String[] args){
        System.out.println(padCharacter("0",8,"hello"));
    }
    public static String padCharacter(String c, int num, String str){
        for(int i=0;i<=num-str.length()+1;i++){str = c+str;}
        return str;
    }
}

public static void main(String[] args)
{
    String stringForTest = "Apple";
    int requiredLengthAfterPadding = 8;
    int inputStringLengh = stringForTest.length();
    int diff = requiredLengthAfterPadding - inputStringLengh;
    if (inputStringLengh < requiredLengthAfterPadding)
    {
        stringForTest = new String(new char[diff]).replace("\0", "0")+ stringForTest;
    }
    System.out.println(stringForTest);
}

public static String lpad(String str, int requiredLength, char padChar) {
    if (str.length() > requiredLength) {
        return str;
    } else {
        return new String(new char[requiredLength - str.length()]).replace('\0', padChar) + str;
    }
}

En Java:

String zeroes="00000000";
String apple="apple";

String result=zeroes.substring(apple.length(),zeroes.length())+apple;

Dans Scala:

"Apple".foldLeft("00000000"){(ac,e)=>ac.tail+e}

Vous pouvez également explorer un moyen dans Java 8 de le faire à l'aide de flux et de réduire (comme je l'ai fait avec Scala). C'est un peu différent de toutes les autres solutions et je l'aime particulièrement beaucoup.

C'est rapide et fonctionne pour n'importe quelle longueur.

public static String prefixZeros(String value, int len) {
    char[] t = new char[len];
    int l = value.length();
    int k = len-l;
    for(int i=0;i<k;i++) { t[i]='0'; }
    value.getChars(0, l, t, k);
    return new String(t);
}

Peut être plus rapide que la réponse de Chris Lercher lorsque la plupart des éléments de String ont exactement 8 caractères

int length = in.length();
return length == 8 ? in : ("00000000" + in).substring(length);

dans mon cas sur ma machine 1/8 plus rapide.

Voici la version simple de "script lisible" sans API que j'utilise pour le pré-remplissage d'une chaîne. (Simple, lisible et réglable).

while(str.length() < desired_length)
  str = '0'+str;

Quelqu'un a-t-il essayé cette solution Java pure (sans SpringUtils):

//decimal to hex string 1=> 01, 10=>0A,..
String.format("%1$2s", Integer.toString(1,16) ).replace(" ","0");
//reply to original question, string with leading zeros. 
//first generates a 10 char long string with leading spaces, and then spaces are
//replaced by a zero string. 
String.format("%1$10s", "mystring" ).replace(" ","0");

Malheureusement, cette solution ne fonctionne que si vous ne disposez pas d'espaces vides dans une chaîne.

Si vous souhaitez écrire le programme en Java pur, vous pouvez suivre la méthode ci-dessous ou il existe de nombreux String Utils pour vous aider à mieux avec des fonctionnalités plus avancées.

En utilisant une méthode statique simple, vous pouvez y parvenir comme ci-dessous.

public static String addLeadingText(int length, String pad, String value) {
    String text = value;
    for (int x = 0; x < length - value.length(); x++) text = pad + text;
    return text;
}

Vous pouvez utiliser la méthode ci-dessus addLeadingText(length, padding text, your text)

addLeadingText(8, "0", "Apple");

La sortie serait 000Apple

Ce n'est pas joli, mais ça marche. Si vous avez accès à apache commons, je vous suggère de l'utiliser

if (val.length() < 8) {
  for (int i = 0; i < val - 8; i++) {
    val = "0" + val;
  }
}