Java doubleとは？使い方・精度・誤差の原因とBigDecimalとの違いを徹底解説

1. Javaのdouble型とは

Javaのdouble型は、小数を扱うための基本的なデータ型です。整数を扱うintやlongとは異なり、doubleは「1.5」「3.14」「0.01」のような小数点を含む数値を表現するために使われます。Javaで数値計算を行う場面では、非常に登場頻度の高い型です。

初心者の方が最初につまずきやすいポイントでもあるため、まずは「doubleがどんな性質を持つ型なのか」を正しく理解することが重要です。

1.1 doubleは「倍精度浮動小数点数」

doubleは、64ビット（8バイト）を使って数値を表現する「倍精度浮動小数点数」です。
この「浮動小数点」という言葉が示す通り、doubleは内部的に近似値として数値を扱います。

そのため、次のような特徴があります。

• 非常に広い範囲の数値を扱える
• 小数点以下を含む計算ができる
• ただし、すべての小数を正確に表現できるわけではない

「正確に表現できない」という点は、後のセクションで詳しく解説しますが、doubleは万能ではないという前提をここで押さえておくと理解が楽になります。

1.2 doubleで扱える数値のイメージ

doubleが扱える数値の範囲は非常に広く、ざっくり言うと次のようなイメージです。

• 非常に小さい数（0.0000000001 など）
• 非常に大きい数（10の300乗レベル）
• 小数点を含む一般的な数値

例えば、次のようなコードはすべてdoubleで扱えます。

double a = 3.14;
double b = 0.1;
double c = 123456789.987;

日常的な数値計算や、物理量・統計データ・座標計算など、「だいたい正確であればよい」計算ではdoubleが標準的に使われます。

1.3 Javaでは小数リテラルは基本的にdouble

Javaでは、小数点を含む数値を書いた場合、特に指定しなければdoubleとして扱われます。

double x = 1.23;   // OK
float  y = 1.23;   // コンパイルエラー

上記の例で、float y = 1.23;がエラーになるのは、1.23がdoubleとして解釈されるためです。
floatとして使いたい場合は、次のように明示的に指定する必要があります。

float y = 1.23f;

この仕様からも分かる通り、Javaでは小数計算の基本はdoubleという位置づけになっています。

1.4 doubleがよく使われる場面

doubleは、次のような場面でよく使われます。

• 割り算の結果を小数で扱いたいとき
• 平均値や割合などの計算
• グラフ描画や座標計算
• 科学技術計算、統計処理

一方で、金額計算や厳密な小数処理には向いていません。
この点については、後半でBigDecimalとの使い分けとして詳しく説明します。

1.5 最初に覚えておきたいポイント

ここまでの内容を、初心者向けに整理すると次の通りです。

• doubleは小数を扱うための基本型
• 内部的には「近似値」で計算される
• Javaでは小数はデフォルトでdouble
• 精度が必要な場面では注意が必要

2. doubleの範囲と精度（有効桁数の目安）

double型を理解するうえで避けて通れないのが、**「どこまで正確に数値を扱えるのか」**という問題です。
ここでは、doubleの数値範囲と精度、有効桁数の考え方を初心者向けに整理します。

2.1 doubleが扱える数値の範囲

doubleは64ビットで数値を表現するため、非常に広い範囲の数値を扱えます。

イメージとしては次のような範囲です。

• 非常に小さい数：
  例）4.9 × 10^-324 付近まで
• 非常に大きい数：
  例）1.8 × 10^308 付近まで

普段のプログラミングで、この上限や下限を意識することはほとんどありません。
日常的な計算では「ほぼ無限に近い範囲を扱える」と考えて問題ないでしょう。

2.2 有効桁数はおおよそ15〜17桁

doubleの精度を考える際に重要なのが有効桁数です。

doubleでは、およそ15〜17桁分の数字が正確に保持できるとされています。

例えば、次のような数値を考えてみます。

double a = 123456789012345.0;
double b = 1234567890123456.0;

• a（15桁）は正確に表現できる
• b（16桁以上）は、下位の桁が丸められる可能性がある

つまり、桁数が増えるほど細かい部分の正確さは失われていくということです。

2.3 「精度が高い」＝「小数が正確」ではない

ここで初心者が誤解しやすい点があります。

doubleは精度が高い
→ 小数も正確に扱える

これは必ずしも正しくありません。

