本文へスキップ

本ページはプロモーションが含まれています

Java入門

【Java】BigDecimalの初期化・使い方|計算・比較・丸めを解説

CATEGORY
DRAWN BY
TOM
DATE
REV.
READ
約20分
SHEETS
6枚
BigDecimal(計算・比較・丸め)

トム

SESで約8年、環境を変えられないもどかしさの中にいました。32歳で自社開発企業に転職し、今はClaude Codeと自動化で、仕事も時間も組み直している途中です。
・Javaバックエンドエンジニア(Java歴12年以上)
・資格:基本情報技術者/応用情報技術者/Java Silver/Python3エンジニア認定基礎
詳細なプロフィール

𝕏

Javaでdoubleを使うと0.1 + 0.2が0.30000000000000004になります。BigDecimalなら、金額や税率の計算を誤差なしで行えます。

四則演算・丸め・比較は、次の形で書けます。

BigDecimal price = new BigDecimal("1980");   // 生成は必ず文字列で
BigDecimal tax = price.multiply(new BigDecimal("0.1"));             // 四則演算はメソッド(add / subtract / multiply / divide)
BigDecimal total = price.add(tax.setScale(0, RoundingMode.DOWN));   // 丸めは setScale + RoundingMode
BigDecimal per = new BigDecimal("10").divide(new BigDecimal("3"), 2, RoundingMode.HALF_UP); // 割り算は桁数と丸めモードを必ず渡す

System.out.println(tax);    // 198.0
System.out.println(total);  // 2178
System.out.println(per);    // 3.33
System.out.println(new BigDecimal("1.0").compareTo(new BigDecimal("1.00")) == 0); // true(数値の比較は compareTo)

ハマりどころは次の3つです。

  • new BigDecimal(0.1)とdoubleを渡すと、0.1000000000000000055511151231257827021181583404541015625になる。文字列かBigDecimal.valueOf(0.1)で作る
  • divide()に桁数と丸めモードを渡さず割り切れない数で割ると、ArithmeticExceptionで落ちる
  • equals()は桁数まで見るので、1.0と1.00はfalseになる

JDK 23.0.1で実行した出力を載せています。この記事ではBigDecimalの初期化・四則演算・比較・丸め・divideの例外・文字列への変換を順に説明します。

この記事でわかること

  • BigDecimalが必要な理由とdoubleとの違い
  • 正しい生成方法と、new BigDecimal(0.1)がダメな理由
  • 四則演算・剰余・compareToとequalsの使い分け
  • setScaleとRoundingModeによる丸め処理
  • divideのArithmeticExceptionを避ける3つの書き方
  • toStringとtoPlainStringの違い(指数表記)

PARTS LIST /目次

BigDecimalとは?doubleとの違いと必要な理由

まずはBigDecimalがどのようなもので、なぜ必要なのかから説明していきます。

特にdouble型との比較を通して、BigDecimalの存在価値を明らかにします。

BigDecimalとは何か?概要とできること

BigDecimalは、Javaで正確な10進数の計算を行うために用意されたクラスです。

java.mathパッケージに属しており、小数点以下の数値を誤差なく表現できます。

私たちが普段使う数字は0から9の10個の数字を組み合わせる10進数です。

一方、コンピュータの内部では0と1の2つの数字で表現する2進数が使われています。

doubleやfloatといった型は、この2進数で小数を扱おうとします。

0.1のような単純な小数でさえ、内部的には無限に続く循環小数になり、誤差が生まれてしまいます。

BigDecimalは、double型のこの丸め誤差を解決するために作られました。

内部的に数値を10進数のまま保持するため、私たちが期待する通りの正確な計算が可能です。

特に、お金の計算や精密な科学技術計算など、わずかな誤差も許されない場面でBigDecimalの真価を発揮します。

なぜBigDecimalが必要なのか? doubleとの比較

BigDecimalの必要性を理解するために、double型で計算した場合の問題点を確認します。

例えば、0.1 + 0.2という簡単な足し算を考えます。答えはもちろん0.3になるはずです。

しかし、この計算をdouble型で行うと、驚くべき結果が返ってきます。

System.out.println(0.1 + 0.2)
実行結果:
0.30000000000000004

ごくわずかながら誤差が生じてしまいます。この誤差は、doubleが2進数で小数を近似的に表現していることに起因します。

一度の計算では小さな誤差でも、計算を繰り返すうちに無視できない大きなずれになる可能性があります。

一方で、同じ計算をBigDecimalで行うとどうなるでしょうか。

