¿Cómo eliminar los ceros a la izquierda del texto alfanumérico?

He visto preguntas sobre cómo prefijar ceros aquí en SO. ¡Pero no al revés!

¿Pueden sugerirme cómo eliminar los ceros a la izquierda en el texto alfanumérico? ¿Hay alguna API incorporada o necesito escribir un método para recortar los ceros iniciales?

Ejemplo:

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 es la mejor herramienta para el trabajo; lo que debería ser depende de la especificación del problema. Lo siguiente elimina los ceros a la izquierda, pero deja uno si es necesario (es decir, no se convertiría "0"en una cadena en blanco).

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

El ^ancla se asegurará de que la 0+coincidencia se encuentre al comienzo de la entrada. La (?!$)anticipación negativa asegura que no se emparejará toda la cadena.

Arnés de prueba:

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+(?!$)", "") + "]");
}

Ver también

• regular-expressions.info
  • repeticiones , miradas y anclas
• String.replaceFirst(String regex)

Puede usar la clase StringUtils de Apache Commons Lang de esta manera:

StringUtils.stripStart(yourString,"0");

¿Qué tal la forma regex:

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

Los ^anclajes al inicio de la cadena (supongo por contexto que sus cadenas no son de varias líneas aquí, de lo contrario, es posible que deba buscar el \Ainicio de la entrada en lugar del inicio de la línea). Los 0*medios cero o más 0caracteres (se podrían utilizar 0+también). El replaceFirstjusto reemplaza todos esos 0personajes al principio con nada.

Y si, como Vadzim, su definición de ceros iniciales no incluye convertir "0"(o "000"cadenas similares) en una cadena vacía (una expectativa lo suficientemente racional), simplemente vuelva a colocarla si es necesario:

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

Una forma clara sin necesidad de regExp y ninguna biblioteca externa.

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 con la respuesta de Apache Commons de thelost: usando guava-bibliotecas (la biblioteca de utilidad Java de propósito general de Google, que diría que ahora debería estar en el classpath de cualquier proyecto Java no trivial), esto usaría CharMatcher :

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

Si está utilizando Kotlin, este es el único código que necesita:

yourString.trimStart('0')

Podrías simplemente hacer: String s = Integer.valueOf("0001007").toString();

Use la StringUtilsclase Apache Commons :

StringUtils.strip(String str, String stripChars);

Utilizar este:

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

Usando Regexp con 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 expresiones regulares como sugieren algunas de las respuestas es una buena manera de hacerlo. Si no desea usar expresiones regulares, puede usar este código:

String s = "00a0a121";

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

Creo que es muy fácil hacer eso. Simplemente puede recorrer la cadena desde el principio y eliminar los ceros hasta que encuentre un carácter no cero.

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 (como yo) necesita eliminar todos los ceros a la izquierda de cada "palabra" en una cadena, puede modificar la respuesta de @polygenelubricants a lo siguiente:

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

lo que resulta en:

3 d0g ss 0 0 0

Sin usar Regexo substring()función en la Stringque 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
    }

Se podría sustituir "^0*(.*)"a "$1"la expresión regular

       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 no quieres usar regex o una biblioteca externa. Puedes hacer con "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

Hice algunas pruebas de referencia y descubrí que la forma más rápida (con mucho) es esta solución:

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

Especialmente las expresiones regulares son muy lentas en una iteración larga. (Necesitaba encontrar la forma más rápida para un trabajo por lotes).

¿Y qué hay de solo buscar el primer carácter distinto de cero?

[1-9]\d+

Esta expresión regular encuentra el primer dígito entre 1 y 9 seguido de cualquier número de dígitos, por lo que para "00012345" devuelve "12345" . Se puede adaptar fácilmente para cadenas alfanuméricas.