Como remover os zeros principais do texto alfanumérico?
https://stackoverflow.com/questions/2800739
-
25-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Eu já vi perguntas sobre como prefixar zeros aqui. Mas não de outra maneira!
Vocês podem me sugerir como remover os zeros principais no texto alfanumérico? Existem APIs embutidas ou preciso escrever um método para aparar os zeros principais?
Exemplo:
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
Solução
Regex é a melhor ferramenta para o trabalho; O que deve ser depende da especificação do problema. O seguinte remove os zeros líderes, mas deixa um, se necessário (ou seja, não iria apenas virar "0" para uma corda em branco).
s.replaceFirst("^0+(?!$)", "")
o ^ âncora garantirá que o 0+ Ser combinado está no início da entrada. o (?!$) O visual negativo garante que nem toda a string será correspondente.
Equipamento de teste:
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+(?!$)", "") + "]");
}
Veja também
Outras dicas
Você pode usar o Stringutils classe de Apache Commons Lang assim:
StringUtils.stripStart(yourString,"0");
Que tal a maneira regex:
String s = "001234-a";
s = s.replaceFirst ("^0*", "");
o ^ âncoras para o início da string (estou assumindo que, do contexto, suas cordas não são multi-lines aqui, caso contrário, você pode precisar analisar \A para início da entrada em vez de início da linha). o 0* significa zero ou mais 0 personagens (você poderia usar 0+ também). o replaceFirst apenas substitui todos aqueles 0 Personagens no início sem nada.
E se, como Vadzim, sua definição de zeros líder não incluir "0" (ou "000" ou strings semelhantes) em uma corda vazia (uma expectativa racional o suficiente), basta colocá -la de volta, se necessário:
String s = "00000000";
s = s.replaceFirst ("^0*", "");
if (s.isEmpty()) s = "0";
Uma maneira clara sem a necessidade de regexp e quaisquer bibliotecas externas.
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";
}
Para ir com o Apache Commons de Thelost Resposta: Usando bibliotecas de goiaba (Biblioteca de utilitário java de uso geral do Google, que eu argumentaria que agora deveria estar no caminho de classe de qualquer projeto Java não trivial), isso usaria Charmatcher:
CharMatcher.is('0').trimLeadingFrom(inputString);
Use Apache Commons StringUtils classe:
StringUtils.strip(String str, String stripChars);
Você poderia simplesmente fazer:String s = Integer.valueOf("0001007").toString();
Usando regexp com grupos:
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;
Usa isto:
String x = "00123".replaceAll("^0*", ""); // -> 123
Usar Regex como algumas das respostas sugerem é uma boa maneira de fazer isso. Se você não quiser usar o Regex, pode usar este código:
String s = "00a0a121";
while(s.length()>0 && s.charAt(0)=='0')
{
s = s.substring(1);
}
Eu acho que é tão fácil fazer isso. Você pode simplesmente atravessar a corda do início e remover os zeros até encontrar um char não zero.
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());
Se você (como eu) precisar remover todos os zeros principais de cada "palavra" em uma string, você pode modificar a resposta de @polygeNeLubricants ao seguinte:
String s = "003 d0g 00ss 00 0 00";
s.replaceAll("\\b0+(?!\\b)", "");
o que resulta em:
3 d0g ss 0 0 0
Se você está usando o Kotlin, este é o único código que você precisa:
yourString.trimStart('0')
Você pode substituir "^0*(.*)" para "$1" com regex
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,""));
Se você não deseja usar o Regex ou a biblioteca externa. Você pode fazer com "para":
String input="0000008008451"
String output = input.trim();
for( ;output.length() > 1 && output.charAt(0) == '0'; output = output.substring(1));
System.out.println(output);//8008451
Fiz alguns testes de referência e descobri que a maneira mais rápida (de longe) é esta solução:
private static String removeLeadingZeros(String s) {
try {
Integer intVal = Integer.parseInt(s);
s = intVal.toString();
} catch (Exception ex) {
// whatever
}
return s;
}
Expressões especialmente regulares são muito lentas em uma iteração longa. (Eu precisava descobrir a maneira mais rápida de um Batchjob.)
Sem utilizar Regex ou substring() função em String que será ineficiente -
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
}
E quanto a apenas procurar o primeiro personagem diferente de zero?
[1-9]\d+
Este regex encontra o primeiro dígito entre 1 e 9, seguido de qualquer número de dígitos, então para "00012345" ele retorna "12345". Pode ser facilmente adaptado para cordas alfanuméricas.
