Javaのlong型を完全解説｜範囲・Lの意味・Longクラス・オーバーフロー対策まで

1. この記事で分かること（結論を先に）

Javaのlongは、大きな整数を安全に扱うための基本型（プリミティブ型）です。
ただし、初心者がつまずきやすいポイントがいくつかあります。この記事では、java longで検索してきた人が「いま知りたいこと」を、順番に整理して理解できるように解説します。

1.1 long型の役割がすぐ分かる（「何に使うの？」が明確になる）

longは64bitの符号付き整数で、intよりもずっと大きい数値を扱えます。
そのため、次のような場面でよく使われます。

• ID（データベースの連番などが大きくなるケース）
• 時間（UNIX時間のミリ秒、ログのタイムスタンプなど）
• 金額（小数を使わず「最小単位」で整数管理したいケース）

つまり、「大きくなる可能性がある整数」を扱うなら、longは非常に重要です。

1.2 longの範囲（最大値・最小値）を正確に説明できるようになる

「longってどこまで入るの？」は、実務でもよく聞かれる質問です。
この記事では、Long.MAX_VALUEやLong.MIN_VALUEを使って、範囲を安全に把握する方法を解説します。

さらに、「intの範囲は超えるのに、なぜエラーになるの？」といった疑問も、あとでスッキリ解消できるように説明していきます。

1.3 数値リテラルの「L」が必要な理由が腹落ちする

longの話で最も検索されやすいのが、これです。

• 123L の L って何？
• なぜ 3000000000 を代入するとエラーになるの？
• L を付ける基準は？

この記事では、「Javaでは整数リテラルが基本的にint扱い」という前提から、Lが必要になる理由を丁寧に説明します。
ここが分かると、longの理解が一気に安定します。

1.4 オーバーフロー（桁あふれ）の仕組みと対策が分かる

longは大きい数を扱えますが、無限ではありません。
最大値を超える計算をすると、値が“おかしく見える”状態になることがあります（これがオーバーフローです）。

この記事では、

• オーバーフローが起きる典型例
• なぜそうなるのか（難しすぎない範囲で）
• 実務での対策（安全に計算する方法）

まで、初心者にも分かる形でまとめます。

1.5 long と Long の違い（プリミティブ型とラッパークラス）が分かる

Javaには long と Long が存在します。
見た目が似ているので混乱しやすいですが、役割が違います。

• long：基本型（高速・null不可）
• Long：クラス（メソッドが使える・nullを持てる）

この記事では、この違いが「暗記」ではなく「使い分け」として理解できるように整理します。

1.6 この記事を読み終えた時のゴール

この記事を最後まで読むと、次の状態を目指せます。

• longを使うべき場面と、intで十分な場面を判断できる
• Lの意味を説明でき、エラーを自分で直せる
• Long.MAX_VALUEなどを使って安全に境界を扱える
• 途中計算でのオーバーフローや型変換の罠を避けられる
• longとLongを状況に応じて使い分けられる

ここまで理解できれば、java longに関して「なんとなく不安」という状態から抜け出して、安心してコードを書けるようになります。

2. Javaのlong型とは（基本の定義）

ここからは、long型の基礎をしっかり固めていきます。
「なんとなく大きい数が入る型」という理解から一歩進んで、仕様として正しく理解することが目的です。

2.1 longは「64bitの符号付き整数型」

Javaのlongは、64bit（8バイト）の符号付き整数型です。
「符号付き」というのは、マイナスの値も扱えるという意味です。

内部的には次の特徴を持っています。

• 使用ビット数：64bit
• 表現できる値：正の数・0・負の数
• 小数は扱えない（整数専用）

この64bitというサイズのおかげで、intよりもはるかに大きな整数を扱えます。

long a = 10;
long b = -500;
long c = 1234567890123L;

いずれも問題なく代入できます。

2.2 int・short・byteとの違い

Javaには、long以外にも整数型がいくつか存在します。
ここで一度、サイズ感を整理しておきましょう。

