Java – ラッパークラスで使えるメソッドまとめ

2025-04-15更新日: 2025-04-15

Javaのラッパークラスは、基本データ型をオブジェクトとして扱うためのクラスです。

各ラッパークラスには、基本データ型を操作するための便利なメソッドが用意されています。

例えば、Integerクラスには、文字列を整数に変換するparseInt()や、整数を文字列に変換するtoString()があります。

Doubleクラスには、parseDouble()やtoString()があり、Booleanクラスには、parseBoolean()やtoString()があります。

これらのメソッドは、データ型の変換や比較、解析に役立ちます。

また、valueOf()メソッドは、文字列をラッパークラスのインスタンスに変換する際に使用されます。

これらのメソッドを活用することで、データの操作がより柔軟になります。

目次から探す

Javaを使った求人

読み込み中…

ラッパークラスとは

Javaのラッパークラスは、基本データ型をオブジェクトとして扱うためのクラスです。

これにより、基本データ型をコレクションなどのオブジェクトが必要な場面で利用することが可能になります。

ラッパークラスは、java.langパッケージに含まれており、各基本データ型に対応するクラスが用意されています。

ラッパークラスの基本

ラッパークラスは、以下のように基本データ型に対応しています。

基本データ型	ラッパークラス
`int`	`Integer`
`double`	`Double`
`boolean`	`Boolean`
`char`	`Character`
`byte`	`Byte`
`short`	`Short`
`long`	`Long`
`float`	`Float`

これらのラッパークラスは、基本データ型をオブジェクトとして扱うためのメソッドを提供しています。

例えば、Integerクラスは、int型の値をオブジェクトとして扱うためのメソッドを持っています。

ラッパークラスの必要性

ラッパークラスが必要とされる理由は、Javaのコレクションフレームワークなど、オブジェクトとしてデータを扱う必要がある場面が多いためです。

基本データ型はオブジェクトではないため、直接コレクションに格納することができません。

ラッパークラスを使用することで、基本データ型をオブジェクトとして扱い、コレクションに格納することが可能になります。

また、ラッパークラスは、基本データ型に対する便利なメソッドを提供しています。

例えば、文字列を数値に変換するparseメソッドや、数値を文字列に変換するtoStringメソッドなどがあります。

ラッパークラスと基本データ型の違い

ラッパークラスと基本データ型の主な違いは、以下の通りです。

特徴	基本データ型	ラッパークラス
メモリ使用量	少ない	多い
オブジェクト性	なし	あり
メソッド	なし	あり

基本データ型は、メモリ使用量が少なく、処理速度が速いという利点がありますが、オブジェクトとして扱うことができません。

一方、ラッパークラスは、オブジェクトとして扱うことができ、便利なメソッドを利用できますが、メモリ使用量が多くなるというデメリットがあります。

ラッパークラスを使用する際は、これらの違いを理解し、適切に使い分けることが重要です。

ラッパークラスの種類

Javaには、基本データ型に対応するラッパークラスが用意されています。

それぞれのラッパークラスは、基本データ型をオブジェクトとして扱うための機能を提供します。

ここでは、主要なラッパークラスについて詳しく見ていきます。

Integerクラス

Integerクラスは、int型の値をオブジェクトとして扱うためのラッパークラスです。

Integerクラスは、数値の変換や比較を行うためのメソッドを提供しています。

// App.java
public class App {
    public static void main(String[] args) {
        // Integerオブジェクトの作成
        Integer num = Integer.valueOf(10);
        
        // int型への変換
        int intValue = num.intValue();
        
        // 文字列からintへの変換
        int parsedValue = Integer.parseInt("123");
        
        // Integerオブジェクトの比較
        int comparison = num.compareTo(20);
        
        System.out.println("intValue: " + intValue);
        System.out.println("parsedValue: " + parsedValue);
        System.out.println("comparison: " + comparison);
    }
}

intValue: 10
parsedValue: 123
comparison: -1

この例では、IntegerクラスのvalueOf、intValue、parseInt、compareToメソッドを使用しています。