import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("0.1");
        BigDecimal b = new BigDecimal("0.2");
        System.out.println(a.add(b));
    }
}
実行結果:
0.3

期待通り、正確な0.3という結果が得られました。計算の正確性を担保したい場合にBigDecimalは必須です。

BigDecimalを使うメリット・デメリット

BigDecimalの利用には、メリットとデメリットの両方があります。

メリット:
  • 高い精度: 小数計算で誤差が発生しません。金融システムなど、正確性が最優先される場面で必須です。
  • 柔軟な丸め処理: 四捨五入、切り捨て、切り上げなど、8種類の丸めモードを細かく指定できます。消費税の計算などで便利です。
デメリット:
  • パフォーマンス: doubleやlongなどのプリミティブ型と比べて、オブジェクトを生成するため処理速度が遅く、メモリも多く消費します。
  • 記述の煩雑さ: 四則演算が+や-のような演算子ではなく、add()やsubtract()といったメソッド呼び出しになるため、コードが長くなりがちです。

すべての数値計算をBigDecimalで行う必要はありません。

パフォーマンスが重視され、多少の誤差が許容されるグラフィック処理などではdoubleが適しています。用途に応じて使い分けます。

あわせて読む

BigDecimalの使い方:初期化・四則演算・比較

ここでは、BigDecimalを実際に使うための基本的な操作方法を解説します。

オブジェクトの作り方から、四則演算、そして値の比べ方まで、サンプルコードを交えて説明します。

BigDecimalの初期化(生成)方法

BigDecimalのオブジェクトを生成するには、いくつかの方法がありますが、文字列を引数に取るコンストラクタを使うのが最も安全で確実です。

// 推奨される方法: 文字列から生成
BigDecimal bd1 = new BigDecimal("10.5");

// doubleから生成(非推奨)
BigDecimal bd2 = new BigDecimal(0.1);

System.out.println("文字列から: " + bd1);
System.out.println("doubleから: " + bd2);
実行結果:
文字列から: 10.5
doubleから: 0.1000000000000000055511151231257827021181583404541015625

doubleを引数にすると、doubleが元々持っている誤差までBigDecimalオブジェクトに変換されてしまいます。

誤差を引き継いでしまっては、BigDecimalを使う意味がありません。必ず文字列コンストラクタを使ってください。

また、よく使う0や1、10については、定数が用意されています。

BigDecimal zero = BigDecimal.ZERO; // 0
BigDecimal one = BigDecimal.ONE;   // 1
BigDecimal ten = BigDecimal.TEN;   // 10

valueOf()メソッドを使う方法もあります。

valueOf(double val)は内部でDouble.toString(val)を呼び出すため、文字列コンストラクタと同じ結果になり安全です。

BigDecimal bd3 = BigDecimal.valueOf(10.5); // こちらも安全
System.out.println(bd3); // 10.5

BigDecimalの四則演算:add, subtract, multiply, divide

BigDecimalの四則演算は、それぞれ専用のメソッドで行います。

  • 加算: add()
  • 減算: subtract()
  • 乗算: multiply()
  • 除算: divide()

add()やsubtract()などのメソッドは、計算結果を新しいBigDecimalオブジェクトとして返します(詳しくは後述の「不変性」で解説します)。

BigDecimal a = new BigDecimal("10");
BigDecimal b = new BigDecimal("3");

// 加算: 10 + 3
BigDecimal resultAdd = a.add(b);
System.out.println("加算: " + resultAdd); // 13

// 減算: 10 - 3
BigDecimal resultSubtract = a.subtract(b);
System.out.println("減算: " + resultSubtract); // 7

// 乗算: 10 * 3
BigDecimal resultMultiply = a.multiply(b);
System.out.println("乗算: " + resultMultiply); // 30

// 除算: 10 / 3
// このままだと割り切れないため例外が発生する
// BigDecimal resultDivide = a.divide(b); 

// 正しくは、桁数と丸めモードを指定する
BigDecimal resultDivide = a.divide(b, 5, RoundingMode.HALF_UP);
System.out.println("除算: " + resultDivide); // 3.33333

除算については、割り切れない場合にArithmeticExceptionという例外が発生する可能性があるため注意が必要です。

この除算時の例外については後ほど詳しく解説します。

BigDecimalの剰余(余り)計算

割り算の余りを求めるにはremainder()メソッドを使います。また、商と余りを同時に取得できるdivideAndRemainder()も便利です。

