Deep Java

Javaで小数点を切り捨てる方法まとめ｜Math.floor・キャスト・BigDecimalの違いと使い分け

データ操作・コレクション（標準ライブラリ関連）
目次

1. Javaで「小数点を切り捨てる」とは？

Javaで「小数点を切り捨てる」と言うと、多くの場合は 小数点以下を消して整数にする、または 小数第n位以降を捨てる ことを指します。
ただし実務では「切り捨て」の意味が1種類ではないため、最初に結論を整理します。

1.1 切り捨て＝floor？キャスト？（用語の整理）

「切り捨て」には主に次の2パターンがあります。

  • (A) 0方向への切り捨て（truncate）
    小数点以下を消すが、負の数では「0に近づく」
    例：3.9 → 3、-3.9 → -3
    → Javaでは キャスト(int) がこの挙動になります
  • (B) -∞方向への切り捨て（floor）
    数直線で下方向（小さい方向）へ寄せる
    例：3.9 → 3、-3.9 → -4
    → Javaでは Math.floor() がこの挙動になります

初心者が混乱しやすいのは、正の数だけを見ると(A)も(B)も同じ結果になることです。
しかし、負の数を扱う瞬間に結果がズレます。

1.2 この記事で解決できること（用途別に最短ルート）

「java 小数点 切り捨て」で検索する人の目的は、ほぼ次のどれかです。

  • 整数にしたいだけ（例：3.14 → 3）
    → キャスト (int) が最短。ただし負の数は注意
  • 小数第2位で切り捨てたい（例：1.239 → 1.23）
    → Math.floor(x * 100) / 100 も可能
    → ただし 誤差が困るなら BigDecimal が安全
  • 金額・請求・レートなど、誤差が許されない計算をしたい
    → BigDecimal + setScale + RoundingMode を推奨

用途を間違えると「一見動くけど後で壊れる」形になりやすいです。
特に double（小数）計算は誤差が出ることがあるため、金額系は最初からBigDecimalで設計する方が安全です。

1.3 つまずきポイント・注意点（最初に潰す）

よくある失敗は次の3つです。

  • (int)は常にfloorだと思い込む
    → 実際は「0方向」なので、負の数でズレます
  • 小数第n位切り捨てで Math.floor を使ったのに、微妙にズレる
    → double の誤差が原因（環境や値により異なる）
  • 表示の整形（DecimalFormatなど）を計算に使う
    → 見た目は変わっても内部の値は変わらないことがあります

まずは「整数にするだけならキャスト」という最短手段を確認し、次に「負の数の罠」を理解するのが安全です。

次章では、最短で使われる (int)キャストによる切り捨て を具体例つきで解説します。

2. intにしたいだけなら「キャスト」でOK（ただし注意あり）

小数点以下を消して 整数（int）にしたいだけなら、Javaでは キャスト（型変換） が最短です。
ただし、キャストは「数学的な切り捨て（floor）」ではなく、0方向への丸め（truncate）になる点が重要です。

2.1 (int)で小数点以下を切り捨てる基本

double や float を int に変換すると、小数点以下が落ちます。

double x = 3.99;
int a = (int) x;
System.out.println(a); // 3

これは「小数点以下を切り捨てたい」という検索意図に対して、最もシンプルな答えです。

手順としては次の通りです。

  • 変換したい数値が double / float であることを確認
  • (int) を付けて int へキャストする
  • 結果が期待通りか、負の数も含めて確認する

2.2 注意：キャストは「0方向への丸め」（負の数でズレる）

初心者が一番ハマるのがここです。
キャストは「常に小さい方へ落とす」わけではありません。

System.out.println((int) 3.9);   // 3
System.out.println((int) -3.9);  // -3

負の数の -3.9 が -4 にならず -3 になるのは、キャストが 0に近づく方向に変換する仕様だからです。

  • 3.9 → 3（0に近づく）
  • -3.9 → -3（0に近づく）