実務では、

• 通常の計算 → int
• 大きくなる可能性がある整数 → long

という使い分けが基本になります。

2.3 なぜ最初からlongを使わないのか？

初心者の方からよく出る疑問に、こんなものがあります。

「longの方が大きいなら、全部longでよくない？」

技術的には可能ですが、必ずしも最適ではありません。

理由は次の通りです。

• intの方が計算コストが低い（CPUが扱いやすい）
• 配列や大量データでは、メモリ使用量に差が出る
• Javaの多くのAPIは、標準でintを前提に設計されている

そのため、

• サイズが明確に小さい → int
• 将来的に増える、溢れる可能性がある → long

という判断が現実的です。

2.4 longがよく使われる具体的な場面

longは、次のような場面で頻繁に使われます。

2.4.1 IDや連番

データベースの主キーや、システム内の一意なIDは、
長期間運用すると intの上限（約21億）を超える可能性があります。

long userId = 10000000001L;

このようなケースでは、longがほぼ必須です。

2.4.2 時間・日時（タイムスタンプ）

Javaでは、時間を「ミリ秒単位の整数」で扱うことがよくあります。

long now = System.currentTimeMillis();

UNIX時間（ミリ秒）は数値が非常に大きいため、intでは確実に不足します。

2.4.3 金額（最小単位での管理）

金額をdoubleで扱うと、誤差が問題になることがあります。
そのため、実務では「最小単位の整数」で管理することが多いです。

// 1円単位で管理
long price = 1500;

このような用途でも、longは定番です。

2.5 longは「安全」だが「無限」ではない

ここで重要な注意点があります。

• longは大きい
• しかし 無限に大きいわけではない

上限・下限を超える計算をすると、オーバーフローが発生します。
この点については、後のセクションで詳しく解説します。

3. longの範囲（最大値・最小値）を正しく理解する

longを扱ううえで、必ず押さえておくべきポイントが「数値の範囲」です。
ここを曖昧にしたまま使うと、思わぬ不具合や計算ミスにつながります。

3.1 longの最大値・最小値はどこで確認する？

Javaでは、longの範囲を定数として安全に取得できる仕組みが用意されています。

long max = Long.MAX_VALUE;
long min = Long.MIN_VALUE;

• Long.MAX_VALUE：long型で表現できる最大値
• Long.MIN_VALUE：long型で表現できる最小値

この2つは覚える必要はありません。
「コードで取得する」という考え方が重要です。

3.2 longの具体的な数値範囲

参考として、longの範囲を数値で表すと次の通りです。

• 最大値：9,223,372,036,854,775,807
• 最小値：-9,223,372,036,854,775,808

桁数が非常に大きく、直感的には分かりにくいですが、

• 約9京（けい）まで扱える
• int（約21億）とは桁がまったく違う

というイメージを持っておけば十分です。

3.3 なぜ最大値と最小値が非対称なのか？

よく見ると、longの範囲は少し不思議です。

• 最大値：+9,223,372,036,854,775,807
• 最小値：-9,223,372,036,854,775,808

「なぜマイナスの方が1大きいの？」と疑問に思うかもしれません。

これは、Javaが整数を2の補数表現で管理しているためです。
難しく考える必要はなく、

マイナス側に1つ余分な値が割り当てられる仕様

と理解しておけば問題ありません。

3.4 intの範囲と比較してみる

ここで、intとの違いを具体的に比べてみましょう。

int intMax = Integer.MAX_VALUE;   // 2,147,483,647
long longMax = Long.MAX_VALUE;    // 9,223,372,036,854,775,807

intの最大値は約21億です。
一方、longはその何百万倍もの範囲を持っています。

この差があるため、

• 件数
• 時間（ミリ秒）
• 累積値
• 連番ID

などでは、intでは足りなくなる可能性が高いのです。

3.5 境界値を扱うときの注意点

longの最大値・最小値付近では、特に注意が必要です。

