JavaのListにおける浅いコピーと深いコピーを解説する記事のアイキャッチ。

実装・エラー解決

JavaでListをコピーしても元データが変わる理由|浅いコピーと深いコピー

この記事でわかること

Listだけをコピーしても、Userやその中のtagsまで独立するとは限りません。同じUserを使い、List本体だけ・Userまで・tagsまでの3段階を比べ、変更がどこに伝わるかをJUnit 10件で確認します。recordで受け取ったListを作成時点の状態に固定する例も試せます。

新人SE
新人SE
new ArrayListでコピーしたのに、コピー側のUser名を変えたら元Listも変わりました。
ポンコツSE
ポンコツSE
List本体は別ですが、中のUserは同じオブジェクトを参照しています。浅いコピーだからです。

画面編集用DTO、取込前のバックアップ、更新前後の比較でListをコピーすることがあります。new ArrayList<>(original)を使えば独立したListになりますが、要素が可変オブジェクトなら完全に独立したデータにはなりません。

この違いを知らずに編集すると、変更前データまで書き換わり、差分監査や取消処理が成立しなくなります。何を独立させたいのかを決め、浅いコピー、不変化、要素コピーを使い分けます。

この記事のポイント

  • new ArrayListはList構造だけをコピーする
  • 要素オブジェクトは同じ参照のまま
  • List.copyOfは変更不可だが深いコピーではない
  • 要素を独立させるなら明示的にコピーする
  • 不変オブジェクトなら浅いコピーでも安全に共有しやすい

実行サンプル

User(String id, String name, List<String> tags)を使う実行一式です。JDK 17とMaven 3.9系で、展開先のpom.xmlからmvn testを実行すると10件を確認できます。mvn packageの後、java -cp target/classes info.syachiku.listcopy.Mainで名前とタグの4行比較を表示します。User・コピー処理・JUnit全文・Main・POM・READMEを同梱し、下のJUnit章でも全文を開けます。各章の抜粋は、この実行一式の同じコードです。

List本体と要素は別に考える

Listは要素そのものではなく、要素への参照を順番に保持します。ArrayListのコピーコンストラクタは新しい入れ物を作り、参照を並べ直します。

ここではUserに、変更しないID・編集する名前・変更できるタグ一覧を持たせます。最初のcopyStructureOnlyが作るのは、新しいList本体だけです。

public static List<User> copyStructureOnly(List<User> source) {
    return new ArrayList<>(source);
}

addやremoveは別々にできますが、getしたUserは同じです。『Listをコピーした』という言葉だけでは、どこまで独立したか分かりません。

要素を変更すると元からも見える

コピー側から同じUserのsetterを呼ぶと、そのUserオブジェクトが変わります。元Listも同じUserを指すため変更後の値が見えます。

Main.structureDemoの抜粋です。各比較は新しい元データを作り、前の比較の変更を引き継ぎません。

private static void structureDemo() {
    List<User> original = sourceUsers();
    List<User> copied = UserLists.copyStructureOnly(original);
    copied.get(0).setName("佐藤");
    copied.add(new User("U003", "追加", new ArrayList<>()));
    System.out.printf("STRUCTURE listSame=%s userSame=%s originalName=%s originalSize=%d copiedSize=%d%n",
            original == copied, original.get(0) == copied.get(0),
            original.get(0).getName(), original.size(), copied.size());
}

出力のlistSame=falseでもuserSame=trueです。コピー側へ1人追加しても元は2人のままですが、同じUserの名前を変えると元も「佐藤」になります。

これはListの不具合ではなく参照共有の結果です。JPA Entityを含むListなら、setterがダーティチェックでDB更新へつながる可能性もあります。

List.copyOfも深いコピーではない

List.copyOfの結果に、元のListへの追加・削除は反映されません。結果のListも追加・削除できません。ただし、両方のListが同じUserを参照しているので、そのUserの名前を変えると両方から見えます。入れ物と、中のオブジェクトを分けて考えます。

同じ3引数Userを使うMain.readOnlyDemoです。