もし「数学的に切り捨て（floor）」をしたいなら、キャストではなく Math.floor() が必要です。
ここを理解していないと、例えば「損益計算」「手数料計算」「座標計算」などで、マイナス側だけ結果がズレる事故が起きます。

2.3 よくある失敗：四捨五入だと思い込む／負の数で事故る

キャストは四捨五入ではありません。
次のように「0.9だから1になる」と思うと失敗します。

System.out.println((int) 0.9);  // 0
System.out.println((int) 1.9);  // 1

また、負の数が絡むと「切り捨てたのに増えた／減った」のように感じることがあります。

  • -3.9 → -3 は、数直線的には 大きい方（増える方向）へ動いています
  • 期待が -4 なら、これは完全にバグになります

対策はシンプルです。

  • 正の数しか扱わない → キャストでOK
  • 負の数もあり得る → Math.floor() を検討する
  • 金額など厳密性が必要 → BigDecimal を検討する

次章では、負の数でも「切り捨て」を数学通りに行える Math.floor() / Math.ceil() を解説します。

3. 小数点以下を確実に切り捨てるなら Math.floor / Math.ceil を使う

「切り捨て」を 数学的に正しく行いたい場合は、キャストではなく Math.floor() を使うのが基本です。
特に、負の数が入り得る処理では Math.floor() を選ぶだけで事故が減ります。

3.1 Math.floor()で切り捨て（床関数）

Math.floor() は 床関数（floor） と呼ばれ、数直線上で 下方向（小さい方向）に丸めます。

System.out.println(Math.floor(3.9));   // 3.0
System.out.println(Math.floor(-3.9));  // -4.0

ポイントは次の通りです。

  • 3.9 → 3.0（小さい方へ）
  • -3.9 → -4.0（さらに小さい方へ）

「負の数でも切り捨てがズレない」ことが最大のメリットです。

つまずきポイントとして、Math.floor() は 戻り値がdouble になる点があります。
整数が欲しい場合は、後で型変換が必要です。

3.2 Math.ceil()は切り上げなので混同注意

Math.ceil() は Math.floor() の逆で、数直線上で 上方向（大きい方向）に丸めます。

System.out.println(Math.ceil(3.1));   // 4.0
System.out.println(Math.ceil(-3.1));  // -3.0

ここでよくある失敗は、次のような混同です。

  • 「小数点以下を消したい」＝ ceil だと思ってしまう
    → 実際には 切り上げなので、意図と逆になることが多いです

基本的に「切り捨て」で検索している場合、使うのは floor が中心です。

3.3 long/intに変換する時の型変換の注意点

Math.floor() の結果を int や long にしたい場合は、キャストします。

double x = -3.9;

int a = (int) Math.floor(x);
System.out.println(a); // -4

ただし注意点があります。

  • Math.floor() の結果は double
  • int へキャストすると 小数点以下は消える（この時点ではズレない）
  • ただし値が大きすぎると int に収まらない可能性がある

安全寄りにするなら、まず long を使う選択もあります。

double x = 12345678901.9;

long b = (long) Math.floor(x);
System.out.println(b); // 12345678901

よくある失敗・注意点は次の通りです。

  • (int)Math.floor(x) を忘れて double のまま扱ってしまう
  • floorとキャストの違いを理解せず、負の数でバグる
  • intの範囲超えで値が壊れる（オーバーフロー）

結論として、負の数が絡む可能性があるなら、最初から Math.floor() を基準に設計するのが安全です。

次章では、実務で特に多い「小数第2位で切り捨て」など 小数点第n位で切り捨てる方法を具体例で解説します。

4. 「小数点第n位で切り捨て」する方法（表示・計算で頻出）

「小数点以下を全部消す」だけでなく、実務では 小数第2位まで残して、それ以降を切り捨てたいケースが非常に多いです。
例：税率、レート、単価、パーセンテージ計算など。

ここでは「小数第n位で切り捨て」を すぐ使える形で整理します。
ただし double を使う場合は誤差が出ることがあるため、注意点もセットで押さえます。