import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("10");
        BigDecimal b = new BigDecimal("3");

        // 余りを取得
        BigDecimal remainder = a.remainder(b);
        System.out.println("余り: " + remainder); // 1

        // 商と余りを同時に取得
        BigDecimal[] results = a.divideAndRemainder(b);
        System.out.println("商: " + results[0]);  // 3
        System.out.println("余り: " + results[1]); // 1
    }
}

divideAndRemainder()はBigDecimalの配列を返し、[0]が商、[1]が余りです。

割り勘計算や在庫の均等配分など、商と余り両方が必要な場面で重宝します。

BigDecimalの比較:equalsとcompareToの違い

BigDecimalの値を比較するにはequals()とcompareTo()の2つのメソッドがありますが、この2つは役割が異なります。

  • equals(): 数値とスケール(小数点以下の桁数)の両方が完全に一致する場合にtrueを返します。
  • compareTo(): 数値の大小を比較します。スケールは無視されます。
    • a.compareTo(b)の結果
      • -1: aがbより小さい
      • 0: aとbが等しい
      • 1: aがbより大きい

具体的なコードで違いを示します。

BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("1.00");

// equals()での比較
System.out.println("equals: " + bd1.equals(bd2)); // false

// compareTo()での比較
System.out.println("compareTo: " + (bd1.compareTo(bd2) == 0)); // true

1.0と1.00は、数値的には同じですが、スケール(小数点以下の桁数)がそれぞれ1と2で異なります。そのため、equals()はfalseを返します。

金額の比較など、純粋に数値として等しいかを確認したい場合はcompareTo()を使います。

equals()は、スケールまで厳密に一致しているかを確認したい特殊なケースで利用します。

大小の判定はcompareTo()の結果を0と比べて書きます。0との比較ならsignum()(正なら1、0なら0、負なら-1)も使えます。

BigDecimal x = new BigDecimal("2.5");

System.out.println(x.compareTo(BigDecimal.ONE) > 0);   // true(x > 1)
System.out.println(x.max(new BigDecimal("3")));         // 3
System.out.println(new BigDecimal("-2.5").signum());    // -1

// 0かどうかの判定
BigDecimal zero = new BigDecimal("0.00");
System.out.println(zero.compareTo(BigDecimal.ZERO) == 0); // true
System.out.println(zero.equals(BigDecimal.ZERO));         // false

0.00とBigDecimal.ZEROもequals()ではfalseになります。ゼロ判定をequals(BigDecimal.ZERO)で書くと、DBから0.00で取れた値を見逃します。

equals()のこの性質は、HashSetやHashMapのキーにしたときにも効いてきます。

Set<BigDecimal> hashSet = new HashSet<>();
hashSet.add(new BigDecimal("1.0"));
hashSet.add(new BigDecimal("1.00"));
System.out.println(hashSet.size()); // 2(別の値として入る)

Set<BigDecimal> treeSet = new TreeSet<>();
treeSet.add(new BigDecimal("1.0"));
treeSet.add(new BigDecimal("1.00"));
System.out.println(treeSet.size()); // 1(compareToで比べるので同じ値)

HashSetはequals()とhashCode()で、TreeSetはcompareTo()で重複を判定するためです。金額をキーにまとめたいときは、setScale()で桁数をそろえてから入れるか、TreeMapを使います。

BigDecimalでハマりやすい落とし穴と対策

BigDecimalは便利なクラスですが、使い方を誤ると予期せぬエラーやバグの原因になります。特にdivideの丸めモードの指定漏れは、割り切れる数でテストしていると気づけません。10 ÷ 4は通るのに、本番で10 ÷ 3が来た瞬間にArithmeticExceptionで落ちます。

スケールと精度:丸め処理の重要性

BigDecimalでは、スケール(scale)と精度(precision)を理解しておきます。

スケールは小数点以下の桁数、精度は数値全体の有効桁数を表します。例えば123.45の場合、スケールは2、精度は5です。

特に、計算結果の桁数を調整するsetScale()メソッドを使う際には注意が必要です。

例えば、1.235という数値を小数点以下2桁に丸めたいとします。

import java.math.BigDecimal;
import java.math.RoundingMode;

public class Main {
    public static void main(String[] args) {
        BigDecimal num = new BigDecimal("1.235");

        // 小数点以下2桁に、四捨五入で丸める
        BigDecimal rounded = num.setScale(2, RoundingMode.HALF_UP);
        System.out.println(rounded); // 1.24

        // 丸めモードを指定しないと例外が発生する可能性がある
        try {
            BigDecimal error = new BigDecimal("1.235").setScale(2);
        } catch (ArithmeticException e) {
            System.err.println("エラー: " + e.getMessage());
        }
    }
}
実行結果:
1.24
エラー: Rounding necessary

