数値

【Java】基本プリミティブ型から参照型までわかるデータ型一覧

2025-04-23更新日: 2025-04-23

Javaのデータ型は基本のプリミティブ型と参照型に分かれます。

プリミティブ型は8種類あり、byte、short、int、long、float、double、char、booleanで構成されます。

参照型はStringや配列、ユーザー定義のクラスやインターフェースでデータを扱います。

目次から探す

プリミティブ型

Javaの基本的なデータ型は、「プリミティブ型」と呼ばれ、あらかじめ言語仕様として定義されています。

これらの型は、メモリ上に直接値を格納し、計算や処理を高速に行うことができるため、プログラムの効率化に役立ちます。

プリミティブ型は大きく分けて、整数型、浮動小数点型、文字型、論理型の4つに分類されます。

整数型

整数型は、符号付きの整数値を扱うための型です。

範囲やビット数に応じて複数の種類が用意されており、用途に応じて使い分けることが重要です。

byte

byteは8ビットの符号付き整数型です。

範囲は-128から127までとなっており、メモリの節約や大量のデータを扱う場合に適しています。

例えば、画像処理やネットワーク通信のデータ処理に利用されることがあります。

public class App {
    public static void main(String[] args) {
        // byte型の例
        byte smallNumber = 100; // 100はbyteの範囲内
        System.out.println("byte型の値: " + smallNumber);
    }
}

byte型の値: 100

short

shortは16ビットの符号付き整数型です。

範囲は-32,768から32,767までです。

byteよりも広い範囲を扱いたい場合に使用します。

例えば、センサーからのデータや一部のゲームプログラムで使われることがあります。

public class App {
    public static void main(String[] args) {
        // short型の例
        short temperature = 32767; //範囲内の値
        System.out.println("short型の値: " + temperature);
    }
}

short型の値: 32767

int

intは32ビットの符号付き整数型で、Javaで最も一般的に使われる整数型です。

範囲は-2,147,483,648から2,147,483,647までです。

ほとんどの計算やループカウンタに利用されます。

public class App {
    public static void main(String[] args) {
        // int型の例
        int count = 100000;
        System.out.println("int型の値: " + count);
    }
}

int型の値: 100000

long

longは64ビットの符号付き整数型です。

範囲は-9,223,372,036,854,775,808から9,223,372,036,854,775,807までです。

非常に大きな数値を扱う必要がある場合に使用します。

例えば、天文学的な計算や金融の大きな金額の計算に適しています。

public class App {
    public static void main(String[] args) {
        // long型の例
        long bigNumber = 9223372036854775807L; // 数値の末尾にLを付ける
        System.out.println("long型の値: " + bigNumber);
    }
}

long型の値: 9223372036854775807

浮動小数点型

浮動小数点型は、小数点を含む数値を扱うための型です。

計算の精度や範囲に応じてfloatとdoubleの2種類があります。

float

floatは32ビットの単精度浮動小数点数です。

約6～7桁の10進数の精度を持ち、メモリの節約や大量の浮動小数点数を扱う場合に適しています。

public class App {
    public static void main(String[] args) {
        // float型の例
        float pi = 3.14159f; // 数値の末尾にfを付ける
        System.out.println("float型の値: " + pi);
    }
}

float型の値: 3.14159

double

doubleは64ビットの倍精度浮動小数点数です。

約15桁の10進数の精度を持ち、科学計算や高精度の計算に使われます。

public class App {
    public static void main(String[] args) {
        // double型の例
        double e = 2.718281828459045;
        System.out.println("double型の値: " + e);
    }
}

double型の値: 2.718281828459045

文字型

charは16ビットのUnicode文字を扱う型です。

Unicodeの範囲は\u0000から\uFFFFまでで、多言語の文字や記号を表現できます。

public class App {
    public static void main(String[] args) {
        // char型の例
        char letter = 'A'; // シングルクォーテーションで囲む
        System.out.println("char型の文字: " + letter);
    }
}

char型の文字: A

また、Unicodeコードポイントを直接指定して文字を設定することも可能です。

public class App {
    public static void main(String[] args) {
        // Unicodeコードポイントを使った例
        char smiley = '\u263A'; // ☺
        System.out.println("Unicode文字: " + smiley);
    }
}

Unicode文字: ☺

論理型

booleanは論理値を扱う型で、trueまたはfalseの2つの値だけを取ります。

条件判定やフラグ管理に利用されます。

public class App {
    public static void main(String[] args) {
        // boolean型の例
        boolean isJavaFun = true;
        System.out.println("Javaは楽しい？: " + isJavaFun);
    }
}

Javaは楽しい？: true

public class App {
    public static void main(String[] args) {
        // 条件判定の例
        boolean isAdult = false;
        if (isAdult) {
            System.out.println("成人です。");
        } else {
            System.out.println("未成年です。");
        }
    }
}

