Arrotondare i numeri in Java

I numeri in virgola mobile (float, double) vengono utilizzati quando si calcolano espressioni che richiedono precisione decimale. Spesso è necessaria un'elevata precisione nella contabilità e in altre operazioni informatiche. Arrotondare i numeri in Java - 1

Ma abbiamo sempre bisogno di una lunga “coda” di numeri dopo la virgola? Forse ci basta una precisione di tre parti reali? E siamo soddisfatti di questa opzione, come eseguire correttamente l'arrotondamento? Questo è esattamente ciò di cui parleremo oggi: esamineremo i modi per arrotondare i numeri in Java .

Formato stringa

Come primo metodo, esamineremo l'arrotondamento doppio:

double value = 34.766674;
String result = String.format("%.3f",value);
System.out.print(result);//  34,767

Di conseguenza, formatteremo il nostro numero in virgola mobile 34766674 con una precisione di 3 cifre decimali , poiché nelle istruzioni di formattazione abbiamo specificato tre cifre decimali "%.3f. A sua volta, %f durante la formattazione di una stringa indica il tipo di virgola mobile numeri, che include il tipo di dati double e float in Java. Nell'esempio sopra, mostriamo il valore risultante alla console. Ora la domanda è: come potremmo abbreviarlo? È semplice: devi usare printf, che a sua volta è formato + stampa, di conseguenza il nostro esempio precedente si ridurrebbe a:

double value = 34.766674;
System.out.printf("%.3f",value);

Oltre a questo metodo , l'istanza out della classe PrintStream ha anche un metodo format, che funziona in modo simile:

double value = 34.766674;
System.out.format("%.3f",value);

L'arrotondamento avviene nella modalità HALF_UP - verso il numero più vicino a quello da eliminare (a 0 o 10). Se questi numeri sono equidistanti (nel caso di 5), l'arrotondamento viene effettuato per eccesso. Esempio:

String firstResult = String.format("%.3f",7.0004);// 7,000
String secondResult = String.format("%.3f",7.0005);// 7,001
String thirdResult = String.format("%.3f",7.0006);// 7,001

Discuteremo le modalità di arrotondamento in modo più dettagliato di seguito. Arrotondare i numeri in Java - 2

DecimalFormat

Un'altra opzione è utilizzare la classe DecimalFormat . È progettato per formattare qualsiasi numero in Java, sia esso un numero intero o un numero in virgola mobile. Quando istanziamo DecimalFormat, possiamo passargli una stringa di formato. Indicherà quante cifre decimali formattare per l'input. Questo è come apparirebbe il nostro esempio utilizzando DecimalFormat :

double value = 34.766674;
DecimalFormat decimalFormat = new DecimalFormat( "#.###" );
String result = decimalFormat.format(value);
System.out.print(result);//34,767

La riga #.### è un modello che indica che stiamo formattando il valore passato a 3 cifre decimali. Per modificare il modello dopo che l'oggetto DecimalFormat è stato creato, puoi utilizzare i suoi metodi applyPattern e applyLocalizedPattern :

DecimalFormat decimalFormat = new DecimalFormat("#.###");
decimalFormat.applyPattern("#.#");
decimalFormat.applyLocalizedPattern("#.#####");

Ma oggi parliamo di arrotondamenti, no? Quando si tronca un numero con cifre decimali oltre lo schema specificato, DecimalFormat arrotonda il numero per eccesso se l'ultimo numero troncato è maggiore di 5. Ma cosa succede se il numero è 5? Si scopre che è esattamente nel mezzo tra gli interi più vicini. Cosa poi? In questo caso viene preso in considerazione il numero precedente. Se è pari, viene eseguito l'arrotondamento:

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String result = decimalFormat.format(7.4565);
System.out.println((result));// 7,457

Se dispari non viene eseguito:

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String result = decimalFormat.format(7.4575);
System.out.println((result));// 7,457

C'è una leggera differenza tra la formattazione dei numeri in virgola mobile utilizzando String.format() e DecimalFormat.format(). Il primo stamperà sempre gli zeri finali anche se non è presente alcuna parte frazionaria. Per esempio:

String firstResult = String.format("%.3f", 7.000132);
System.out.println((firstResult)); // 7.000

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String secondResult = decimalFormat.format(7.000132);
System.out.println((secondResult));  // 7

Come possiamo vedere, quando si formatta il numero 7.000132 con tre cifre decimali, il metodo format() di String restituirà 7.000, mentre il metodo format() di DecimalFormat restituirà 7. Cioè, puoi scegliere String.format() o DecimalFormat. format( ) a seconda che siano necessari o meno gli zeri finali. Utilizzando i metodi sopra descritti, abbiamo ricevuto il risultato sotto forma di stringa. Diamo un'occhiata ai modi per recuperare esattamente i valori numerici.