compareToメソッドは、比較対象の値が大きい場合に負の値を返します。

Doubleクラス

Doubleクラスは、double型の値をオブジェクトとして扱うためのラッパークラスです。

浮動小数点数の変換や比較を行うためのメソッドを提供しています。

// App.java
public class App {
    public static void main(String[] args) {
        // Doubleオブジェクトの作成
        Double num = Double.valueOf(10.5);
        
        // double型への変換
        double doubleValue = num.doubleValue();
        
        // 文字列からdoubleへの変換
        double parsedValue = Double.parseDouble("123.45");
        
        // Doubleオブジェクトの比較
        int comparison = num.compareTo(20.5);
        
        System.out.println("doubleValue: " + doubleValue);
        System.out.println("parsedValue: " + parsedValue);
        System.out.println("comparison: " + comparison);
    }
}

doubleValue: 10.5
parsedValue: 123.45
comparison: -1

この例では、DoubleクラスのvalueOf、doubleValue、parseDouble、compareToメソッドを使用しています。

Booleanクラス

Booleanクラスは、boolean型の値をオブジェクトとして扱うためのラッパークラスです。

真偽値の変換や比較を行うためのメソッドを提供しています。

// App.java
public class App {
    public static void main(String[] args) {
        // Booleanオブジェクトの作成
        Boolean flag = Boolean.valueOf(true);
        
        // boolean型への変換
        boolean boolValue = flag.booleanValue();
        
        // 文字列からbooleanへの変換
        boolean parsedValue = Boolean.parseBoolean("true");
        
        // Booleanオブジェクトの比較
        int comparison = flag.compareTo(false);
        
        System.out.println("boolValue: " + boolValue);
        System.out.println("parsedValue: " + parsedValue);
        System.out.println("comparison: " + comparison);
    }
}

boolValue: true
parsedValue: true
comparison: 1

この例では、BooleanクラスのvalueOf、booleanValue、parseBoolean、compareToメソッドを使用しています。

Characterクラス

Characterクラスは、char型の値をオブジェクトとして扱うためのラッパークラスです。

文字の判定や変換を行うためのメソッドを提供しています。

// App.java
public class App {
    public static void main(String[] args) {
        // Characterオブジェクトの作成
        Character letter = Character.valueOf('A');
        
        // char型への変換
        char charValue = letter.charValue();
        
        // 文字が数字かどうかの判定
        boolean isDigit = Character.isDigit('5');
        
        // 文字を小文字に変換
        char lowerCase = Character.toLowerCase('B');
        
        System.out.println("charValue: " + charValue);
        System.out.println("isDigit: " + isDigit);
        System.out.println("lowerCase: " + lowerCase);
    }
}

charValue: A
isDigit: true
lowerCase: b

この例では、CharacterクラスのvalueOf、charValue、isDigit、toLowerCaseメソッドを使用しています。

その他のラッパークラス

Javaには、他にも以下のラッパークラスがあります。

基本データ型	ラッパークラス
`byte`	`Byte`
`short`	`Short`
`long`	`Long`
`float`	`Float`

これらのラッパークラスも、基本データ型をオブジェクトとして扱うためのメソッドを提供しています。

各クラスは、対応する基本データ型に対する変換や比較を行うためのメソッドを持っています。

ラッパークラスで使える基本メソッド

Javaのラッパークラスは、基本データ型をオブジェクトとして扱うための便利なメソッドを提供しています。

ここでは、ラッパークラスでよく使われる基本的なメソッドについて解説します。

parseメソッド

parseメソッドは、文字列を対応する基本データ型に変換するためのメソッドです。

例えば、Integer.parseIntは文字列をint型に変換します。

// App.java
public class App {
    public static void main(String[] args) {
        // 文字列をintに変換
        int intValue = Integer.parseInt("123");
        
        // 文字列をdoubleに変換
        double doubleValue = Double.parseDouble("123.45");
        
        // 文字列をbooleanに変換
        boolean boolValue = Boolean.parseBoolean("true");
        
        System.out.println("intValue: " + intValue);
        System.out.println("doubleValue: " + doubleValue);
        System.out.println("boolValue: " + boolValue);
    }
}