未成年です。

これらのプリミティブ型は、Javaのプログラムの基礎を支える重要な要素です。

適切な型を選択し、効率的なデータ処理を行うことが、良いプログラム設計の第一歩となります。

参照型

Javaの参照型は、プリミティブ型とは異なり、実際のデータの参照(アドレス)を格納します。

これにより、複雑なデータ構造やオブジェクト指向プログラミングの実現が可能となります。

参照型は、基本的にクラスやインターフェース、配列などのデータ構造を扱うために使用されます。

String

Stringは文字列を扱うためのクラスで、Javaで最も頻繁に使用される参照型の一つです。

文字列の操作や比較、結合など、多くの便利なメソッドが用意されています。

public class App {
    public static void main(String[] args) {
        // Stringの例
        String greeting = "こんにちは";
        System.out.println(greeting);
    }
}

こんにちは

Stringは不変(イミュータブル)なクラスであり、一度作成された文字列は変更できません。

文字列の操作を行うと、新しいStringオブジェクトが生成されます。

public class App {
    public static void main(String[] args) {
        // 文字列の連結例
        String message = "Java" + "プログラミング";
        System.out.println(message);
    }
}

Javaプログラミング

配列

配列は、同じ型の複数のデータをまとめて管理できるデータ構造です。

一次元配列と多次元配列の2種類があります。

一次元配列

一次元配列は、単純に連続したメモリ領域にデータを格納します。

インデックスを使ってアクセスし、要素の追加や削除はできません。

public class App {
    public static void main(String[] args) {
        // 一次元配列の例
        int[] numbers = {1, 2, 3, 4, 5};
        System.out.println("最初の要素: " + numbers[0]);
    }
}

最初の要素: 1

配列の長さはlengthプロパティで取得できます。

public class App {
    public static void main(String[] args) {
        // 一次元配列の例
        int[] numbers = {1, 2, 3, 4, 5};
        System.out.println("最初の要素: " + numbers[0]);

        // 配列の長さ
        System.out.println("配列の長さ: " + numbers.length);
    }
}

最初の要素: 1
配列の長さ: 5

多次元配列

多次元配列は、配列の中に配列を格納した構造です。

最も一般的なのは二次元配列で、表やマトリックスの表現に適しています。

public class App {
    public static void main(String[] args) {
        // 二次元配列の例
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6}
        };
        System.out.println("二次元配列の要素: " + matrix[1][2]);
    }
}

二次元配列の要素: 6

多次元配列は、配列の長さや次元数に応じてアクセス方法が異なります。

public class App {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6}
        };
        // 配列の行数と列数
        System.out.println("行数: " + matrix.length);
        System.out.println("列数(1行目): " + matrix[0].length);
    }
}

行数: 2
列数(1行目): 3

コレクションフレームワーク

Javaのコレクションフレームワークは、データの格納や操作を効率的に行うためのクラス群です。

リスト、セット、マップなどのインターフェースと、それを実装した具体的なクラスが用意されています。

List

Listは、順序付けられたコレクションで、重複を許容します。

インデックスによるアクセスや挿入、削除が可能です。

import java.util.List;
import java.util.ArrayList;
public class App {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("リンゴ");
        fruits.add("バナナ");
        fruits.add("オレンジ");
        System.out.println("リストの内容: " + fruits);
    }
}

リストの内容: [リンゴ, バナナ, オレンジ]

ArrayList

ArrayListはListインターフェースの最も一般的な実装クラスです。

動的にサイズが変化し、要素の追加や削除が高速に行えます。

// ArrayListの例
import java.util.ArrayList;
public class App {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        System.out.println("ArrayListの内容: " + numbers);
    }
}

ArrayListの内容: [10, 20, 30]

LinkedList

LinkedListはListとDequeの両方のインターフェースを実装しており、挿入や削除が頻繁に行われる場合に適しています。

// LinkedListの例
import java.util.LinkedList;
public class App {
    public static void main(String[] args) {
        LinkedList<String> queue = new LinkedList<>();
        queue.add("最初");
        queue.add("次");
        queue.add("最後");
        System.out.println("LinkedListの内容: " + queue);
    }
}

LinkedListの内容: [最初, 次, 最後]

Set

Setは、重複しない要素のコレクションです。

順序は保証されません。

HashSet

HashSetはハッシュテーブルを使った実装で、最も高速なセットです。

// HashSetの例
import java.util.HashSet;
public class App {
    public static void main(String[] args) {
        HashSet<String> uniqueNames = new HashSet<>();
        uniqueNames.add("佐藤");
        uniqueNames.add("鈴木");
        uniqueNames.add("佐藤"); // 重複は無視される
        System.out.println("HashSetの内容: " + uniqueNames);
    }
}

