Javaは、基幹システムやWebアプリケーション、Androidアプリ開発など、多岐にわたる分野で使用されているプログラミング言語です。

その中でも、数値計算はあらゆるプログラムの根幹を成す重要な要素です。

単純な数値の足し算から、金融システムで求められる厳密な小数点計算まで、Javaには多様な計算手法が用意されています。

しかし、浮動小数点数の特性や精度の限界を正しく理解していないと思わぬバグの原因にもなりかねません。

本記事では、Javaにおける基本的な四則演算から、実務で必須となるBigDecimalを用いた精密な計算手法まで、テクニカルな視点で詳しく解説します。

目次 [ close ]
  1. Javaにおける基本的な四則演算
    1. 基本的な算術演算子の種類
    2. 整数同士の計算と注意点
  2. 演算子の優先順位と結合規則
    1. 優先順位の制御
    2. 複合代入演算子の活用
  3. Javaの数値型と精度の違い
    1. 整数型（byte, short, int, long）
    2. 浮動小数点型（float, double）
  4. Mathクラスによる高度な計算
    1. 主要なMathクラスのメソッド
  5. 浮動小数点計算の落とし穴：丸め誤差
    1. 誤差が発生する仕組み
  6. BigDecimalによる精密計算
    1. BigDecimalの生成における注意点
    2. 基本的なメソッドの使い方
    3. 割り切れない場合の除算（ArithmeticException）
  7. 計算処理におけるオーバーフローの対策
    1. オーバーフローの例
    2. Math.addExactによる安全な計算
  8. 数値の比較方法
    1. プリミティブ型の比較
    2. BigDecimalの比較
  9. まとめ

Javaにおける基本的な四則演算

Javaでの数値計算の基本は、算術演算子を使用した四則演算です。

これは数学で使われる記号とほぼ同じですが、プログラミング特有の挙動、特に整数の割り算などには注意が必要です。

基本的な算術演算子の種類

Javaで使用される主な算術演算子は以下の5種類です。

演算子意味例
+加算（足し算）10 + 5 = 15
-減算（引き算）10 - 5 = 5
*乗算（掛け算）10 * 5 = 50
/除算（割り算）10 / 3 = 3
%剰余（余り）10 % 3 = 1

整数同士の計算と注意点

Javaでint型などの整数同士で除算を行った場合、結果も整数になります。

小数点以下は切り捨てられるため、「10 / 4」の結果は「2.5」ではなく「2」になるという点に注意してください。

正確な小数点以下の値を得るためには、少なくとも片方の数値を浮動小数点数（double型など）として扱う必要があります。

Java
public class BasicCalculation {
    public static void main(String[] args) {
        // 整数の除算（小数点以下切り捨て）
        int intResult = 10 / 4;
        System.out.println("10 / 4 (int) = " + intResult);

        // 片方をdouble型にキャストして計算
        double doubleResult = 10.0 / 4;
        System.out.println("10.0 / 4 (double) = " + doubleResult);

        // 剰余演算
        int remainder = 10 % 3;
        System.out.println("10 % 3 = " + remainder);
    }
}
実行結果
10 / 4 (int) = 2
10.0 / 4 (double) = 2.5
10 % 3 = 1

演算子の優先順位と結合規則

複雑な数式を記述する場合、どの演算が先に処理されるかという優先順位を理解しておく必要があります。

Javaでは数学のルールと同様に、乗除算（*, /, %）は加減算（+, -）よりも優先されます。

優先順位の制御

計算順序を明示的に変更したい場合は、丸括弧 () を使用します。

括弧内の計算が最優先されるため、複雑な計算式では可読性を高めるためにも括弧を積極的に活用することが推奨されます。

また、同じ優先順位の演算子が並んでいる場合は、左から右へと順に計算される「左結合」が適用されます。

ただし、代入演算子（=）などは右から左へと処理される「右結合」です。

複合代入演算子の活用

変数の値を更新しながら計算を行う場合、複合代入演算子を使用するとコードを簡潔に記述できます。

  • a += b （a = a + b と同等）
  • a -= b （a = a - b と同等）
  • a *= b （a = a * b と同等）
  • a /= b （a = a / b と同等）
Java
public class AssignmentOperator {
    public static void main(String[] args) {
        int score = 100;
        
        // 50を加算
        score += 50; 
        System.out.println("加算後: " + score);

        // 2倍にする
        score *= 2;
        System.out.println("倍増後: " + score);
    }
}
実行結果
加算後: 150
倍増後: 300

Javaの数値型と精度の違い

Javaで数値を扱うためのデータ型には、大きく分けて「整数型」と「浮動小数点型」があります。

