Como remover zeros à esquerda do texto alfanumérico?

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

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

• regular-expressions.info
  • repetições , olhares e âncoras
• String.replaceFirst(String regex)

Você pode usar a classe StringUtils do Apache Commons Lang assim:

StringUtils.stripStart(yourString,"0");

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";

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";
}

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);

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

yourString.trimStart('0')

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

Use a StringUtilsclasse Apache Commons :

StringUtils.strip(String str, String stripChars);

Usa isto:

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

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;

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); 
}

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

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

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
    }

Você poderia substituir "^0*(.*)"a "$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 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

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.)

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.