HashSetの内容: [鈴木, 佐藤]

TreeSet

TreeSetは要素を自然順序または指定したComparatorでソートします。

// TreeSetの例
import java.util.TreeSet;
public class App {
    public static void main(String[] args) {
        TreeSet<Integer> sortedNumbers = new TreeSet<>();
        sortedNumbers.add(5);
        sortedNumbers.add(2);
        sortedNumbers.add(8);
        System.out.println("TreeSetの内容: " + sortedNumbers);
    }
}

TreeSetの内容: [2, 5, 8]

Map

Mapはキーと値のペアを管理します。

キーは重複しません。

HashMap

HashMapはハッシュテーブルを使った実装で、高速な検索が可能です。

// HashMapの例
import java.util.HashMap;
public class App {
    public static void main(String[] args) {
        HashMap<String, Integer> ageMap = new HashMap<>();
        ageMap.put("田中", 30);
        ageMap.put("山本", 25);
        System.out.println("HashMapの内容: " + ageMap);
    }
}

HashMapの内容: {山本=25, 田中=30}

TreeMap

TreeMapはキーを自然順序またはComparatorでソートします。

// TreeMapの例
import java.util.TreeMap;
public class App {
    public static void main(String[] args) {
        TreeMap<String, Integer> sortedMap = new TreeMap<>();
        sortedMap.put("リンゴ", 3);
        sortedMap.put("バナナ", 2);
        System.out.println("TreeMapの内容: " + sortedMap);
    }
}

TreeMapの内容: {バナナ=2, リンゴ=3}

日付・時刻API

Java 8以降、java.timeパッケージに新しい日付・時刻APIが導入され、従来のDateやCalendarよりも使いやすくなっています。

LocalDate

日付(年月日)を表すクラスです。

時間情報は含まれません。

// LocalDateの例
import java.time.LocalDate;
public class App {
    public static void main(String[] args) {
        LocalDate today = LocalDate.now();
        System.out.println("今日の日付: " + today);
    }
}

今日の日付: 2024-04-27

LocalDateTime

日付と時刻を表すクラスです。

タイムゾーンの情報は含まれません。

// LocalDateTimeの例
import java.time.LocalDateTime;
public class App {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();
        System.out.println("現在の日時: " + now);
    }
}

現在の日時: 2025-04-23T02:25:07.739047400

ZonedDateTime

タイムゾーンを考慮した日時を表します。

// ZonedDateTimeの例
import java.time.ZonedDateTime;
import java.time.ZoneId;
public class App {
    public static void main(String[] args) {
        ZonedDateTime tokyoTime = ZonedDateTime.now(ZoneId.of("Asia/Tokyo"));
        System.out.println("東京の日時: " + tokyoTime);
    }
}

東京の日時: 2025-04-23T02:25:20.586465500+09:00[Asia/Tokyo]

Duration／Period

Durationは時間の長さを表し、Periodは年月日単位の期間を表します。

// Durationの例
import java.time.Duration;
import java.time.LocalTime;
public class App {
    public static void main(String[] args) {
        LocalTime start = LocalTime.of(9, 0);
        LocalTime end = LocalTime.of(17, 30);
        Duration workDuration = Duration.between(start, end);
        System.out.println("勤務時間: " + workDuration.toHours() + "時間");
    }
}

勤務時間: 8時間

// Periodの例
import java.time.Period;
import java.time.LocalDate;
public class App {
    public static void main(String[] args) {
        LocalDate startDate = LocalDate.of(2024, 1, 1);
        LocalDate endDate = LocalDate.of(2024, 4, 27);
        Period period = Period.between(startDate, endDate);
        System.out.println("経過期間: " + period.getMonths() + "ヶ月と" + period.getDays() + "日");
    }
}

経過期間: 3ヶ月と26日

Enum型

enumは列挙型を定義し、限定された値の集合を表現します。

enumの定義

列挙型はenumキーワードを使って定義します。

// enumの例
public enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}

enumで利用できるメソッド

enum型は自動的にvalues()やvalueOf()といった便利なメソッドを持ちます。

enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY;
}

public class App {
    public static void main(String[] args) {
        for (Day day : Day.values()) {
            System.out.println(day);
        }
        // 特定の値を取得
        Day today = Day.valueOf("FRIDAY");
        System.out.println("今日の曜日: " + today);
    }
}

SUNDAY
MONDAY
TUESDAY
WEDNESDAY
THURSDAY
FRIDAY
SATURDAY
今日の曜日: FRIDAY

アノテーション型

アノテーションは、コードにメタ情報を付与する仕組みです。

アノテーションの定義

自作のアノテーションは@interfaceを使って定義します。

// アノテーションの例
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
    String value() default "テストメソッド";
}

アノテーションの適用

