Javaの心臓部！java.langパッケージ徹底解説 – 基本から応用まで

Javaでプログラミングを行う際、私たちは数多くのクラスを利用します。その中でも、最も基本的かつ重要なクラス群が格納されているのがjava.langパッケージです。このパッケージは非常に特別で、Javaプログラムをコンパイルする際に自動的にインポートされます。 そのため、私たちはimport java.lang.String;のように明示的にインポート文を記述することなく、StringクラスやSystemクラスなどを自由に使用できるのです。

java.langパッケージには、Javaという言語の根幹を支える、まさに「心臓部」とも言えるクラスが含まれています。 これから、このパッケージに含まれる主要なクラスを一つひとつ丁寧に見ていきながら、Javaの基礎を深く、そして強固なものにしていきましょう。

Javaの世界では、すべてのクラスは直接的または間接的にObjectクラスを継承しています。 これは、たとえextendsキーワードを使って継承を明示しなかったとしても、コンパイラが自動的にObjectクラスを継承するように処理するためです。 この仕組みにより、Javaのすべてのオブジェクトは、Objectクラスが持つ基本的なメソッドを利用することができます。

ここでは、Objectクラスで定義されている、特に重要なメソッドについて詳しく解説します。

文字列の扱いは、あらゆるプログラミングにおいて基本中の基本です。Javaでは、そのためのクラスとしてString、StringBuilder、StringBufferの3つが提供されています。 これらは似て非なるものであり、それぞれの特性を理解して使い分けることが、パフォーマンスの高いコードを書く鍵となります。

3.1. 不変(Immutable)なクラス – String

Stringクラスの最大の特徴は、不変（Immutable）であるということです。 つまり、一度生成されたStringオブジェクトの内容は、後から変更することができません。

「え、でも `+` 演算子で文字列を連結できるじゃないか」と思うかもしれません。実は、以下のようなコードを実行すると、

String str = "Hello";
str = str + ", World!";

元の “Hello” という文字列オブジェクトが変更されるわけではありません。内部的には、”Hello, World!” という新しい`String`オブジェクトが生成され、変数`str`がその新しいオブジェクトを指すように参照が変更されているのです。

この不変性には、スレッドセーフである、キャッシュとして利用しやすいといったメリットがありますが、ループ処理などで頻繁に文字列連結を行うと、新しいオブジェクトが次々と生成され、パフォーマンスの低下やメモリの無駄遣いを引き起こす原因となります。

3.2. 可変(Mutable)なクラス – StringBuilder と StringBuffer

頻繁な文字列の変更が予想される場面では、可変な文字列クラスであるStringBuilderまたはStringBufferを使用します。 これらのクラスは、内部にバッファ（文字を保持する領域）を持っており、文字列の追加や変更を行っても、新しいオブジェクトを都度生成するのではなく、内部バッファを直接操作します。 これにより、高速な文字列操作が可能になります。

では、StringBuilderとStringBufferの違いは何でしょうか？その答えはスレッドセーフ性にあります。

`StringBuffer`のメソッドはsynchronizedキーワードで同期化されており、複数のスレッドから同時にアクセスされても安全なように設計されています。 しかし、その同期化のためのオーバーヘッドがあるため、`StringBuilder`に比べてパフォーマンスは劣ります。

したがって、一般的なプログラミング（特にシングルスレッド環境）では、まずは`StringBuilder`の使用を検討するのがセオリーです。

コード例：ループでの文字列連結

// 非推奨: ループ内でStringの+連結
String resultString = "";
for (int i = 0; i < 10000; i++) {
    resultString += i; // 毎回新しいStringオブジェクトが生成される
}

// 推奨: StringBuilderを使用
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append(i); // 内部バッファに変更が加えられる
}
String resultBuilder = sb.toString(); // 最後にStringに変換