doubleは確かに精度の高い型ですが、それは
「ある程度の桁数まで、近似値として正確」
という意味です。

例えば、次のような計算を行うとします。

double x = 0.1 + 0.2;
System.out.println(x);

多くの人が 0.3 を期待しますが、実際には

0.30000000000000004

のような結果になることがあります。

これはバグではなく、doubleの仕様です。
理由は、0.1 や 0.2 が2進数では正確に表現できないためです。

2.4 なぜ有効桁数の話が重要なのか

有効桁数を理解していないと、次のような問題に直面します。

• 計算結果が微妙にズレる
• == で比較したら一致しない
• 合計や平均で誤差が蓄積する

これらはすべて、doubleが近似値を扱う型であることに起因します。

逆に言えば、

• グラフ表示
• 物理シミュレーション
• 統計処理

のように、「完全一致」よりも「現実的な精度」が重要な分野では、doubleは非常に優秀です。

2.5 範囲と精度を踏まえた正しい理解

ここまでをまとめると、次のように整理できます。

• doubleは非常に広い範囲の数値を扱える
• 有効桁数は約15〜17桁
• 小数は近似値として扱われる
• 精度が必要な用途では注意が必要

3. doubleとfloatの違い（どっちを使う？）

Javaで小数を扱う際、必ずと言っていいほど比較されるのがdoubleとfloatです。
どちらも小数を扱う型ですが、精度・用途・扱いやすさに大きな違いがあります。

このセクションでは、初心者が迷わないための判断基準を中心に解説します。

3.1 floatとdoubleの基本的な違い

まずは、両者の違いをシンプルに整理しましょう。

この表から分かる通り、精度はdoubleの方が圧倒的に高いです。

3.2 なぜJavaではdoubleが標準なのか

Javaでは、小数リテラル（1.23など）はデフォルトでdoubleとして扱われます。
これは、次の理由によります。

• 現代のCPUでは、doubleの計算コストがほぼ問題にならない
• 精度不足によるバグの方が深刻
• 可読性・安全性の観点でdoubleが有利

そのため、特別な理由がなければdoubleを使うというのが、Javaにおける一般的な考え方です。

3.3 floatを使うべきケース

では、floatは不要なのでしょうか。
答えは「用途次第では有効」です。

floatが選ばれる代表的なケースは次の通りです。

• メモリ使用量を極端に抑えたい場合
• 大量の数値データを扱う配列や画像処理
• ゲーム開発や3D計算などで精度より速度を優先する場合

ただし、業務系アプリケーションやWebアプリでは、
floatを使う必然性はほとんどありません。

3.4 初心者が迷ったときの結論

初心者の方が「どっちを使えばいいか分からない」と感じた場合は、
次のルールを覚えておくと安心です。

• 迷ったら double
• メモリや性能に強い制約があるときだけ float

特に学習段階では、float特有の精度問題に悩まされるより、
doubleでシンプルに理解を進める方が効率的です。

3.5 doubleとfloatの違いを理解する意味

この違いを理解しておくと、次のような場面で役立ちます。

• 他人のコードを読んだときに意図が分かる
• 不要な精度低下を防げる
• 数値計算に関するバグを未然に防げる

4. doubleの基本的な使い方（宣言・計算・出力）

ここからは、実際のコードを使ってdoubleの基本的な使い方を確認していきます。
「宣言 → 計算 → 出力」という流れを押さえれば、doubleの基本操作は一通り理解できます。

4.1 doubleの宣言と代入

doubleは、他の基本型と同じように宣言します。

double x = 1.5;
double y = 2.0;

小数点を含む数値を代入する場合、特別な指定は不要です。
整数値を代入することもできますが、その場合は自動的にdoubleへ変換されます。

double a = 10;   // 10.0 として扱われる

4.2 四則演算の基本

doubleは、加算・減算・乗算・除算といった四則演算をそのまま行えます。

double a = 5.0;
double b = 2.0;

double sum = a + b;      // 加算
double diff = a - b;     // 減算
double product = a * b;  // 乗算
double quotient = a / b; // 除算

結果はいずれもdoubleとなり、小数を含む計算結果を自然に扱えます。

4.3 割り算で注意すべきポイント

doubleの割り算は、どちらか一方でもdoubleであれば小数計算になるという点が重要です。