定義したアノテーションは、対象のクラスやメソッドに付与します。

// アノテーションの適用例
public class Sample {
    @Test("このメソッドはテスト用です")
    public void testMethod() {
        // 処理内容
    }
}

ユーザー定義クラス

Javaでは、独自のデータ型を作成するためにクラスを定義します。

クラスの宣言とフィールド

クラスはclassキーワードを使って宣言し、フィールド(変数)を持ちます。

// ユーザー定義クラスの例
public class Person {
    // フィールド
    String name;
    int age;
}

コンストラクタとメソッド

コンストラクタはインスタンス生成時に呼び出され、フィールドの初期化に使います。

// コンストラクタとメソッドの例
public class Person {
    String name;
    int age;
    // コンストラクタ
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // メソッド
    public void introduce() {
        System.out.println("私の名前は" + name + "です。年齢は" + age + "歳です。");
    }
}

インスタンス生成と参照

クラスのインスタンスはnewキーワードを使って生成し、変数に格納します。

// インスタンス生成例
public class App {
    public static void main(String[] args) {
        Person person = new Person("山田太郎", 28);
        person.introduce();
    }
}

私の名前は山田太郎です。年齢は28歳です。

インターフェース

インターフェースは、クラスが実装すべきメソッドの仕様を定義します。

インターフェースの定義

interfaceキーワードを使って定義します。

// インターフェースの例
public interface Animal {
    void eat();
    void sleep();
}

実装クラスとの関係

インターフェースを実装するクラスはimplementsキーワードを使います。

// 実装クラスの例
public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("犬は食べます");
    }
    @Override
    public void sleep() {
        System.out.println("犬は寝ます");
    }
}

// 同じファイルに複数クラス記述するのは非推奨なので注意
import java.util.*;

// インターフェースの例
public interface Animal {
    void eat();
    void sleep();
}

// 実装クラスの例
public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("犬は食べます");
    }
    @Override
    public void sleep() {
        System.out.println("犬は寝ます");
    }
}

public class App {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        dog.sleep();
    }
}

犬は食べます
犬は寝ます

ジェネリクス

ジェネリクスは、クラスやメソッドの型をパラメータ化し、再利用性と型安全性を高める仕組みです。

型パラメータ

クラスやメソッドに<T>のように型パラメータを指定します。

// ジェネリクスクラスの例
public class Box<T> {
    private T item;
    public void set(T item) {
        this.item = item;
    }
    public T get() {
        return item;
    }
}

ワイルドカードと制約

?を使ったワイルドカードは、柔軟な型の指定に役立ちます。

// ワイルドカードの例
public void printList(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
}

これにより、任意の型のリストを引数に取ることが可能です。

これらの参照型は、Javaのオブジェクト指向の基盤を支え、多様なデータ構造や設計パターンを実現します。

適切な型の選択と理解が、堅牢で拡張性の高いプログラム作成に直結します。

ラッパークラス

Javaのプリミティブ型は、値を直接格納するため、オブジェクトとしての機能やメソッドを持ちません。

そこで、各プリミティブ型に対応したクラスが用意されており、これらを「ラッパークラス」と呼びます。

ラッパークラスは、プリミティブ型の値をオブジェクトとして扱いたい場合や、コレクションフレームワークでプリミティブ型を格納したい場合に役立ちます。

各プリミティブ型のラッパー

Javaには、以下のプリミティブ型に対応したラッパークラスが用意されています。

Byte／Short／Integer／Long

これらは、それぞれbyte、short、int、longのラッパークラスです。

これらのクラスは、プリミティブ値を格納し、さまざまなユーティリティメソッドを提供します。

Byte：byteのラッパー。バイト値の範囲は-128から127
Short：shortのラッパー。範囲は-32,768から32,767
Integer：intのラッパー。範囲は-2,147,483,648から2,147,483,647
Long：longのラッパー。範囲は-9,223,372,036,854,775,808から9,223,372,036,854,775,807

これらのクラスは、値の比較や変換、文字列との相互変換など、多くの便利なメソッドを持ちます。

public class App {
    public static void main(String[] args) {
        // Integerの例
        int num = 100;
        Integer wrappedNum = Integer.valueOf(num); // オブジェクトに変換
        System.out.println("ラッパークラスの値: " + wrappedNum);
    }
}

ラッパークラスの値: 100

Float／Double

floatとdoubleのラッパークラスです。

Float：floatのラッパー。約6～7桁の精度を持ちます
Double：doubleのラッパー。約15桁の精度を持ちます

これらは、数値の比較や文字列変換、特殊値(NaNやInfinity)の扱いに便利です。

import java.lang.Double;

public class App {
    public static void main(String[] args) {
        // Doubleの例
        double pi = 3.14159;
        Double wrappedPi = Double.valueOf(pi);
        System.out.println("Doubleの値: " + wrappedPi);
    }
}

