Como remover zeros à esquerda do texto alfanumérico?


228

Eu já vi perguntas sobre como prefixar zeros aqui no SO. Mas não o contrário!

Vocês podem me sugerir como remover os zeros à esquerda no texto alfanumérico? Existem APIs internas ou preciso escrever um método para aparar os zeros à esquerda?

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

Respostas:


617

Regex é a melhor ferramenta para o trabalho; o que deveria ser depende da especificação do problema. O seguinte remove os zeros à esquerda, mas deixa um se necessário (ou seja, não passaria apenas "0"para uma sequência em branco).

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

A ^âncora garantirá que a 0+correspondência esteja no início da entrada. A (?!$)aparência negativa garante que nem toda a cadeia seja correspondida.

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


21
Obrigado. E você testou sem piedade;) Ótimo !! +1 para os testes.
jai

4
@ Greg: Esta pergunta é sobre Java, não JavaScript. O Java SE possui o método String.replaceFirst () desde a versão 1.4.
22612 Jonik

5
adicionar trim () a s.replaceFirst ("^ 0 + (?! $)", "") (por exemplo, s.trim (). replaceFirst ("^ 0 + (?! $)", "") ajudará na remoção de espaços acolchoados!
AVA 31 /

2
regex não é um pouco caro para uma tarefa tão simples?
31515 demongolem

5
Isso não funciona em Kotlin, você precisa ser explícito sobre o Regex.replaceFirst("^0+(?!$)".toRegex(), "")
mkabatek


32

Como sobre a maneira regex:

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

As ^âncoras para o início da string (suponho que, no contexto, suas strings não sejam multilinhas aqui, caso contrário, talvez seja necessário procurar o \Ainício da entrada em vez do início da linha). Os 0*meios zero ou mais 0caracteres (você pode usar 0+também). O replaceFirstjust substitui todos esses 0caracteres no início por nada.

E se, como Vadzim, sua definição de zeros à esquerda não inclui transformar "0"(ou "000"seqüências semelhantes) em uma sequência vazia (uma expectativa bastante racional), basta recolocá-la se necessário:

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

6
Tem problema com "0" sozinho.
Vadzim

23

Uma maneira clara, sem a necessidade de regExp e 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";
}

1
Embora sua verificação de espaço não esteja de acordo com a pergunta, acho que sua resposta seria a mais rápida possível.
John Fowler

@JohnFowler 10x para a captura, fixado após 2 + anos
magiccrafter

1
E o método precisa de um retorno no final se o loop encontrar apenas zeros. Retorna ""; ou retorne "0"; se você quiser pelo menos um zero
slipperyseal

@slipperyseal Deixei aberto para que você possa alterá-lo com base nas suas necessidades, mas como as pessoas costumam copiar / colar, não é uma má idéia ter sempre um comportamento padrão. obrigado pelo comentário
magiccrafter 23/02

14

Para acompanhar a resposta do Apache Commons da thelost: usando bibliotecas de goiaba (a biblioteca de utilitários Java de uso geral do Google, que eu argumentaria que deveria estar agora no caminho de classe de qualquer projeto Java não trivial), isso usaria o CharMatcher :

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

+1, a resposta correta para qualquer projeto usando o Guava. (E agora em 2012, que deve significar praticamente qualquer projeto Java.)
Jonik

1
@ Cowan Isso tem um problema com "0" sozinho? Will CharMatcher.is ('0'). TrimLeadingFrom ("0"); Retornar o "0" ou String vazia?
PhoonOne

@PhoonOne: Acabei de testar isso; retorna a string vazia.
Stephan202

10

Se você estiver usando o Kotlin Este é o único código que você precisa:

yourString.trimStart('0')

5

Você poderia apenas fazer: String s = Integer.valueOf("0001007").toString();


2
Não manipula alfanuméricos.
slaman 30/12/19

4

Use a StringUtilsclasse Apache Commons :

StringUtils.strip(String str, String stripChars);

2
AVISO! Isso eliminará os zeros à esquerda e à esquerda, o que pode não ser o que você deseja.
Jens Bannmann

18
Você pode remover apenas os zeros à esquerda usando StringUtils.stripStart ().
Josh Rosen


2

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;

2

Usar regex como algumas das respostas sugerem é uma boa maneira de fazer isso. Se você não quiser usar regex, poderá usar este código:

String s = "00a0a121";

while(s.length()>0 && s.charAt(0)=='0')
{
   s = s.substring(1); 
}

Isso pode criar um monte de String... use a abordagem do artífice .
AxelH 12/01

1

Eu acho que é tão fácil fazer isso. Você pode fazer um loop sobre a string desde o início e remover zeros até encontrar um caractere diferente de 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());

1

Se você (como eu) precisar remover todos os zeros à esquerda de cada "palavra" em uma string, poderá modificar a resposta dos @polygenelubricants para o seguinte:

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

o que resulta em:

3 d0g ss 0 0 0

1

Sem usar Regexou substring()função na Stringqual 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
    }

0

Você poderia substituir "^0*(.*)"a "$1"com regex


1
O único problema que vejo aqui é que isso pode substituir um zero solitário '0' por um espaço em branco.
Dilipkumar J

0
       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

Se você não quiser usar regex ou biblioteca externa. Você pode fazer com "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

Muitos Stringgerado durante este ciclo ... se houver 1000 0...
AxelH

0

Fiz alguns testes de benchmark 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 o caminho mais rápido para um trabalho em lote.)


-2

E que tal procurar pelo primeiro caractere diferente de zero?

[1-9]\d+

Essa regex localiza o primeiro dígito entre 1 e 9 seguido por qualquer número de dígitos; portanto, para "00012345", ele retorna "12345" . Pode ser facilmente adaptado para seqüências alfanuméricas.


Isso não permitirá zero depois também.
Nishant Dongare 28/04
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.