setScale()で桁数を減らす場合、1.235を1.23にするには端数の5をどう処理するか決めなければなりません。

この「どう処理するか」を指定するのが丸めモード(RoundingMode)です。

丸めモードを指定せずにsetScale()を呼ぶと、「丸めが必要なのにモードが指定されていない」という理由でArithmeticExceptionが発生します。

計算の最終結果を特定の桁数に揃える場合は、必ずsetScale()とRoundingModeをセットで使います。

桁数を増やす方向なら丸めは不要で、setScale(2)だけで足ります(1.5が1.50になります)。減らす方向で、捨てる部分に0以外の数字が残るときだけ、丸めモードが必要です。

HALF_UP(四捨五入)以外では、HALF_EVEN(偶数丸め。ちょうど5のとき、結果が偶数になるほうへ丸める)がよく話題になります。2.5と3.5で違いが出ます。

System.out.println(new BigDecimal("2.5").setScale(0, RoundingMode.HALF_UP));   // 3
System.out.println(new BigDecimal("2.5").setScale(0, RoundingMode.HALF_EVEN)); // 2
System.out.println(new BigDecimal("3.5").setScale(0, RoundingMode.HALF_EVEN)); // 4
System.out.println(new BigDecimal("2.5").setScale(0, RoundingMode.HALF_DOWN)); // 2

どれを使うかは、扱う金額の取り決め次第です。決まっていなければ、学校で習った四捨五入と同じHALF_UPを選ぶのが自然です。一覧は後半の「RoundingMode」の節にあります。

あわせて読む

除算時のArithmeticException:例外処理

BigDecimalの落とし穴として最も有名なのが、除算時のArithmeticExceptionです。

これは、割り算の結果が無限小数になる(割り切れない)場合に発生します。

実際に10 ÷ 3を計算すると3.333...となり、割り切れません。

BigDecimal a = new BigDecimal("10");
BigDecimal b = new BigDecimal("3");

// 割り切れないため ArithmeticException が発生する
// a.divide(b);

この例外を回避するには、divide()メソッドのオーバーロードを使い、スケール(小数点以下の桁数)と丸めモードを明示的に指定します。

import java.math.BigDecimal;
import java.math.RoundingMode;

public class Main {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("10");
        BigDecimal b = new BigDecimal("3");

        // 小数点以下5桁まで求め、それ以降は四捨五入する
        BigDecimal result = a.divide(b, 5, RoundingMode.HALF_UP);
        System.out.println(result); // 3.33333
    }
}

スケールと丸めモードを指定することで、計算が指定桁数で打ち切られ、例外の発生を防げます。

divide()の書き方は3通りあります。

書き方結果の桁数10 ÷ 3の結果
divide(b)割り切れる桁数まで例外(割り切れないため)
divide(b, 5, RoundingMode.HALF_UP)小数点以下5桁(スケールで指定)3.33333
divide(b, new MathContext(5))有効数字5桁(精度で指定)3.3333

指定するのが「小数点以下の桁数」か「有効数字の桁数」かが違います。divide(b, RoundingMode.HALF_UP)のようにスケールを省く書き方もありますが、結果のスケールが被除数と同じになります。

System.out.println(new BigDecimal("10").divide(new BigDecimal("3"), RoundingMode.HALF_UP));    // 3(被除数のスケール0に合わせる)
System.out.println(new BigDecimal("10.00").divide(new BigDecimal("3"), RoundingMode.HALF_UP)); // 3.33

10のままだと小数が全部落ちて3になります。意図しない桁落ちを避けるため、桁数は自分で渡す書き方を基本にします。割り切れる数だけを割る場面(1 ÷ 4が0.25になる、など)に限って、桁数なしのdivide(b)が使えます。

例外のメッセージは次のとおりです。

Non-terminating decimal expansion; no exact representable decimal result.

「循環小数になり、正確に表せない」という意味です。このメッセージが出たら、divideに桁数と丸めモードを渡します。

特にユーザーの入力値など、どのような数値が来るか分からない計算では、必ず桁数と丸めモードを指定してください。

BigDecimalの不変性:注意点とコピー

BigDecimalオブジェクトは不変(Immutable)です。

これは、一度作成したオブジェクトの内部状態(値)が決して変わらないという性質を意味します。

add()やsetScale()などのメソッドを呼び出しても、元のオブジェクトの値は変化しません。

こうした演算メソッドは、計算結果を持つ新しいBigDecimalオブジェクトを生成して返すのです。

初心者がやりがちな間違いが、この戻り値を受け取らないことです。

