Javaのデータ型とは？プリミティブ型・参照型の違いと一覧を完全解説【初心者向け】

1. Javaのデータ型とは？基礎知識と全体像

Javaのデータ型とは、「変数にどの種類の値を入れるのかを決める仕組み」です。
Javaは型安全（Type Safety：不正な型の操作をコンパイル時に防ぐ仕組み）を重視する言語であり、すべての変数には必ず型を指定します。

たとえば、次のコードを見てください。

int number = 10;
double price = 19.8;
String name = "Java";

• int → 整数専用
• double → 小数専用
• String → 文字列専用

このように、型を明確にすることで次のようなメリットがあります。

• 不正な代入を防げる
• メモリ使用量が最適化される
• バグをコンパイル段階で検出できる

もし型がなければ、整数に文字列を入れるなどの誤りが実行時まで発覚しません。Javaはそれを防ぐ設計になっています。

1.1 データ型とは何か（初心者向け定義）

データ型は「その変数が扱える値の種類」と考えてください。

基本構文は次の通りです。

型名 変数名 = 値;

例：

int age = 25;

このとき、

• int が型
• age が変数名
• 25 が値

という関係です。

もし次のように書くとエラーになります。

int age = "25";  // コンパイルエラー

整数型に文字列は代入できません。これが型安全の仕組みです。

よくあるつまずき

• 型を省略できると思い込む（Javaでは基本的に省略不可）
• 数値と文字列を混同する
• =（代入）と==（比較）を混同する

1.2 Javaのデータ型の分類（2種類）

Javaのデータ型は大きく分けて次の2種類です。

1. プリミティブ型（基本型）
2. 参照型（Reference Type）

プリミティブ型とは

値そのものを直接保持する型です。
例：int, double, boolean など。

特徴：

• メモリ効率が良い
• 高速
• nullを持てない

参照型とは

値そのものではなく、「値が保存されている場所（参照）」を保持する型です。

例：

String text = "Hello";

String はクラス型（参照型）です。

特徴：

• クラスを元に作られる
• nullを代入できる
• メソッド（機能）を持つ

1.3 値型と参照型のイメージの違い

簡単な例で違いを確認します。

int a = 10;
int b = a;
b = 20;

この場合、

• a は 10 のまま
• b だけが 20

一方、参照型では次のようになります。

String s1 = "Java";
String s2 = s1;

ここでは s1 と s2 は同じオブジェクトを参照する場合があります（実装や最適化により異なることもあります）。

つまずきやすい点

• String をプリミティブ型だと誤解する
• 参照型をコピーすると値もコピーされると思い込む
• nullの扱いを理解していない

1.4 なぜデータ型の理解が重要なのか

データ型の理解不足は、次の問題を引き起こします。

• 計算結果が想定と違う
• オーバーフロー（値の範囲超過）が発生
• NullPointerExceptionが発生
• 型変換エラー

Javaを正しく使うためには、まずデータ型の全体像を理解することが必須です。

2. プリミティブ型（基本データ型）の一覧と使い方

プリミティブ型（primitive type）は、値そのものを直接保持するデータ型です。
Javaには全部で 8種類 あります。

※サイズはJava仕様により固定です（環境依存しません）。

2.1 整数型（byte / short / int / long）

基本的な使い方

int number = 100;
long population = 8000000000L;

各型の範囲（代表例）

• byte：-128 ～ 127
• short：-32,768 ～ 32,767
• int：約±21億
• long：約±922京

通常は intを使えば十分 です。
メモリ節約目的でbyteやshortを使う必要はほぼありません。

long使用時の注意

long value = 10000000000L;  // Lが必要

Lを付けないとintとして扱われ、範囲超過でエラーになります。

よくある失敗

• 範囲を超えてオーバーフローする
• longにLを付け忘れる
• int同士の計算で桁あふれに気づかない

2.2 浮動小数点型（float / double）

double price = 19.99;
float rate = 0.5f;

基本ルール

• 通常は doubleを使う
• floatは末尾に f が必要

float value = 3.14f;

精度の違い

• float：約7桁精度
• double：約15桁精度

重要な注意点（誤差問題）

System.out.println(0.1 + 0.2);

結果は正確に 0.3 にならない場合があります。
これは 2進数表現の誤差 が原因です。

金額計算の注意

金額処理では doubleは原則非推奨。
BigDecimalを使用するのが安全です。

よくある失敗