double result1 = 1 / 2;    // 結果は 0.0
double result2 = 1 / 2.0;  // 結果は 0.5

1 / 2 はどちらも整数のため、整数除算が行われてしまいます。
これを避けるためには、次のようにします。

• 片方をdoubleにする
• 明示的にキャストする

double result = (double) 1 / 2;

4.4 計算結果の出力

計算結果は、System.out.println()でそのまま出力できます。

double value = 3.14159;
System.out.println(value);

ただし、そのまま出力すると、
必要以上に桁が表示されることがあります。

4.5 表示桁数を指定して出力する

表示を整えたい場合は、printfを使うと便利です。

double value = 3.14159;
System.out.printf("%.2f%n", value);

この例では、小数点以下2桁まで表示されます。

• %.2f：小数点以下2桁
• %n：改行

ユーザー向けの表示では、必ず桁数を制御することをおすすめします。

4.6 doubleを使った計算の基本まとめ

このセクションで押さえておきたいポイントは次の通りです。

• doubleは自然に小数計算ができる
• 整数同士の割り算には注意
• 出力時は表示桁数を意識する

5. よくある落とし穴1：誤差が出る理由

doubleを使い始めた多くの人が最初に戸惑うのが、
「計算結果が直感と一致しない」という現象です。

これはJavaの不具合ではなく、doubleという型の本質的な仕様によるものです。

5.1 代表的な誤差の例

まずは、非常によく知られた例を見てみましょう。

double x = 0.1 + 0.2;
System.out.println(x);

多くの人は 0.3 が表示されると期待しますが、実際には次のような結果になることがあります。

0.30000000000000004

この結果を見て「計算がおかしい」「バグでは？」と感じるかもしれません。
しかし、これはdoubleとしては正しい結果です。

5.2 なぜこのような誤差が起きるのか

理由は、doubleが2進数で数値を表現していることにあります。

人間が普段使っているのは10進数ですが、コンピュータ内部では2進数が使われます。
このとき問題になるのが、次の点です。

• 10進数の小数の多くは、2進数で有限桁で表現できない
• そのため、内部では最も近い近似値が使われる

0.1 や 0.2 は、2進数では割り切れないため、
内部では「限りなく近い別の数」として保持されます。

その近似値同士を足した結果が、
0.30000000000000004 という形で表に出てきているのです。

5.3 誤差は必ず発生する前提で考える

ここで重要なのは、

doubleでは誤差は避けられない

という前提を持つことです。

誤差は次のような場面で特に目立ちます。

• 加算や減算を何度も繰り返したとき
• 割り算を含む計算
• 小数第何位まで正確である必要がある場合

つまり、doubleは「完全に正確な小数」を扱うための型ではありません。

5.4 誤差が問題にならないケース

一方で、誤差がほとんど問題にならないケースも多く存在します。

例えば次のような用途です。

• グラフ描画やアニメーション
• センサー値や統計データ
• 科学技術計算
• ゲームやシミュレーション

これらは「絶対値が完全一致すること」よりも、
現実的な精度で計算できることが重要です。

そのような場面では、doubleは非常に優秀な型です。

5.5 誤差とどう向き合うべきか

誤差を完全になくそうとすると、設計が破綻します。
大切なのは、次の考え方です。

• 誤差は「発生するもの」として受け入れる
• 比較や判定の方法を工夫する
• 誤差が許されない計算では別の手段を使う

6. よくある落とし穴2：double同士の比較は「==」が危険

doubleの誤差を理解したあと、次に必ず直面するのが
「比較がうまくいかない問題」です。

初心者がやりがちなのが、== を使って数値を比較してしまうケースです。

6.1 「==」で比較すると何が起きるのか

次のコードを見てください。

double a = 0.1 + 0.2;
double b = 0.3;

System.out.println(a == b);

直感的には true になりそうですが、実際には false になることがあります。
これは、前のセクションで説明した誤差が原因です。

• a は 0.30000000000000004 に近い値
• b は 0.3 を表す別の近似値

この2つは、ビットレベルでは一致していないため、== では一致しません。

6.2 double比較の基本ルール

ここで覚えておくべき大原則があります。

double同士を「完全一致」で比較してはいけない

== は「数値が近いか」ではなく、
内部表現が完全に同じかどうかを比較します。

そのため、浮動小数点数には不向きです。

6.3 許容誤差（epsilon）で比較する

