はじめに

この記事は、Javaプログラミング初学者の方や、ArrayList<String>などのコレクションをメソッドに渡す際に意図しない動作やエラーに遭遇した方を対象としています。特に、他の言語の「参照渡し」の概念に慣れている方がJavaの動作に戸惑うことがあるかもしれません。

この記事を読むことで、Javaにおける「参照の値渡し」の基本的な考え方、ArrayListをメソッドに渡した際に起こりうる問題、そしてそれらの問題を回避し、安全にリストを操作するための具体的な方法を理解できるようになります。リストの操作でつまずいた経験のある方は、ぜひ最後までお読みください。

前提知識

この記事を読み進める上で、以下の知識があるとスムーズです。 * Javaの基本的な文法（変数宣言、メソッドの定義と呼び出し） * ArrayListの基本的な使い方（要素の追加、取得、削除など）

Javaにおける変数渡しとArrayListの特性

Javaにおける変数の受け渡しは、「値渡し」が基本です。しかし、この「値渡し」がプリミティブ型と参照型で異なる挙動をするため、特に参照型であるArrayListを扱う際に混乱が生じがちです。

プリミティブ型と参照型の「値渡し」

  • プリミティブ型（例: int, boolean, doubleなど） メソッドにプリミティブ型の変数を渡すと、その変数の値そのものがコピーされてメソッドに渡されます。したがって、メソッド内でその変数の値を変更しても、呼び出し元の変数の値には影響しません。

    ```java void increment(int num) { num = num + 1; // メソッド内のnumだけが変更される System.out.println("メソッド内: " + num); }

    int myNum = 10; increment(myNum); System.out.println("メソッド呼び出し後: " + myNum); // 結果は10のまま ```

  • 参照型（例: String, ArrayList, 自作クラスのオブジェクトなど） メソッドに参照型の変数を渡すと、オブジェクトそのものではなく、そのオブジェクトへの「参照（メモリ上のアドレス）」の値がコピーされてメソッドに渡されます。つまり、メソッド内の変数は、呼び出し元の変数と同じオブジェクトを指すことになります。

    ```java class MyObject { public int value; public MyObject(int value) { this.value = value; } }

    void changeValue(MyObject obj) { obj.value = 20; // メソッド内のobjが指すオブジェクトのvalueを変更 System.out.println("メソッド内: " + obj.value); }

    MyObject myObj = new MyObject(10); changeValue(myObj); System.out.println("メソッド呼び出し後: " + myObj.value); // 結果は20になる `` この例では、myObjとobjはそれぞれ異なる変数ですが、同じMyObjectインスタンスを参照しているため、メソッド内でobj.valueを変更するとmyObj.value`も変更されます。

ArrayListの特性とよくある誤解

ArrayListも参照型の一種です。したがって、ArrayList<String>の変数をメソッドに渡す場合、リストの「中身（要素）」がコピーされるわけではなく、そのArrayListオブジェクトがメモリ上のどこにあるかを示す「参照（アドレス）」がコピーされて渡されます。

これにより、メソッド内で受け取ったArrayListオブジェクトに対して要素の追加、削除、変更などを行うと、呼び出し元で保持している同じArrayListオブジェクトが変更されることになります。これを意図しない動作と捉え、「エラーが出た」と感じることがよくあります。これはJavaの仕様通りの動作であり、厳密にはエラーではありませんが、開発者の意図と異なる結果をもたらすため、注意が必要です。

例えば、「メソッド内でリストを一時的に加工したいが、元のリストは変更したくない」といったシナリオで、この挙動が問題となることがあります。次のセクションでは、具体的なケースとその解決策を見ていきましょう。

ArrayListをメソッドに渡す際の落とし穴と解決策

ここからは、ArrayList<String>をメソッドに渡す際に陥りやすい状況と、それらを解決するための具体的なアプローチをコード例とともに解説します。

ステップ1: 意図せずリストが変更されてしまうケース

最も一般的なのは、メソッド内で受け取ったリストを直接操作してしまい、呼び出し元のリストにもその変更が反映されてしまうケースです。

Java

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

public class ListModificationExample {

    // 受け取ったリストに要素を追加するメソッド
    public static void addElementToList(List<String> list) {
        System.out.println("--- addElementToList メソッド内 ---");
        System.out.println("変更前リスト: " + list);
        list.add("Orange"); // リストに要素を追加
        list.add("Grape");
        System.out.println("変更後リスト: " + list);
        System.out.println("---------------------------------");
    }