Doubleの値: 3.14159

Character

charのラッパークラスです。

Unicode文字を扱います。

import java.lang.Character;

public class App {
    public static void main(String[] args) {
        // Characterの例
        char letter = 'A';
        Character wrappedChar = Character.valueOf(letter);
        System.out.println("Characterの値: " + wrappedChar);
    }
}

Characterの値: A

Characterクラスは、文字の判定や変換、Unicodeコードポイントの取得などのメソッドを提供します。

import java.lang.Character;

public class App {
    public static void main(String[] args) {
        // 文字判定例
        char ch = 'A';
        if (Character.isUpperCase(ch)) {
            System.out.println(ch + "は大文字です。");
        }
    }
}

Aは大文字です。

Boolean

booleanのラッパークラスです。

public class App {
    public static void main(String[] args) {
        // Booleanの例
        Boolean isJavaFun = Boolean.valueOf(true);
        System.out.println("Booleanの値: " + isJavaFun);
    }
}

Booleanの値: true

Booleanクラスは、文字列から真偽値への変換や、真偽値の比較に役立ちます。

// 文字列からBooleanへの変換
public class App {
    public static void main(String[] args) {
        Boolean result = Boolean.parseBoolean("true");
        System.out.println("パース結果: " + result);
    }
}

パース結果: true

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

Javaでは、プリミティブ型とラッパークラス間の変換を自動的に行う仕組みが導入されています。

これを「オートボクシング」と呼び、逆にオブジェクトからプリミティブ型に変換することを「アンボクシング」と呼びます。

オートボクシング

プリミティブ型の値を自動的にラッパークラスのオブジェクトに変換します。

public class App {
    public static void main(String[] args) {
        // オートボクシングの例
        int num = 50;
        Integer wrappedNum = num; // 自動的にInteger.valueOf(50)に変換
        System.out.println("オートボクシング後の値: " + wrappedNum);
    }
}

オートボクシング後の値: 50

アンボクシング

ラッパークラスのオブジェクトを自動的にプリミティブ型に変換します。

public class App {
    public static void main(String[] args) {
        // アンボクシングの例
        Integer wrappedNum = Integer.valueOf(100);
        int num = wrappedNum; // 自動的にintに変換
        System.out.println("アンボクシング後の値: " + num);
    }
}

アンボクシング後の値: 100

これらの仕組みにより、コードの記述が簡潔になり、プリミティブ型とオブジェクト型の間の変換がシームレスに行えます。

ただし、オートボクシングとアンボクシングはパフォーマンスに影響を与える場合もあるため、必要に応じて明示的な変換を行うことも重要です。

これらのラッパークラスとオートボクシングの仕組みを理解しておくことで、Javaの型安全性やコレクション操作の柔軟性を高めることができます。

特に、コレクションフレームワークではプリミティブ型を直接扱えないため、ラッパークラスを活用する場面が多くあります。

文字列操作クラス

Javaでは、文字列を効率的に操作するためのクラスがいくつか用意されています。

これらのクラスを適切に使い分けることで、文字列の結合や置換、正規表現によるパターンマッチングなどの処理を効率良く行うことが可能です。

StringBuilder

StringBuilderは、可変長の文字列を扱うためのクラスです。

Stringは不変(イミュータブル)であるため、文字列の連結や変更を頻繁に行う場合にはStringBuilderを使うのが効率的です。

StringBuilderは内部的に文字配列を持ち、必要に応じて容量を拡張しながら文字列を操作します。

// StringBuilderの例
public class App {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("こんにちは");
        sb.append("、Javaの世界へ！");
        System.out.println(sb.toString());
    }
}

こんにちは、Javaの世界へ！

append()メソッドは文字列の末尾に新しい文字列を追加します。

StringBuilderは、文字列の連結や挿入、削除などの操作に対して高速に動作します。

StringBuffer

StringBufferもStringBuilderと似たクラスで、可変長の文字列を扱います。

ただし、StringBufferはスレッドセーフ(同期化されている)ため、複数のスレッドから同時にアクセスされる環境で安全に使用できます。

一方、StringBuilderはスレッド非安全ですが、その分高速です。

// StringBufferの例
public class App {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("おはよう");
        sb.append("ございます");
        System.out.println(sb.toString());
    }
}

おはようございます

一般的に、シングルスレッド環境ではStringBuilderを使い、マルチスレッド環境ではStringBufferを選択します。

正規表現用クラス

正規表現は、文字列のパターンマッチングや置換に非常に便利な仕組みです。

Javaでは、PatternとMatcherクラスを使って正規表現を扱います。

Pattern

Patternクラスは、正規表現のパターンを表現します。

パターンは一度コンパイルしておき、複数の文字列に対して効率的にマッチングを行うことができます。