private static void readOnlyDemo() {
    List<User> original = sourceUsers();
    List<User> readOnly = UserLists.copyReadOnlyStructure(original);
    String addResult;
    try {
        readOnly.add(new User("U003", "追加", new ArrayList<>()));
        addResult = "unexpected success";
    } catch (UnsupportedOperationException expected) {
        addResult = expected.getClass().getSimpleName();
    }
    readOnly.get(0).setName("佐藤");
    System.out.printf("READ_ONLY add=%s userSame=%s originalName=%s%n",
            addResult, original.get(0) == readOnly.get(0), original.get(0).getName());
}

『不変List』と『不変なデータ構造全体』を混同しません。外部公開APIで変更を防ぎたいなら、要素の不変性も必要です。

関連記事JavaのCollections.unmodifiableListで元のList変更が反映される理由|List.copyOfとの違い 元の明細を追加・差し替えたとき、ビューと作成時点のコピーで何が違うかを比べます。注文バッチのJUnitを5件実行して確かめられます。 記事を読む

要素までコピーする方法

要素を独立させるには、各要素から新しいオブジェクトを作ります。ただし、Userを新しくすることと、Userが持つtagsも新しくすることは別です。

配布するUserListsには比較用3メソッドを用意しました。どの参照を新しくしたかと、変更が漏れるかを対応させて読んでください。

まずUserだけを新しくし、tagsの参照はそのまま渡した比較です。名前は独立しますが、タグはまだ共有されます。

public static List<User> copyUsersSharingTags(List<User> source) {
    return source.stream()
            .map(user -> new User(user.getId(), user.getName(), user.getTags()))
            .collect(Collectors.toCollection(ArrayList::new));
}
private static void elementDemo() {
    List<User> original = sourceUsers();
    List<User> copied = UserLists.copyUsersSharingTags(original);
    copied.get(0).setName("佐藤");
    copied.get(0).getTags().add("review");
    System.out.printf("ELEMENTS userSame=%s tagsSame=%s originalName=%s copiedName=%s originalTags=%s copiedTags=%s%n",
            original.get(0) == copied.get(0),
            original.get(0).getTags() == copied.get(0).getTags(),
            original.get(0).getName(), copied.get(0).getName(),
            original.get(0).getTags(), copied.get(0).getTags());
}

この版はuserSame=false・tagsSame=true。コピー側の名前を「佐藤」にしても元は「田中」ですが、reviewを追加すると元のtagsも[general, review]になります。Userをnewしたことだけで、編集前データを守れたと判断しません。

今回の編集仕様は、名前とタグの追加が元へ伝わらないことです。そこでtagsのListも新しくします。

public static List<User> copyForEditing(List<User> source) {
    return source.stream()
            .map(user -> new User(user.getId(), user.getName(),
                    new ArrayList<>(user.getTags())))
            .collect(Collectors.toCollection(ArrayList::new));
}
private static void editingDemo() {
    List<User> original = sourceUsers();
    List<User> copied = UserLists.copyForEditing(original);
    copied.get(0).setName("佐藤");
    copied.get(0).getTags().add("review");
    System.out.printf("EDITING userSame=%s tagsSame=%s originalName=%s copiedName=%s originalTags=%s copiedTags=%s%n",
            original.get(0) == copied.get(0),
            original.get(0).getTags() == copied.get(0).getTags(),
            original.get(0).getName(), copied.get(0).getName(),
            original.get(0).getTags(), copied.get(0).getTags());
}

表は横にスクロールできます。

コピー方法List本体UsertagsのList
copyStructureOnly別共有共有
copyUsersSharingTags別別共有
copyForEditing別別別

修正版はuserSame=false・tagsSame=false。元の名前は「田中」、tagsは[general]のまま、コピー側だけ「佐藤」・[general, review]になります。tagsの要素は不変なStringなので、その文字列までnewする必要はありません。任意の入れ子・循環参照を複製する万能なdeep copyではなく、この編集で変更する境界を独立させたものです。

ListだけのコピーではUserとtagsを共有し、Userもコピーするとtagsだけを共有し、tagsもコピーすると編集元と編集先が分かれる3段階の参照図。
矢印はオブジェクトへの参照です。この例では可変のUserとtagsのListを分け、Stringの値は共有します。

このサンプルはID・名前・タグ一覧に限定しています。タグの要素が可変なオブジェクトへ変わるなら、new ArrayList<>(tags)だけではその要素を共有するので、同じ境界判断をもう一段行います。

不変オブジェクトなら共有しやすい