    public static void main(String[] args) {
        List<String> originalList = new ArrayList<>();
        originalList.add("Apple");
        originalList.add("Banana");
        originalList.add("Cherry");

        System.out.println("メインメソッド: 初期リスト: " + originalList);

        // メソッドにリストを渡す
        addElementToList(originalList);

        // メソッド呼び出し後のoriginalListの状態を確認
        System.out.println("メインメソッド: メソッド呼び出し後リスト: " + originalList);
        // 期待: [Apple, Banana, Cherry]
        // 実際: [Apple, Banana, Cherry, Orange, Grape]
    }
}

実行結果:

メインメソッド: 初期リスト: [Apple, Banana, Cherry]
--- addElementToList メソッド内 ---
変更前リスト: [Apple, Banana, Cherry]
変更後リスト: [Apple, Banana, Cherry, Orange, Grape]
---------------------------------
メインメソッド: メソッド呼び出し後リスト: [Apple, Banana, Cherry, Orange, Grape]

この例では、addElementToListメソッド内でlist.add()を実行した結果、メインメソッドのoriginalListも変更されてしまっています。これは、「参照の値渡し」によってoriginalListとlistが同じArrayListオブジェクトを参照しているためです。

ステップ2: 意図しない変更を防ぐための解決策

元のリストを変更せずにメソッド内で安全に操作したい場合や、メソッド内でリストが変更されないことを保証したい場合の解決策をいくつか紹介します。

解決策1: 新しいArrayListを作成して渡す（防御的コピー）

最もシンプルで推奨される方法の一つが、メソッドに渡す前にリストのコピーを作成し、そのコピーを渡す方法です。これを「防御的コピー」と呼びます。

Java

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

public class DefensiveCopyExample {

    public static void processListSafely(List<String> list) {
        System.out.println("--- processListSafely メソッド内 ---");
        System.out.println("受け取ったリスト (変更前): " + list);
        // 受け取ったリストは変更せずに、独自の処理を行う
        // 例: 最初の要素を大文字にする (ここでは直接変更しないことを示すためコメントアウト)
        // if (!list.isEmpty()) {
        //     list.set(0, list.get(0).toUpperCase());
        // }
        // メソッド内でリストをクリアしても、元のリストには影響しない
        // list.clear();
        System.out.println("受け取ったリスト (変更後): " + list); // ここでの変更はメインに反映されない
        System.out.println("------------------------------------");
    }

    public static void main(String[] args) {
        List<String> originalList = new ArrayList<>();
        originalList.add("Apple");
        originalList.add("Banana");

        System.out.println("メインメソッド: 初期リスト: " + originalList);

        // 防御的コピーを作成してメソッドに渡す
        List<String> copyOfOriginalList = new ArrayList<>(originalList);
        processListSafely(copyOfOriginalList);

        // メソッド呼び出し後のoriginalListの状態を確認
        System.out.println("メインメソッド: メソッド呼び出し後リスト: " + originalList);
        // 期待: [Apple, Banana] (元のリストは変更されない)
    }
}

実行結果:

メインメソッド: 初期リスト: [Apple, Banana]
--- processListSafely メソッド内 ---
受け取ったリスト (変更前): [Apple, Banana]
受け取ったリスト (変更後): [Apple, Banana]
------------------------------------
メインメソッド: メソッド呼び出し後リスト: [Apple, Banana]

この方法では、new ArrayList<>(originalList)で新しいリストオブジェクトが作成され、その参照がメソッドに渡されます。そのため、メソッド内でcopyOfOriginalListをどのように操作しても、originalListには影響しません。

解決策2: 読み取り専用のリストを渡す（不変リスト）

メソッド内でリストの変更を一切許可しない場合は、Collections.unmodifiableList()を使って読み取り専用のリストを渡すことができます。変更操作を試みるとUnsupportedOperationExceptionがスローされます。

Java

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

public class UnmodifiableListExample {

    public static void printListInfo(List<String> list) {
        System.out.println("--- printListInfo メソッド内 ---");
        System.out.println("リストの要素数: " + list.size());
        System.out.println("最初の要素: " + list.get(0));

        // 読み取り専用リストなので、変更しようとすると例外が発生
        try {
            list.add("Grape"); // UnsupportedOperationException が発生する
        } catch (UnsupportedOperationException e) {
            System.out.println("エラー: 読み取り専用リストへの変更は許可されていません。");
        }
        System.out.println("--------------------------------");
    }