// Patternの例
import java.util.regex.Pattern;
public class App {
    public static void main(String[] args) {
        String regex = "\\d+"; // 数字の連続
        Pattern pattern = Pattern.compile(regex);
        System.out.println("パターン作成完了");
    }
}

Pattern.compile()メソッドで正規表現をコンパイルし、Patternオブジェクトを生成します。

Matcher

Matcherクラスは、Patternで作成したパターンに対して文字列のマッチングを行います。

Matcherは、文字列の検索や置換、抽出などの操作を提供します。

// Matcherの例
import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class App {
    public static void main(String[] args) {
        String text = "私の電話番号は090-1234-5678です。";
        String regex = "\\d{3}-\\d{4}-\\d{4}";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        if (matcher.find()) {
            System.out.println("見つかった番号: " + matcher.group());
        } else {
            System.out.println("番号が見つかりませんでした。");
        }
    }
}

この例では、文字列中から電話番号のパターンを検索し、見つかった場合はその部分を出力します。

見つかった番号: 090-1234-5678

Matcherはfind()やmatches()メソッドを使ってパターンにマッチする部分を検出し、group()メソッドでマッチした部分を取得します。

これらの文字列操作クラスを適切に使いこなすことで、文字列の結合や置換、パターンマッチングといった処理を効率的に行うことができ、プログラムの可読性とパフォーマンスを向上させることが可能です。

特にStringBuilderやStringBufferは、大量の文字列操作を伴う処理において重要な役割を果たします。

正規表現は、複雑な文字列パターンの検出や抽出に不可欠な技術です。

型変換とキャスト

Javaでは、異なるデータ型間で値を変換する必要が生じることがあります。

これには自動的に行われる「自動型変換(型の昇格)」と、プログラマが明示的に指定する「明示的キャスト」があります。

適切な型変換を理解しておくことで、型の不一致によるエラーを防ぎ、正確なデータ操作を行うことが可能です。

自動型変換

自動型変換は、コンパイラが自動的に行う型の昇格です。

これは、より精度の低い型から高い型へと変換される場合に適用されます。

例えば、int型の値をdouble型の変数に代入する場合などです。

// 自動型変換の例
public class App {
    public static void main(String[] args) {
        int num = 100;
        double decimal = num; // intからdoubleへ自動変換
        System.out.println("double型の値: " + decimal);
    }
}

double型の値: 100.0

このように、intからdoubleへの変換は自動的に行われ、プログラマが明示的にキャストを記述する必要はありません。

明示的キャスト

明示的キャストは、プログラマがキャスト演算子()を使って、型を指定して変換を行います。

これは自動変換が行われない場合や、意図的に型を変換したい場合に使用します。

同種プリミティブ間

同じ種類のプリミティブ型間でのキャストは、値の範囲や精度に注意しながら行います。

// intからbyteへのキャスト例
public class App {
    public static void main(String[] args) {
        int largeNumber = 130;
        byte smallNumber = (byte) largeNumber; // 明示的キャスト
        System.out.println("byte型の値: " + smallNumber);
    }
}

この例では、intの130をbyteにキャストしていますが、byteの範囲は-128から127なので、結果はオーバーフローし、-126となります。

byte型の値: -126

浮動小数点⇔整数

浮動小数点型と整数型間のキャストは、値の丸めや情報の損失に注意が必要です。

// doubleからintへのキャスト例
public class App {
    public static void main(String[] args) {
        double pi = 3.14159;
        int intPi = (int) pi; // 小数点以下を切り捨て
        System.out.println("int型の値: " + intPi);
    }
}

出力は小数点以下が切り捨てられた値となります。

int型の値: 3

逆に、intからdoubleへのキャストは自動的に行われるため、明示的に書く必要はありません。

// intからdoubleへのキャスト
int num = 42;
double doubleNum = num; // 自動的にキャスト

参照型キャスト

参照型のキャストは、オブジェクトの型階層に基づいて行います。

親クラスから子クラスへのキャストは安全ですが、その逆はClassCastExceptionを引き起こす可能性があります。

// 例：親クラスと子クラスのキャスト
class Animal {
    void sound() {
        System.out.println("動物の鳴き声");
    }
}
class Dog extends Animal {
    void sound() {
        System.out.println("ワンワン");
    }
    void fetch() {
        System.out.println("おもちゃを取る");
    }
}
public class App {
    public static void main(String[] args) {
        Animal animal = new Dog(); // upcasting(自動的に行われる)
        Dog dog = (Dog) animal; // downcasting
        dog.fetch(); // 子クラスのメソッド呼び出し
    }
}

おもちゃを取る

ただし、animalが実際にはDogのインスタンスでない場合、キャスト時にClassCastExceptionが発生します。