4.1 基本：10^n倍して floor して戻す（定番パターン）

最もよくある方法は、次の手順です。

  1. 切り捨てたい桁数 n を決める
  2. 10^n を掛けて整数っぽくする
  3. Math.floor() で切り捨て
  4. 10^n で割って元に戻す

小数第2位で切り捨てたい場合（例：1.239 → 1.23）はこう書けます。

double x = 1.239;
double y = Math.floor(x * 100) / 100;
System.out.println(y); // 1.23

小数第3位で切り捨てたい場合（例：1.2399 → 1.239）はこうです。

double x = 1.2399;
double y = Math.floor(x * 1000) / 1000;
System.out.println(y); // 1.239

この方法のメリットは次の通りです。

  • コードが短い
  • Math.floor() を使うため、負の数でも「切り捨て」の意味がブレにくい
  • ライブラリ追加不要

一方で、double の誤差が絡むため、金額などの厳密な計算には不向きです。

4.2 つまずきポイント：doubleの誤差で想定とズレる例

Javaの double は 浮動小数点数（ふどうしょうすうてんすう）で、0.1や0.01のような値を 完全に正確に表現できないことがあります。
そのため、次のような「意味不明なズレ」が起きることがあります（値や環境により見え方は異なります）。

  • 本当は 1.29 にしたいのに 1.28 になったように見える
  • 0.3 を扱っているのに 0.299999999... が内部に残る

たとえば、次のような処理は「理屈では正しそう」に見えます。

double x = 1.29;
double y = Math.floor(x * 100) / 100;
System.out.println(y);

しかし、内部では x * 100 が 128.999999999... のように表現される可能性があり、floor が 128 を返してしまうと 1.28 になります。
これはバグというより 浮動小数点の仕様です。

このタイプの失敗は「たまにしか起きない」ため、運用で発覚しやすいのが厄介です。

4.3 BigDecimalで「小数n桁切り捨て」を安全にやる（推奨）

小数第n位切り捨てを 確実にやりたいなら、BigDecimal を使うのが安全です。
BigDecimalは 10進数を正確に扱えるクラスで、金額計算などで標準的に使われます。

基本形はこれです。

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

BigDecimal x = new BigDecimal("1.239");
BigDecimal y = x.setScale(2, RoundingMode.DOWN); // 小数第2位で切り捨て
System.out.println(y); // 1.23

ポイントは次の2つです。

  • setScale(2, ...) で「小数第2位まで残す」
  • RoundingMode.DOWN で「0方向への切り捨て（truncate）」を指定する

注意点として、BigDecimalの「DOWN」は Math.floor() と同じではありません。
負の数では挙動が変わることがあるため、負の値も扱うなら後述の FLOOR も検討対象になります。

よくある失敗は次の通りです。

  • new BigDecimal(1.239) のように doubleから作って誤差を持ち込む
  • setScale を忘れて「切り捨てできていない」
  • 丸めモードを間違えて「四捨五入」になってしまう

結論として、表示目的だけならMath.floor方式でも十分なことがありますが、
計算結果が重要ならBigDecimalが無難です。

次章では、BigDecimalを使った切り捨てを「正しい生成方法」から含めて、実務向けに詳しく解説します。

5. BigDecimalで切り捨てる（金融・請求・レート計算はこれが安全）

小数点の切り捨てを「正確さ最優先」で行うなら、Javaでは BigDecimal が第一候補です。
double は高速ですが誤差が混入しやすく、金額・請求・手数料・レートなどでは後から問題になりがちです。
BigDecimalは 10進数を人間の感覚に近い形で扱えるため、業務コードでもよく使われます。

5.1 BigDecimalの基本：doubleから作ると危険（最重要）

BigDecimalでよくある失敗が「作り方」です。
次のように double を直接渡すと、内部の誤差がそのまま入る可能性があります。

import java.math.BigDecimal;

BigDecimal a = new BigDecimal(0.1);
System.out.println(a); // 0.10000000000000000555... のようになることがある