long value = Long.MAX_VALUE;
value = value + 1;
System.out.println(value);

このコードを実行すると、エラーは出ません。
しかし、表示される値は想像と違うものになります。

これはオーバーフローと呼ばれる現象です。

• 上限を超えた瞬間に、値がマイナス側へ回り込む
• Javaでは自動でエラーにはならない

この仕組みを知らないと、「なぜ急に負の数になったのか分からない」という状態に陥りがちです。

3.6 範囲は「覚える」のではなく「守る」

重要なのは、次の考え方です。

• 数値そのものを暗記しない
• Long.MAX_VALUE / Long.MIN_VALUE を使う
• 境界を超える可能性がある計算には注意する

この姿勢を持つだけで、longに関するトラブルは大幅に減ります。

4. 数値リテラルの「L」が必要な理由（最も混乱しやすいポイント）

java longで検索する人が、最も疑問に感じやすいのが**数値の後ろに付く「L」**です。
ここを正しく理解すると、longに関するエラーや違和感が一気に減ります。

4.1 Javaでは整数リテラルは「int」が基本

まず重要な前提があります。
Javaでは、整数リテラルはデフォルトで int として扱われます。

int a = 100;

これは当然問題ありません。
しかし次のコードを見てみましょう。

long b = 3000000000;

一見すると問題なさそうですが、これはコンパイルエラーになります。

理由はシンプルで、

• 3000000000 は int の範囲を超えている
• しかし、Javaはまず int として解釈しようとする
• その時点で「大きすぎる」と判断される

という流れになっているからです。

4.2 「L」を付けると何が変わるのか？

このエラーは、次のように書き換えると解消されます。

long b = 3000000000L;

数値の後ろに L を付けることで、

• 「この数値は long型のリテラル です」
• 「intではなく、最初からlongとして扱ってください」

という意思を、Javaに明確に伝えることができます。

つまり、Lは型を指定するための目印です。

4.3 どんなときに「L」が必要になるのか？

Lが必要になるのは、次のようなケースです。

4.3.1 intの範囲を超える数値を書くとき

long x = 2147483648L; // intの最大値を超えている

このような場合、必ず L が必要です。

4.3.2 longであることを明示したいとき

数値自体は int の範囲内でも、
「これは long として扱う」という意図を明確にしたい場合があります。

long count = 100L;

必須ではありませんが、可読性の面で有効なこともあります。

4.4 「l（小文字）」ではダメなのか？

Javaでは、次の書き方も文法上は正しいです。

long y = 100l;

しかし、小文字の l は推奨されません。

理由は単純で、

• 数字の「1」と見分けがつきにくい
• コードレビューで誤読されやすい

という問題があるからです。

そのため、必ず大文字の L を使うのが一般的なルールです。

4.5 16進数・2進数・区切り文字とLの組み合わせ

longリテラルは、10進数以外でも使えます。

long hex = 0x7FFF_FFFF_FFFF_FFFFL;
long bin = 0b1010_1010_1010L;

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

• _（アンダースコア）は桁区切りとして使える
• L は 最後に付ける
• 可読性を上げるための工夫として有効

大きな数値を扱うときほど、この書き方は役に立ちます。

4.6 計算式の中でも「L」は重要

次のコードは、初心者がよくハマる例です。

long result = 1000 * 1000 * 1000;

一見問題なさそうですが、途中計算はすべて int で行われます。
その結果、途中でオーバーフローが起きる可能性があります。

正しい書き方は次の通りです。

long result = 1000L * 1000 * 1000;

最初に L を付けておくことで、計算全体が long として評価され、安全になります。

4.7 「L」はエラー回避ではなく、意図を伝えるためのもの

まとめると、Lの役割は次の通りです。

• Javaに「これはlongだ」と明示する
• intの範囲を超える数値を安全に扱う
• 計算途中のオーバーフローを防ぐ
• コードの意図を読み手に伝える

単なる記号ではなく、安全で読みやすいコードを書くための重要な要素だと考えてください。

