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
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+(?!$)", "") + "]");
}
Vous pouvez utiliser le StringUtils class de Apache Commons Lang comme ceci:
StringUtils.stripStart(yourString,"0");
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";
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";
}
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);
Utilisez Apache Commons StringUtils
class:
StringUtils.strip(String str, String stripChars);
Utilisez ceci:
String x = "00123".replaceAll("^0*", ""); // -> 123
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);
}
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;
Vous pouvez juste faire: String s = Integer.valueOf("0001007").toString();
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
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());
Si vous utilisez Kotlin C'est le seul code dont vous avez besoin:
yourString.trimStart('0')
Vous pouvez remplacer "^0*(.*)"
par "$1"
par regex
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.)
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
}
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,""));
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