intValue: 123
doubleValue: 123.45
boolValue: true

この例では、parseInt、parseDouble、parseBooleanメソッドを使用して、文字列をそれぞれの基本データ型に変換しています。

valueOfメソッド

valueOfメソッドは、基本データ型の値をラッパークラスのオブジェクトに変換するためのメソッドです。

これにより、基本データ型をオブジェクトとして扱うことができます。

// App.java
public class App {
    public static void main(String[] args) {
        // intをIntegerオブジェクトに変換
        Integer intObj = Integer.valueOf(123);
        
        // doubleをDoubleオブジェクトに変換
        Double doubleObj = Double.valueOf(123.45);
        
        // booleanをBooleanオブジェクトに変換
        Boolean boolObj = Boolean.valueOf(true);
        
        System.out.println("intObj: " + intObj);
        System.out.println("doubleObj: " + doubleObj);
        System.out.println("boolObj: " + boolObj);
    }
}

intObj: 123
doubleObj: 123.45
boolObj: true

この例では、valueOfメソッドを使用して、基本データ型の値をラッパークラスのオブジェクトに変換しています。

toStringメソッド

toStringメソッドは、ラッパークラスのオブジェクトを文字列に変換するためのメソッドです。

これにより、オブジェクトの値を文字列として扱うことができます。

// App.java
public class App {
    public static void main(String[] args) {
        // Integerオブジェクトを文字列に変換
        String intStr = Integer.toString(123);
        
        // Doubleオブジェクトを文字列に変換
        String doubleStr = Double.toString(123.45);
        
        // Booleanオブジェクトを文字列に変換
        String boolStr = Boolean.toString(true);
        
        System.out.println("intStr: " + intStr);
        System.out.println("doubleStr: " + doubleStr);
        System.out.println("boolStr: " + boolStr);
    }
}

intStr: 123
doubleStr: 123.45
boolStr: true

この例では、toStringメソッドを使用して、ラッパークラスのオブジェクトを文字列に変換しています。

compareToメソッド

compareToメソッドは、ラッパークラスのオブジェクトを他のオブジェクトと比較するためのメソッドです。

比較結果として、負の値、0、正の値を返します。

// App.java
public class App {
    public static void main(String[] args) {
        Integer num1 = Integer.valueOf(10);
        Integer num2 = Integer.valueOf(20);
        
        // 比較
        int comparison = num1.compareTo(num2);
        
        System.out.println("comparison: " + comparison);
    }
}

comparison: -1

この例では、compareToメソッドを使用して、num1とnum2を比較しています。

num1がnum2より小さいため、負の値が返されます。

equalsメソッド

equalsメソッドは、ラッパークラスのオブジェクトが他のオブジェクトと等しいかどうかを判定するためのメソッドです。

// App.java
public class App {
    public static void main(String[] args) {
        Integer num1 = Integer.valueOf(10);
        Integer num2 = Integer.valueOf(10);
        
        // 等価判定
        boolean isEqual = num1.equals(num2);
        
        System.out.println("isEqual: " + isEqual);
    }
}

isEqual: true

この例では、equalsメソッドを使用して、num1とnum2が等しいかどうかを判定しています。

両者が同じ値を持つため、trueが返されます。

各ラッパークラスの詳細メソッド

Javaのラッパークラスは、基本データ型をオブジェクトとして扱うための多くのメソッドを提供しています。

ここでは、各ラッパークラスの詳細なメソッドについて解説します。

Integerクラスのメソッド

parseInt

parseIntメソッドは、文字列をint型に変換します。

数値形式の文字列を整数に変換する際に使用します。

// App.java
public class App {
    public static void main(String[] args) {
        // 文字列をintに変換
        int number = Integer.parseInt("123");
        System.out.println("Parsed int: " + number);
    }
}

Parsed int: 123

valueOf

valueOfメソッドは、int型の値をIntegerオブジェクトに変換します。

