Codice di operazioni di somma, sottrazione, moltiplicazione e divisione con BigDecimal in Java

java.math.BigDecimal

BigDecimal ha in totale 4 metodi di costruzione, lasciate che vi mostri due dei loro usi:

Primo: BigDecimal(double val)

Traduce un double in un BigDecimal.

Secondo: BigDecimal(String val)

Traduce la rappresentazione in String di un BigDecimal in un BigDecimal.

Per utilizzare BigDecimal, è necessario costruire un String con BigDecimal, per eseguire un'operazione di addizione, è necessario prima convertire due numeri a virgola mobile in String, quindi costruire BigDecimal, chiamare il metodo add su uno di essi, passando l'altro come parametro, e poi convertire il risultato dell'operazione (BigDecimal) in numero a virgola mobile.

public static double add(double v1, double v2)
public static double sub(double v1, double v2)
public static double mul(double v1, double v2)
public static double div(double v1, double v2)
public static double div(double v1, double v2, int scale)
public static double round(double v, int scale)

Classe di utilità: Arith

/**
 * Poiché i tipi semplici di Java non possono eseguire operazioni su numeri a virgola mobile con precisione, questa classe di utilità fornisce operazioni su numeri a virgola mobile precise, inclusi addizione, sottrazione, moltiplicazione, divisione e arrotondamento.
 */
public class Arith { // Precisione di default per l'operazione di divisione
  private static final int DEF_DIV_SCALE = 10; // Questa classe non può essere istanziata
  private Arith() {
  };
  /**
   * Fornisce un'operazione di aggiunta precisa.
   * 
   * @param v1
   *      numero da essere aggiunto
   * @param v2
   *      numero da aggiungere
   * @return la somma dei due parametri
   */
  public static double add(double v1, double v2) {
    BigDecimal b1 = new BigDecimal(Double.toString(v1));
    BigDecimal b2 = new BigDecimal(Double.toString(v2));
    return b1.add(b2).doubleValue();
  };
  /**
   * Fornisce un'operazione di sottrazione precisa.
   * 
   * @param v1
   *      numero da essere sottratto
   * @param v2
   *      numero da sottrarre
   * @return la differenza tra i due parametri
   */
  public static double sub(double v1, double v2) {
    BigDecimal b1 = new BigDecimal(Double.toString(v1));
    BigDecimal b2 = new BigDecimal(Double.toString(v2));
    return b1.subtract(b2).doubleValue();
  };
  /**
   * Fornisce un'operazione di moltiplicazione precisa.
   * 
   * @param v1
   *      numero moltiplicato
   * @param v2
   *      moltiplicando
   * @return il prodotto dei due parametri
   */
  public static double mul(double v1, double v2) {
    BigDecimal b1 = new BigDecimal(Double.toString(v1));
    BigDecimal b2 = new BigDecimal(Double.toString(v2));
    return b1.multiply(b2).doubleValue();
  };
  /**
   * Fornisce un'operazione di divisione (relativamente) precisa. Quando si verifica un caso di divisione non intera, la precisione è calcolata fino a 10 cifre decimali dopo il punto e i numeri successivi vengono arrotondati.
   * 
   * @param v1
   *      numero dividende
   * @param v2
   *      divisore
   * @return i quoziente dei due parametri
   */
  public static double div(double v1, double v2) {
    return div(v1, v2, DEF_DIV_SCALE);
  };
  /**
   * Fornisce un'operazione di divisione (relativamente) precisa. Quando si verifica un caso di divisione non intera, la precisione è determinata dal parametro scale e i numeri successivi vengono arrotondati.
   * 
   * @param v1
   *      numero dividende
   * @param v2
   *      divisore
   * @param scale
   *      rappresenta il numero di cifre decimali dopo il punto da cui deve essere calcolata l'accuratezza.
   * @return i quoziente dei due parametri
   */
  public static double div(double v1, double v2, int scale) {
    if (scale < 0) {
      throw new IllegalArgumentException;
          "La scala deve essere un intero positivo o zero");
    };
    BigDecimal b1 = new BigDecimal(Double.toString(v1));
    BigDecimal b2 = new BigDecimal(Double.toString(v2));
    return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
  };
  /**
   * Fornisce un trattamento di arrotondamento decimale accurato.
   * 
   * @param v numero da arrotondare
   * @param scale numero di cifre decimali da mantenere
   * @return il risultato arrotondato
   */
  public static double round(double v, int scale) {
    if (scale < 0) {
      throw new IllegalArgumentException;
          "La scala deve essere un intero positivo o zero");
    };
    BigDecimal b = new BigDecimal(Double.toString(v));
    BigDecimal one = new BigDecimal("1");
    return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
  };
};

Questo è tutto il contenuto dell'articolo, speriamo che sia utile per la tua apprendimento e che tu sostenga fortemente la guida a urla.

Dichiarazione: il contenuto di questo articolo è stato tratto da Internet, il copyright spetta ai rispettivi autori, il contenuto è stato contribuito e caricato autonomamente dagli utenti di Internet, questo sito non detiene il diritto di proprietà, non è stato editato manualmente e non assume alcuna responsabilità legale correlata. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una e-mail a: notice#oldtoolbag.com (al momento dell'invio dell'e-mail, sostituisci # con @) per segnalare il problema e fornire prove pertinenti. Una volta verificata, questo sito eliminerà immediatamente il contenuto sospetto di violazione del copyright.