// 間違った例
BigDecimal price = new BigDecimal("1000");
BigDecimal taxRate = new BigDecimal("0.1");

// price.add(price.multiply(taxRate)); // 計算結果を捨ててしまっている
// System.out.println(price); // 1000 のまま

// 正しい例
BigDecimal tax = price.multiply(taxRate);
BigDecimal totalPrice = price.add(tax); // 戻り値を受け取る

System.out.println(totalPrice); // 1100.0

price.add(tax)を実行しても、price自体の値は1000のままです。

計算結果である1100は、新しく作られたBigDecimalオブジェクトとして返されるので、それをtotalPriceという別の変数で受け取る必要があります。

この不変性という性質は、複数の場所から同じオブジェクトを参照しても値が書き換わる心配がないため、安全なプログラミングにつながります。

BigDecimalの演算を行う際は、必ず戻り値を変数に代入することを忘れないでください。

BigDecimalのnull判定と安全な初期化

BigDecimalはオブジェクト型のため、nullが代入される可能性があります。

nullのまま演算メソッドを呼ぶとNullPointerExceptionが発生するため、外部入力やデータベースから取得した値を扱う際は注意が必要です。

import java.math.BigDecimal;
import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        // nullチェックしてからデフォルト値を設定するパターン
        BigDecimal input = null;
        BigDecimal safeValue = (input != null) ? input : BigDecimal.ZERO;
        System.out.println(safeValue); // 0

        // Optionalを使ったパターン
        BigDecimal result = Optional.ofNullable(input)
                                    .orElse(BigDecimal.ZERO);
        System.out.println(result); // 0
    }
}

データベースのNULLABLEカラムや、ユーザー入力の未入力フィールドなど、nullが入り得る場面では、計算前に必ずnullチェックを行います。

BigDecimalの実践:応用テクニック

基本を押さえたところで、次はより実践的なBigDecimalの使い方を紹介します。

MathContextによる精度管理、丸めモードの使い分け、通貨・パーセントの表示形式など、実務で役立つテクニックを紹介します。

MathContext:精度を一括管理する

MathContextは、計算時の精度(有効桁数)と丸めモードをまとめて指定できるクラスです。複数の計算で同じ精度設定を使い回したい場合に便利です。

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;

public class Main {
    public static void main(String[] args) {
        // 有効桁数5桁、四捨五入のMathContextを作成
        MathContext mc = new MathContext(5, RoundingMode.HALF_UP);

        BigDecimal a = new BigDecimal("123.456789");
        BigDecimal b = new BigDecimal("9.87654321");

        // MathContextを適用した計算
        BigDecimal result = a.multiply(b, mc);
        System.out.println(result); // 1219.3
    }
}

あらかじめ定義された定数もあります。

MathContext.DECIMAL32(7桁)・MathContext.DECIMAL64(16桁)・MathContext.DECIMAL128(34桁)の3つのほか、精度を制限しないMathContext.UNLIMITEDも用意されています。用途に応じて選択できます。

RoundingMode:様々な丸めモードを使いこなす

BigDecimalの強力な機能の一つが、豊富な丸めモードです。

java.math.RoundingModeというenumで定義されており、全部で8種類あります。

なお、古いコードで見かけるBigDecimal.ROUND_HALF_UPなどの整数定数はJava 9で非推奨になりました。

新規コードでは必ずRoundingModeを使います。ここでは、特によく使われるものを紹介します。

RoundingMode説明例 (5.5)例 (2.5)例 (-2.5)
HALF_UPいわゆる四捨五入。端数が0.5以上なら切り上げる。63-3
DOWN切り捨て。0から遠ざからないように丸める。52-2
UP切り上げ。0から遠ざかるように丸める。63-3
CEILING正の無限大方向に丸める(天井)。63-2
FLOOR負の無限大方向に丸める(床)。52-3
2.5 と -2.5 はどちらへ丸められる?(数直線の向きで見る)
ROUNDINGMODE
丸める向き
-2.5 →
2.5 →
HALF_UP四捨五入
端数が0.5以上なら0から遠ざかる
← -3
3 →
DOWN切り捨て
0に近づく
-2 →
← 2
UP切り上げ
0から遠ざかる
← -3
3 →
CEILING天井
正の無限大方向(右へ)
-2 →
3 →
FLOOR床
負の無限大方向(左へ)
← -3
← 2
NOTE上の表の「例(2.5)」「例(-2.5)」を数直線の向きにしたもの。矢印は丸めた結果が元の値から見て右(大きい側)か左(小さい側)かを示します。DOWN・UP は0を基準に向きが決まり、CEILING・FLOOR は値の正負に関係なく右・左の一方向に丸めます。斜線のマスは、CEILING・FLOOR が0に近づく向き(DOWN と同じ向き)に丸めるところです。