// App.java
public class App {
    public static void main(String[] args) {
        // intをIntegerオブジェクトに変換
        Integer number = Integer.valueOf(123);
        System.out.println("Integer object: " + number);
    }
}

Integer object: 123

toString

toStringメソッドは、Integerオブジェクトを文字列に変換します。

// App.java
public class App {
    public static void main(String[] args) {
        // Integerオブジェクトを文字列に変換
        String str = Integer.toString(123);
        System.out.println("String: " + str);
    }
}

String: 123

compare

compareメソッドは、2つのint値を比較します。

比較結果として、負の値、0、正の値を返します。

// App.java
public class App {
    public static void main(String[] args) {
        // 2つのint値を比較
        int result = Integer.compare(10, 20);
        System.out.println("Comparison result: " + result);
    }
}

Comparison result: -1

Doubleクラスのメソッド

parseDouble

parseDoubleメソッドは、文字列をdouble型に変換します。

// App.java
public class App {
    public static void main(String[] args) {
        // 文字列をdoubleに変換
        double number = Double.parseDouble("123.45");
        System.out.println("Parsed double: " + number);
    }
}

Parsed double: 123.45

valueOf

valueOfメソッドは、double型の値をDoubleオブジェクトに変換します。

// App.java
public class App {
    public static void main(String[] args) {
        // doubleをDoubleオブジェクトに変換
        Double number = Double.valueOf(123.45);
        System.out.println("Double object: " + number);
    }
}

Double object: 123.45

toString

toStringメソッドは、Doubleオブジェクトを文字列に変換します。

// App.java
public class App {
    public static void main(String[] args) {
        // Doubleオブジェクトを文字列に変換
        String str = Double.toString(123.45);
        System.out.println("String: " + str);
    }
}

String: 123.45

compare

compareメソッドは、2つのdouble値を比較します。

// App.java
public class App {
    public static void main(String[] args) {
        // 2つのdouble値を比較
        int result = Double.compare(10.5, 20.5);
        System.out.println("Comparison result: " + result);
    }
}

Comparison result: -1

Booleanクラスのメソッド

parseBoolean

parseBooleanメソッドは、文字列をboolean型に変換します。

// App.java
public class App {
    public static void main(String[] args) {
        // 文字列をbooleanに変換
        boolean value = Boolean.parseBoolean("true");
        System.out.println("Parsed boolean: " + value);
    }
}

Parsed boolean: true

valueOf

valueOfメソッドは、boolean型の値をBooleanオブジェクトに変換します。

// App.java
public class App {
    public static void main(String[] args) {
        // booleanをBooleanオブジェクトに変換
        Boolean value = Boolean.valueOf(true);
        System.out.println("Boolean object: " + value);
    }
}

Boolean object: true

toString

toStringメソッドは、Booleanオブジェクトを文字列に変換します。

// App.java
public class App {
    public static void main(String[] args) {
        // Booleanオブジェクトを文字列に変換
        String str = Boolean.toString(true);
        System.out.println("String: " + str);
    }
}

String: true

compare

compareメソッドは、2つのboolean値を比較します。

// App.java
public class App {
    public static void main(String[] args) {
        // 2つのboolean値を比較
        int result = Boolean.compare(true, false);
        System.out.println("Comparison result: " + result);
    }
}

Comparison result: 1

Characterクラスのメソッド

isDigit

isDigitメソッドは、指定された文字が数字かどうかを判定します。

// App.java
public class App {
    public static void main(String[] args) {
        // 文字が数字かどうかを判定
        boolean isDigit = Character.isDigit('5');
        System.out.println("Is digit: " + isDigit);
    }
}

Is digit: true

isLetter

isLetterメソッドは、指定された文字がアルファベットかどうかを判定します。

// App.java
public class App {
    public static void main(String[] args) {
        // 文字がアルファベットかどうかを判定
        boolean isLetter = Character.isLetter('A');
        System.out.println("Is letter: " + isLetter);
    }
}

Is letter: true

toUpperCase