5. longの基本操作（代入・計算・キャスト）

ここでは、longを実際に使うときに必ず登場する
代入・計算・型変換（キャスト）のポイントを整理します。
初心者が「動くと思ったのに結果がおかしい」と感じやすい部分なので、丁寧に確認していきましょう。

5.1 longへの代入の基本

longへの代入は、基本的に次の形になります。

long a = 10;
long b = 100L;

• intの範囲内の値 → そのまま代入可能
• intの範囲を超える値 → L が必要

これはすでに前のセクションで説明した通りです。

5.2 計算時の「型昇格」に注意する

Javaでは、計算の途中で型が自動的に決まるというルールがあります。
ここが理解できていないと、思わぬバグにつながります。

5.2.1 int同士の計算は、結果もintになる

次の例を見てください。

long result = 1000 * 1000 * 1000;

このコードでは、

1. 1000 * 1000 → int同士なので int
2. さらに * 1000 → やはり int
3. その結果を long に代入

という順番で処理されます。

途中計算が int のまま行われるため、途中でオーバーフローが発生する可能性があります。

5.2.2 最初からlongで計算させる方法

この問題を防ぐには、最初の段階でlongに昇格させることが重要です。

long result = 1000L * 1000 * 1000;

これで、

• 計算全体が long として評価される
• 途中のオーバーフローを防げる

という状態になります。

5.3 暗黙の型変換（安全なケース）

Javaでは、小さい型から大きい型への変換は自動で行われます。

int x = 100;
long y = x;  // OK

このような変換は情報が失われないため、安全です。

5.4 明示的なキャストが必要なケース（危険）

逆に、long → int のような縮小変換では注意が必要です。

long big = 3000000000L;
int small = (int) big;

このコードはコンパイルできますが、値は正しく保持されません。

• 上位ビットが切り捨てられる
• 結果が全く別の数値になる

つまり、キャストは「安全」ではなく「強制」です。

5.5 キャストを使うべきかどうかの判断基準

次のように考えると安全です。

• 「値が必ずintの範囲に収まる」 → キャスト可
• 「将来どうなるか分からない」 → キャストしない
• 「境界値の可能性がある」 → longのまま扱う

無理に小さな型へ戻そうとせず、必要な大きさの型を使い続けるのが基本です。

6. オーバーフロー（桁あふれ）の挙動と対策

longは非常に大きな数を扱えますが、限界を超えると必ず問題が起きます。
ここでは、オーバーフローが「なぜ起きるのか」「どう防ぐのか」を、初心者にも分かる形で説明します。

6.1 longでもオーバーフローは起きる

まず大前提として、longも有限な範囲の型です。
そのため、次のようなコードはコンパイルエラーにならず、実行時に値がおかしくなります。

long value = Long.MAX_VALUE;
value = value + 1;
System.out.println(value);

結果は、最大値の次なのに非常に大きなマイナス値になります。

これはバグではなく、Javaの仕様通りの挙動です。

6.2 なぜ値が「回り込む」のか？

Javaの整数は、内部的に2の補数表現で管理されています。
そのため、

• 最大値を超える
• 最上位ビットが変化する
• 結果としてマイナス側に回り込む

という現象が起こります。

重要なのは、Javaはオーバーフローを自動では検知しないという点です。
そのため、何も対策しなければ、気づかないまま不正な値を使い続ける可能性があります。

6.3 オーバーフローが問題になる典型例

次のようなケースでは、特に注意が必要です。

• 金額の累積計算
• 件数・カウンタの加算
• 時間計算（期間の加算）
• IDや通番の自動生成

これらは「徐々に増える」性質を持つため、長期運用で上限に達する可能性があります。

6.4 安全に計算する方法（Math.addExact など）

Javaには、オーバーフローを検知するためのメソッドが用意されています。

long result = Math.addExact(a, b);

このメソッドは、

• 計算結果が long の範囲内 → 正常に結果を返す
• 範囲を超える → ArithmeticException を投げる