この状態で切り捨てや計算をすると、「なぜかズレる」原因になります。

安全な作り方は次のどちらかです。

(A) 文字列から作る（最も分かりやすい）

BigDecimal a = new BigDecimal("0.1");

(B) BigDecimal.valueOf(double) を使う（推奨されることが多い）

BigDecimal a = BigDecimal.valueOf(0.1);

初心者向けの結論としては、迷ったら 文字列で作るのが安全です。

5.2 小数点n桁で切り捨て：RoundingMode.DOWN

小数第n位で切り捨てたい場合は setScale を使います。

  • setScale(2, ...) → 小数第2位まで残す
  • RoundingMode.DOWN → 0方向へ切り捨て（truncate）
import java.math.BigDecimal;
import java.math.RoundingMode;

BigDecimal x = new BigDecimal("123.4567");
BigDecimal y = x.setScale(2, RoundingMode.DOWN);

System.out.println(y); // 123.45

「小数点以下を切り捨てて整数にしたい」場合も同様です。

BigDecimal x = new BigDecimal("123.999");
BigDecimal y = x.setScale(0, RoundingMode.DOWN);

System.out.println(y); // 123

ここでの注意点は、setScale は 桁数を指定して丸める操作であり、
「表示を整えるだけ」ではなく 値そのものが変わるという点です。

5.3 0方向の切り捨てと、floor方向の切り捨ての違いに注意

BigDecimalの丸めモードは複数あり、「切り捨てっぽいもの」が2種類あるのが落とし穴です。

  • RoundingMode.DOWN：0方向への切り捨て
    • 3.9 → 3
    • -3.9 → -3
  • RoundingMode.FLOOR：-∞方向への切り捨て（数学のfloor）
    • 3.9 → 3
    • -3.9 → -4

負の値も含めて「常に小さい方へ落としたい」なら FLOOR が候補です。

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

BigDecimal x1 = new BigDecimal("-3.9");
System.out.println(x1.setScale(0, RoundingMode.DOWN));  // -3
System.out.println(x1.setScale(0, RoundingMode.FLOOR)); // -4

「どちらが正しいか」は用途次第です。

  • 単純に桁を落とす（truncate） → DOWN
  • 数学的な切り捨て（floor） → FLOOR

ここを曖昧にすると、マイナス値が出た瞬間に結果が変わり、仕様事故になります。

5.4 よくある失敗

BigDecimalの切り捨てで多いミスをまとめます。

  • doubleからBigDecimalを作って誤差を混入させる
    → new BigDecimal(0.1) は避け、文字列 or valueOfを使う
  • setScaleの桁数を間違える
    → 2桁のつもりで0桁にしてしまう等
  • 丸めモードを間違える
    → DOWN/FLOORを混同して負の数でズレる
  • 「表示だけ」のつもりで値を変えてしまう
    → setScaleは値を変える操作なので、用途を分ける

結論として、金額・請求・レートなど「1円でもズレたら困る」領域では、
BigDecimalを使って 生成方法＋丸めモードまで固定するのが安全です。

次章では、DecimalFormatやString.formatなどの「表示用の整形」と、計算の切り捨てを混同しないための考え方を解説します。

6. DecimalFormat / String.format は「表示用」（計算用に使わない）

小数点の切り捨ては「計算として切り捨てたい」のか、「表示だけ整えたい」のかで、使う手段が変わります。
ここを混同すると、見た目は正しいのに内部の値がズレている状態になり、後でバグになります。

結論として、DecimalFormat や String.format は 表示用です。
計算結果を正確に切り捨てたい場合は、BigDecimal や Math.floor() を使うべきです。

6.1 DecimalFormatで小数桁を整える（切り捨て設定も可能）

DecimalFormat は数値を文字列に整形するためのクラスです。
例えば「小数第2位まで表示したい」という目的で使います。

import java.text.DecimalFormat;

double x = 1.239;

DecimalFormat df = new DecimalFormat("0.00");
System.out.println(df.format(x)); // 1.24 のようになることがある（丸め）