このサンプルのid・name・タグ要素はStringです。String自体は書き換わらないため、Userの値として同じ参照を共有できます。setNameはUserが持つ参照を別のStringへ替える操作なので、Userを分ければ元のnameは変わりません。recordや不変クラスを選ぶ場合も、保持する値の可変性まで確認します。

recordのタグが後から変わるなら、受け取るときにコピーする

商品 SKU-001 の公開時のタグを [java] で保存します。公開後、編集側の input に sale を追加しても、公開時のタグは変えない仕様です。同じ初期値で、recordを2通り作ります。

受け取ったListをそのまま保持SharedLabel の tags() は編集側と同じListです。input.add("sale") の後は [java, sale] が見えます。

コンストラクターでListを固定SnapshotLabel は tags = List.copyOf(tags) を実行してから保持します。編集側が追加しても [java] のままです。

recordのコンポーネントのフィールドは final です。固定されるのは、そのフィールドが参照する先です。コンパクトコンストラクターの tags にコピーを代入すると、コンストラクターの処理後にその値がフィールドに入ります。Java 17のRecord仕様

次の出力では、呼び出し元からの変更と tags().add(...) の両方を確認します。タグが String なので、一覧を固定すればこの仕様を満たせます。可変オブジェクトを要素にするなら、要素の状態まで固定する方法が必要です。List.copyOf は null 要素を拒否するので、未設定を null で表す入力は別途扱いを決めます。

元のタグと公開時のタグを比べる

上のUserの実習とは別のZIPです。CatalogLabelDemo.java、CatalogLabelDemoTest.java、POM、実行手順を収録しています。JDK 17とMavenを用意して、展開先で mvn clean test を実行すると4件を確認できます。続けて java -cp target/classes example.recordcopy.CatalogLabelDemo を実行すると、次の4行が出ます。

SHARED sku=SKU-001 tags=[java, sale]
SNAPSHOT sku=SKU-001 tags=[java]
ACCESSOR add=UnsupportedOperationException tags=[java]
NULL_ELEMENT sharedTags=[java, null] snapshot=NullPointerException
package example.recordcopy;

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

public class CatalogLabelDemo {
    // recordのフィールドはfinalでも、このListの内容は共有される。
    public record SharedLabel(String sku, List<String> tags) {}

    public record SnapshotLabel(String sku, List<String> tags) {
        public SnapshotLabel {
            tags = List.copyOf(tags);
        }
    }

    public static void main(String[] args) {
        List<String> input = new ArrayList<>(List.of("java"));
        SharedLabel shared = new SharedLabel("SKU-001", input);
        SnapshotLabel snapshot = new SnapshotLabel("SKU-001", input);
        input.add("sale");
        System.out.printf("SHARED sku=%s tags=%s%n", shared.sku(), shared.tags());
        System.out.printf("SNAPSHOT sku=%s tags=%s%n", snapshot.sku(), snapshot.tags());

        try {
            snapshot.tags().add("preview");
            throw new AssertionError("Expected an unmodifiable list");
        } catch (UnsupportedOperationException expected) {
            System.out.printf("ACCESSOR add=%s tags=%s%n",
                    expected.getClass().getSimpleName(), snapshot.tags());
        }

        List<String> withNull = Arrays.asList("java", null);
        SharedLabel nullable = new SharedLabel("SKU-001", withNull);
        try {
            new SnapshotLabel("SKU-001", withNull);
            throw new AssertionError("Expected null element rejection");
        } catch (NullPointerException expected) {
            System.out.printf("NULL_ELEMENT sharedTags=%s snapshot=%s%n",
                    nullable.tags(), expected.getClass().getSimpleName());
        }
    }
}
CatalogLabelDemoTest.java の全文を表示する
package example.recordcopy;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class CatalogLabelDemoTest {
    @Test
    void recordWithoutCopySharesInputAndAccessorChanges() {
        List<String> input = new ArrayList<>(List.of("java"));
        var label = new CatalogLabelDemo.SharedLabel("SKU-001", input);
        input.add("sale");
        assertSame(input, label.tags());
        assertEquals(List.of("java", "sale"), label.tags());
        label.tags().add("preview");
        assertEquals(List.of("java", "sale", "preview"), input);
        assertEquals("SKU-001", label.sku());
    }

    @Test
    void compactConstructorKeepsTheTagsAtCreation() {
        List<String> input = new ArrayList<>(List.of("java"));
        var label = new CatalogLabelDemo.SnapshotLabel("SKU-001", input);
        input.add("sale");
        assertEquals(List.of("java", "sale"), input);
        assertEquals(List.of("java"), label.tags());
        assertEquals("SKU-001", label.sku());
    }

    @Test
    void snapshotAccessorRejectsAddAndKeepsTheTags() {
        var label = new CatalogLabelDemo.SnapshotLabel("SKU-001",
                new ArrayList<>(List.of("java")));
        assertThrowsExactly(UnsupportedOperationException.class,
                () -> label.tags().add("preview"));
        assertEquals(List.of("java"), label.tags());
    }

    @Test
    void nullElementIsAcceptedByTheSharedVersionButRejectedByCopyOf() {
        List<String> input = Arrays.asList("java", null);
        var shared = new CatalogLabelDemo.SharedLabel("SKU-001", input);
        assertEquals("java", shared.tags().get(0));
        assertNull(shared.tags().get(1));
        assertThrowsExactly(NullPointerException.class,
                () -> new CatalogLabelDemo.SnapshotLabel("SKU-001", input));
    }
}