Matematica

È impossibile non menzionare una classe speciale su misura per varie operazioni aritmetiche con i numeri: Matematica . Arrotondare i numeri in Java - 3

Questa classe dispone anche di metodi per l'arrotondamento, ma a differenza di quelli già descritti, non permettono di impostare un certo numero di cifre decimali, bensì di arrotondare ad un numero intero:

Math.ceil() arrotonda per eccesso al numero intero più vicino, ma restituisce non un tipo intero, ma un doppio:
```
double value = 34.777774;
double result = Math.ceil(value);
System.out.println((result)); //35.0
```
Anche se abbiamo 34.0000000, dopo aver utilizzato Math.ceil otterremo comunque 35.0.
Math.floor() arrotonda per difetto all'intero più vicino, restituendo anche il risultato come double:
```
double value = 34.777774;
double result = Math.floor(value);
System.out.println((result)); //34.0
```
Ancora una volta, anche se abbiamo un valore di 34.999999999, dopo aver utilizzato Math.floor otterremo 34.0.
Math.round () - arrotonda al numero intero più vicino, fornendo il risultato int:
```
double value = 34.777774;
int result = Math.round(value);
System.out.println((result)); //35
```
Se il nostro numero è 34,5 verrà arrotondato a 35, ma se è leggermente inferiore a 34,499 il numero verrà troncato a 34.

Per non tagliare semplicemente l'intera parte reale, ma per regolare questo processo a un certo numero di cifre decimali e allo stesso tempo arrotondare, il numero viene moltiplicato per 10^n (10 elevato a n), dove n è uguale al numero di cifre decimali necessarie. Successivamente, viene utilizzato un metodo della classe Math per arrotondare e quindi dividere nuovamente per 10^n:
```
double value = 34.777774;
double scale = Math.pow(10, 3);
double result = Math.ceil(value * scale) / scale;
System.out.println((result)); //34.778
```
Math.pow : accetta due argomenti. Il primo è il numero, il secondo è la potenza a cui bisogna elevarlo.

Arrotondamento con BigDecimal

BigDecimal è una classe che ti consente di lavorare con numeri in virgola mobile. In particolare, la sua caratteristica principale è che può memorizzare numeri frazionari di lunghezza arbitraria (ovvero, non vi è alcun limite all'intervallo del numero). Inoltre, questa classe memorizza vari metodi per l'elaborazione aritmetica, incluso l'arrotondamento. La classe di questo oggetto può essere creata impostando il costruttore su double, string per visualizzare un numero in virgola mobile, double e MathContext e così via. MathContext è una combinazione di RoundingMode e un numero che descrive il numero totale di cifre nel valore cercato. Regole di arrotondamento RoundingMode: DOWN - arrotondamento verso zero. SU : modalità di arrotondamento da zero. TETTO - arrotondamento verso l'infinito positivo. FLOOR - arrotondamento verso l'infinito negativo. HALF_UP - Arrotonda al "vicino più vicino" se entrambi i vicini non sono equidistanti (ovvero quando il numero da arrotondare è 5). In questo caso viene eseguito l'arrotondamento per eccesso. HALF_DOWN - arrotondamento verso il “vicino più vicino”. Se entrambi i vicini non sono equidistanti, in questo caso arrotonda per difetto. HALF_EVEN - Arrotonda al "vicino più vicino" se entrambi i vicini non sono equidistanti. In questo caso, arrotondare al vicino pari (come in DecimalFormat descritto sopra). NON NECESSARIO - Utilizzato per confermare che l'operazione richiesta ha dato il risultato corretto. Pertanto non è necessario eseguire l'arrotondamento. Esempio:

MathContext context = new MathContext(5, RoundingMode.HALF_UP);
double value = 34.777554;
BigDecimal result = new BigDecimal(value, context);
System.out.println(result); //34.778

Oltre alla possibilità di impostare una regola di arrotondamento nel costruttore, BigDecimal consente di impostare la modalità di arrotondamento dopo la creazione dell'istanza. Per fare ciò, utilizzare il metodo setScale , in cui è necessario impostare il numero di cifre decimali e le regole di arrotondamento:

double value = 34.777554;
BigDecimal result = new BigDecimal(value);
result = result.setScale(3, RoundingMode.DOWN);
System.out.println(result); //34.777

BigDecimal dispone anche di variabili int interne progettate per impostare la modalità di arrotondamento ( ROUND_DOWN , ROUND_CEILING , ROUND_FLOOR ...). Queste sono regole di arrotondamento simili a quelle presentate nella classe RoundingMode e sono utilizzate in modo simile in setScale :

BigDecimal result = new BigDecimal(value);
result = result.setScale(3, BigDecimal.ROUND_DOWN);

Maggiori informazioni sulla classe BigDecimal in questo articolo .

Commenti

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION