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

He visto preguntas sobre cómo prefijar los ceros aquí en SO. ¡Pero no a la inversa!

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

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. A continuación, se eliminan los ceros iniciales, pero se deja uno si es necesario (es decir, no se convierte simplemente "0" en una cadena en blanco).

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

El anclaje ^ se asegurará de que el 0+ que coincida esté al comienzo de la entrada. El look-up negativo (?!$) Asegura que no se hará coincidir 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 , orientaciones y anclas
  • String.replaceFirst(String regex)

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

 StringUtils.stripStart(yourString,"0"); 

¿Qué hay de la manera regex:

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

Los ^ anclajes al comienzo de la cadena (supongo que por contexto tus cadenas no son multilíneas aquí, de lo contrario, es posible que tengas que buscar \A para iniciar la entrada en lugar de comenzar la línea). El 0* significa cero o más 0 caracteres (también podría usar 0+ ). El replaceFirst simplemente reemplaza todos esos 0 caracteres al comienzo sin nada.

Y si, como Vadzim, su definición de ceros a la izquierda no incluye convertir "0" (o "000" o 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 manera clara sin necesidad de regExp y cualquier 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 del thelost: usando guava-libraries (la biblioteca de utilidad Java de propósito general de Google, que yo 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); 

Utilice la clase StringUtils Apache Commons:

 StringUtils.strip(String str, String stripChars); 

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 quiere usar expresiones regulares, puede usar este código:

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

Utilizar esta:

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

Creo que es tan fácil hacer eso. Puedes simplemente recorrer la cadena desde el principio y eliminar los ceros hasta que encuentres 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 usted (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 

Puede reemplazar "^0*(.*)" "$1" con expresiones regulares

  String s="0000000000046457657772752256266542=56256010000085100000"; String removeString=""; for(int i =0;i 

Si no desea utilizar expresiones regulares 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 comparativas y descubrí que la forma más rápida (con diferencia) 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; } 

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

¿Y qué hay de buscar el primer personaje distinto de cero?

 [1-9]\d+ 

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

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