レビューでは、record の宣言だけを見ず、元のListにタグを追加した後も公開時のタグが残るかを確認します。さらに、アクセサーからの追加を拒否できるかを、別のテストにします。

EntityとDTOを同じListで扱わない

JPA EntityのListを画面編集用としてコピーし、Entity自体を変更すると永続化コンテキストの管理対象が変わります。表示・編集用DTOへ変換すると、DB更新との境界を明確にできます。

更新時はFormから対象Entityへ明示的に値を反映します。自動マッピングを使う場合も、IDや監査項目を上書きしない設定を確認します。

シリアライズコピーを安易に使わない

JSONへ変換して戻す方法は深いコピーに見えますが、型情報、日付形式、無視項目、性能、例外処理へ依存します。コピーのためだけにシリアライズを使うと意図が不透明です。

外部通信のDTO変換が本来の目的なら結果的に独立しますが、ドメインオブジェクトのコピーは明示的なコンストラクタや不変設計を優先します。

JUnitで参照と値を確認する

List本体・User・tagsの参照と値を分けます。assertNotSameだけで終えず、コピー側からも元側からも名前・タグ・List構造を変え、もう一方へ漏れないことを確認します。

以下がこの専用ZIPの全文です。最初にUserとUserListsを開き、同じメソッドを呼ぶUserListsTestへ進んでください。未定義のcopierや別モデルへの読み替えは不要です。

src/main/java/info/syachiku/listcopy/User.java の全文
package info.syachiku.listcopy;

import java.util.List;

// BEGIN userModel
public final class User {
    private final String id;
    private String name;
    private final List<String> tags;

    public User(String id, String name, List<String> tags) {
        this.id = id;
        this.name = name;
        this.tags = tags;
    }

    public String getId() { return id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public List<String> getTags() { return tags; }
}
// END userModel
src/main/java/info/syachiku/listcopy/UserLists.java の全文
package info.syachiku.listcopy;

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

public final class UserLists {
    private UserLists() {}

    // BEGIN structureCopy
    public static List<User> copyStructureOnly(List<User> source) {
        return new ArrayList<>(source);
    }
    // END structureCopy

    // BEGIN elementCopy
    public static List<User> copyUsersSharingTags(List<User> source) {
        return source.stream()
                .map(user -> new User(user.getId(), user.getName(), user.getTags()))
                .collect(Collectors.toCollection(ArrayList::new));
    }
    // END elementCopy

    // BEGIN editingCopy
    public static List<User> copyForEditing(List<User> source) {
        return source.stream()
                .map(user -> new User(user.getId(), user.getName(),
                        new ArrayList<>(user.getTags())))
                .collect(Collectors.toCollection(ArrayList::new));
    }
    // END editingCopy