別の例として、消費税の端数を切り捨てる計算ならRoundingMode.DOWNが使えます(端数をどう扱うかは事業者ごとの取り決めなので、仕様書で確認してください)。

import java.math.BigDecimal;
import java.math.RoundingMode;

public class Main {
    public static void main(String[] args) {
        BigDecimal price = new BigDecimal("198");
        BigDecimal taxRate = new BigDecimal("0.1");

        // 消費税を計算し、小数点以下を切り捨てる
        BigDecimal tax = price.multiply(taxRate).setScale(0, RoundingMode.DOWN);
        System.out.println("消費税: " + tax); // 19

        BigDecimal totalPrice = price.add(tax);
        System.out.println("税込価格: " + totalPrice); // 217
    }
}

商品ごとの税込価格は切り捨て、合計金額への課税は四捨五入、のように、同じシステムの中で丸めモードが分かれることもあります。

仕様書に「端数処理」の記載がない場合は、実装する前に確認を取ります。丸めモードは業務の取り決めで決まるもので、コードの都合では決まりません。

NumberFormat:通貨やパーセント表示

BigDecimalで計算した結果を、ユーザーに分かりやすく表示する際にはNumberFormatクラスが便利です。

例えば、数値を「¥1,234」のような通貨形式や、「50%」のようなパーセント形式に整形できます。

import java.math.BigDecimal;
import java.text.NumberFormat;
import java.util.Locale;

public class Main {
    public static void main(String[] args) {
        BigDecimal amount = new BigDecimal("12345.67");

        // 日本の通貨形式にフォーマット
        NumberFormat currencyFormatter = NumberFormat.getCurrencyInstance(Locale.JAPAN);
        System.out.println(currencyFormatter.format(amount)); // ¥12,346(JDK 21・23では全角の円記号で表示される)

        BigDecimal ratio = new BigDecimal("0.55");

        // パーセント形式にフォーマット
        NumberFormat percentFormatter = NumberFormat.getPercentInstance();
        System.out.println(percentFormatter.format(ratio)); // 55%
    }
}

NumberFormatは内部で自動的に丸め処理を行いますが、既定の丸めモードは四捨五入(HALF_UP)ではなく、偶数丸め(HALF_EVEN)です。たとえば12346.5を通貨形式にすると12,346になります。

getCurrencyInstanceにLocaleを指定することで、様々な国の通貨形式に対応できます。

計算はBigDecimalで正確に行い、表示の整形はNumberFormatに任せる、という役割分担が理想的です。

BigDecimalとコレクション:合計値の計算

Listなどのコレクションに格納された複数のBigDecimalオブジェクトの合計値を計算する場面もよくあります。

これは、ループ処理やJava 8以降で利用可能なStream APIを使うことで簡単に実現できます。

for-eachループを使った方法:
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<BigDecimal> prices = Arrays.asList(
            new BigDecimal("198.5"),
            new BigDecimal("2050"),
            new BigDecimal("378.99")
        );

        BigDecimal sum = BigDecimal.ZERO;
        for (BigDecimal price : prices) {
            sum = sum.add(price);
        }
        System.out.println("合計金額 (for-each): " + sum); // 2627.49
    }
}
Stream APIを使った方法:

Stream APIのreduceメソッドを使うと、より簡潔に記述できます。

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<BigDecimal> prices = Arrays.asList(
            new BigDecimal("198.5"),
            new BigDecimal("2050"),
            new BigDecimal("378.99")
        );

        BigDecimal streamSum = prices.stream()
                                     .reduce(BigDecimal.ZERO, BigDecimal::add);
        System.out.println("合計金額 (Stream): " + streamSum); // 2627.49
    }
}

どちらの方法でも正しい結果が得られますが、Stream APIを使うとコードがすっきりとします。

プロジェクトのコーディング規約やJavaのバージョンに合わせて使い分けてください。

BigDecimalの型変換:int・String・doubleへの相互変換

実務ではBigDecimalを他の型に変換したり、逆に他の型からBigDecimalを生成したりする場面が頻繁にあります。主要な変換方法をまとめます。

