streamalism.org

1. Inleiding

In deze zelfstudie bekijken we de verschillende manieren om een dubbele waarde voor een Draad, waarbij de decimalen worden verwijderd.

We zullen bekijken hoe we dit moeten doen als we het decimale gedeelte alleen willen afkappen en wanneer we het willen afronden.

2. Afkappen door middel van casten

Als onze dubbele waarde is binnen de int bereik, we kunnen cast het naar een int. De cast kapt het decimale gedeelte af, wat betekent dat het wordt afgekapt zonder af te ronden.

Deze benadering is ongeveer 10 keer zo snel als de andere benaderingen die we zullen bekijken.

Zodra het een int, dan kunnen we het dan doorgeven aan de waarde van methodeop de Draad klasse:

String afgekapt = String.valueOf ((int) doubleValue);

We kunnen deze benadering met vertrouwen gebruiken als we er zeker van zijn dat de dubbele waarde binnen het bereik van een ligt int. Maar als onze waarde die overtreft, zal casten niet werken zoals we zouden willen.

3. Afronden met String.format ()

Nu zijn de resterende benaderingen niet zo beperkt als gieten, maar ze hebben hun eigen nuances.

Een andere benadering is bijvoorbeeld om de formaat methode van de Draad klasse. De eerste parameter van de methode specificeert dat we een drijvende-kommawaarde opmaken met nul cijfers achter de komma:

String afgerond = String.format ("%. 0f", doubleValue);

De formaat methode gebruikt HALF_UP afronding die naar boven wordt afgerond als de waarde na het breukgedeelte 0,5 of hoger is. Anders retourneert het het getal vóór de komma.

En hoewel eenvoudig, String.format is de langzaamste manier om dit te doen.

4. Met behulp van NumberFormat.format ()

De Nummer formaat klasse biedt ook een formaat methode vergelijkbaar met de Draad klasse, maar Nummer formaat is sneller en daarmee kunnen we de afrondingsmodus specificeren om afkapping of afronding te bereiken.

De setMaximumFractionDigits () methode vertelt de formatter hoeveel decimale cijfers achter de komma moeten worden opgenomen in de uitvoer:

NumberFormat nf = NumberFormat.getNumberInstance (); nf.setMaximumFractionDigits (0); String afgerond = nf.format (doubleValue);

Vreemd genoeg, Nummer formaat gebruikt niet HALF_UP standaard. In plaats daarvan gebruikt het HALF_EVEN standaard afronden, wat betekent dat het zal afronden zoals normaal behalve op 0,5, in dat geval kiest het het dichtstbijzijnde even getal.

Terwijl HALF_EVEN is nuttig bij statistische analyse, laten we gebruiken HALF_UP consistent zijn:

nf.setRoundingMode (RoundingMode.HALF_UP); String afgerond = nf.format (doubleValue);

En, we kunnen dit veranderen en afkappen bereiken door de formatter zo in te stellen dat deze de VERDIEPING afrondingsmodus in plaats daarvan:

nf.setRoundingMode (RoundingMode.FLOOR); String afgekapt = nf.format (doubleValue)

En nu wordt het afgekapt in plaats van rond.

5. Met behulp van DecimalFormat.format ()

Gelijkwaardig aan Nummer formaat, de DecimalFormat class kan worden gebruikt om dubbele waarden. In plaats van het uitvoerformaat in te stellen met methodeaanroepen, we kunnen de formatter vertellen welke output we willen door de constructor een specifiek patroon te geven:

DecimalFormat df = nieuw DecimalFormat ("#, ###"); df.setRoundingMode (RoundingMode.HALF_UP); String afgerond = df.format (doubleValue);

Het patroon "#, ###" geeft aan dat we willen dat de formatter alleen het gehele deel van de invoer retourneert. Het geeft ook aan dat we de cijfers in drieën willen groeperen, gescheiden door een komma.

Dezelfde standaardinstellingen voor afronding zijn hier van toepassing, dus als we een afgekapte waarde willen uitvoeren, kunnen we de afrondingsmodus instellen op VERDIEPING:

df.setRoundingMode (RoundingMode.FLOOR); String afgekapt = df.format (doubleValue)

6. Met behulp van BigDecimal.toString ()

De laatste benadering die we zullen bekijken is BigDecimal, die we zullen opnemen omdat het presteert beter Nummer formaat en DecimalFormat voor grotere dubbeles.

We kunnen gebruiken BigDecimal‘S setScale methode om te bepalen of we willen afronden of afkappen:

dubbele largeDouble = 345_345_345_345.56; BigDecimal big = nieuwe BigDecimal (largeDouble); big = big.setScale (0, RoundingMode.HALF_UP);

Onthoud dat BigDecimals zijn onveranderlijk, dus net als Strings moeten we de waarde opnieuw instellen.

En dan bellen we gewoon BigDecimal‘S toString:

String afgerond = big.toString ();

7. Conclusie

In deze tutorial we hebben gekeken naar de verschillende manieren waarop we een dubbele naar een Draad terwijl u decimalen verwijdert. We hebben benaderingen geboden die ofwel afgeronde of afgekapte waarden opleveren.

Zoals gewoonlijk zijn de voorbeelden en benchmarks beschikbaar op GitHub.