    // BEGIN readOnlyCopy
    public static List<User> copyReadOnlyStructure(List<User> source) {
        return List.copyOf(source);
    }
    // END readOnlyCopy
}
src/test/java/info/syachiku/listcopy/UserListsTest.java の全文
package info.syachiku.listcopy;

import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class UserListsTest {
    private static List<User> users() {
        return new ArrayList<>(List.of(
                new User(new String("U001"), new String("田中"),
                        new ArrayList<>(List.of("general", "pending"))),
                new User(new String("U002"), new String("鈴木"),
                        new ArrayList<>(List.of("support")))));
    }

    private static List<String> ids(List<User> users) {
        return users.stream().map(User::getId).toList();
    }

    @Test
    void structureCopyCreatesOnlyANewList() {
        List<User> original = users();
        List<User> copied = UserLists.copyStructureOnly(original);
        assertNotSame(original, copied);
        assertEquals(List.of("U001", "U002"), ids(copied));
        for (int i = 0; i < original.size(); i++) {
            assertSame(original.get(i), copied.get(i));
            assertSame(original.get(i).getTags(), copied.get(i).getTags());
        }
    }

    @Test
    void structureAddAndRemoveDoNotChangeTheOtherList() {
        List<User> original = users();
        List<User> copied = UserLists.copyStructureOnly(original);
        copied.remove(0);
        copied.add(new User("U003", "追加", new ArrayList<>()));
        assertEquals(List.of("U001", "U002"), ids(original));
        original.remove(1);
        original.add(new User("U004", "元へ追加", new ArrayList<>()));
        assertEquals(List.of("U002", "U003"), ids(copied));
    }

    @Test
    void structureCopyNameChangesFlowInBothDirections() {
        List<User> original = users();
        List<User> copied = UserLists.copyStructureOnly(original);
        copied.get(0).setName("佐藤");
        assertEquals("佐藤", original.get(0).getName());
        original.get(1).setName("岡田");
        assertEquals("岡田", copied.get(1).getName());
    }

    @Test
    void userOnlyCopyPreservesEveryFieldButSharesTags() {
        List<User> original = users();
        List<User> copied = UserLists.copyUsersSharingTags(original);
        assertNotSame(original, copied);
        for (int i = 0; i < original.size(); i++) {
            assertNotSame(original.get(i), copied.get(i));
            assertEquals(original.get(i).getId(), copied.get(i).getId());
            assertEquals(original.get(i).getName(), copied.get(i).getName());
            assertEquals(original.get(i).getTags(), copied.get(i).getTags());
            assertSame(original.get(i).getTags(), copied.get(i).getTags());
        }
    }

    @Test
    void userOnlyCopyNameChangesStayIndependentInBothDirections() {
        List<User> original = users();
        List<User> copied = UserLists.copyUsersSharingTags(original);
        copied.get(0).setName("佐藤");
        assertEquals("田中", original.get(0).getName());
        original.get(1).setName("岡田");
        assertEquals("鈴木", copied.get(1).getName());
    }

    @Test
    void userOnlyCopyTagsStillLeakInBothDirections() {
        List<User> original = users();
        List<User> copied = UserLists.copyUsersSharingTags(original);
        copied.get(0).getTags().add("review");
        assertEquals(List.of("general", "pending", "review"), original.get(0).getTags());
        original.get(1).getTags().add("source-change");
        assertEquals(List.of("support", "source-change"), copied.get(1).getTags());
    }

    @Test
    void editingCopyPreservesAllFieldsAndOnlySharesImmutableStrings() {
        List<User> original = users();
        List<User> copied = UserLists.copyForEditing(original);
        assertNotSame(original, copied);
        for (int i = 0; i < original.size(); i++) {
            User before = original.get(i);
            User after = copied.get(i);
            assertNotSame(before, after);
            assertNotSame(before.getTags(), after.getTags());
            assertEquals(before.getId(), after.getId());
            assertEquals(before.getName(), after.getName());
            assertEquals(before.getTags(), after.getTags());
            assertSame(before.getId(), after.getId());
            assertSame(before.getName(), after.getName());
            assertSame(before.getTags().get(0), after.getTags().get(0));
        }
    }

    @Test
    void editingCopyNameAndTagChangesDoNotLeakEitherWay() {
        List<User> original = users();
        List<User> copied = UserLists.copyForEditing(original);
        copied.get(0).setName("佐藤");
        copied.get(0).getTags().add("review");
        assertEquals("田中", original.get(0).getName());
        assertEquals(List.of("general", "pending"), original.get(0).getTags());
        original.get(1).setName("岡田");
        original.get(1).getTags().add("source-change");
        assertEquals("鈴木", copied.get(1).getName());
        assertEquals(List.of("support"), copied.get(1).getTags());
    }

    @Test
    void editingCopyListStructureIsAlsoIndependentInBothDirections() {
        List<User> original = users();
        List<User> copied = UserLists.copyForEditing(original);
        copied.remove(0);
        copied.add(new User("U003", "追加", new ArrayList<>()));
        assertEquals(List.of("U001", "U002"), ids(original));
        original.remove(1);
        original.add(new User("U004", "元へ追加", new ArrayList<>()));
        assertEquals(List.of("U002", "U003"), ids(copied));
    }

    @Test
    void copyOfRejectsStructuralChangesButStillSharesMutableUsers() {
        List<User> original = users();
        List<User> readOnly = UserLists.copyReadOnlyStructure(original);
        assertThrows(UnsupportedOperationException.class,
                () -> readOnly.add(new User("U003", "追加", new ArrayList<>())));
        assertThrows(UnsupportedOperationException.class, () -> readOnly.remove(0));
        original.add(new User("U004", "元へ追加", new ArrayList<>()));
        assertEquals(2, readOnly.size());
        assertSame(original.get(0), readOnly.get(0));
        readOnly.get(0).setName("佐藤");
        assertEquals("佐藤", original.get(0).getName());
        original.get(0).getTags().add("source-change");
        assertEquals(List.of("general", "pending", "source-change"), readOnly.get(0).getTags());
    }
}
src/main/java/info/syachiku/listcopy/Main.java の全文
package info.syachiku.listcopy;

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

public final class Main {
    private Main() {}

    static List<User> sourceUsers() {
        return new ArrayList<>(List.of(
                new User("U001", "田中", new ArrayList<>(List.of("general"))),
                new User("U002", "鈴木", new ArrayList<>(List.of("support")))));
    }

    public static void main(String[] args) {
        structureDemo();
        elementDemo();
        editingDemo();
        readOnlyDemo();
    }

    // BEGIN structureDemo
    private static void structureDemo() {
        List<User> original = sourceUsers();
        List<User> copied = UserLists.copyStructureOnly(original);
        copied.get(0).setName("佐藤");
        copied.add(new User("U003", "追加", new ArrayList<>()));
        System.out.printf("STRUCTURE listSame=%s userSame=%s originalName=%s originalSize=%d copiedSize=%d%n",
                original == copied, original.get(0) == copied.get(0),
                original.get(0).getName(), original.size(), copied.size());
    }
    // END structureDemo

    // BEGIN elementDemo
    private static void elementDemo() {
        List<User> original = sourceUsers();
        List<User> copied = UserLists.copyUsersSharingTags(original);
        copied.get(0).setName("佐藤");
        copied.get(0).getTags().add("review");
        System.out.printf("ELEMENTS userSame=%s tagsSame=%s originalName=%s copiedName=%s originalTags=%s copiedTags=%s%n",
                original.get(0) == copied.get(0),
                original.get(0).getTags() == copied.get(0).getTags(),
                original.get(0).getName(), copied.get(0).getName(),
                original.get(0).getTags(), copied.get(0).getTags());
    }
    // END elementDemo

    // BEGIN editingDemo
    private static void editingDemo() {
        List<User> original = sourceUsers();
        List<User> copied = UserLists.copyForEditing(original);
        copied.get(0).setName("佐藤");
        copied.get(0).getTags().add("review");
        System.out.printf("EDITING userSame=%s tagsSame=%s originalName=%s copiedName=%s originalTags=%s copiedTags=%s%n",
                original.get(0) == copied.get(0),
                original.get(0).getTags() == copied.get(0).getTags(),
                original.get(0).getName(), copied.get(0).getName(),
                original.get(0).getTags(), copied.get(0).getTags());
    }
    // END editingDemo

    // BEGIN readOnlyDemo
    private static void readOnlyDemo() {
        List<User> original = sourceUsers();
        List<User> readOnly = UserLists.copyReadOnlyStructure(original);
        String addResult;
        try {
            readOnly.add(new User("U003", "追加", new ArrayList<>()));
            addResult = "unexpected success";
        } catch (UnsupportedOperationException expected) {
            addResult = expected.getClass().getSimpleName();
        }
        readOnly.get(0).setName("佐藤");
        System.out.printf("READ_ONLY add=%s userSame=%s originalName=%s%n",
                addResult, original.get(0) == readOnly.get(0), original.get(0).getName());
    }
    // END readOnlyDemo
}
pom.xml の全文
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>info.syachiku.samples</groupId><artifactId>list-copy-boundary-1950</artifactId><version>1.0.0</version>
  <properties><maven.compiler.release>17</maven.compiler.release><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties>
  <dependencies><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter</artifactId><version>5.12.2</version><scope>test</scope></dependency></dependencies>
  <build><plugins>
    <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-resources-plugin</artifactId><version>3.3.1</version></plugin>
    <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.14.1</version></plugin>
    <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-surefire-plugin</artifactId><version>3.5.6</version></plugin>
    <plugin><groupId>org.codehaus.mojo</groupId><artifactId>exec-maven-plugin</artifactId><version>3.6.3</version><configuration><mainClass>info.syachiku.listcopy.Main</mainClass></configuration></plugin>
  </plugins></build>
</project>
README.md の全文
# Listコピーの境界:List本体、User、User内のtags

Java17、Maven3.9系、JUnit5.12.2。このサンプルはSpring/DB/外部サービスを使いません。

```sh
mvn test
mvn -q exec:java
```

検証環境Java17.0.8/Maven3.9.16。既存キャッシュでoffline実行しています。空のキャッシュから初回に依存を取る検証はしていません。必要なプラグインやJUnitがなければMaven Centralへの接続が必要です。

## 同じUserモデルで境界を比べる

`User(String id, String name, List<String> tags)`。getId/getName/setName/getTagsを使います。Userのname参照はsetNameで変更でき、tagsは可変Listです。この教材ではsource List・User・tagsを非nullとし、tagsの要素は不変のStringとして扱います。任意の型/循環参照を再帰的にコピーする汎用機能ではありません。

Userコンストラクタは渡されたtags参照を保持します。教材で「共有する」「独立させる」を区別するため、UserLists側がどのListを渡すか明示します。防御的コピーを常に行う不変モデルの実装例ではありません。

| 正式メソッド | Listの構造 | User | tags List | コピー側name変更 | コピー側tags変更 |
|---|---|---|---|---|---|
| copyStructureOnly | 別の可変List | 共有 | 共有 | 元へ伝わる | 元へ伝わる |
| copyUsersSharingTags | 別の可変List | 別 | 共有 | 元へ伝わらない | 元へ伝わる |
| copyForEditing | 別の可変List | 別 | 別 | 元へ伝わらない | 元へ伝わらない |
| copyReadOnlyStructure | 変更不可の構造snapshot | 共有 | 共有 | 元へ伝わる | 元へ伝わる |

copyForEditingはid/name/tagsの値と順序を保ったまま、このモデルで編集する可変部分を独立させます。id/nameと各タグのStringは不変なので、同じString参照を共有して構いません。「すべての参照を別にする」ことが目的ではありません。

List.copyOfの戻り値が常に新しいオブジェクトとは仮定しません。List.copyOfの仕様は追加・削除・置換を禁止します。このサンプルではadd/removeの拒否と、元Listへの追加が影響しないことを検証し、Userの可変性とは分けます。List.copyOfはnull要素を受け付けませんが、null境界の試験は今回の10件に含めていません。

## JUnit10件

1. 構造コピーはListだけ別でUser/tagsは共有。
2. 構造コピー後のadd/removeが両方向で独立。
3. 構造コピーのname変更は両方向へ伝わる。
4. Userだけのコピーは全フィールド値を保持するがtagsは共有。
5. Userだけのコピーはname変更が両方向で独立。
6. Userだけのコピーではtags変更が両方向へ漏れる。
7. 編集用コピーは全フィールド値を保持し、User/tagsを別にし、不変Stringだけ共有する。
8. 編集用コピーのname/tags変更が両方向で独立。
9. 編集用コピーのList add/removeも両方向で独立。
10. copyOfはadd/removeを拒否し、元の構造変更を反映しないが、User/name/tagsの変更は共有する。

テストは各ケースで新しい2ユーザーを用意します。U001/田中/tags[general,pending]、U002/鈴木/tags[support]。Mainは出力を短くするためU001の初期tagsを[general]とし、各比較を新しいデータで始めます。テストとMainのタグ数の違いを省略しないでください。

## Mainの4行

構造コピーで佐藤へ改名したとき、元も佐藤だが元の件数2/コピー3。Userだけのコピーは元名田中を保つがtagsのreviewが両方へ入る。編集用コピーは元名田中・元tags[general]を保つ。readOnlyへaddはUnsupportedOperationException、Userの改名は元へ伝わる。出力の同一性は固定の真偽値で、オブジェクトのアドレス等は出力しません。

## 抜粋と全文

User.javaはuserModel、UserLists.javaはstructureCopy/elementCopy/editingCopy/readOnlyCopy、Main.javaはstructureDemo/elementDemo/editingDemo/readOnlyDemoのBEGIN/ENDを持ちます。記事で抜粋するときはこの領域と対応させ、全文は同じファイルから確認できます。

収録はUser.java、UserLists.java、Main.java、UserListsTest.java、POM、README、LICENSE。依存JAR、class、個人設定は含みません。旧2ファイルのListCopyDemoや旧ZIPは変更せず、この記事の新しい統一APIに対応する独立moduleです。

Java17公式仕様:
https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/List.html#copyOf(java.util.Collection)
https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/ArrayList.html#%3Cinit%3E(java.util.Collection)

MainのU001のtagsは[general]、JUnitのU001は複数要素の保持を見るため[general, pending]です。入力の違いを混ぜず、テストではID・名前・全タグ・順序を保持すること、編集が両方向に漏れないこと、List.copyOfでは可変Userが共有されることを確認します。

現場レビューでよくある指摘

コピー処理のレビューでは、List構造、要素、入れ子要素のどこまで独立させる必要があるかを確認します。

// レビューコメント例
Userをnewしてもtagsへ同じ参照を渡しているため、タグ追加が元データへ漏れます。
名前とタグを編集する仕様なら、tagsのListも独立させてください。

// レビューコメント例
List.copyOfはListの追加を防ぎますが、Userのsetterやtagsの追加は防ぎません。
どこまで変更を伝えない契約か、同じ入力のテストで示してください。

『deep copyが必要です』だけで終わらず、何を変更する処理か、元データを残す目的は何かを説明します。不要な全オブジェクトコピーは避け、所有境界を明確にします。

提出前のセルフチェック

レビュー前に確認すること