double同士を比較する場合は、
「どれくらい近ければ同じとみなすか」
という基準を設けます。

これを**許容誤差（epsilon）**と呼びます。

double a = 0.1 + 0.2;
double b = 0.3;

double epsilon = 1e-9;

if (Math.abs(a - b) < epsilon) {
    System.out.println("ほぼ等しい");
}

この方法では、

• 差の絶対値が十分に小さい
• 実用上、同じ値とみなせる

という判断ができます。

6.4 epsilonの値はどう決める？

初心者が迷いやすいのが、
「epsilonはどれくらいにすればいいのか？」という点です。

考え方はシンプルです。

• 扱う数値のスケール
• 許容できる誤差の大きさ

これによって決めます。

一般的な目安としては、

• 1e-9：多くの計算で無難
• 1e-12：かなり厳密
• 1e-6：表示や概算向け

絶対的な正解はありません。
用途に応じて決めることが重要です。

6.5 BigDecimalとの考え方の違い

ここで少し先取りしておくと、

• double：誤差を許容して扱う
• BigDecimal：誤差を許さない設計

という思想の違いがあります。

「比較が面倒だ」と感じる場合は、
そもそもdoubleを使うべきかどうかを再検討するサインでもあります。

6.6 比較に関するポイントまとめ

このセクションの要点を整理します。

• == は使わない
• 差の絶対値で比較する
• 許容誤差は用途次第
• 厳密さが必要なら別の型を検討

7. よくある落とし穴3：整数除算で結果が0になる

doubleを使っているのに、なぜか計算結果が0になる。
これは初心者が非常によく遭遇するミスのひとつです。

原因はシンプルで、計算の途中が「整数同士の演算」になっていることです。

7.1 なぜ整数除算が発生するのか

Javaでは、演算に使われる型によって計算方法が決まります。
次のコードを見てください。

double result = 1 / 2;
System.out.println(result);

結果は次のようになります。

0.0

理由は、1 と 2 がどちらも int であるため、
最初に整数除算が行われ、その結果（0）がdoubleに代入されるからです。

7.2 正しく小数として計算する方法

整数除算を避ける方法は、とても簡単です。
どちらか一方をdoubleにするだけで、小数計算になります。

double result1 = 1 / 2.0;
double result2 = 1.0 / 2;
double result3 = (double) 1 / 2;

いずれも結果は次の通りです。

0.5

7.3 実務でよくあるミス例

次のようなコードは、業務でもよく見かけます。

int total = 5;
int count = 2;

double average = total / count;

一見すると正しそうですが、結果は 2.0 になります。
正しく平均値を求めるには、次のように書く必要があります。

double average = (double) total / count;

7.4 初心者が覚えておくべきルール

この問題を防ぐために、次のルールを覚えておきましょう。

• 割り算では 型を必ず意識する
• 整数同士の計算は整数になる
• 結果をdoubleで受けても途中が整数なら意味がない

7.5 整数除算の落とし穴まとめ

• 原因は「計算順序」と「型」
• doubleを使うなら、計算の最初からdoubleにする
• 平均・割合・比率の計算では特に注意

8. 文字列とdoubleの変換（実務で最も使う）

実務では、doubleを直接コードに書くよりも、
文字列（String）から数値に変換する場面の方が圧倒的に多くなります。

例えば次のようなケースです。

• フォーム入力値
• CSV・JSONファイル
• 設定ファイル
• APIレスポンス

このセクションでは、String と double の相互変換を、安全に行う方法を解説します。

8.1 Stringをdoubleに変換する方法

8.1.1 Double.parseDouble()

最も基本的でよく使われる方法です。

String text = "3.14";
double value = Double.parseDouble(text);

数値として正しい文字列であれば、問題なく変換できます。

8.1.2 変換できない場合の例外に注意

文字列が数値として不正な場合、例外が発生します。

String text = "abc";
double value = Double.parseDouble(text); // 例外発生

この場合、NumberFormatException がスローされます。
そのため、実務では必ず try-catch とセットで使います。

try {
    double value = Double.parseDouble(text);
} catch (NumberFormatException e) {
    // エラー処理
}

8.2 Double.valueOf()との違い

Double.valueOf() も文字列を数値に変換するメソッドです。

Double value = Double.valueOf("3.14");

違いは次の通りです。