ここで重要なのは、format() の戻り値は String（文字列） であり、
数値としての x が変わるわけではない点です。

また、DecimalFormatは丸め方（RoundingMode）を指定できます。
切り捨て表示にしたい場合は次のようにします。

import java.text.DecimalFormat;
import java.math.RoundingMode;

double x = 1.239;

DecimalFormat df = new DecimalFormat("0.00");
df.setRoundingMode(RoundingMode.DOWN);

System.out.println(df.format(x)); // 1.23

ただし、これは 表示が1.23になるだけで、x の値自体は変わりません。

6.2 String.formatで整形する場合の注意点

String.format はフォーマット指定で表示を整えられます。

double x = 1.239;
System.out.println(String.format("%.2f", x)); // 1.24 のように四捨五入される

多くのケースで String.format("%.2f", x) は 四捨五入寄りの結果になります。
「切り捨て表示」には向かないことが多いので、目的に合わないなら避ける方が安全です。

初心者がやりがちな失敗は、次のように「表示を整えた文字列」を数値に戻して計算してしまうことです。

double x = 1.239;
String s = String.format("%.2f", x); // "1.24"
double y = Double.parseDouble(s);    // 1.24

// この時点で、切り捨てではなく丸めが入った値で計算してしまう

この流れは、計算ロジックに「表示の都合」を混ぜることになり、後から仕様変更にも弱くなります。

6.3 つまずきポイント：表示が合っても内部値は変わらない

表示系で一番危険なのは、「画面に正しく見えるからOK」と判断してしまうことです。

  • DecimalFormat / String.format は 見せ方を変える
  • Math.floor / BigDecimal.setScale は 値を変える

この区別を間違えると、例えば次のような事故が起きます。

  • 画面では「1.23円」なのに、内部計算では「1.239円」のまま合計される
  • 端数処理のタイミングがズレて、請求合計が一致しない
  • 表示用の丸めが計算に混ざり、監査や検算で差が出る

判断基準としてはシンプルです。

  • 表示だけ整えたい → DecimalFormat（またはUI側の表示設定）
  • 計算結果として切り捨てたい → BigDecimal / Math.floor

次章では「結局どれを使えばいいのか」を迷わず選べるように、用途別のベストプラクティス早見表を提示します。

7. 用途別のベストプラクティス早見表

「Java 小数点 切り捨て」は、方法が複数あるせいで迷いやすいテーマです。
ここでは 用途 → 最適解 を固定して、読者が最短で選べるようにします。

7.1 intにしたい（正の数だけ）→ キャストでOK

「小数点以下を消して int にしたい」だけで、かつ 負の数が絶対に出ないなら、キャストが最短です。

double x = 12.99;
int y = (int) x;
System.out.println(y); // 12

注意点は次の通りです。

  • キャストは 0方向への丸め
  • 正の数だけなら、見た目は「切り捨て」と同じになる
  • 負の数が混ざる可能性があるなら、ここで決め打ちしない

7.2 負の数も含めて切り捨てたい → Math.floor

「数学的に切り捨てたい（floor）」なら Math.floor() が正解です。
負の数が出る可能性がある処理では、キャストより安全です。

double x = -3.9;
int y = (int) Math.floor(x);
System.out.println(y); // -4

よくある注意点：

  • Math.floor() の戻り値は double
  • int や long にしたいならキャストが必要
  • 値が大きい場合は int の範囲に注意

7.3 小数第n位で切り捨てたい（厳密）→ BigDecimal + setScale

「小数第2位で切り捨て」などを 誤差なしでやりたいなら、BigDecimalが安全です。

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

BigDecimal x = new BigDecimal("1.239");
BigDecimal y = x.setScale(2, RoundingMode.DOWN);

System.out.println(y); // 1.23

この方法が向いているケース：

  • 金額（円、ドル）
  • 請求、税計算
  • レート計算で誤差が許されない
  • 「必ず同じ結果」が求められるバッチ処理