// 実行例
Animal animal = new Animal(); // これはDogではない
Dog dog = (Dog) animal; // 実行時例外

Exception in thread "main" java.lang.ClassCastException: class Animal cannot be cast to class Dog (Animal and Dog are in unnamed module of loader com.sun.tools.javac.launcher.MemoryClassLoader @7334aada)

このため、キャスト前にinstanceof演算子を使って型を確認することが推奨されます。

if (animal instanceof Dog) {
    Dog dog = (Dog) animal;
    dog.fetch();
}

型変換とキャストは、Javaプログラムの柔軟性と安全性を高めるために重要な技術です。

適切な場面で正しい方法を選択し、型の不一致によるエラーや予期しない動作を防ぐことが、堅牢なコードを書くポイントとなります。

型チェック

Javaでは、オブジェクトの型やnull値の確認を行うために、いくつかの基本的な方法が用意されています。

これらの型チェックは、プログラムの安全性を高め、実行時エラーを未然に防ぐために重要です。

instanceof演算子

instanceof演算子は、オブジェクトが特定のクラスまたはインターフェースのインスタンスかどうかを判定します。

これにより、キャスト前に型の適合性を確認でき、安全にダウンキャストを行うことが可能です。

// instanceofの例
public class App {
    public static void main(String[] args) {
        Animal animal = new Dog(); // upcasting(親クラスの型に代入)
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal; // safeなキャスト
            dog.fetch(); // 子クラスのメソッド呼び出し
        } else {
            System.out.println("これはDogのインスタンスではありません。");
        }
    }
}
class Animal {
    void sound() {
        System.out.println("動物の鳴き声");
    }
}
class Dog extends Animal {
    void fetch() {
        System.out.println("おもちゃを取る");
    }
}

おもちゃを取る

この例では、animalがDogのインスタンスかどうかをinstanceofで確認し、安全にキャストしています。

instanceofは、複雑なクラス階層やインターフェースの実装状況を確認する際に役立ちます。

特に、多態性を利用したプログラムでは、実行時にオブジェクトの正確な型を判定するために頻繁に使用されます。

nullチェック

オブジェクトがnullかどうかを確認することも、型安全性を保つために重要です。

null参照に対してメソッドを呼び出すとNullPointerExceptionが発生するため、事前にnullチェックを行う必要があります。

// nullチェックの例
public class App {
    public static void main(String[] args) {
        String str = null;
        if (str != null) {
            System.out.println("文字列の長さ: " + str.length());
        } else {
            System.out.println("文字列はnullです。");
        }
    }
}

文字列はnullです。

このように、nullかどうかを!= nullで判定し、安全にメソッド呼び出しや操作を行います。

また、Java 8以降ではObjectsクラスのisNull()やnonNull()メソッドを使って、より直感的にnullチェックを行うことも可能です。

import java.util.Objects;
public class App {
    public static void main(String[] args) {
        String str = null;
        if (Objects.nonNull(str)) {
            System.out.println("文字列の長さ: " + str.length());
        } else {
            System.out.println("文字列はnullです。");
        }
    }
}

nullチェックは、特にコレクションや外部入力を扱う際に頻繁に必要となるため、確実に行う習慣をつけることが望ましいです。

instanceof演算子とnullチェックは、Javaプログラムの堅牢性を高めるための基本的なツールです。

これらを適切に使いこなすことで、予期しない型の不一致やnull参照によるエラーを未然に防ぎ、安全なコードを書くことができます。

型推論

Java 10以降では、varキーワードを使った型推論が導入され、変数の型を明示的に記述せずに宣言できるようになりました。

これにより、コードの記述量を減らし、可読性を向上させることが可能です。

ただし、型推論にはいくつかの制約も存在します。

varの基本

varを使うと、コンパイラが右辺の式から変数の型を推論します。

これは、静的型付けの言語でありながら、型を明示しなくても良いという便利な機能です。

import java.util.ArrayList;

// varの基本例
public class App {
    public static void main(String[] args) {
        var message = "こんにちは"; // String型に推論される
        var number = 42; // int型に推論される
        var list = new ArrayList<String>(); // ArrayList<String>に推論される
        System.out.println(message);
        System.out.println(number);
        System.out.println(list);
    }
}

こんにちは
42
[]

この例では、messageはString型、numberはint型、listはArrayList<String>型に推論されます。

varを使うことで、型を明示的に記述する必要がなくなり、コードがすっきりします。

ただし、varはローカル変数の宣言にのみ使用でき、クラスのフィールドやメソッドのパラメータには使えません。

// 使用できない例
public class Example {
    private var name; // コンパイルエラー
}

varの制約

varにはいくつかの制約があります。

これらを理解しておくことで、適切に利用できるようになります。

初期化必須

varを使う場合、宣言と同時に初期化しなければなりません。

推論のために右辺の式が必要です。

