Eliminar el cero final en Java

Tengo cadenas (desde DB), que pueden contener valores numéricos. Si contiene valores numéricos, me gustaría eliminar ceros finales como:

  • 10.0000
  • 10.234000

str.replaceAll("\\.0*$", "") funciona en el primero, pero no en el segundo.

Muchas de las respuestas apuntan a usar BigDecimal , pero la String que obtengo puede no ser numérica. Entonces creo que una mejor solución probablemente sea a través del Regex.

hay posibilidades:

 1000 -> 1000 10.000 -> 10 (without point in result) 10.0100 -> 10.01 10.1234 -> 10.1234 

Soy vago y estúpido, solo

 s = s.indexOf(".") < 0 ? s : s.replaceAll("0*$", "").replaceAll("\\.$", ""); 

Usa DecimalFormat , su forma más limpia

 String s = "10.1200"; DecimalFormat decimalFormat = new DecimalFormat("0.#####"); String result = decimalFormat.format(Double.valueOf(s)); System.out.println(result); 

Encuentro que toda la otra solución es demasiado complicada. Simplemente

 s.replaceFirst("\\.0*$|(\\.\\d*?)0+$", "$1"); 

hace el trabajo. Primero prueba la primera alternativa, de modo que el punto seguido de todos los ceros se reemplaza por nada (ya que el grupo no se establece). De lo contrario, si encuentra un punto seguido de algunos dígitos (el menor número posible debido al cuantificador perezoso *? ) Seguido de algunos ceros, los ceros se descartan ya que no están incluidos en el grupo. Funciona

Advertencia

Mi código se basa en mi suposición de que agregar un grupo sin igual no hace nada . Esto es cierto para la implementación de Oracle, pero no para otros, incluido Android , que parecen agregar la cadena “nula”. Llamaría a las implementaciones como rotas ya que no tiene sentido, pero están correctas de acuerdo con el Javadoc .

 String value = "10.010" String s = new DecimalFormat("0.####").format(Double.parseDouble(value)); System.out.println(s); Output: 10.01 

Lo siguiente funciona para todos los ejemplos siguientes:

 "1" -> "1" "1.0" -> "1" "1.01500" -> "1.015" "1.103" -> "1.103" s = s.replaceAll("()\\.0+$|(\\..+?)0+$", "$2"); 

La respuesta de manipulación de cuerdas de Kent funciona mágicamente y también se ocupa de la pérdida de precisión. Pero aquí hay una solución más limpia que usa BigDecimal.

 String value = "10.234000"; BigDecimal stripedVal = new BigDecimal(value).stripTrailingZeros(); 

A continuación, puede convertir a otros tipos

 String stringValue = stripedVal.toPlainString(); double doubleValue = stripedVal.doubleValue(); long longValue = stripedVal.longValue(); 

Si la pérdida de precisión es su principal preocupación, obtenga el valor primitivo exacto. Esto arrojaría ArithmeticException si hubiera alguna pérdida de precisión para la primitiva. Vea abajo

 int intValue = stripedVal.intValueExact(); 

¿Qué hay de reemplazar

 (\d*\.\d*)0*$ 

por

 \1 

?

Puedes reemplazar con:

 String result = (str.indexOf(".")>=0?str.replaceAll("\\.?0+$",""):str); 

Para mantener la Regex lo más simple posible. (Y cuenta entradas como 1000 como se señala en los comentarios)

Separe primero la parte de la fracción. Entonces puedes usar la siguiente lógica.

 BigDecimal value = BigDecimal.valueOf(345000); BigDecimal div = new BigDecimal(10).pow(Integer.numberOfTrailingZeros(value.intValue())); System.out.println(value.divide(div).intValue());