という挙動になります。

同様に、次のようなメソッドもあります。

• Math.subtractExact
• Math.multiplyExact

「安全性が重要な計算」では、これらを使うことで
異常を即座に検知できるようになります。

6.5 if文で事前チェックする方法

例外を使わず、事前にチェックする方法もあります。

if (value > Long.MAX_VALUE - add) {
    // オーバーフローの可能性あり
}

この方法は、

• 高頻度で実行される処理
• 例外を避けたい場面

で有効です。

6.6 longで足りない場合の選択肢

もし、

• 数値が long の範囲を超える可能性がある
• 金融計算などで桁数が非常に重要

という場合は、longを使い続けるべきではありません。

その場合は、

• BigInteger（任意精度整数）
• BigDecimal（任意精度小数）

といったクラスを検討します。

「longで無理をしない」という判断も、正しい設計の一部です。

7. long と Long の違い（プリミティブ型とラッパークラス）

Javaには、よく似た名前の long と Long が存在します。
この2つは役割が明確に異なり、使い分けを理解していないと不具合や設計ミスにつながります。

7.1 long と Long の根本的な違い

まずは違いを整理します。

簡単に言うと、

• 計算や数値処理の主役 → long
• オブジェクトとして扱いたい場合 → Long

です。

7.2 Longクラスとは何か？

Longは、longをオブジェクトとして扱うためのクラスです。

Long a = 10L;
Long b = Long.valueOf(20);

Longを使うことで、次のようなことが可能になります。

• null を表現できる
• メソッドを使って変換・比較ができる
• コレクション（List, Mapなど）に格納できる

7.3 オートボクシングとアンボクシング

Javaでは、long と Long の間で自動変換が行われます。

Long a = 10L;   // オートボクシング（long → Long）
long b = a;    // アンボクシング（Long → long）

便利な仕組みですが、注意点もあります。

7.3.1 nullによる例外に注意

Long a = null;
long b = a;  // NullPointerException

Longがnullの状態でアンボクシングが起きると、
実行時例外が発生します。

そのため、

• 値が必ず存在する → long
• 未設定・欠損の可能性がある → Long

という使い分けが重要です。

7.4 比較時の注意点（== と equals）

Long同士の比較では、== を使うべきではありません。

Long a = 100L;
Long b = 100L;

System.out.println(a == b);      // true になることもある
System.out.println(a.equals(b)); // 常に true

== は「参照の比較」、equals は「値の比較」です。
特に Long では、内部キャッシュの影響で挙動が分かりにくくなります。

値を比較したい場合は必ず equals を使う、
これが安全なルールです。

7.5 Longでよく使う定数とメソッド

Longクラスには、実務でよく使われる機能があります。

Long.MAX_VALUE
Long.MIN_VALUE

これらは、longの範囲を安全に扱うための定数です。

また、変換系のメソッドも頻出です。

long x = Long.parseLong("123");
Long y = Long.valueOf("456");

• parseLong：プリミティブ long を返す
• valueOf：Long オブジェクトを返す

用途に応じて使い分けましょう。

7.6 どちらを使うべきかの判断基準

迷ったときは、次の基準で判断すると安全です。

• 計算・数値処理が中心 → long
• nullの可能性がある → Long
• コレクションに入れる → Long
• パフォーマンス重視 → long

無理に Long を使う必要はなく、基本は long、必要な場面だけ Longという考え方が実務では最も安定します。

8. 文字列⇄long変換（入力・設定値・外部データで必須）

実務では、longを直接コードに書くよりも、文字列として受け取った値を変換するケースの方が多くなります。

• フォーム入力
• CSVやJSON
• 設定ファイル
• 環境変数

ここでは、文字列とlongの相互変換を安全に行う方法を整理します。

8.1 String → long（数値に変換する）

文字列をlongに変換する代表的な方法は、次の2つです。

8.1.1 Long.parseLong を使う（最も一般的）