// 初期化なしはエラー
var message; // コンパイルエラー

ローカル変数限定

varはローカル変数のみに使用可能です。

クラスのフィールドやメソッドの引数には使えません。

// フィールドには使えない
public class App {
    private var name; // エラー
}

推論できる型は明確

右辺の式から型が明確に推論できる必要があります。

例えば、空のリストやnullを代入した場合は推論できません。

推論できない例
var list = null; // エラー
var list = new ArrayList<>(); // OK(型推論可能)

型の曖昧さに注意

複雑な式や曖昧なコードでは、推論結果が予期しない型になることもあります。

明示的に型を指定した方が安全な場合もあります。

// 複雑な式の例
var result = someMethod(); // someMethodの返り値の型に依存

これらの制約を理解し、適切にvarを使うことで、コードの簡潔さと安全性を両立させることができます。

特に、型が明らかで冗長な記述を避けたい場合に有効です。

Java 8以降の補助型

Java 8から導入されたOptionalは、値が存在するかどうかを明示的に表現し、NullPointerExceptionのリスクを低減させるためのクラスです。

Optionalを適切に利用することで、null値の扱いを安全かつ明確に行うことが可能となります。

import java.util.Optional;が必要なので注意しましょう。

Optionalの生成方法

Optionalのインスタンスは、いくつかの方法で生成できます。

空のOptionalを作成する

Optional<String> emptyOpt = Optional.empty();

この方法は、値が存在しない状態を表すときに使用します。

非null値から生成する

Optional<String> opt = Optional.of("こんにちは");

このof()メソッドは、引数がnullの場合はNullPointerExceptionをスローします。

値が確実に存在する場合に使用します。

null許容の値から生成する

Optional<String> optNullable = Optional.ofNullable(null);
Optional<String> optNullable2 = Optional.ofNullable("Java");

ofNullable()は、引数がnullの場合は空のOptionalを返し、nullでない場合は値を持つOptionalを返します。

null値の可能性がある場合に便利です。

主なメソッド

Optionalは、多くの便利なメソッドを提供しています。

代表的なものを紹介します。

isPresent()：値が存在する場合にtrueを返します

import java.util.Optional;

public class App {
    public static void main(String[] args) {
        Optional<String> opt = Optional.of("こんにちは");
        if (opt.isPresent()) {
            System.out.println("値が存在します: " + opt.get());
        }
    }
}
// 出力結果:
// 値が存在します: こんにちは

値が存在します: こんにちは

get()：値を取得します。ただし、値が存在しない場合はNoSuchElementExceptionをスローするため、isPresent()と併用するか、orElse()を使うのが安全です

Optional<String> opt = Optional.of("こんにちは");
String value = opt.get(); // 安全に使える例

orElse()：値が存在しない場合にデフォルト値を返します

Optional<String> opt = Optional.ofNullable(null);
String message = opt.orElse("値がありません");
System.out.println(message);

orElseGet()：値が存在しない場合に、Supplierから値を生成して返します

Optional<String> opt = Optional.ofNullable(null);
String message = opt.orElseGet(() -> "デフォルト値");
System.out.println(message);

orElseThrow()：値が存在しない場合に例外をスローします

Optional<String> opt = Optional.ofNullable(null);
try {
    String value = opt.orElseThrow(() -> new IllegalArgumentException("値がありません"));
} catch (IllegalArgumentException e) {
    System.out.println(e.getMessage());
}

ifPresent()：値が存在する場合に、引数のConsumerを実行します

Optional<String> opt = Optional.of("こんにちは");
opt.ifPresent(val -> System.out.println("値: " + val));

map()：値が存在する場合に、関数を適用し、新しいOptionalを返します

Optional<String> opt = Optional.of("Java");
Optional<Integer> lengthOpt = opt.map(String::length);
lengthOpt.ifPresent(len -> System.out.println("文字列の長さ: " + len));

flatMap()：map()と似ているが、返す関数もOptionalを返す場合に使用

Optional<String> opt = Optional.of("Java");
Optional<String> upperOpt = opt.flatMap(val -> Optional.of(val.toUpperCase()));
upperOpt.ifPresent(System.out::println);

これらのメソッドを組み合わせて使うことで、null安全なコードを書きやすくなります。

Optionalは、値の有無を明示的に扱うことで、コードの意図を明確にし、バグの発生を抑える効果的なツールです。

まとめ

この記事では、Javaの基本的なデータ型と参照型、型変換やキャストの方法、型推論の仕組み、そしてJava 8以降の補助型であるOptionalの使い方について詳しく解説しました。

これらの知識を理解することで、安全で効率的なプログラム設計や、null安全なコーディングが可能となります。

特に、Optionalを活用することで、nullによるエラーを防ぎ、コードの可読性と堅牢性を高めることができます。