toUpperCaseメソッドは、指定された文字を大文字に変換します。

// App.java
public class App {
    public static void main(String[] args) {
        // 文字を大文字に変換
        char upperCase = Character.toUpperCase('b');
        System.out.println("Upper case: " + upperCase);
    }
}

Upper case: B

toLowerCase

toLowerCaseメソッドは、指定された文字を小文字に変換します。

// App.java
public class App {
    public static void main(String[] args) {
        // 文字を小文字に変換
        char lowerCase = Character.toLowerCase('B');
        System.out.println("Lower case: " + lowerCase);
    }
}

Lower case: b

これらのメソッドを活用することで、Javaのラッパークラスをより効果的に利用することができます。

ラッパークラスの応用例

ラッパークラスは、Javaプログラミングにおいて多くの場面で応用されています。

ここでは、ラッパークラスの具体的な応用例をいくつか紹介します。

データ型変換の実例

ラッパークラスは、文字列から基本データ型への変換や、基本データ型から文字列への変換を簡単に行うことができます。

これにより、ユーザー入力の処理やデータのフォーマット変換が容易になります。

// App.java
public class App {
    public static void main(String[] args) {
        // 文字列をintに変換
        int intValue = Integer.parseInt("42");
        
        // intを文字列に変換
        String intStr = Integer.toString(intValue);
        
        // 文字列をdoubleに変換
        double doubleValue = Double.parseDouble("3.14");
        
        // doubleを文字列に変換
        String doubleStr = Double.toString(doubleValue);
        
        System.out.println("intValue: " + intValue);
        System.out.println("intStr: " + intStr);
        System.out.println("doubleValue: " + doubleValue);
        System.out.println("doubleStr: " + doubleStr);
    }
}

intValue: 42
intStr: 42
doubleValue: 3.14
doubleStr: 3.14

この例では、parseIntやtoStringメソッドを使用して、データ型の変換を行っています。

コレクションでの使用例

ラッパークラスは、Javaのコレクションフレームワークで基本データ型を扱う際に必要です。

コレクションはオブジェクトを格納するため、基本データ型をラッパークラスでラップする必要があります。

// App.java
import java.util.ArrayList;
import java.util.List;
public class App {
    public static void main(String[] args) {
        // Integerオブジェクトのリストを作成
        List<Integer> numbers = new ArrayList<>();
        numbers.add(Integer.valueOf(10));
        numbers.add(Integer.valueOf(20));
        numbers.add(Integer.valueOf(30));
        
        // リストの内容を表示
        for (Integer number : numbers) {
            System.out.println("Number: " + number);
        }
    }
}

Number: 10
Number: 20
Number: 30

この例では、ArrayListにIntegerオブジェクトを格納し、コレクションとして扱っています。

スレッドセーフな操作

ラッパークラスは、スレッドセーフな操作を行う際にも役立ちます。

特に、AtomicIntegerやAtomicBooleanなどのクラスは、スレッドセーフな操作をサポートしています。

// App.java
import java.util.concurrent.atomic.AtomicInteger;
public class App {
    public static void main(String[] args) {
        // AtomicIntegerを使用してスレッドセーフな操作を行う
        AtomicInteger atomicInt = new AtomicInteger(0);
        
        // 値をインクリメント
        int newValue = atomicInt.incrementAndGet();
        
        System.out.println("New value: " + newValue);
    }
}

New value: 1

この例では、AtomicIntegerを使用して、スレッドセーフなインクリメント操作を行っています。

null安全なプログラミング

ラッパークラスを使用することで、nullを扱う際の安全性を高めることができます。

特に、Optionalクラスを使用することで、nullを明示的に扱うことができます。

// App.java
import java.util.Optional;
public class App {
    public static void main(String[] args) {
        // Optionalを使用してnull安全なプログラミングを行う
        Optional<Integer> optionalInt = Optional.ofNullable(null);
        
        // 値が存在するか確認し、存在しない場合はデフォルト値を使用
        int value = optionalInt.orElse(0);
        
        System.out.println("Value: " + value);
    }
}