long value = Long.parseLong("12345");

• 戻り値：long
• 失敗時：NumberFormatException が発生

数値として使いたい場合は、基本的にこの方法を選びます。

8.1.2 Long.valueOf を使う

Long value = Long.valueOf("12345");

• 戻り値：Long
• 内部的にはキャッシュが使われることもある

コレクションに入れる、nullを扱う可能性がある、といった場合に使われます。

8.2 変換に失敗するケースと例外処理

次のような文字列は、変換に失敗します。

Long.parseLong("abc");
Long.parseLong("12.3");
Long.parseLong("");

これらはすべて、実行時に NumberFormatException が発生します。

そのため、外部入力を扱う場合は、必ず例外処理を行います。

try {
    long value = Long.parseLong(input);
} catch (NumberFormatException e) {
    // 数値として扱えない場合の処理
}

「入力は必ず正しい」という前提は、実務ではほぼ成り立たないと考えておきましょう。

8.3 long → String（表示・出力用）

数値を文字列に変換する方法も複数あります。

8.3.1 Long.toString を使う

long value = 12345;
String text = Long.toString(value);

long専用の変換メソッドで、意図が明確です。

8.3.2 String.valueOf を使う

String text = String.valueOf(value);

こちらもよく使われる方法で、null安全性がある点が特徴です。

8.4 どの変換方法を選ぶべきか？

判断基準は次の通りです。

• 計算用の値が欲しい → Long.parseLong
• オブジェクトとして扱いたい → Long.valueOf
• 表示・ログ出力 → String.valueOf / Long.toString

用途を意識して選ぶことで、コードの意図が読みやすくなります。

8.5 変換時に意識すべきポイント

文字列⇄long変換では、次の点を常に意識してください。

• 入力は信用しない
• 例外が発生する前提で書く
• 境界値（MAX / MIN）を意識する
• 桁数が増える可能性を考慮する

これらを押さえるだけで、
変換まわりのバグは大幅に減らせます。

9. 実務でのlongの使いどころ（具体例で理解する）

ここまでで、longの仕様や使い方は一通り押さえました。
このセクションでは、「なぜ実務でlongが選ばれるのか」を、よくあるケース別に確認します。

9.1 UNIX時間・タイムスタンプの管理

Javaで現在時刻を取得する代表例が次です。

long now = System.currentTimeMillis();

UNIX時間（ミリ秒）は、すでに intの範囲を大きく超えています。
そのため、時間を数値で扱う場合は、longが事実上の標準です。

• ログの出力
• 処理時間の計測
• 有効期限・タイムアウト管理

これらはすべて、long前提で設計されることが多いです。

9.2 データベースのID・連番

多くのシステムでは、レコードを識別するために
連番のIDを使用します。

long userId;
long orderId;

サービスが長期間稼働すると、

• レコード数が数億〜数十億を超える
• 将来的な拡張で桁が増える

といった状況が珍しくありません。

そのため、最初からlongを使っておくことで、後から型変更に追われるリスクを減らせます。

9.3 金額の管理（小数を使わない設計）

金額を double や float で扱うと、
誤差が積み重なる問題が発生します。

そこでよく使われるのが、
「最小単位をlongで管理する」という方法です。

// 円単位で管理
long price = 1500;

// 銭単位やポイントなどでも同様

• 加算・減算が正確
• 比較がシンプル
• オーバーフローも検知しやすい

というメリットがあります。

9.4 件数・累積値・カウンタ

アクセス数や処理件数など、
増え続ける値にも long は適しています。

long totalCount = 0;
totalCount++;

最初は小さくても、「いつか増えるかもしれない値」には long を選ぶ、という判断は実務ではよく行われます。

9.5 ハッシュ値・内部計算用の数値

アルゴリズムや内部処理では、

• 計算結果を一時的に保持したい
• intでは桁が足りないが、BigIntegerほどでもない

といった場面があります。

こうした中間計算でも、longはバランスの良い選択肢です。

