Comment couper décimal en Java SANS arrondi?

J'ai une série de Java décimales comme:

0.43678436287643872
0.4323424556455654
0.6575643254344554

Je souhaite couper tout ce qui est après 5 décimales. Comment est-ce possible?

Techniquement, pas de: la loi de couper le plus de décimales est arrondi, que vous êtes toujours arrondi vers le bas à 5 décimales. Voir les réponses ci-dessous pour vos options.
voulez-vous vous entraîner à être une Chaîne de caractères ou un nombre?
Je veux que le résultat soit un nombre

OriginalL'auteur Zubair | 2011-12-13

  1. 25

    Si vous voulez garder les choses simples et rapides. 😉

    public static void main(String... args) {
    double[] values = {0.43678436287643872, 0.4323424556455654, 0.6575643254344554,
            -0.43678436287643872, -0.4323424556455654, -0.6575643254344554,
            -0.6575699999999999 };

    for (double v : values) 
        System.out.println(v + " => "+roundDown5(v));
}

public static double roundDown5(double d) {
    return ((long)(d * 1e5)) / 1e5;
    //Long typecast will remove the decimals
}

//Or this. Slightly slower, but faster than creating objects. ;)
public static double roundDown5(double d) {
    return Math.floor(d * 1e5) / 1e5;
}

    imprime

    0.43678436287643874 => 0.43678
0.4323424556455654 => 0.43234
0.6575643254344554 => 0.65756
-0.43678436287643874 => -0.43678
-0.4323424556455654 => -0.43234
-0.6575643254344554 => -0.65756
-0.6575699999999999 => -0.65756
    Excellente solution! Simple et délicat. Je l'adore! thx
    Ce n'est peut-être la meilleure solution! Je suis juste en essayant de trouver des problèmes avec elle avant que je l'accepte!
    Dans le premier cas, votre valeur doit être inférieure à dix billions de dollars pour éviter un débordement, dans le second cas, vous n'avez pas besoin de s'inquiéter.
    c'est fantastique, merci! se charge de code de refactoriser maintenant 🙂
    La dernière fois que j'ai testé Math.floor(x) était légèrement plus lente que la fonte (long) x mais qui a au moins 5 ans. J'imagine que si vous avez essayé de JMH ce aujourd'hui, il n'est probablement pas beaucoup plus lents.

    OriginalL'auteur Peter Lawrey

  2. 17
    float f = 0.43678436287643872;
BigDecimal fd = new BigDecimal(f);
BigDecimal cutted = fd.setScale(5, RoundingMode.DOWN);
f = cutted.floatValue();
    Ne serait-ce pas le tour de la dernière décimale? L'OP veut éviter que les.
    HALF_UP n'est pas correct. peut-être "en BAS"?
    Oui, vers le BAS, bien sûr.
    maintenant rien ne vous empêche de l'édition de votre réponse
    Juste une note pour toute personne cherchant à cela, convertir votre flotteur à une chaîne puis construire votre BigDecimal avec cette chaîne.

    OriginalL'auteur Artem

  3. 8
    Double.parseDouble(String.valueOf(x).substring(0,7));

    OU

    Double.valueOf(String.valueOf(x).substring(0,7));

    où x contient la valeur que vous voulez couper comme 0.43678436287643872

    Vous pouvez modifier votre réponse, au lieu de poster des commentaires.
    Mon erreur. Je n'ai pas compté "0.". Édité.
    Merci pour suggérer
    Mise en garde: Fonctionne si et seulement si l'entrée est entre -10 et 10.
    Je dirais, si vous avez neagative valeur, son 0-8 sinon, il sera 0-7. @Piskvor: i 'aint vous obtenez..

    OriginalL'auteur Kris

  4. 6

    La DecimalFormat pourrait aussi être de l'aide ici:

        double d = 0.436789436287643872;
    DecimalFormat df = new DecimalFormat("0.#####");
    df.setRoundingMode(RoundingMode.DOWN);

    double outputNum = Double.valueOf(df.format(d));
    String outpoutString = df.format(d);

    OriginalL'auteur Costis Aivalis

  5. 2

    Je crois que le java.texte.DecimalFormat classe est ce que vous avez besoin.

    OriginalL'auteur thejartender

  6. 1

    Je le ferais avec des expressions régulières comme ceci:

        double[] values = { 
            0.43678436287643872,
            0.4323424556455654,
            0.6575643254344554,
            -0.43678436287643872,
            -0.4323424556455654,
            -0.6575643254344554
    };

    Pattern p = Pattern.compile("^(-?[0-9]+[\\.\\,][0-9]{1,5})?[0-9]*$");
    for(double number : values) {
        Matcher m = p.matcher(String.valueOf(number));
        boolean matchFound = m.find();
        if (matchFound) {
            System.out.println(Double.valueOf(m.group(1)));
        }
    }

    Le modèle peut facilement être modifié si vous avez besoin d'un soutien plus ou moins de décimales.

    OriginalL'auteur nowaq

  7. 1

    De généraliser Pierre de réponse, vous pouvez faire:

    public static double round(double n, int decimals) {
    return Math.floor(n * Math.pow(10, decimals)) / Math.pow(10, decimals);
}

    OriginalL'auteur FrankMonza