import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) {
        BigDecimal bd = new BigDecimal("123.456");

        // BigDecimal → int(小数点以下切り捨て)
        int intValue = bd.intValue();
        System.out.println("intValue: " + intValue); // 123

        // BigDecimal → int(小数点以下があると例外を投げる安全版)
        // bd.intValueExact(); // ArithmeticException

        // BigDecimal → double
        double doubleValue = bd.doubleValue();
        System.out.println("doubleValue: " + doubleValue); // 123.456

        // BigDecimal → String
        String strValue = bd.toPlainString();
        System.out.println("toPlainString: " + strValue); // 123.456

        // String → BigDecimal
        BigDecimal fromStr = new BigDecimal("789.012");
        System.out.println("fromString: " + fromStr); // 789.012

        // int → BigDecimal
        BigDecimal fromInt = BigDecimal.valueOf(42);
        System.out.println("fromInt: " + fromInt); // 42
    }
}

intValue()は小数点以下を単純に切り捨てます。

金額計算などで端数の扱いを明示したい場合は、先にsetScale(0, RoundingMode.HALF_UP)で丸めます。

そのあとにintValue()を呼ぶと安全です。

intValueExact()は小数部分が残っている場合にArithmeticExceptionを投げるため、データ検証に便利です。

その他の便利なメソッド

四則演算以外にも、BigDecimalには実務で役立つメソッドが用意されています。

import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) {
        BigDecimal num = new BigDecimal("-123.4500");

        // 絶対値を取得
        System.out.println(num.abs()); // 123.4500

        // 符号を反転
        System.out.println(num.negate()); // 123.4500

        // 累乗(n乗)
        BigDecimal base = new BigDecimal("2");
        System.out.println(base.pow(10)); // 1024

        // 末尾のゼロを除去
        System.out.println(num.stripTrailingZeros()); // -123.45

        // 指数表記を使わない文字列変換
        BigDecimal large = new BigDecimal("12345678901234567890");
        System.out.println(large.toPlainString()); // 12345678901234567890
    }
}

特にstripTrailingZeros()は、データベースから取得した数値を表示する際に便利です。

toPlainString()は指数表記(例: 1.23E+10)を避けたい場合に使います。

文字列にする方法はtoString()とtoPlainString()の2つで、System.out.println(bd)や文字列連結はtoString()を呼んでいます。toString()は桁の大きさ次第で指数表記になります。

BigDecimal thousand = new BigDecimal("1000").stripTrailingZeros();
System.out.println(thousand);                 // 1E+3
System.out.println(thousand.toPlainString()); // 1000

System.out.println(new BigDecimal("0.0000001"));  // 1E-7
System.out.println(new BigDecimal("0.000001"));   // 0.000001

stripTrailingZeros()で末尾の0を落とすと、1000が1E+3になります。画面表示やCSV出力、DBに文字列で渡すときは、toPlainString()を使います。

よくある質問

Q1. Javaで正確な小数計算を行うにはどうすればいいですか?

A1. BigDecimalクラスを使います。doubleやfloatは2進数で小数を近似的に表現するため誤差が生じますが、BigDecimalは10進数のまま保持するため誤差なく計算できます。

Q2. BigDecimalの初期化はどう書けばいいですか?

A2. 文字列を引数に取るコンストラクタ(例: new BigDecimal("10.5"))を使うのが最も安全です。doubleを直接渡すと、doubleが持つ誤差までBigDecimalに引き継がれてしまいます。

Q3. BigDecimalの比較にequals()とcompareTo()どちらを使うべきですか?

A3. 数値として等しいかを確認したい場合はcompareTo()を使います。equals()は数値とスケール(小数点以下の桁数)の両方が一致する場合のみtrueを返すため、1.0と1.00はequals()ではfalseになります。

Q4. BigDecimalの除算でArithmeticExceptionが発生するのはなぜですか?

A4. 割り算の結果が無限小数になり割り切れない場合に発生します。divide()メソッドでスケール(小数点以下の桁数)と丸めモード(RoundingMode)を明示的に指定することで回避できます。

Q5. BigDecimalとdoubleはどう使い分ければいいですか?

A5. 金融・会計計算やECサイトの料金計算など正確性が最優先される場面ではBigDecimalを使います。3Dグラフィックスの座標計算など速度が重要でわずかな誤差が許容できる場合はdoubleが適しています。

Q6. BigDecimalの演算結果を反映するにはどうすればいいですか?

A6. add()やsetScale()などのメソッドの戻り値を変数に代入する必要があります。BigDecimalは不変(Immutable)オブジェクトのため、メソッドを呼び出しても元のオブジェクトの値は変化せず、計算結果は新しいオブジェクトとして返されます。

BigDecimalのまとめと使い分けガイド

最後に、これまでの内容をまとめ、BigDecimalをさらに深く理解するためのヒントを提供します。

