web-dev-qa-db-fra.com

Supprimer le zéro final en Java

J'ai des chaînes (de DB), qui peuvent contenir des valeurs numériques. S'il contient des valeurs numériques, j'aimerais supprimer les zéros de fin, tels que:

  • 10.0000
  • 10.234000

str.replaceAll("\\.0*$", ""), travaille sur le premier, mais pas le second.

Beaucoup de réponses suggèrent d'utiliser BigDecimal, mais la String que je reçois peut ne pas être numérique. Donc, je pense qu'une meilleure solution passe probablement par le regex.

javaregexstring
31
fivelements

il y a des possibilités:

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

Je suis paresseux et stupide, juste

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

Même solution en utilisant contient au lieu de indexof comme mentionné dans certains des commentaires pour faciliter la compréhension

 s = s.contains(".") ? s.replaceAll("0*$","").replaceAll("\\.$","") : s
63
Kent

Utilisez DecimalFormat , sa manière la plus propre

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

Je trouve toute autre solution trop compliquée. Simplement

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

fait le travail. Il essaie d'abord la première alternative, de sorte que le point suivi de tous les zéros ne soit remplacé par rien (car le groupe n'est pas défini). Sinon, s'il trouve un point suivi de quelques chiffres (le moins possible en raison du quantificateur lazy *?) suivi de quelques zéros, ceux-ci sont ignorés car ils ne sont pas inclus dans le groupe. Ça marche .

Attention

Mon code repose sur mon supposer que l'ajout d'un groupe sans correspondance ne fait rien }. Cela est vrai pour l'implémentation Oracle, mais pas pour les autres, y compris Android, qui semblent ajouter la chaîne "null". J'appellerais ces implémentations comme étant cassées car cela n'a aucun sens, mais elles sont correctes selon le Javadoc .

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

Output:

   10.01
4
PAC

Kent Réponse de manipulation des cordes fonctionne comme par magie et prend également en charge la perte de précision. Mais voici une solution plus propre utilisant BigDecimal

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

Vous pouvez ensuite convertir en d'autres types

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

Si la perte de précision est une préoccupation majeure pour vous, obtenez la valeur primitive exacte. Cela lève ArithmeticException s'il y a perte de précision pour la primitive. Voir ci-dessous

int intValue = stripedVal.intValueExact();
1
Komoo

Ce qui suit fonctionne pour tous les exemples suivants: 

"1" -> "1"
"1.0" -> "1"
"1.01500" -> "1.015"
"1.103" -> "1.103"

s = s.replaceAll("()\\.0+$|(\\..+?)0+$", "$2");
1
Pit

Séparez d'abord la fraction. Ensuite, vous pouvez utiliser la logique ci-dessous.

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

Qu'en est-il de remplacer

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

par

\1

?

0
alestanis

Vous pouvez remplacer par:

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

Pour garder le regex aussi simple que possible. (Et tenez compte d'entrées comme 1000 comme indiqué dans les commentaires)

0
mdm

Mon implémentation avec possibilité de sélectionner des nombres de chiffres après le diviseur:

public static String removeTrailingZero(String number, int minPrecise, char divider) {
    int dividerIndex = number.indexOf(divider);

    if (dividerIndex == -1) {
        return number;
    }

    int removeCount = 0;
    for (int i = dividerIndex + 1; i < number.length(); i++) {
        if (number.charAt(i) == '0') {
            removeCount++;
        } else {
            removeCount = 0;
        }
    }

    int fracLen = number.length() - dividerIndex - 1;

    if (fracLen - removeCount < minPrecise) {
        removeCount = fracLen - minPrecise;
    }

    if (removeCount < 0) {
        return number;
    }

    String result = number.substring(0, number.length() - removeCount);

    if (result.endsWith(String.valueOf(divider))) {
        return result.substring(0, result.length() - 1);
    }

    return result;
}
0
Vadim