• 金額計算にdoubleを使う
• floatとdoubleを混同する
• ==で小数比較する

2.3 文字型（char）

char letter = 'A';

• シングルクォートを使用
• Unicode（文字コード規格）で管理される
• 1文字のみ保持可能

char kanji = '日';

よくある失敗

• ダブルクォートを使う（これはString）
• 複数文字を入れようとする

2.4 真偽値型（boolean）

boolean isActive = true;

• 値は true または false のみ
• 0や1は使えない（C言語と違う）

boolean result = (5 > 3);

よくある失敗

• 数値を代入しようとする
• 比較式を書き忘れる

2.5 プリミティブ型の共通注意点

• nullは代入できない
• デフォルト値はフィールド変数では自動設定されるが、ローカル変数は初期化必須

int x;
System.out.println(x);  // コンパイルエラー（未初期化）

プリミティブ型は高速かつ軽量ですが、nullを扱えない・メソッドを持たないなどの制限があります。

3. 参照型（Reference Type）の基本

参照型（Reference Type）は、値そのものではなく「オブジェクトの参照（メモリアドレス）」を保持する型です。
プリミティブ型との最大の違いは、「データの実体」と「変数」が別に存在する点にあります。

例を見てください。

String text = "Java";

このとき、text には文字列そのものではなく、文字列オブジェクトの参照が格納されます。

3.1 String型（最も使用頻度が高い参照型）

String はクラス型（class）です。プリミティブ型ではありません。

String name = "Taro";

特徴

• イミュータブル（immutable：変更不可）
• nullを代入できる
• メソッドを持つ

String str = "Hello";
System.out.println(str.length());  // 5

イミュータブルの注意点

String s = "Java";
s.concat(" SE");
System.out.println(s);  // "Java"

concat() は新しい文字列を返しますが、元の文字列は変更されません。

正しくは：

s = s.concat(" SE");

よくある失敗

• Stringをプリミティブ型だと思い込む
• 文字列比較に == を使う
• 連結を大量に行いパフォーマンス低下（StringBuilder推奨）

3.2 配列とクラス型

配列（Array）

int[] numbers = {1, 2, 3};

配列も参照型です。

int[] a = {1, 2};
int[] b = a;
b[0] = 99;

System.out.println(a[0]);  // 99

aとbは同じ配列を参照しているため、片方の変更が影響します。

クラス型

class Person {
    String name;
}

Person p = new Person();
p.name = "Ken";

new はオブジェクトを生成するキーワードです。

3.3 nullとは何か

null は「参照先が存在しない状態」を表します。

String text = null;

nullの状態でメソッドを呼ぶとエラーになります。

text.length();  // NullPointerException

これを NullPointerException（NPE） と呼びます。

null対策

if (text != null) {
    System.out.println(text.length());
}

3.4 == と equals() の違い

==（参照比較）

メモリアドレスが同じかどうかを比較します。

equals()（内容比較）

中身が同じかどうかを比較します。

String a = new String("Java");
String b = new String("Java");

System.out.println(a == b);        // false
System.out.println(a.equals(b));   // true

よくある失敗

• 文字列比較に == を使う
• nullチェックせずequalsを呼ぶ
• 参照のコピーと値のコピーを混同する

3.5 プリミティブ型との違いの整理

参照型は柔軟ですが、null管理や参照共有に注意が必要です。

4. ラッパークラス（Wrapper Class）と自動ボクシング

ラッパークラスとは、プリミティブ型をオブジェクトとして扱うためのクラスです。
Javaではコレクション（ListやMapなど）は参照型しか扱えないため、プリミティブ型をそのまま格納できません。そのためにラッパークラスが用意されています。

4.1 主なラッパークラス一覧

例：

Integer number = 10;
Double price = 19.99;

ラッパークラスはクラス型なので、nullを扱えます。

Integer value = null;  // OK

4.2 自動ボクシングとは

ボクシング（Boxing）とは、プリミティブ型をラッパークラスへ変換することです。

Java 5以降では、自動で変換されます。

Integer num = 10;  // 自動ボクシング

内部的には次と同等です。

Integer num = Integer.valueOf(10);

4.3 アンボクシングとは

アンボクシング（Unboxing）は、ラッパークラスからプリミティブ型へ戻すことです。

Integer num = 20;
int value = num;  // 自動アンボクシング

内部的には：

int value = num.intValue();

4.4 ラッパークラスが必要になる場面