• parseDouble → primitive の double を返す
• valueOf → ラッパークラスの Double を返す

通常の数値計算では parseDouble を使えば十分です。
コレクション（List<Double> など）で扱う場合は valueOf が使われます。

8.3 doubleをStringに変換する方法

逆に、double を文字列に変換するケースもよくあります。

double value = 3.14;
String text = String.valueOf(value);

または、次の方法も一般的です。

String text = Double.toString(value);

どちらも安全で、用途に応じて使い分ければ問題ありません。

8.4 表示用の文字列はフォーマットを使う

ユーザーに見せる数値の場合は、
必ず表示用フォーマットを使いましょう。

double value = 3.14159;
String text = String.format("%.2f", value);

この例では、小数点以下2桁で整形されます。

8.5 文字列変換のポイントまとめ

• 入力値は常に例外を想定する
• 内部計算用と表示用は分けて考える
• 表示時は必ず桁数を制御する

次のセクションでは、
double特有の値である NaN と Infinity について解説します。
これを知らないと、原因不明の不具合に悩まされることがあります。

9. Doubleクラスで知っておきたい特別な値（NaN / Infinity）

doubleには、通常の数値とは異なる特別な値が存在します。
これらを理解しておかないと、デバッグが非常に困難になります。

9.1 NaN（Not a Number）とは

NaN は「数値ではない」ことを表します。
例えば、次のような計算で発生します。

double value = 0.0 / 0.0;
System.out.println(value);

出力結果は次の通りです。

NaN

9.2 Infinity（無限大）とは

割り算の結果が無限大になる場合、Infinity が使われます。

double value = 1.0 / 0.0;
System.out.println(value);

結果は次のようになります。

Infinity

マイナスの場合は -Infinity になります。

9.3 NaNやInfinityの判定方法

これらの値は、== では正しく判定できません。
必ず専用メソッドを使います。

double value = 0.0 / 0.0;

if (Double.isNaN(value)) {
    System.out.println("NaNです");
}

if (Double.isInfinite(value)) {
    System.out.println("無限大です");
}

9.4 なぜ判定が重要なのか

NaNやInfinityは、そのまま計算を続けると、

• 結果がすべてNaNになる
• 異常値が画面に表示される
• ロジックが破綻する

といった問題を引き起こします。

異常値は早めに検知することが重要です。

10. 金額計算や厳密な計算はBigDecimalを使う

ここまで見てきた通り、doubleは非常に便利ですが、
誤差を完全に避けることはできません。

そのため、次のような用途では不向きです。

• 金額計算
• ポイント・残高管理
• 厳密な四捨五入が必要な処理

10.1 BigDecimalとは何か

BigDecimalは、10進数を正確に扱えるクラスです。
誤差を許さない設計になっています。

BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");

BigDecimal result = a.add(b);
System.out.println(result); // 0.3

10.2 BigDecimal使用時の重要な注意点

doubleから直接生成すると、誤差を引き継いでしまいます。

new BigDecimal(0.1); // 非推奨

必ず 文字列から生成してください。

new BigDecimal("0.1"); // 正しい

10.3 doubleとBigDecimalの使い分け

• 計算速度・扱いやすさ重視 → double
• 正確性最優先 → BigDecimal

無理にどちらかに統一するのではなく、
用途に応じて使い分けることが大切です。

11. まとめ：Javaのdoubleを正しく使うために

最後に、この記事のポイントを整理します。

• doubleはJavaで最も基本的な小数型
• 誤差は仕様であり、避けられない
• 比較には許容誤差を使う
• 整数除算に注意する
• 厳密な計算にはBigDecimalを使う

doubleの特性を正しく理解すれば、
数値計算に対する不安は大きく減ります。

12. よくある質問（FAQ）

Q1. Javaのdoubleは何桁まで正確ですか？

約15〜17桁の有効桁数を持ちます。ただし、小数は近似値として扱われます。

Q2. doubleとfloatはどちらを使うべきですか？

特別な理由がなければdoubleを使うのが一般的です。

Q3. 金額計算にdoubleを使ってはいけませんか？

推奨されません。BigDecimalを使うのが安全です。

Q4. doubleの比較に「==」は使えますか？

使うべきではありません。許容誤差を使って比較してください。

Q5. NaNやInfinityはどう扱えばいいですか？

Double.isNaN() や Double.isInfinite() で判定し、早めに処理してください。