Javaの学習を進めていくと必ず耳にするのが「ラッパークラス（Wrapper Class）」という概念です。ラッパークラスとは、Javaのプリミティブ型（intやdoubleなど）をオブジェクトとして扱うためのクラスの総称です。
前提知識 プリミティブ型 / オブジェクトとは？（クラスとは？）
なぜプリミティブ型をわざわざオブジェクトにする必要があるのか、どのように使うのが正しいのか。一見複雑に感じるかもしれませんが、Javaのコレクションフレームワークを使う上でも、ラッパークラスの知識は不可欠です。このページでは、Javaのラッパークラスを初心者向けに１から順を追ってわかりやすく解説します。
まずはプリミティブ型の復習から始め、ラッパークラスがなぜ必要なのかを明らかにし、その後、各種ラッパークラスの特徴やオートボクシングとアンボクシングの仕組みまで詳しく説明します。
前提知識の復習：プリミティブ型とオブジェクト
Javaには、大きく分けて「プリミティブ型」と「参照型」の2種類のデータ型があります。プリミティブ型は、いわゆる基本的な型（intやdoubleなど）であり、値そのものをメモリ上に直接格納する仕組みになっています。一方、オブジェクトとして扱われるのは参照型であり、クラスによって定義されるインスタンスのメモリアドレスを参照する形で取り扱います。
プリミティブ型
Javaのプリミティブ型は以下の8種類に分類されます。
byte：8ビット整数（-128～127）short：16ビット整数（-32768～32767）int：32ビット整数（約-21億～21億）long：64ビット整数（非常に大きな範囲）float：単精度浮動小数点数（32ビット）double：倍精度浮動小数点数（64ビット）char：文字型（実体は16ビットのUnicode）boolean：真偽値（trueまたはfalse）
これらは、Java言語の中核を支える基本的なデータ型です。プログラムでよく使われるのがintやdouble、そして真偽を扱うbooleanでこれは何となく暗記できている方も多いかもしれません。
参照型（オブジェクト）
プリミティブ型以外のもの、すなわちクラスとして定義されたオブジェクトは「参照型」と呼ばれます。たとえばStringや自作のクラスなどがこれにあたります。参照型では、変数に格納されているのはインスタンス（オブジェクト）のアドレス（参照先）であり、実際のオブジェクトの中身はヒープ領域などに保存されます。
なぜプリミティブ型をオブジェクトにする必要があるのか？
ここで疑問に思う方もいるかもしれません。プリミティブ型は値を直接扱えるので操作も高速ですし、わざわざオブジェクトに変換する必要などないのでは？
Javaではコレクション（ListやSetなど）の要素にオブジェクト以外は格納できません。つまり、プリミティブ型だけではコレクションフレームワークと連携できないのです。この問題を解決するのがラッパークラスになります。
ラッパークラス（Wrapper Class）とは
ラッパークラス（Wrapper Class）とは、先ほど述べたプリミティブ型をオブジェクトとして扱うためのクラスです。たとえばintであればIntegerクラス、doubleであればDoubleクラスといった具合に、プリミティブ型に対応したクラスが標準ライブラリとして用意されています。
具体的には、以下がその対応表です。
先頭を大文字にしたもの（int と char だけは例外）と覚えればOKです。
ラッパークラスはすべてjava.langパッケージに存在するため、特別なインポートを行わなくてもすぐに利用可能です。たとえばIntegerクラスのインスタンスを使えば、intの値をオブジェクトとして扱うことができ、コレクションの中にIntegerのインスタンスを格納して管理するといった使い方ができます。
- Q1という数値をオブジェクトとして扱う、というイメージがわかない・・・。クラスの中にそれ専用のフィールドがある感じ？
- A
はい、その通りです。Javaのラッパークラス、例えば Integer クラスは、プリミティブ型の値（この場合は 100）をオブジェクトとして扱うために、その値を内部のフィールドに格納しています。内部実装のイメージを以下に示します。
public final class Integer {
private final int value; // プリミティブ型の値を格納するフィールド
public Integer(int value) {
this.value = value;
}
public int intValue() {
return value; // 内部の値を返す
}
// 例: 使用例
public static void main(String[] args) {
Integer obj = new Integer(100); // オブジェクト化
int x = obj.intValue(); // 値を取り出す
System.out.println(x); // 出力: 100
}
}
このように、オブジェクトとしての Integer は、内部に専用のフィールド（上記の例では value）を持ち、100 という値を保持しています。また、このオブジェクトには数値の変換や比較といった便利なメソッドが実装されているため、プリミティブ型ではできない操作を可能にします。
Numberクラス
ここで、現場で使える知識としてNumberクラスについて解説します。
Numberクラスは、すべての数値型ラッパー（Integer、Double、Long、Float、Byte、Short、BigInteger、BigDecimalなど）の共通のスーパークラスとして機能する抽象クラスです。具体的なポイントは以下の通り。
Numberクラスの主な抽象メソッド
Numberクラスには、以下のような抽象メソッドが定義されており、具体的な数値クラスはこれらを実装しています。
これにより、プログラム内で扱う数値の具体的な型に依存せず、統一した方法で値を取得できるメリットがあります。
public class NumberDemo {
public static void main(String[] args) {
// 異なる数値ラッパーのインスタンスを生成
Number num1 = Integer.valueOf(42);
Number num2 = Double.valueOf(3.1415);
// Number型として共通のメソッドを使用して変換値を出力
System.out.println("=== Integerの場合 ===");
printNumberValues(num1);
System.out.println("=== Doubleの場合 ===");
printNumberValues(num2);
}
/**
* Number型の値を各種プリミティブ型に変換して表示するメソッド
*
* @param number 処理対象のNumberオブジェクト
*/
public static void printNumberValues(Number number) {
System.out.println("Original Number: " + number);
System.out.println("byteValue: " + number.byteValue());
System.out.println("shortValue: " + number.shortValue());
System.out.println("intValue: " + number.intValue());
System.out.println("longValue: " + number.longValue());
System.out.println("floatValue: " + number.floatValue());
System.out.println("doubleValue: " + number.doubleValue());
}
}
出力結果
=== Integerの場合 === Original Number: 42 byteValue: 42 shortValue: 42 intValue: 42 longValue: 42 floatValue: 42.0 doubleValue: 42.0 === Doubleの場合 === Original Number: 3.1415 byteValue: 3 shortValue: 3 intValue: 3 longValue: 3 floatValue: 3.1415 doubleValue: 3.1415
オートボクシングとアンボクシング
Java 1.5（Java 5）以降では、オートボクシング（自動的にプリミティブ型を対応するラッパークラスへ変換）とアンボクシング（ラッパークラスを自動的にプリミティブ型へ変換）がサポートされています。これにより、ラッパークラスとプリミティブ型を意識せずに扱える場面が増え、コードが簡潔になりました。
この仕組みのおかげで、あまり両者を意識的に区別せずともコードを書きやすくなっています。ここではその基本的な仕組みを詳しく見ていきましょう。
オートボクシング（Auto-boxing）
オートボクシング（autoboxing）とは、プリミティブ型（int, doubleなど）を自動的にラッパークラス（Integer, Doubleなど）に変換する機能です。Java 5以降で導入されました。
例えば、以下のようなコードを書いた場合、Javaコンパイラは自動的にint型をInteger型へ変換します。
int num = 10; Integer numObj = num; // 自動で new Integer(num) と同等の処理が行われる
昔のJava（1.4以前）では、明示的にInteger numObj = Integer.valueOf(num);と書く必要がありましたが、今ではオートボクシングのおかげで、初心者でも直感的にプリミティブ型とラッパークラスを扱えるようになっています。
アンボクシング（Unboxing）
逆に、ラッパークラスからプリミティブ型へ変換することをアンボクシングといいます。例えば、Integer numObjをint型として使用したい場合、次のように自動でアンボクシングが行われます。
Integer numObj = 100; int n = numObj; // 自動で numObj.intValue() が呼び出される
これもJava 1.5以前のコードでは、メソッド呼び出しを明示的に行わなければいけませんでした。
このように、オートボクシングとアンボクシングがあるおかげで、強く両者の違いを意識しなくても変換が可能になっています。ただし初期の勉強段階ではプリミティブ型とラッパー型が何者なのか？をしっかり識別しておくことは（今後の応用をしていくうえでも）非常に重要です。
何となく、プリミティブ型をオブジェクトとして扱えるようにしたのがラッパークラスなんだな！と理解できたところで、ここから具体的な利用方法の例をお示ししていきます。
各ラッパークラスの特徴と使い方
ここでは8種類のプリミティブ型に対応するラッパークラスを、ひとつひとつ取り上げて解説します。それぞれがどのような用途やメソッドを持っているかを理解しておきましょう。
Byteクラス
- プリミティブ型：
byte - ラッパークラス：
Byte - 主な範囲：-128～127
Byteクラスは範囲が非常に限られているため、あまり使われる機会は多くありません。ただし、ネットワーク通信やバイナリデータを扱う際には、byte配列を用いることが一般的で、その際にByteを扱うこともあります。
byte b = 10; Byte bObj = b; // オートボクシング byte b2 = bObj; // アンボクシング
Shortクラス
- プリミティブ型：
short - ラッパークラス：
Short - 主な範囲：-32768～32767
Shortクラスを使う場面もそこまで多くはありませんが、メモリを節約したい場合に利用されることがあります。ただし、Javaではintが最も一般的に使われる整数型なので、Shortが活躍する場面はこれまた限定的です。
short s = 100; Short sObj = s; short s2 = sObj;
Integerクラス
- プリミティブ型：
int - ラッパークラス：
Integer - 主な範囲：約 -2,147,483,648～2,147,483,647
int型はJavaで最も頻繁に使われる整数型であり、対応するIntegerクラスも非常に利用価値が高いです。Integerには、様々な静的メソッド（valueOf(), parseInt(), toString()など）が用意されており、文字列から整数への変換や整数同士の比較などで重宝します。
public class IntegerSample {
public static void main(String[] args) {
// オートボクシング（int → Integer）
Integer a = 100;
Integer b = Integer.valueOf("200");
// アンボクシング（Integer → int）
int x = a.intValue();
System.out.println("intValue(): " + x); // 出力: 100
// 文字列への変換
String str = a.toString();
System.out.println("toString(): " + str); // 出力: "100"
// 文字列から整数へ
int parsed = Integer.parseInt("300");
System.out.println("parseInt(): " + parsed); // 出力: 300
// 大小比較
int cmp = a.compareTo(b);
System.out.println("compareTo(): " + cmp); // 出力:
Longクラス
- プリミティブ型：
long - ラッパークラス：
Long - 主な範囲：非常に広い（-2^63～2^63-1）
より大きな整数を扱いたいときに使用するのがlong型とLongクラスです。特に、Javaのバージョンによっては、日時を扱う際にUNIXタイムスタンプなどをlongで管理するケースもあります。
long l = 10000000000L; Long lObj = l; long l2 = lObj;
Floatクラス
- プリミティブ型：
float - ラッパークラス：
Float - 精度：単精度浮動小数点数（約6～7桁）
浮動小数点数を扱う際にはdoubleのほうが精度が高いため、floatとFloatはそれほど頻繁には使われません。ただし、グラフィック系のプログラムや、大量の小数をやり取りする場合にメモリ使用量を抑える目的で用いられることがあります。
float f = 3.14f; Float fObj = f; float f2 = fObj;
Doubleクラス
- プリミティブ型：
double - ラッパークラス：
Double - 精度：倍精度浮動小数点数（約15～16桁）
doubleは浮動小数点数の中で最も一般的に使われる型で、計算やデータ処理でもよく登場します。DoubleクラスではparseDouble(), toString()といった便利な静的メソッドが提供されています。
double d = 3.14159265; Double dObj = d; // オートボクシング double d2 = dObj;
Characterクラス
- プリミティブ型：
char - ラッパークラス：
Character - 文字コード：UTF-16 (Unicode)
charは1文字を表すのに使われますが、実際にはUnicodeを16ビットで扱います。Characterクラスには、文字が数字かアルファベットかを判定するようなメソッド（isDigit(), isLetter()など）が用意されています。
char c = 'A'; Character cObj = c; char c2 = cObj;
Booleanクラス
- プリミティブ型：
boolean - ラッパークラス：
Boolean - 値：
trueまたはfalse
Booleanは真偽値のラッパークラスです。論理型をコレクションに格納したり、nullを扱いたいときなどに使用されます。booleanをそのまま使うよりも、オブジェクトとしての柔軟性が高いのが特徴です。
boolean flag = true; Boolean flagObj = flag; boolean flag2 = flagObj;
補足：よく使う数値はキャッシュされている
ラッパークラス（特に Integer や Long など）では、よく使われる小さな数値はJavaの中で再利用される仕組み（＝キャッシュ）があります。
Javaのラッパークラス（Integer や Long など）は「クラス（＝オブジェクト）」です。
だから普通は、次のように == で比べると false になると思いますよね。
Integer a = new Integer(100); Integer b = new Integer(100); System.out.println(a == b); // false（オブジェクト同士は別物）
これは正解です。== は「同じ箱（同じメモリの場所）かどうか」を比べるので、別々に作ったオブジェクトは false になります。
でも、↓のコードを見てください。
Integer a = 100; Integer b = 100; System.out.println(a == b); // true
なんと、これは true になります。なぜか？実は、Javaでは -128 〜 127 の数値はあらかじめ使いまわされる仕組みがあります。これを「キャッシュ」といいます。
つまり、Integer a = 100; と Integer b = 100; は、同じオブジェクトを指すように裏で工夫されているんです。
もちろんキャッシュされる数値の範囲外だとこうなります↓。
Integer x = 200; Integer y = 200; System.out.println(x == y); // false
このときはキャッシュされず、Javaが新しいオブジェクトを別々に作るため、== は false になります。
ポイント キャッシュされる範囲（覚えておくと安心）
-128〜127の間の数値はキャッシュされます（Integer,Short,Byte,Long,Characterに共通）。- この範囲内なら同じオブジェクトが使い回されるため、
==比較もtrueになります。 - 値を比べたいときは
equals()を使うのが安全です。==はオブジェクト同士の「箱として同じか」を比べるので、キャッシュの影響を受けます。
Integer a = 200; Integer b = 200; System.out.println(a.equals(b)); // true（中身を比較）
ラッパークラスの実践的な使い方
ここでは、実際にラッパークラスとコレクションを組み合わせて使う例を紹介します。多くの場合、ラッパークラスを扱うシーンとして頻出するのが、List<Integer>やList<Double>など、コレクションフレームワークとの連携です。
import java.util.ArrayList;
import java.util.List;
public class WrapperClassExample {
public static void main(String[] args) {
// intのリストを作成したい場合
// intはプリミティブ型なので直接は扱えない ⇒ Integerでラップする
List<Integer> intList = new ArrayList<>();
// オートボクシングによって自動的にIntegerに変換される
intList.add(10);
intList.add(20);
intList.add(30);
// リストから値を取り出すときはアンボクシングされ、intとして取得できる
for (int value : intList) {
System.out.println("値: " + value);
}
// Doubleを使った例
List<Double> doubleList = new ArrayList<>();
doubleList.add(3.14); // オートボクシングでDoubleに
doubleList.add(2.71828);
for (double d : doubleList) {
System.out.println("浮動小数点数: " + d);
}
}
}
このサンプルでは、オートボクシングとアンボクシングが自然に使われています。もしオートボクシングがなければ、それぞれInteger.valueOf(10)などと明示的に記述する必要があるでしょう。オートボクシングが導入されてからは、プリミティブ型とラッパークラス間の煩雑な変換作業が大幅に削減され、コードの可読性も上がっています。
ラッパークラス使用時の注意点
パフォーマンスへの影響
オートボクシングやアンボクシングは便利ですが、その都度オブジェクトの生成が行われたり、メソッド呼び出しを経由したりするため、プリミティブ型を直接扱う場合よりもパフォーマンスが低下する可能性があります。大量の数値演算を行うような場合は、ラッパークラスよりもプリミティブ型を優先的に使うほうが望ましいでしょう。
nullの取り扱い
ラッパークラスはオブジェクトであるため、nullを代入することが可能です。一方、プリミティブ型にはnullを入れることはできません。この違いは、プログラムにバグを生みやすい要因となります。たとえばIntegerがnullの場合にアンボクシングを行うと、NullPointerExceptionが発生してしまう可能性があります。
値の比較方法
ラッパークラスのインスタンス同士を==演算子で比較すると、オブジェクトの参照先が等しいかどうかを判定することになります。数値として等しいかどうかを判定したい場合は、equals()メソッドを使う必要があります。例えばIntegerクラスなら以下のようになります。
Integer a = 100; Integer b = 100; System.out.println(a == b); // trueになる場合もあればfalseになる場合も（値のキャッシュ機構による） System.out.println(a.equals(b)); // true（値が同じ場合）
Javaでは-128～127の範囲をキャッシュする機能があるため、値によっては==演算子でtrueが返ることがありますが、仕様に依存した挙動なので注意が必要です。正確な値比較を行う場合は常にequals()か、プリミティブ型へのアンボクシング後に==で比較することを推奨します。
よくある疑問とベストプラクティス
- Qいつラッパークラスを使うべきか？
- A
- コレクション（
List,Set,Mapなど）にプリミティブ型を格納したいとき - メソッドの引数や戻り値として
nullを扱いたいとき（プリミティブ型ではnullは扱えない） - ライブラリ側がラッパークラスを要求する場合（リフレクションなど）
このように、オブジェクトとして扱う必要がある場面ではラッパークラスを積極的に使います。一方、大量の数値計算やパフォーマンスが重要な場面ではプリミティブ型を使うのがベターです。
- コレクション（
- Qラッパークラス間の変換はできる？
- A
Javaの標準ライブラリには、ラッパークラス間での直接的な変換メソッドはあまり用意されていません。たとえば
IntegerからDoubleへの直接変換メソッドは存在せず、いったんプリミティブ型のintにアンボクシングした後でdoubleにキャストし、それをDoubleにオートボクシングする、という手順が必要になる場合があります。Integer i = 10;Double d = i.doubleValue(); // Integer → int → double → DoubleInteger i = 10; Double d = i.doubleValue(); // Integer → int → double → DoubleInteger i = 10; Double d = i.doubleValue(); // Integer → int → double → Double
- Q
Stringとの相互変換は？ - A
数値を文字列に変換する場合、ラッパークラスの
toString()やString.valueOf()、あるいはInteger.toString(int value)などの静的メソッドを活用します。逆に文字列から数値への変換には、parseInt(),parseDouble()などが用いられます。String str = "100";int value = Integer.parseInt(str); // 文字列からintへString str2 = String.valueOf(value); // intから文字列へString str = "100"; int value = Integer.parseInt(str); // 文字列からintへ String str2 = String.valueOf(value); // intから文字列へString str = "100"; int value = Integer.parseInt(str); // 文字列からintへ String str2 = String.valueOf(value); // intから文字列へ