9.6 「とりあえずlong」は正解か？

最後に重要な考え方です。

• 無条件でlongを選ぶのは正解ではない
• しかし「将来増える可能性」があるなら、有力候補

設計段階で、

• 値の最大規模はどれくらいか
• 増え続ける性質があるか

を一度考えるだけで、longを使うべきかどうかの判断はしやすくなります。

10. （発展）符号なしとして扱いたいときの考え方

Javaのlongは符号付き整数です。
そのため、「負の値を使わず、0以上の範囲を最大限に使いたい」というケースでは、少し工夫が必要になります。

10.1 Javaに「unsigned long」は存在しない

C言語などと違い、Javaには符号なしlong型（unsigned long）は用意されていません。
longは常に、次の範囲で扱われます。

• -9,223,372,036,854,775,808
• +9,223,372,036,854,775,807

つまり、負の値も含めた範囲が前提です。

10.2 それでも符号なし的に扱いたいケース

実務では、次のような場面で「符号なしとして扱いたい」ことがあります。

• ビット演算の結果
• ハッシュ値
• ネットワーク・プロトコルの数値
• IDやトークンを数値として扱う場合

これらでは、「負の意味を持たせない」ことが重要です。

10.3 Longクラスのunsigned系メソッドを使う

Javaでは、Longクラスに符号なしとして扱うためのメソッドが用意されています。

代表的なものは次の通りです。

Long.compareUnsigned(a, b);
Long.divideUnsigned(a, b);
Long.remainderUnsigned(a, b);

これらを使うことで、

• 内部表現はlongのまま
• 比較や演算だけを符号なしとして扱う

ということが可能になります。

10.4 表示だけ符号なしにしたい場合

数値を「符号なしとして表示」したい場合は、次のような方法もあります。

String text = Long.toUnsignedString(value);

これにより、内部的には負の値でも、符号なしの大きな数として文字列化できます。

10.5 無理にunsignedを使わない判断も重要

とはいえ、次のような場合は、
無理に符号なしとして扱うべきではありません。

• 通常の業務データ
• 金額・件数・時間
• 人が理解する数値

これらは、符号付きlongのまま扱う方が安全です。

unsignedは、「どうしても必要な場面だけ使う補助的な考え方」として覚えておくのが現実的です。

11. まとめ（long型で最も重要なポイント）

ここまで解説してきた内容を、重要ポイントだけ整理します。

• longは 64bitの符号付き整数型
• 大きな整数（ID・時間・金額など）に適している
• 範囲は Long.MAX_VALUE / Long.MIN_VALUE で把握する
• 数値リテラルは 必要に応じて L を付ける
• 計算途中は int評価によるオーバーフローに注意
• longでもオーバーフローは起きる
• 安全性が必要なら Math.addExact などを使う
• 基本は long、必要な場面だけ Long
• 文字列変換・境界値・例外処理を軽視しない

これらを意識できれば、longに関するトラブルの多くは回避できます。

12. よくある質問（FAQ）

12.1 Q. longの最大値・最小値はいくつですか？

A.
数値を暗記する必要はありません。
次の定数を使って取得してください。

Long.MAX_VALUE;
Long.MIN_VALUE;

12.2 Q. 数値の後ろに付ける「L」は必ず必要ですか？

A.
intの範囲を超える数値リテラルでは必須です。
また、計算途中をlongとして扱いたい場合にも有効です。

12.3 Q. longでもオーバーフローは起きますか？

A.
はい、起きます。
Javaでは自動でエラーにならないため、必要に応じて
Math.addExact などで検知してください。

12.4 Q. longとLongはどちらを使うべきですか？

A.
基本は long です。
nullを扱う、コレクションに入れるなどの理由がある場合のみ Long を使います。

12.5 Q. 文字列をlongに変換する正しい方法は？

A.
次の方法が一般的です。

long value = Long.parseLong(str);

外部入力の場合は、例外処理を忘れないようにしてください。