  • List本体だけか要素も独立させるか決めたか
  • 要素が可変オブジェクトか
  • List.copyOfを深いコピーと誤解していないか
  • 入れ子のListや配列も共有されていないか
  • コピーコンストラクタの項目が十分か
  • Entityを画面から直接変更していないか
  • 不変DTOやrecordへ変換できないか
  • コピー側変更が元へ影響しないテストがあるか

良いコードとデータ設計を学ぶ参考書

コピーの問題は、可変性、所有権、EntityとDTOの責務に関係します。良いコード/悪いコードの具体例から、変更範囲を限定する設計を学べます。

書籍「改訂新版 良いコード/悪いコードで学ぶ設計入門」の表紙
商品画像:Amazon.co.jp
PR Java新人・若手向け

改訂新版 良いコード/悪いコードで学ぶ設計入門

仙塲 大也 (著)

レビューで直される理由を、Javaの具体例から理解する。

命名、責務、クラス設計、不変性などを良い例と悪い例で比較できます。現場のコードレビューと結びつけやすい一冊です。

  • 設計の悪さを具体例から学びたい
  • レビュー指摘の判断軸を増やしたい

当サイトはAmazonアソシエイト・プログラムの参加者です。価格・在庫・配送条件はAmazonでご確認ください。

この記事とあわせて読みたい

関連記事Spring BootのDTO変換はどこでやるべきか EntityとDTOの変換をController・Service・Mapperへ分ける判断を整理します。 記事を読む 関連記事Lombokの使い方と@Dataの危険性 可変オブジェクトに無条件なsetterやequalsを生成する注意点を整理します。 記事を読む

まとめ

new ArrayListやList.copyOfはList本体を分けたり変更を禁止したりしますが、要素オブジェクトを深くコピーしません。可変要素は元とコピーで同じ参照になります。

編集前データや画面用DTOを独立させるなら、コピーコンストラクタや明示的な変換を使います。不変オブジェクトを選び、List・要素・入れ子のどこまで独立させるかテストしてください。

-実装・エラー解決
-,