    public static void main(String[] args) {
        List<String> originalList = new ArrayList<>();
        originalList.add("Apple");
        originalList.add("Banana");

        System.out.println("メインメソッド: 初期リスト: " + originalList);

        // 読み取り専用リストを作成してメソッドに渡す
        List<String> unmodifiableList = Collections.unmodifiableList(originalList);
        printListInfo(unmodifiableList);

        // メソッド呼び出し後のoriginalListの状態を確認 (unmodifiableListは元のリストのラッパーなので、
        // originalListが変更されるとunmodifiableListからも変更が見える点に注意)
        System.out.println("メインメソッド: メソッド呼び出し後リスト: " + originalList);
    }
}

実行結果:

メインメソッド: 初期リスト: [Apple, Banana]
--- printListInfo メソッド内 ---
リストの要素数: 2
最初の要素: Apple
エラー: 読み取り専用リストへの変更は許可されていません。
--------------------------------
メインメソッド: メソッド呼び出し後リスト: [Apple, Banana]

この方法は、リストの内容がメソッド内で意図せず変更されることを確実に防ぎたい場合に有効です。ただし、Collections.unmodifiableList()が返すのは元のリストの「ラッパー」であるため、元のリスト（originalList）が外部から変更された場合、unmodifiableListからもその変更が見えてしまう点に注意が必要です。完全に不変なリストが必要な場合は、List.of()（Java 9以降）やImmutableList（Guavaライブラリ）のような選択肢も検討できます。

解決策3: メソッドの設計を見直す（新しいリストを返す）

メソッドがリストを受け取り、何らかの処理を施した後に、その結果を新しいリストとして返すように設計することも有効です。元のリストは全く変更されません。

Java

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class ReturnNewListExample {

    // 受け取ったリストの各要素を大文字にして、新しいリストとして返すメソッド
    public static List<String> toUpperCaseList(List<String> originalList) {
        System.out.println("--- toUpperCaseList メソッド内 ---");
        System.out.println("受け取ったリスト: " + originalList);
        List<String> newList = originalList.stream()
                                           .map(String::toUpperCase)
                                           .collect(Collectors.toList());
        System.out.println("変換後リスト (新): " + newList);
        System.out.println("----------------------------------");
        return newList;
    }

    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");
        fruits.add("banana");

        System.out.println("メインメソッド: 初期リスト: " + fruits);

        // 新しいリストとして結果を受け取る
        List<String> upperCaseFruits = toUpperCaseList(fruits);

        System.out.println("メインメソッド: 元のリスト: " + fruits); // 変化なし
        System.out.println("メインメソッド: 大文字リスト: " + upperCaseFruits);
    }
}

実行結果:

メインメソッド: 初期リスト: [apple, banana]
--- toUpperCaseList メソッド内 ---
受け取ったリスト: [apple, banana]
変換後リスト (新): [APPLE, BANANA]
----------------------------------
メインメソッド: 元のリスト: [apple, banana]
メインメソッド: 大文字リスト: [APPLE, BANANA]

このアプローチは、関数型プログラミングの考え方にも近く、副作用（元のリストへの変更）を避ける上で非常にクリーンな方法です。

ハマった点やエラー解決

ここでは、リストの受け渡しでよく遭遇する問題と、その具体的な解決策を掘り下げます。

シナリオ1: 「メソッド内でリストをクリアしたら、呼び出し元でも空になってしまった！」

これは、上述の「ステップ1: 意図せずリストが変更されてしまうケース」と同じ原因です。メソッドが受け取ったリストの参照が、呼び出し元のリストと同じオブジェクトを指しているため、メソッド内でlist.clear()を実行すると、そのオブジェクトの中身が空になり、結果として呼び出し元のリストも空になります。

Java

public static void clearList(List<String> list) {
    list.clear(); // ここでリストが空になる
}

public static void main(String[] args) {
    List<String> myList = new ArrayList<>(List.of("A", "B", "C"));
    System.out.println("前: " + myList); // [A, B, C]
    clearList(myList);
    System.out.println("後: " + myList); // []
}

解決策: 元のリストを変更したくない場合は、防御的コピー（解決策1）を使用します。

Java

