Comment supprimer les zéros en tête du texte alphanumérique?

J’ai vu des questions sur la façon de préfixer les zéros ici dans SO. Mais pas l’inverse!

Pouvez-vous me suggérer comment supprimer les zéros en tête du texte alphanumérique? Existe-t-il des API intégrées ou dois-je écrire une méthode pour réduire les zéros en tête?

Exemple:

01234 converts to 1234 0001234a converts to 1234a 001234-a converts to 1234-a 101234 remains as 101234 2509398 remains as 2509398 123z remains as 123z 000002829839 converts to 2829839 

Regex est le meilleur outil pour le travail; ce que cela devrait être dépend de la spécification du problème. Ce qui suit supprime les zéros en tête, mais en laisse un si nécessaire (c.-à-d. Qu’il ne suffit pas de "0" pour une chaîne vide).

 s.replaceFirst("^0+(?!$)", "") 

L’ancre s’assurera que le 0+ correspondant est au début de l’entrée. Le lookahead négatif (?!$) Garantit que la chaîne entière ne correspondra pas.

Test harnais:

 Ssortingng[] in = { "01234", // "[1234]" "0001234a", // "[1234a]" "101234", // "[101234]" "000002829839", // "[2829839]" "0", // "[0]" "0000000", // "[0]" "0000009", // "[9]" "000000z", // "[z]" "000000.z", // "[.z]" }; for (Ssortingng s : in) { System.out.println("[" + s.replaceFirst("^0+(?!$)", "") + "]"); } 

Voir également

  • regular-expressions.info
    • répétitions , regards et ancres
  • Ssortingng.replaceFirst(Ssortingng regex)

Vous pouvez utiliser la classe SsortingngUtils d’ Apache Commons Lang comme ceci:

 SsortingngUtils.ssortingpStart(yourSsortingng,"0"); 

Que diriez-vous de la manière regex:

 Ssortingng s = "001234-a"; s = s.replaceFirst ("^0*", ""); 

Le ^ ancre au début de la chaîne (je suppose que dans le contexte vos chaînes ne sont pas multi-lignes ici, sinon vous devrez peut-être regarder \A pour le début de l’entrée plutôt que le début de la ligne). Le 0* signifie zéro ou plus de 0 caractères (vous pouvez également utiliser 0+ ). Le replaceFirst remplace simplement tous ces 0 caractères au début par rien.

Et si, comme Vadzim, votre définition des zéros à gauche n’inclut pas le fait de "0" (ou "000" ou des chaînes similaires) dans une chaîne vide (une attente assez rationnelle), remettez-la simplement si nécessaire:

 Ssortingng s = "00000000"; s = s.replaceFirst ("^0*", ""); if (s.isEmpty()) s = "0"; 

Une manière claire sans avoir besoin de regExp et de bibliothèques externes.

 public static Ssortingng sortingmLeadingZeros(Ssortingng source) { for (int i = 0; i < source.length(); ++i) { char c = source.charAt(i); if (c != '0') { return source.substring(i); } } return ""; // or return "0"; } 

Pour aller avec la réponse d’Apache Commons: en utilisant des librairies de goyaves (la librairie utilitaire Java de Google que je dirais maintenant sur le classpath de tout projet Java non sortingvial), cela utiliserait CharMatcher :

 CharMatcher.is('0').sortingmLeadingFrom(inputSsortingng); 

Utilisez la classe Apache Commons SsortingngUtils :

 SsortingngUtils.ssortingp(Ssortingng str, Ssortingng ssortingpChars); 

Utiliser Regexp avec des groupes:

 Pattern pattern = Pattern.comstack("(0*)(.*)"); Ssortingng result = ""; Matcher matcher = pattern.matcher(content); if (matcher.matches()) { // first group contains 0, second group the remaining characters // 000abcd - > 000, abcd result = matcher.group(2); } return result; 

L’utilisation de regex comme le suggèrent certaines réponses est un bon moyen d’y parvenir. Si vous ne souhaitez pas utiliser regex, vous pouvez utiliser ce code:

 Ssortingng s = "00a0a121"; while(s.length()>0 && s.charAt(0)=='0') { s = s.subssortingng(1); } 

Utilisez ceci:

 Ssortingng x = "00123".replaceAll("^0*", ""); // -> 123 

Je pense que c’est si facile à faire. Vous pouvez simplement parcourir la chaîne depuis le début et supprimer les zéros jusqu’à ce que vous trouviez un caractère non nul.

 int lastLeadZeroIndex = 0; for (int i = 0; i < str.length(); i++) { char c = str.charAt(i); if (c == '0') { lastLeadZeroIndex = i; } else { break; } } str = str.subString(lastLeadZeroIndex+1, str.length()); 

Si vous (comme moi) devez supprimer tous les zéros en tête de chaque “mot” d’une chaîne, vous pouvez modifier la réponse de @polygenelubricants aux éléments suivants:

 Ssortingng s = "003 d0g 00ss 00 0 00"; s.replaceAll("\\b0+(?!\\b)", ""); 

qui se traduit par:

 3 d0g ss 0 0 0 

Vous pouvez remplacer "^0*(.*)" "$1" avec regex

  Ssortingng s="0000000000046457657772752256266542=56256010000085100000"; Ssortingng removeSsortingng=""; for(int i =0;i 

Si vous ne voulez pas utiliser regex ou bibliothèque externe. Vous pouvez faire avec “pour”:

 Ssortingng input="0000008008451" Ssortingng output = input.sortingm(); for( ;output.length() > 1 && output.charAt(0) == '0'; output = output.subssortingng(1)); System.out.println(output);//8008451 

J’ai fait des tests de performances et trouvé que le moyen le plus rapide (de loin) est cette solution:

  private static Ssortingng removeLeadingZeros(Ssortingng s) { try { Integer intVal = Integer.parseInt(s); s = intVal.toSsortingng(); } catch (Exception ex) { // whatever } return s; } 

Les expressions régulières sont particulièrement lentes dans une longue itération. (Je devais trouver le moyen le plus rapide pour un batchjob.)

Et qu’en est-il de la recherche du premier caractère non nul?

 [1-9]\d+ 

Cette regex trouve le premier chiffre entre 1 et 9 suivi d’un nombre quelconque de chiffres, donc pour “00012345”, elle renvoie “12345” . Il peut être facilement adapté aux chaînes alphanumériques.

Sans utiliser la fonction Regex ou subssortingng() sur Ssortingng qui sera inefficace –

 public static Ssortingng removeZero(Ssortingng str){ SsortingngBuffer sb = new SsortingngBuffer(str); while (sb.length()>1 && sb.charAt(0) == '0') sb.deleteCharAt(0); return sb.toSsortingng(); // return in Ssortingng }