計算の目的に応じて適切な型を選択することが、パフォーマンスと精度の両立には不可欠です。

整数型（byte, short, int, long）

最も一般的に使用されるのは int（32ビット）ですが、より大きな数値を扱う場合は long（64ビット）を使用します。

  • int: 約-21億から21億まで。
  • long: 非常に広大な範囲をカバー。リテラルの末尾に L を付与します（例: 10000000000L）。

浮動小数点型（float, double）

小数を扱うための型であり、IEEE 754規格に準拠しています。

  • float: 単精度（32ビット）。精度は低いがメモリ消費が少ない。末尾に f を付与。
  • double: 倍精度（64ビット）。Javaのデフォルトの小数型。

浮動小数点型は「近似値」を扱うため、厳密な計算には向かないという特徴があります。

これについては後述する「計算誤差」のセクションで詳しく解説します。

Mathクラスによる高度な計算

Javaの標準ライブラリには、複雑な数学的計算をサポートする java.lang.Math クラスが用意されています。

このクラスのメソッドはすべて static であるため、インスタンス化せずに直接呼び出すことができます。

主要なMathクラスのメソッド

日常的な開発で頻繁に使用されるメソッドは以下の通りです。

  • Math.abs(): 絶対値を求める。
  • Math.max() / Math.min(): 2つの値の大きい方 / 小さい方を返す。
  • Math.pow(a, b): aのb乗を計算する。
  • Math.sqrt(): 平方根（ルート）を求める。
  • Math.round(): 四捨五入を行う。
  • Math.ceil() / Math.floor(): 切り上げ / 切り捨て。
Java
public class MathSample {
    public static void main(String[] args) {
        double val = -25.6;

        System.out.println("絶対値: " + Math.abs(val));
        System.out.println("切り上げ: " + Math.ceil(val));
        System.out.println("四捨五入: " + Math.round(val));
        System.out.println("2の10乗: " + Math.pow(2, 10));
        System.out.println("円周率: " + Math.PI);
    }
}
実行結果
絶対値: 25.6
切り上げ: -25.0
四捨五入: -26
2の10乗: 1024.0
円周率: 3.141592653589793

浮動小数点計算の落とし穴：丸め誤差

Java（および多くのプログラミング言語）において、double や float を使った計算には致命的な弱点があります。

それは、「10進数の小数を2進数で正確に表現できないことによる誤差」です。

誤差が発生する仕組み

コンピュータは内部的にすべての数値を2進数で処理しています。

しかし、10進数における「0.1」のような数値は、2進数に変換すると無限小数になってしまいます。

限られたビット数でこれを表現しようとすると、どこかで値を切り捨てなければならず、その結果として微小な誤差（丸め誤差）が発生します。

Java
public class FloatingPointError {
    public static void main(String[] args) {
        // 期待値は 0.3 だが...
        double result = 0.1 + 0.2;
        System.out.println("0.1 + 0.2 = " + result);

        // 比較演算も意図通りに動かない可能性がある
        if (result == 0.3) {
            System.out.println("等しい");
        } else {
            System.out.println("等しくない（誤差あり）");
        }
    }
}
実行結果
0.1 + 0.2 = 0.30000000000000004
等しくない（誤差あり）

このように、0.1を3回足しても0.3にはならないという現象は、金融系システムや在庫管理システムにおいて深刻な不具合を引き起こします。

そのため、お金や精密な数値を扱う計算に double や float を使用してはいけません。

BigDecimalによる精密計算

前述の誤差問題を解決するためにJavaが提供しているのが java.math.BigDecimal クラスです。

このクラスは、任意の精度の10進数計算をサポートしており、誤差を許容できない業務システムでの計算には必須となります。

BigDecimalの生成における注意点

BigDecimal を使用する際、最も注意すべきなのはインスタンスの生成方法です。

推奨：String引数のコンストラクタ

new BigDecimal("0.1") のように文字列として渡すと、正確に 0.1 として扱われます。

非推奨：double引数のコンストラクタ

new BigDecimal(0.1) とすると、引数の段階で既に発生している double の誤差を引き継いでしまいます。

基本的なメソッドの使い方

BigDecimal はプリミティブ型ではないため、+ や * といった演算子は使えません。

代わりに専用のメソッドを呼び出します。

また、BigDecimalはイミュータブル（不変）なオブジェクトであるため、計算結果は常に新しいインスタンスとして受け取る必要があります。

  • add(): 加算
  • subtract(): 減算
  • multiply(): 乗算
  • divide(): 除算
Java
import java.math.BigDecimal;