public static void processWithClear(List<String> list) {
    List<String> copyList = new ArrayList<>(list); // コピーを作成
    copyList.clear(); // コピーをクリア
    System.out.println("メソッド内のコピー: " + copyList);
}

public static void main(String[] args) {
    List<String> myList = new ArrayList<>(List.of("A", "B", "C"));
    System.out.println("前: " + myList); // [A, B, C]
    processWithClear(myList);
    System.out.println("後: " + myList); // [A, B, C] (元のリストは変更されない)
}

シナリオ2: 「メソッドに渡したリストがnullの時にNullPointerExceptionが出た！」

メソッドの引数としてnullが渡される可能性がある場合、メソッド内でそのリストを操作しようとするとNullPointerExceptionが発生します。

Java

public static void processElements(List<String> list) {
    // nullチェックがないと、listがnullの場合ここでNullPointerException
    for (String item : list) {
        System.out.println(item);
    }
}

public static void main(String[] args) {
    List<String> myNullList = null;
    // processElements(myNullList); // NullPointerException が発生
}

解決策: メソッドの先頭で引数のnullチェックを行うことが重要です。

Java

public static void processElementsSafely(List<String> list) {
    if (list == null) {
        System.out.println("リストがnullです。処理をスキップします。");
        return; // または適切な例外をスローする
    }
    for (String item : list) {
        System.out.println(item);
    }
}

public static void main(String[] args) {
    List<String> myNullList = null;
    processElementsSafely(myNullList); // NullPointerException は発生しない

    List<String> myEmptyList = new ArrayList<>();
    processElementsSafely(myEmptyList); // 空のリストでも安全
}

シナリオ3: 「不変リストを渡したのに、UnsupportedOperationExceptionが出た！」

Collections.unmodifiableList()を使って読み取り専用リストを渡したはずなのに、メソッド内でadd()やremove()などの変更操作を試みた場合に発生します。これはまさに不変リストが「変更を許可しない」という特性を持っているためです。

Java

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

public class UnmodifiableErrorExample {

    public static void tryToModify(List<String> list) {
        System.out.println("--- tryToModify メソッド内 ---");
        try {
            list.add("New Item"); // ここで UnsupportedOperationException が発生
        } catch (UnsupportedOperationException e) {
            System.err.println("エラー: 読み取り専用リストへの変更はできません！");
        }
        System.out.println("----------------------------");
    }

    public static void main(String[] args) {
        List<String> original = new ArrayList<>(List.of("One", "Two"));
        List<String> unmodifiable = Collections.unmodifiableList(original);

        tryToModify(unmodifiable); // 例外が発生し、補足される
        System.out.println("元のリスト: " + original);
    }
}

解決策: 不変リストを受け取るメソッドは、そのリストが変更不可であることを前提として設計する必要があります。変更が必要な場合は、不変リストを受け取らず、通常のListを受け取って、その中で防御的コピー（解決策1）を作成してから操作するか、新しいリストを返す（解決策3）設計にするべきです。

あるいは、メソッドのシグネチャをList<String>ではなくCollection<String>やIterable<String>にするなど、より抽象的な型を使用することで、メソッドがリストの変更を意図していないことを明示することもできます。

まとめ

本記事では、JavaにおけるArrayList<String>の変数渡しにおける「参照の値渡し」の概念と、それによって発生しうる問題、そしてその解決策について詳しく解説しました。

  • Javaの参照型変数の「値渡し」は参照のコピーであるため、メソッド内でリストオブジェクトを変更すると、呼び出し元のリストにもその変更が影響します。
  • 意図しないリストの変更を防ぐためには、メソッドに渡す前に防御的コピーを作成するか、読み取り専用の不変リストを使用することが効果的です。
  • メソッドが新しいリストを生成して返すような設計の見直しも、副作用を避けるクリーンなアプローチです。
  • NullPointerExceptionを回避するためには、メソッドの先頭で引数のnullチェックを徹底することが重要です。

この記事を通して、ArrayListをはじめとするJavaの参照型コレクションをメソッド間で安全かつ意図通りに受け渡しできるようになるはずです。これらの知識は、バグの少ない堅牢なJavaアプリケーションを開発する上で非常に重要です。

今後は、ジェネリクスを深く理解することや、より複雑なデータ構造、並行処理におけるコレクションのスレッドセーフティなどについても学ぶことで、さらにJavaプログラミングの幅が広がるでしょう。

参考資料