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


228

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

Respuestas:


617

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


21
Gracias. Y has probado sin piedad;) ¡Genial! +1 para las pruebas.
jai

44
@ Greg: Esta pregunta es sobre Java, no JavaScript. Java SE ha tenido el método String.replaceFirst () desde la versión 1.4.
Jonik

55
agregar trim () a s.replaceFirst ("^ 0 + (?! $)", "") (es decir, s.trim (). replaceFirst ("^ 0 + (?! $)", "") ayudará en la eliminación de espacios acolchados!
AVA

2
¿No es la expresión regular un poco costosa para una tarea tan simple?
demongolem

55
Esto no funciona en Kotlin, debe ser explícito sobre Regex.replaceFirst("^0+(?!$)".toRegex(), "")
mkabatek


32

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

66
Tiene un problema con "0" solo.
Vadzim

23

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

1
Aunque su verificación de espacio no está de acuerdo con la pregunta, sin embargo, creo que su respuesta se ejecutará más rápido.
John Fowler

@JohnFowler 10x para la captura, arreglado después de más de 2 años
magiccrafter

1
Y el método necesita un retorno al final si el ciclo solo encuentra ceros. regreso ""; o devolver "0"; si quieres al menos un cero
slipperyseal

@slipperyseal Lo dejé abierto para que pueda cambiarlo según sus necesidades, pero dado que las personas tienden a copiar / pegar, no es una mala idea tener siempre un comportamiento predeterminado. gracias por el comentario
magiccrafter

14

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

+1, la respuesta correcta para cualquier proyecto que use Guava. (Y ahora en 2012, eso debería significar casi cualquier proyecto de Java.)
Jonik

1
@Cowan ¿Esto tiene un problema con "0" solo? Will CharMatcher.is ('0'). TrimLeadingFrom ("0"); Devuelve el "0" o cadena vacía?
PhoonOne

@PhoonOne: acabo de probar esto; devuelve la cadena vacía.
Stephan202

10

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

yourString.trimStart('0')

5

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


2
No manejará alfanuméricos.
slaman

4

Use la StringUtilsclase Apache Commons :

StringUtils.strip(String str, String stripChars);

2
¡ADVERTENCIA! Esto eliminará los ceros iniciales y finales, que pueden no ser lo que desea.
Jens Bannmann el

18
Puede eliminar solo los ceros a la izquierda con StringUtils.stripStart ().
Josh Rosen


2

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;

2

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

Esto podría crear una gran cantidad de String... use el enfoque magiccrafter en su lugar.
AxelH

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

1

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

1

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
    }

0

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


1
El único problema que veo aquí es que esto podría reemplazar un solitario cero '0' a un espacio en blanco.
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

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

Demasiados Stringgenerados durante este ciclo ... si hay 1000 0...
AxelH

0

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


-2

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


Esto tampoco permitirá cero después.
Nishant Dongare
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.