public class BigDecimalSample {
    public static void main(String[] args) {
        // 文字列から生成
        BigDecimal bd1 = new BigDecimal("0.1");
        BigDecimal bd2 = new BigDecimal("0.2");

        // 足し算
        BigDecimal sum = bd1.add(bd2);
        System.out.println("0.1 + 0.2 = " + sum);

        // 掛け算
        BigDecimal product = bd1.multiply(bd2);
        System.out.println("0.1 * 0.2 = " + product);
    }
}
実行結果
0.1 + 0.2 = 0.3
0.1 * 0.2 = 0.02

割り切れない場合の除算（ArithmeticException）

BigDecimal の除算で最も多いトラブルが、割り切れない計算（例: 1 / 3）を行った際に発生する ArithmeticException です。

無限小数を表現しきれないため、Javaは例外をスローして停止します。

これを防ぐには、スケール（小数点以下の桁数）と丸めモードを明示的に指定する必要があります。

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

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

        // 小数点第3位まで求め、4位を四捨五入する
        BigDecimal result = a.divide(b, 3, RoundingMode.HALF_UP);
        System.out.println("10 / 3 = " + result);
    }
}
実行結果
10 / 3 = 3.333

丸めモードには HALF_UP（四捨五入）のほか、CEILING（切り上げ）、FLOOR（切り捨て）などが存在します。

業務要件に合わせて最適なものを選択してください。

計算処理におけるオーバーフローの対策

整数計算（int や long）において、もう一つ注意すべきなのが「オーバーフロー」です。

型が保持できる最大値を超えた計算を行うと、エラーにならずに値が最小値にループしてしまうという性質があります。

オーバーフローの例

例えば、Integer.MAX_VALUE（2,147,483,647）に 1 を足すと、結果は -2,147,483,648 になります。

これは非常に検出しにくいバグとなります。

Java
public class OverflowSample {
    public static void main(String[] args) {
        int max = Integer.MAX_VALUE;
        System.out.println("最大値: " + max);
        System.out.println("最大値 + 1: " + (max + 1));
    }
}
実行結果
最大値: 2147483647
最大値 + 1: -2147483648

Math.addExactによる安全な計算

Java 8以降、オーバーフローを検知して例外を投げてくれる Exact 系のメソッドが Math クラスに追加されました。

安全性が求められる箇所ではこれらを使用するのがベストプラクティスです。

  • Math.addExact(a, b)
  • Math.subtractExact(a, b)
  • Math.multiplyExact(a, b)

これらのメソッドを使用すれば、計算結果が型の範囲を超えた瞬間に ArithmeticException が発生するため、不正なデータがシステムを流れるのを防ぐことができます。

数値の比較方法

計算結果を評価する際、比較演算子（==, >, <）の使い分けにも注意が必要です。

プリミティブ型の比較

int や double などのプリミティブ型は、通常の比較演算子で比較可能です。

ただし、前述の通り double の == 比較は誤差の影響で失敗する可能性が高いため、実務では「差の絶対値が極めて小さいか」で判定することがあります。

BigDecimalの比較

BigDecimal の比較には、equals() メソッドではなく compareTo() メソッドを使用するのが鉄則です。

  • equals(): 値とスケールの両方が一致している必要がある（例: “1.0” と “1.00” は false になる）。
  • compareTo(): 数値としての大きさを比較する（例: “1.0” と “1.00” は 0（等しい）になる）。
Java
import java.math.BigDecimal;

public class CompareSample {
    public static void main(String[] args) {
        BigDecimal b1 = new BigDecimal("1.0");
        BigDecimal b2 = new BigDecimal("1.00");

        System.out.println("equalsの結果: " + b1.equals(b2));
        System.out.println("compareToの結果: " + (b1.compareTo(b2) == 0));
    }
}
実行結果
equalsの結果: false
compareToの結果: true

compareTo は、左辺が大きければ 1、等しければ 0、小さければ -1 を返します。

まとめ

Javaにおける計算処理は、単純な算術演算から高度な精度管理まで多岐にわたります。

開発者は、扱うデータの性質に応じて最適な手法を選択しなければなりません。

基本的な数値計算であれば int や double を使用した四則演算で十分ですが、金融、税務、科学計算などの誤差が許されない領域では、必ず BigDecimal を活用するようにしましょう。

その際、コンストラクタには文字列を渡し、除算では丸めモードを適切に設定することが重要です。

また、大規模なデータを扱う際にはオーバーフローのリスクを考慮し、Math.addExact などの安全なメソッドを導入することも検討してください。

これらの知識を組み合わせることで、堅牢で信頼性の高いJavaプログラムを構築することが可能になります。

計算処理はプログラムの品質を左右する「心臓部」であることを忘れず、慎重に実装を進めていきましょう。