Javaには、int, double, booleanといったプリミティブ型が存在します。これらはオブジェクトではなく、高速なデータアクセスを可能にしますが、オブジェクトとして扱えないという制約があります。 例えば、ジェネリクスを使用するコレクション（例: `ArrayList<T>`）には、プリミティブ型を直接指定できません。

この問題を解決するのがラッパークラスです。 ラッパークラスは、各プリミティブ型に対応するクラスで、プリミティブ型の値をオブジェクトとして「包み込む（ラップする）」役割を果たします。

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

Java 5以降では、プリミティブ型とラッパークラス間の変換を自動的に行ってくれるオートボクシング（Autoboxing）とオートアンボクシング（Unboxing）という機能が導入されました。 これにより、コードの記述が大幅に簡潔になっています。

• オートボクシング: プリミティブ型から対応するラッパークラスへの自動変換。
• オートアンボクシング: ラッパークラスから対応するプリミティブ型への自動変換。

import java.util.ArrayList;
import java.util.List;

public class WrapperExample {
    public static void main(String[] args) {
        // オートボクシング: int -> Integer
        List<Integer> list = new ArrayList<>();
        list.add(100); // 本来は list.add(Integer.valueOf(100));
        list.add(200);

        // オートアンボクシング: Integer -> int
        int value = list.get(0); // 本来は int value = list.get(0).intValue();
        System.out.println("Value: " + value);

        // ラッパークラスの便利なメソッド
        String numStr = "12345";
        int parsedInt = Integer.parseInt(numStr); // 文字列をintに変換
        System.out.println("Parsed Integer: " + parsedInt);

        System.out.println("Integer MAX_VALUE: " + Integer.MAX_VALUE); // int型の最大値
    }
}

ラッパークラスは、プリミティブ値をオブジェクトとして扱う機能の他に、その型に関する定数（例：`Integer.MAX_VALUE`）や、便利なユーティリティメソッド（例：`Integer.parseInt()`）を提供しています。

Integer number = null;
int num = number; // ここでNullPointerExceptionが発生する！

Mathクラスは、指数関数、対数関数、平方根、三角関数といった、基本的な数値計算を行うためのメソッドを集めたユーティリティクラスです。 `Math`クラスのすべてのメソッドとフィールドは静的（static）であり、インスタンスを生成せずに `Math.メソッド名()` の形式で直接呼び出して使用します。

よく使われるメソッド

Systemクラスは、Javaプログラムが実行されているシステム環境と対話するための、様々な機能を提供するユーティリティクラスです。 `Math`クラスと同様に、インスタンス化することはできず、すべてのフィールドとメソッドは静的（static）です。

主要なフィールドとメソッド

public class SystemExample {
    public static void main(String[] args) {
        // システムプロパティの表示
        System.out.println("OS Name: " + System.getProperty("os.name"));
        System.out.println("Java Version: " + System.getProperty("java.version"));

        // 時間計測
        long startTime = System.currentTimeMillis();
        // 何らかの重い処理...
        long endTime = System.currentTimeMillis();
        System.out.println("Processing time: " + (endTime - startTime) + " ms");

        // エラー出力
        System.err.println("これはエラーメッセージです。");

        // プログラムの終了
        // System.exit(0);
    }
}

現代のアプリケーションでは、複数の処理を同時に、または並行して実行するマルチスレッドプログラミングが不可欠です。`java.lang`パッケージは、そのための基本的なクラスである`Thread`と、インターフェースである`Runnable`を提供しています。

Javaでスレッドを生成するには、主に2つの方法があります。

1. `Thread`クラスを継承する
2. `Runnable`インターフェースを実装する

`Thread`クラスの継承 vs `Runnable`インターフェースの実装

どちらの方法でもスレッドを作成できますが、一般的には`Runnable`インターフェースを実装する方法が推奨されます。その理由は以下の通りです。