つまずきポイント：

  • new BigDecimal(0.1) のように doubleから作らない
  • DOWNとFLOORの違いを理解する（負の数で差が出る）

7.4 表示だけ整えたい → DecimalFormat（計算には使わない）

表示だけ小数2桁にしたいなら、DecimalFormatが便利です。
ただし 計算値は変わらないので、計算用として使わないのが原則です。

import java.text.DecimalFormat;
import java.math.RoundingMode;

double x = 1.239;

DecimalFormat df = new DecimalFormat("0.00");
df.setRoundingMode(RoundingMode.DOWN);

System.out.println(df.format(x)); // "1.23"

注意点：

  • 返り値は String
  • 表示用と計算用の処理を混ぜると事故る

ここまでの結論を一言でまとめると次の通りです。

  • 速さと簡単さ → キャスト
  • 負の数も正しく切り捨て → Math.floor
  • 正確さ最優先（実務） → BigDecimal
  • 見た目だけ → DecimalFormat

次章では、実際に多発する「失敗パターン」をまとめて、事故を防ぐための注意点を整理します。

8. よくある失敗・注意点まとめ

小数点の切り捨ては「動いたように見える」コードが多く、初心者ほどミスに気づきにくい分野です。
ここでは実務でも起きやすい失敗をまとめ、事故を避けるための判断ポイントを整理します。

8.1 「切り捨て」の定義を間違える（0方向 vs floor）

一番多い失敗は、切り捨て＝常に小さい方だと思い込むことです。
Javaでは、手段によって意味が変わります。

  • キャスト (int)：0方向への丸め
    • 3.9 → 3
    • -3.9 → -3
  • Math.floor()：-∞方向への切り捨て
    • 3.9 → 3
    • -3.9 → -4

例えば「マイナスも含めて常に切り捨てたい」処理でキャストを使うと、負の数だけ結果がズレます。
このズレは、テストデータが正の数だけだと見逃されます。

対策：

  • 負の数が出る可能性があるなら、最初から Math.floor() を検討する
  • BigDecimalの場合も RoundingMode.DOWN と FLOOR を混同しない

8.2 double誤差で想定とズレる

「小数第2位で切り捨て」を Math.floor(x * 100) / 100 で実装すると、理屈では正しいのにズレることがあります。
原因は double の内部表現です（10進数を完全に表現できない場合がある）。

例として、次のようなコードは危険域です。

double x = 1.29;
double y = Math.floor(x * 100) / 100;
System.out.println(y);

値によっては x * 100 が 128.999999999... のようになり、floorで128になってしまうと 1.28 になります。
「毎回起きるわけではない」ため、運用中に見つかるのが厄介です。

対策：

  • 金額や請求など、ズレが許されない処理は BigDecimal に寄せる
  • double方式を使うなら、ズレる可能性がある前提で扱う（用途限定）

8.3 金額計算でdoubleを使って事故る

金額計算で double を使うと、次のような問題が起きやすいです。

  • 端数処理のタイミングで合計が合わない
  • 1円未満の誤差が積み重なって差が出る
  • 表示と内部計算が一致しない

例えば、1件ずつの計算では誤差が小さくても、合計や繰り返し計算で差が目立つことがあります。

対策：

  • 金額は基本 BigDecimal
  • BigDecimalは「生成方法（文字列 or valueOf）」も固定する
  • 端数処理（切り捨て・四捨五入）のルールを仕様として明文化する

8.4 表示用フォーマットで計算してしまう

DecimalFormatやString.formatで「切り捨て表示」を作り、それを数値に戻して計算するのは危険です。

double x = 1.239;
String s = String.format("%.2f", x); // 表示用（多くは丸め）
double y = Double.parseDouble(s);    // これを計算に使うと仕様が崩れる

このパターンは、次の問題を起こします。

  • 表示の都合（丸め）を計算に混ぜてしまう
  • 仕様変更（小数桁変更）で計算結果まで変わる
  • 表示と計算の責務が分離できなくなる

