FR
RU
EN
ES
ZH
DE
PT
AR
HI
Zéros non significatifs en Java : du débutant au pro avec mesure de performance
\n\nChaque développeur Java rencontre tôt ou tard le problème : « Comment ajouter des zéros à gauche d'un nombre ? ». Une opération apparemment triviale — prendre le nombre 42 et le transformer en "000042". Mais dès que vous commencez à chercher sur Google, vous tombez sur des dizaines de méthodes : String.format, DecimalFormat, StringBuilder, des boucles manuelles et même String.repeat (Java 11+).
La question « How can I pad an integer with zeros on the left? » sur Stack Overflow a recueilli des milliers de vues. Et ce n'est pas un hasard. Derrière cette action simple se cache tout un éventail de dilemmes : quelle méthode est la plus rapide ? La plus lisible ? Laquelle ne tuera pas les performances dans une application à forte charge ?
\n\nDans cet article, nous ne nous contenterons pas de montrer du code. Nous mènerons notre propre mini-étude, mesurerons la vitesse de chaque approche et donnerons des recommandations claires. Vous saurez quand sacrifier des microsecondes pour l'élégance, et quand il est préférable d'écrire du code « sale » mais fulgurant.
\n\nPourquoi est-ce important ? Contexte de performance
\n\nSupposons que vous génériez des millions d'identifiants sous forme de chaînes dans un processus ETL, que vous créiez des numéros de commande ou que vous sérialisiez des données pour des logs. Chaque nanoseconde supplémentaire sur le padding zeros est multipliée par le nombre d'opérations. La différence entre le « joli » String.format et le StringBuilder manuel peut représenter des centaines de pourcents.
Mais ne vous précipitez pas à tout optimiser. Comme le disait Donald Knuth : « L'optimisation prématurée est la racine de tous les maux ». Commençons par comprendre les outils, puis nous déciderons lequel choisir.
\n\nMéthode 1 : String.format() — le roi de la lisibilité
\n\nL'option la plus populaire et la plus intuitive. La méthode String.format() utilise le spécificateur %0Nd, où N est la longueur totale de la chaîne résultante.
int number = 42;\nString padded = String.format("%06d", number); // "000042"\nSystem.out.println(padded);Les avantages sont évidents : le code se lit comme un texte normal, pas besoin de réfléchir aux cas limites. L'inconvénient est la performance. String.format crée en interne un Formatter et analyse la chaîne de format à chaque appel. Pour des opérations ponctuelles, c'est idéal ; pour une boucle de 10 millions d'itérations, c'est discutable.
Méthode 2 : DecimalFormat — l'héritage des formats monétaires
\n\nLa classe DecimalFormat du paquetage java.text a été initialement créée pour formater les devises et les pourcentages, mais elle gère parfaitement les leading zeros.
import java.text.DecimalFormat;\n\nDecimalFormat df = new DecimalFormat("000000");\nString padded = df.format(42); // "000042"Le principal inconvénient : DecimalFormat n'est pas thread-safe. Si vous l'utilisez dans un environnement multithread, vous devrez soit synchroniser, soit créer une nouvelle instance à chaque appel (ce qui tue les performances).
Méthode 3 : StringBuilder + calcul manuel — le hardcore
\n\nPour ceux qui n'ont pas peur d'écrire quelques lignes supplémentaires pour gagner en vitesse. Nous créons un tableau de caractères de la longueur souhaitée, le remplissons de zéros, puis copions les chiffres du nombre à partir de la fin.
\n\npublic static String padLeftZeros(int number, int totalLength) {\n char[] result = new char[totalLength];\n for (int i = 0; i < totalLength; i++) {\n result[i] = '0';\n }\n int index = totalLength - 1;\n while (number > 0 && index >= 0) {\n result[index--] = (char) ('0' + (number % 10));\n number /= 10;\n }\n return new String(result);\n}\n\n// Utilisation :\nString padded = padLeftZeros(42, 6); // "000042"Cette méthode est plusieurs fois plus rapide que String.format, mais nécessite de la rigueur : il faut gérer les nombres négatifs (nous ne les traitons pas ici pour simplifier) et le cas où le nombre est plus long que la longueur spécifiée.