• 柔軟性: Javaはクラスの多重継承をサポートしていません。`Thread`クラスを継承してしまうと、他のクラスを継承できなくなります。`Runnable`はインターフェースなので、他のクラスを継承しつつ実装することが可能です。
• 関心の分離: 「スレッドで実行したい処理（タスク）」と「スレッドという実行機構そのもの」を分離できます。 `Runnable`はタスクを定義し、`Thread`はそれを実行する役割、というように責務を明確に分けられるため、より設計として優れています。

コード例: `Runnable`インターフェースの実装

// 1. Runnableインターフェースを実装したクラスを定義
class MyTask implements Runnable {
    private final String taskName;

    public MyTask(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public void run() {
        // スレッドで実行したい処理をrun()メソッドに記述する
        for (int i = 1; i <= 5; i++) {
            System.out.println(taskName + ": Count " + i);
            try {
                // 少し待機させる
                Thread.sleep(500); // 500ミリ秒停止
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        System.out.println("Main thread started.");

        // 2. Runnableの実装クラスのインスタンスを作成
        Runnable task1 = new MyTask("Task A");
        Runnable task2 = new MyTask("Task B");

        // 3. ThreadクラスのコンストラクタにRunnableインスタンスを渡してスレッドを作成
        Thread thread1 = new Thread(task1);
        Thread thread2 = new Thread(task2);

        // 4. start()メソッドを呼び出してスレッドを開始
        // 注意: run()メソッドを直接呼び出してはいけない！
        thread1.start();
        thread2.start();

        System.out.println("Main thread finished.");
    }
}

上記の例を実行すると、`Task A`と`Task B`の処理が交互に実行される様子が確認できます。これは、メインスレッドとは別に2つの新しいスレッドが生成され、並行して処理が進んでいることを示しています。`start()`メソッドを呼び出すと、JVMが新しいスレッドを生成し、そのスレッドが`run()`メソッドを呼び出します。 `run()`メソッドを直接呼び出すと、単にメインスレッドでメソッドが実行されるだけなので注意が必要です。

堅牢なプログラムを作成するためには、実行時に発生するかもしれない予期せぬエラーに正しく対処する「例外処理」が不可欠です。Javaの例外処理の仕組みは、`java.lang.Throwable`クラスを頂点とする階層構造で成り立っています。

`Throwable`クラスには、大きく分けて2つのサブクラスがあります: `Error`と`Exception`です。

`Error`クラス

`Error`とそのサブクラスは、メモリ不足（`OutOfMemoryError`）やスタックオーバーフロー（`StackOverflowError`）など、アプリケーション側で回復することが困難な、システムレベルの致命的な問題を示します。 プログラマは通常、`Error`をキャッチして処理しようとはしません。

`Exception`クラス

`Exception`とそのサブクラスは、プログラムのバグや予期しない外部環境の変化（ファイルの不存在など）によって発生する、アプリケーション側で対処・回復が可能な、あるいはすべき問題を示します。 こちらが、私たちが普段`try-catch`ブロックで扱う対象となります。

`Exception`はさらに2つのカテゴリに分類されます。

import java.io.FileReader;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        // チェック例外の処理
        try {
            FileReader reader = new FileReader("non_existent_file.txt");
            // ファイル操作...
            reader.close();
        } catch (FileNotFoundException e) {
            // 具体的な例外からキャッチするのが良いプラクティス
            System.err.println("エラー: ファイルが見つかりませんでした。");
            e.printStackTrace(); // スタックトレースを出力して詳細な原因を調査
        } catch (IOException e) {
            System.err.println("エラー: ファイルの読み書き中に問題が発生しました。");
            e.printStackTrace();
        } finally {
            // finallyブロックは、例外の有無にかかわらず必ず実行される
            System.out.println("ファイル処理を終了します。");
        }

        // 非チェック例外の例
        try {
            String text = null;
            System.out.println(text.length()); // NullPointerExceptionが発生
        } catch (NullPointerException e) {
            System.err.println("エラー: nullのオブジェクトを参照しようとしました。");
        }
    }
}