対策：

  • 計算は BigDecimal または Math.floor() で完結させる
  • 表示は最後に整形する（DecimalFormatなど）
  • 「計算用」と「表示用」を混ぜない

ここまでの注意点を押さえるだけで、切り捨ての事故はかなり減ります。
次章では、記事の結論として「コピペで使える最短の結論」をまとめます。

9. まとめ：最短の結論（コピペ用の結論）

Javaで小数点を切り捨てる方法は複数ありますが、迷ったら 用途で固定するのが最短です。
ここでは「そのまま使える形」で結論だけをまとめます。

9.1 迷ったらこれ（推奨）

ケース1：小数点以下を消して int にしたい（正の数だけ）

double x = 12.99;
int y = (int) x;  // 12

注意：負の数が混ざると -3.9 → -3 になるため、数学的な切り捨てではありません。

ケース2：負の数も含めて「数学的に切り捨て（floor）」したい

double x = -3.9;
int y = (int) Math.floor(x); // -4

ポイント：Math.floor() は -∞方向への切り捨てです。

ケース3：小数第n位で切り捨てたい（doubleで簡易にやる）

※表示目的など、誤差が許容できる場合の方法です。

double x = 1.239;
double y = Math.floor(x * 100) / 100; // 1.23

注意：double の誤差でズレる可能性があります。厳密さが必要なら次のBigDecimalを使います。

ケース4：小数第n位で「確実に」切り捨てたい（推奨：BigDecimal）

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

BigDecimal x = new BigDecimal("1.239");
BigDecimal y = x.setScale(2, RoundingMode.DOWN); // 1.23

ポイント：

  • new BigDecimal(0.1) のように double から作らない
  • 金額・請求・レートは基本これが安全

ケース5：表示だけ整えたい（計算には使わない）

import java.text.DecimalFormat;
import java.math.RoundingMode;

double x = 1.239;

DecimalFormat df = new DecimalFormat("0.00");
df.setRoundingMode(RoundingMode.DOWN);

System.out.println(df.format(x)); // "1.23"

ポイント：これは 文字列表示であり、内部の数値は変わりません。

次はFAQとして「よくある疑問（DOWNとFLOORの違いなど）」をまとめて解決します。

FAQ

Q1. Javaで小数点以下を切り捨てる一番簡単な方法は？

回答方針：整数にしたいだけなら (int) キャストが最短。ただし負の数が出るなら Math.floor() を検討します。

Q2. (int)で切り捨てたら負の数が想定と違います。なぜ？

回答方針：キャストは「0方向への丸め」です。-3.9 → -3 になります。数学的な切り捨て（floor）なら Math.floor() を使います。

Q3. 小数第2位で切り捨てたいです（例：1.239 → 1.23）

回答方針：簡易なら Math.floor(x * 100) / 100。厳密性が必要なら BigDecimal.setScale(2, RoundingMode.DOWN) を使います。

Q4. Math.floor(x * 100) / 100 を使ったのにズレることがあります

回答方針：double の誤差が原因です。金額などズレが許されない用途では BigDecimalに切り替えるのが安全です。

Q5. BigDecimalで切り捨てる正しい書き方は？

回答方針：BigDecimalは文字列または valueOf で生成し、setScale(n, RoundingMode.DOWN) を使います。new BigDecimal(double) は避けます。

Q6. RoundingMode.DOWN と RoundingMode.FLOOR の違いは？

回答方針：負の数で差が出ます。DOWNは0方向、FLOORは-∞方向です。用途（truncateか数学的floorか）で選びます。

Q7. DecimalFormatで切り捨てできますか？

回答方針：表示としては可能です（RoundingMode設定も可能）。ただし計算用ではなく、内部値は変わらない点に注意します。

Q8. 小数点の切り捨ては「いつ」行うのが正しいですか？

回答方針：仕様次第ですが、金額計算は「最後にまとめて丸める」か「都度丸める」かで結果が変わります。ルールを明文化し、BigDecimalで統一するのが安全です。