BigDecimalを使うべきケース、使わない方が良いケース

BigDecimalは万能ではありません。特性を理解し、適切な場面で使います。

使うべきケース:
  • 金融・会計システム: お金の計算では1円の誤差も許されません。必須です。
  • ECサイトの料金計算: 税金や送料、割引など、正確な金額の算出が求められます。
  • 精密な科学技術計算: 誤差が結果に大きく影響する物理シミュレーションなどで利用します。
  • 法制度に関わる計算: 法律で計算方法や端数処理が厳密に定められている場合。
使わない方が良いケース(doubleなどを検討するケース):
  • パフォーマンスが最優先される計算: 3Dグラフィックスの座標計算や大量の統計データ処理など、速度が重要で、わずかな誤差は許容できる場合。
  • 単純なカウンターやループ変数: 整数で事足りる場面でBigDecimalを使う必要はありません。intやlongを使います。

「正確性が何よりも重要か?」を一つの判断基準にすると、使い分けがしやすくなります。

BigDecimalに関する参考文献・リンク集

さらに学習を深めたい方向けに、公式のドキュメントを紹介します。一次情報にあたることで、より正確で深い知識を得られます。

メソッドの詳細な仕様や、すべてのRoundingModeの説明などが記載されています。

困ったときには、まず公式ドキュメントを参照する習慣をつけることをお勧めします。

本記事のコードはJDK 23.0.1で実行して出力を確かめています。BigDecimalのAPIはJava 8以降で大きな変更がないため、Java 8以降で動作します(RoundingModeとBigDecimal.valueOfは古い版にもあります)。

BigDecimalのパフォーマンスチューニング

BigDecimalはdoubleに比べて低速ですが、使い方を工夫することでパフォーマンスへの影響を最小限に抑えられます。

  • valueOf()を積極的に使う: BigDecimal.valueOf(10)のように、long型の引数を取るvalueOfメソッドは、0から10までのよく使われる値をキャッシュしています。0〜10の範囲内であれば、キャッシュによりnew BigDecimal("10")よりも高速です。
  • ループ内でのオブジェクト生成を避ける: ループの中で何度も同じ値のBigDecimalをnewしている場合、ループの外で一度だけ生成して使い回すことで、不要なオブジェクト生成を減らせます。
  • 不要な精度で計算しない: 計算途中のスケールが不必要に大きくなると、パフォーマンスが低下します。中間結果に対しても適切にsetScale()を適用し、桁数を管理することが有効です。

金額計算の件数が数百〜数千件程度なら、BigDecimalの遅さが問題になることはまずありません。速度が気になったら、先に計測してからdoubleやlongへの置き換えを考えます。

BigDecimalは、Javaで正確な数値を扱うための強力な武器です。

doubleとの違いを正しく理解し、生成・演算・比較の基本をマスターすれば、もう数値計算の誤差に悩まされることはありません。

特に押さえるべきは3つのポイントです。

new BigDecimal(double)を使わないこと、除算では丸めモードを指定すること、不変性を理解することです。

この3つがバグを未然に防ぎます。

現場での開発では、BigDecimalを直接操作するよりも、通貨計算用のユーティリティクラスを作成してチーム全体で統一する方が安全です。

丸めモードやスケールは、プロジェクト共通の定数として定義します。

個人の判断でバラバラにならないようにします。

正確な金額計算が必要な場面では、今日からBigDecimalを使ってみてください。

REVISIONS / 改訂履歴
REV.DATE内容
62026-11-20冒頭に四則演算・丸め・比較の最短コードを追加し、compareToとequals(HashSet)・divideの書き方3通り・toStringの指数表記の節を足した
52026-10-16図解を描き直し(図面のデザインにそろえた)
42026-10-14雰囲気だけの挿絵を外した
32026-08-302026年8月時点の情報で全体を見直し(古い記述を3件更新)
… ほか1回の改訂
12025-10-18初版
NEXT READ本棚から1本

AIで開発を組み直すなら、まずこの5冊から

入門・実践・設計まで、Claude Codeの本をレベル別に5冊選んで比べました。

→ おすすめ5冊を見る

トム

SESで約8年、環境を変えられないもどかしさの中にいました。32歳で自社開発企業に転職し、今はClaude Codeと自動化で、仕事も時間も組み直している途中です。
・Javaバックエンドエンジニア(Java歴12年以上)
・資格:基本情報技術者/応用情報技術者/Java Silver/Python3エンジニア認定基礎
詳細なプロフィール

𝕏

Java入門

TOC