1. コレクション使用時

import java.util.ArrayList;

ArrayList<Integer> list = new ArrayList<>();
list.add(10);  // 自動ボクシング

ArrayList<int> は使えません。

2. nullを扱いたい場合

Integer score = null;

プリミティブ型ではnull不可です。

4.5 注意点・よくある失敗

1. nullのアンボクシングで例外

Integer num = null;
int value = num;  // NullPointerException

自動アンボクシング時に例外が発生します。

2. == で比較してしまう

Integer a = 1000;
Integer b = 1000;

System.out.println(a == b);  // falseになる場合あり

オブジェクト比較なので参照を比較します。
内容比較は equals() を使います。

a.equals(b);

3. パフォーマンスへの影響

ラッパークラスはオブジェクト生成が発生するため、
大量計算ではプリミティブ型より遅くなる可能性があります。

4.6 プリミティブ型とラッパークラスの使い分け

• 計算処理 → プリミティブ型
• コレクション格納 → ラッパークラス
• nullを扱う → ラッパークラス

この基準を覚えておくと実務で迷いません。

5. 型変換（キャスト）の基礎

Javaでは、異なるデータ型同士で値を扱う際に型変換（キャスト）が発生します。
型変換には大きく分けて次の2種類があります。

• 暗黙的型変換（ワイドニング変換）
• 明示的型変換（ナローイング変換）

5.1 暗黙的型変換（ワイドニング）

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

int num = 100;
long bigNum = num;  // 自動変換

数値の表現範囲が広がる方向なので、安全です。

変換の例（整数系）

byte → short → int → long → float → double

例

int a = 10;
double b = a;  // OK

注意点

• 精度は保たれますが、floatやdoubleでは丸めが発生する可能性があります。
• charは整数扱いとして変換されます。

char c = 'A';
int code = c;  // 65

5.2 明示的型変換（ナローイング）

大きい型から小さい型へ変換する場合、明示的なキャストが必要です。

double price = 19.99;
int rounded = (int) price;

結果は：

rounded = 19

小数点以下は切り捨てられます。

書き方

(変換後の型) 変数

5.3 データ損失の例

int big = 1000;
byte small = (byte) big;
System.out.println(small);

結果は予測不能ではなく、範囲内に収まるように丸められます。
この場合、1000はbyteの範囲を超えるため、値が変化します。

よくある誤解

• エラーになると思っている → 実際は値が変わる
• 安全に変換されると思い込む → データ損失が発生

5.4 整数同士の計算の落とし穴

int a = 5;
int b = 2;
double result = a / b;
System.out.println(result);

結果は：

2.0

整数同士の計算は整数で処理されます。

正しくは：

double result = (double) a / b;

結果：

2.5

5.5 小数比較の注意

double x = 0.1 + 0.2;
System.out.println(x == 0.3);  // falseになる可能性

浮動小数点の誤差が原因です。

安全な比較方法

Math.abs(x - 0.3) < 0.000001

5.6 参照型のキャスト

参照型でもキャストは可能です（継承関係がある場合）。

Object obj = "Java";
String str = (String) obj;

誤った型へキャストすると例外が発生します。

Integer num = (Integer) obj;  // ClassCastException

よくある失敗まとめ

• 範囲外変換で値が変わる
• 整数除算に気づかない
• 小数を==で比較する
• 無理な参照型キャスト

型変換はコンパイルエラーにならないケースも多いため、理解不足がバグの原因になります。

6. 実務で迷わないための型選択ガイド

ここまででJavaのデータ型の仕組みを解説しましたが、実務では「結局どの型を使えばよいのか」で迷うことが多くなります。この章では、現場での判断基準を整理します。

6.1 基本は int と double で十分な理由

整数は原則 int

int count = 100;

理由：

• 32bitで十分な範囲
• JVMが最適化しやすい
• 可読性が高い

byteやshortを無理に使う必要は通常ありません。
メモリ節約目的で小さい型を選ぶのは、特殊なケース（大量配列など）に限られます。

小数は原則 double

double rate = 0.75;

floatより精度が高く、標準的に使われます。
明確な理由がない限りdoubleを選びます。

6.2 金額計算では BigDecimal を使うべき理由

金額処理で次のコードは危険です。

double price = 0.1 + 0.2;

浮動小数点誤差により、正確な値にならない可能性があります。

正しい方法：

import java.math.BigDecimal;

BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");
BigDecimal result = a.add(b);

なぜ文字列で渡すのか？

new BigDecimal(0.1);  // 推奨されない

doubleから生成すると誤差を引き継ぐ可能性があります。

よくある失敗

• 金額をdoubleで扱う
• new BigDecimal(double値)を使う
• 四捨五入処理を忘れる

6.3 コレクションではラッパークラスが必要

import java.util.ArrayList;

ArrayList<Integer> list = new ArrayList<>();
list.add(10);

プリミティブ型は直接使えません。

ArrayList<int> list;  // コンパイルエラー

理由：

• ジェネリクス（型安全なコレクション機構）は参照型のみ対応

6.4 nullを扱うかどうかで判断する

null不要 → プリミティブ型

int age = 0;

null必要 → ラッパークラス

Integer age = null;

データベース連携やフォーム入力ではnull管理が必要になるケースがあります。

6.5 パフォーマンスの基本指針

• 計算処理 → プリミティブ型
• コレクション → ラッパークラス
• 高頻度ループ内でのラッパー生成は避ける

例（非推奨）：

for (Integer i = 0; i < 1000000; i++) { }

プリミティブ型を使う方が効率的です。

6.6 型選択のまとめ基準

よくある実務上の失敗

• 不要に小さい型を選ぶ
• doubleで金額計算
• nullを想定しない設計
• ラッパークラスの自動アンボクシング例外

型選択は設計の基本です。曖昧なまま進めると後で修正コストが増大します。

7. Javaデータ型まとめ（一覧表付き総整理）

ここまで解説した内容を、検索意図に最短で答えられる形で整理します。
Javaのデータ型は「プリミティブ型」と「参照型」に大別されます。

7.1 プリミティブ型一覧

※ローカル変数は自動初期化されません。

重要ポイント

• 数値計算は基本 int / double
• 金額は BigDecimal
• nullは使用不可
• メソッドは持たない

7.2 参照型の整理

代表的な参照型：

• String
• 配列（int[] など）
• クラス型（独自クラス）
• ラッパークラス（Integerなど）
• コレクション（List, Map など）

特徴まとめ

7.3 プリミティブ型と参照型の最終比較

7.4 初心者が覚えるべき最小セット

まず覚えるべき型は次の4つです。

• int
• double
• String
• boolean

これだけで基本的なプログラムは作れます。

7.5 よくある総合的な失敗例

1. Stringを==で比較する
2. doubleで金額計算
3. 整数除算に気づかない
4. nullチェックを忘れる
5. longにLを付け忘れる
6. ラッパークラスのnullアンボクシング

これらを避けるだけで、初学者のエラーは大幅に減ります。

7.6 結論としての整理

• Javaは型安全な言語
• データ型理解は全コードの基礎
• プリミティブ型は高速計算向け
• 参照型はオブジェクト管理向け
• 適切な型選択が品質を左右する

FAQ

Q1. Javaのデータ型は全部で何種類ありますか？

回答：
プリミティブ型は8種類です。参照型はクラス・配列・インターフェースなど無数に存在します。まずは8種類のプリミティブ型を理解することが重要です。

Q2. Stringはプリミティブ型ですか？

回答：
いいえ。Stringはクラス型（参照型）です。オブジェクトとして扱われ、nullを代入できます。

Q3. intとIntegerの違いは何ですか？

回答：
intはプリミティブ型、Integerはラッパークラス（参照型）です。Integerはnullを扱えますが、自動アンボクシングで例外が発生することがあります。

Q4. 金額計算にdoubleは使えますか？

回答：
技術的には可能ですが推奨されません。浮動小数点誤差が発生するため、BigDecimalを使用するのが安全です。

Q5. なぜ整数同士の割り算で小数にならないのですか？

回答：
整数同士の演算は整数型で処理されるため、小数部分が切り捨てられます。小数結果が必要な場合は片方をdoubleへキャストします。

Q6. nullとは何ですか？

回答：
参照先が存在しない状態を表します。null状態でメソッドを呼ぶとNullPointerExceptionが発生します。

Q7. == と equals() の違いは何ですか？

回答：
== は参照（メモリアドレス）を比較します。equals() は内容を比較します。文字列比較ではequals()を使用します。

Q8. 初心者はどの型から覚えるべきですか？

回答：
int、double、String、booleanの4つを優先的に理解してください。実務でも使用頻度が高い基本型です。