web-dev-qa-db-fra.com

Comment supprimer les zéros de gauche du texte alphanumérique?

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

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

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
javastringalphanumeric
184
jai

Regex est le meilleur outil pour le travail; ce qu'il devrait être dépend de la spécification du problème. Ce qui suit supprime les zéros non significatifs, mais en laisse un si nécessaire (c’est-à-dire que "0" ne serait pas simplement transformé en chaîne vide).

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

L'ancre ^ s'assurera que le 0+ mis en correspondance se trouve au début de l'entrée. Le préfixe négatif (?!$) garantit que la chaîne entière ne sera pas mise en correspondance.

Harnais de test:

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

Voir également

533
polygenelubricants

Vous pouvez utiliser le StringUtils class de Apache Commons Lang comme ceci:

StringUtils.stripStart(yourString,"0");
75
Hamilton Rodrigues

Que diriez-vous de la manière regex:

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

Le ^ ancre le début de la chaîne (je suppose du contexte que vos chaînes ne sont pas multilignes ici, sinon vous devrez peut-être regarder dans \A pour le début de la saisie plutôt que le début de la ligne). Le 0* signifie zéro ou plusieurs caractères 0 (vous pourriez utiliser aussi 0+). La replaceFirst remplace simplement tous ces caractères 0 au début par rien.

Et si, comme Vadzim, votre définition des zéros non liminaires n'inclut pas la transformation de "0" (ou "000" ou de chaînes similaires) en une chaîne vide (une attente assez rationnelle), restaurez-la si nécessaire:

String s = "00000000";
s = s.replaceFirst ("^0*", "");
if (s.isEmpty()) s = "0";
29
paxdiablo

Un chemin clair sans aucun besoin de regExp ni de bibliothèques externes.

public static String trimLeadingZeros(String 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";
}
17
magiccrafter

Pour aller avec la réponse d'Apache Commons la plus populaire: utiliser guava-libraries (la bibliothèque d'utilitaires Java polyvalente de Google qui, selon moi, devrait maintenant figurer dans le chemin de classe de tout projet Java non trivial), ceci utiliserait CharMatcher :

CharMatcher.is('0').trimLeadingFrom(inputString);
12
Cowan

Utilisez Apache Commons StringUtils class:

StringUtils.strip(String str, String stripChars);
5
thelost

Utilisez ceci:

String x = "00123".replaceAll("^0*", ""); // -> 123
2
Eduardo Cuomo

Utiliser regex comme le suggèrent certaines des réponses est un bon moyen de le faire. Si vous ne voulez pas utiliser regex, vous pouvez utiliser ce code:

String s = "00a0a121";

while(s.length()>0 && s.charAt(0)=='0')
{
   s = s.substring(1); 
}
2
Hüseyin Burhan ÖZKAN

Utilisation de Regexp avec des groupes:

Pattern pattern = Pattern.compile("(0*)(.*)");
String 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;
2
brj

Vous pouvez juste faire: String s = Integer.valueOf("0001007").toString();

1
Damjan

Si vous (comme moi) devez supprimer tous les zéros de chaque "mot" d'une chaîne, vous pouvez modifier la réponse de @polygenelubricants comme suit:

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

qui se traduit par:

3 d0g ss 0 0 0
1
xdhmoore

Je pense que c'est si facile à faire. Vous pouvez simplement boucler la chaîne depuis le début et supprimer les zéros jusqu'à ce que vous trouviez un caractère différent de zéro.

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());
1
vodkhang

Si vous utilisez Kotlin C'est le seul code dont vous avez besoin:

yourString.trimStart('0')
0
Saman Sattari

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

0
YOU

J'ai fait quelques tests de référence et constaté que le moyen le plus rapide (de loin) est cette solution:

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

Surtout les expressions régulières sont très lentes dans une longue itération. (Je devais trouver le moyen le plus rapide pour un batchjob.)

0
Robert Fornesdale

Sans utiliser la fonction Regex ou substring() sur String qui sera inefficace -

public static String removeZero(String str){
        StringBuffer sb = new StringBuffer(str);
        while (sb.length()>1 && sb.charAt(0) == '0')
            sb.deleteCharAt(0);
        return sb.toString();  // return in String
    }
0
Sachin Aggarwal
       String s="0000000000046457657772752256266542=56256010000085100000";      
    String removeString="";

    for(int i =0;i<s.length();i++){
      if(s.charAt(i)=='0')
        removeString=removeString+"0";
      else 
        break;
    }

    System.out.println("original string - "+s);

    System.out.println("after removing 0's -"+s.replaceFirst(removeString,""));
0
Ajit Kumar Sahu

Si vous ne voulez pas utiliser regex ou une bibliothèque externe, vous pouvez utiliser "for": 

String input="0000008008451"
String output = input.trim();
for( ;output.length() > 1 && output.charAt(0) == '0'; output = output.substring(1));

System.out.println(output);//8008451
0
kfatih