Java配列の複製、あなたは本当に理解してる？深掘り徹底解説！シャローとディープ、最適な選び方まで
Javaプログラミングに携わる皆さん、配列の複製、と聞いて何を思い浮かべますか？ 「え、forループでコピーするだけじゃないの？」「System.arraycopy()を使えば速いんでしょ？」そう思われた方は、この記事をぜひ最後まで読んでみてください。実は、Javaの配列複製には、想像以上に奥深い世界が広がっており、その理解が不足していると、思わぬバグやパフォーマンスの問題を引き起こす可能性があります。
この記事では、Javaの配列複製について、基礎的な方法から、多くのプログラマーが陥りやすい「シャローコピー」と「ディープコピー」の罠、そして実務で役立つ最適な選択肢まで、プロの視点から徹底的に解説していきます。あなたのJavaコードが、より安全で、より高速に、そしてより堅牢になるためのヒントが満載です。
さあ、Java配列複製の真髄を一緒に探求していきましょう。
なぜ配列の複製が必要なのか？ – その重要性を見過ごすな
まず、なぜ私たちはわざわざ配列を複製する必要があるのでしょうか？「変数を代入すればいいんじゃないの？」と考えたあなた、まさにその発想が最初の落とし穴です。
Javaにおける配列はオブジェクトの一種であり、変数に配列を代入する行為（例: int[] newArray = originalArray;）は、配列の中身をコピーしているわけではありません。これは、originalArrayが参照している「メモリ上の配列オブジェクト」を、newArrayも参照するようになる、ということを意味します。つまり、originalArrayとnewArrayは、全く同じ配列オブジェクトを指し示している状態です。
この状態の何が問題なのでしょうか？
- データの意図しない変更:
newArrayを通じて配列の要素を変更すると、当然originalArrayを通じてアクセスした際もその変更が反映されます。これは、特にメソッド間で配列を渡す場合や、複数のスレッドで同じ配列を操作する場合に、予期せぬ副作用やデータの一貫性の問題を引き起こす可能性があります。 - 不変性の原則の侵害: 配列を不変なデータとして扱いたい場合（例: 設定値やキャッシュデータ）、参照が共有されている状態では、どこか別の場所で変更されるリスクを常に抱えることになります。
このような問題を回避し、データの独立性を保つために、私たちは「複製」、つまりメモリ上に全く新しい配列オブジェクトを作成し、元の配列の要素をそこにコピーする作業が必要となるのです。この「複製」こそが、Javaプログラミングの安全性を高める上で非常に重要な概念となります。
Java配列複製 基本のキ：主要な5つの方法
Javaで配列を複製する方法はいくつか存在します。それぞれに特徴があり、用途やパフォーマンスに違いが出てきます。まずは、基本的な複製方法を一つずつ見ていきましょう。
1. forループによる要素ごとのコピー（手動コピー）
最も直感的で、誰でも容易に理解できるのがforループを使った手動コピーです。新しい配列を元の配列と同じサイズで作成し、一つ一つの要素をコピーしていきます。
public class ArrayCopyManual {
public static void main(String[] args) {
int[] originalArray = {10, 20, 30, 40, 50};
// 1. 新しい配列を作成 (元の配列と同じサイズ)
int[] copiedArray = new int[originalArray.length];
// 2. ループを使って要素を一つずつコピー
for (int i = 0; i < originalArray.length; i++) {
copiedArray[i] = originalArray[i];
}
System.out.println("Original Array: ");
printArray(originalArray); // 10 20 30 40 50
System.out.println("Copied Array: ");
printArray(copiedArray); // 10 20 30 40 50
// 複製が成功したかを確認
originalArray[0] = 99; // 元の配列を変更
System.out.println("\nOriginal Array after modification: ");
printArray(originalArray); // 99 20 30 40 50
System.out.println("Copied Array after original modification: ");
printArray(copiedArray); // 10 20 30 40 50 (変更されていないことを確認)
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
特徴:
- メリット:
- 非常にシンプルで、コードの意図が明確。
- プリミティブ型配列でも、オブジェクト型配列でも同様に機能する。
- コピー中に要素に対する追加処理（変換など）を加えやすい。
- デメリット:
- 配列のサイズが大きくなると、コード量が多くなりがち。
- 後述する専用のコピーメソッドに比べると、一般的にパフォーマンスが劣る場合がある（特に大規模データ）。
2. System.arraycopy()メソッド
JavaのSystemクラスが提供するarraycopy()メソッドは、配列の一部分または全体を高速にコピーするための低レベルAPIです。これはネイティブコードレベルで実装されているため、非常に高いパフォーマンスを発揮します。
public class ArrayCopySystem {
public static void main(String[] args) {
int[] originalArray = {10, 20, 30, 40, 50};
// 1. 新しい配列を作成 (コピー先)
int[] copiedArray = new int[originalArray.length];
// 2. System.arraycopy() を使ってコピー
// 引数: (コピー元配列, コピー元開始インデックス, コピー先配列, コピー先開始インデックス, コピーする要素数)
System.arraycopy(originalArray, 0, copiedArray, 0, originalArray.length);
System.out.println("Original Array: ");
printArray(originalArray);
System.out.println("Copied Array: ");
printArray(copiedArray);
originalArray[0] = 99;
System.out.println("\nOriginal Array after modification: ");
printArray(originalArray);
System.out.println("Copied Array after original modification: ");
printArray(copiedArray); // 10 20 30 40 50
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
特徴:
- メリット:
- 非常に高速で、大規模な配列のコピーに適している。
- 配列の一部をコピーしたり、指定した位置からコピーを開始したりと、柔軟な範囲指定が可能。
- デメリット:
- コピー先の配列を事前に作成しておく必要がある。
- 引数が多い（5つ）ため、初めて使う際には少し複雑に感じるかもしれない。
- 重要: オブジェクト配列の場合、これは「シャローコピー」になります（後述）。
3. Arrays.copyOf() および Arrays.copyOfRange()メソッド
Java 6で導入されたjava.util.ArraysクラスのcopyOf()およびcopyOfRange()メソッドは、配列を簡単に複製するための便利なAPIです。これらは内部的にSystem.arraycopy()を使用しているため、パフォーマンスも優れています。
Arrays.copyOf(originalArray, newLength)
元の配列の先頭から指定された長さまでを新しい配列にコピーします。newLengthが元の配列の長さより短い場合は切り詰められ、長い場合は残りの要素がデフォルト値（数値型なら0、boolean型ならfalse、参照型ならnull）で埋められます。
import java.util.Arrays;
public class ArrayCopyOf {
public static void main(String[] args) {
int[] originalArray = {10, 20, 30, 40, 50};
// 1. 配列全体をコピー
int[] copiedArray = Arrays.copyOf(originalArray, originalArray.length);
System.out.println("Original Array: ");
printArray(originalArray);
System.out.println("Copied Array: ");
printArray(copiedArray);
originalArray[0] = 99;
System.out.println("\nOriginal Array after modification: ");
printArray(originalArray);
System.out.println("Copied Array after original modification: ");
printArray(copiedArray); // 10 20 30 40 50
// 長さを変えてコピー
int[] shorterArray = Arrays.copyOf(originalArray, 3); // {99, 20, 30}
System.out.println("\nShorter Array (length 3): ");
printArray(shorterArray);
int[] longerArray = Arrays.copyOf(originalArray, 7); // {99, 20, 30, 40, 50, 0, 0}
System.out.println("Longer Array (length 7): ");
printArray(longerArray);
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
Arrays.copyOfRange(originalArray, from, to)
元の配列の指定された範囲（fromインデックスからto-1インデックスまで）を新しい配列にコピーします。
import java.util.Arrays;
public class ArrayCopyOfRange {
public static void main(String[] args) {
int[] originalArray = {10, 20, 30, 40, 50};
// 範囲を指定してコピー (インデックス1から3まで、つまり要素20, 30, 40)
int[] partialArray = Arrays.copyOfRange(originalArray, 1, 4);
System.out.println("Original Array: ");
printArray(originalArray);
System.out.println("Partial Array (from index 1 to 3): ");
printArray(partialArray); // 20 30 40
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
特徴:
- メリット:
- コードが非常に簡潔で分かりやすい。
- コピーと同時に新しい配列を生成してくれる。
System.arraycopy()と同様に高速。copyOf()で新しい配列の長さを調整できる、copyOfRange()で部分コピーができる。
- デメリット:
- 重要: オブジェクト配列の場合、これも「シャローコピー」になります（後述）。
4. clone()メソッド
JavaのすべてのオブジェクトはObjectクラスを継承しており、そのObjectクラスにはclone()メソッドが定義されています。配列もオブジェクトであるため、clone()メソッドを使って複製することができます。
public class ArrayCopyClone {
public static void main(String[] args) {
int[] originalArray = {10, 20, 30, 40, 50};
// 配列のclone()メソッドを呼び出して複製
int[] copiedArray = originalArray.clone();
System.out.println("Original Array: ");
printArray(originalArray);
System.out.println("Copied Array: ");
printArray(copiedArray);
originalArray[0] = 99;
System.out.println("\nOriginal Array after modification: ");
printArray(originalArray);
System.out.println("Copied Array after original modification: ");
printArray(copiedArray); // 10 20 30 40 50
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
特徴:
- メリット:
- 最も簡潔に記述できる複製方法の一つ。
Objectクラスの機能を利用するため、特定の型に依存しない。
- デメリット:
Object.clone()はCloneNotSupportedExceptionをスローする可能性があり、その場合はCloneableインターフェースを実装する必要がある。ただし、配列の場合、この例外は発生せず、Cloneableインターフェースを実装する必要もありません。これは配列がJava言語仕様で特別扱いされているためです。- 重要: オブジェクト配列の場合、これも「シャローコピー」になります（後述）。
Objectのclone()メソッドはデフォルトでシャローコピーを実装します。
5. Java 8以降のストリームAPI
Java 8で導入されたストリームAPIを使うと、関数型プログラミングのアプローチで配列を複製することができます。特に、複製と同時に変換処理を行いたい場合に便利です。
import java.util.Arrays;
import java.util.stream.IntStream;
public class ArrayCopyStream {
public static void main(String[] args) {
int[] originalArray = {10, 20, 30, 40, 50};
// IntStreamを使って配列を複製
int[] copiedArray = IntStream.of(originalArray).toArray();
System.out.println("Original Array: ");
printArray(originalArray);
System.out.println("Copied Array: ");
printArray(copiedArray);
originalArray[0] = 99;
System.out.println("\nOriginal Array after modification: ");
printArray(originalArray);
System.out.println("Copied Array after original modification: ");
printArray(copiedArray); // 10 20 30 40 50
// ストリームを使って、要素を加工しながら複製 (例: 全要素を2倍にする)
int[] doubledArray = IntStream.of(originalArray)
.map(n -> n * 2)
.toArray();
System.out.println("\nDoubled Array: ");
printArray(doubledArray); // 198 40 60 80 100 (originalArray[0]が99になっているため)
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
特徴:
- メリット:
- コードが簡潔で、モダンなJavaらしい記述ができる。
- 複製と同時に要素の変換やフィルタリングなどの処理を加えやすい。
- 並列ストリームを利用することで、並列処理によるパフォーマンス向上が期待できる場合がある（ただし、オーバーヘッドも考慮する必要がある）。
- デメリット:
- 他の専用コピーメソッドに比べると、純粋なコピー処理においてはオーバーヘッドが発生し、パフォーマンスが劣る場合がある。
- 重要: オブジェクト配列の場合、これも「シャローコピー」になります（後述）。
シャローコピーとディープコピー：配列複製最大の罠と解決策
ここからが本題であり、Java配列複製における最も重要な概念です。ここまで紹介した5つの方法、実はそのほとんどがシャローコピー（Shallow Copy）と呼ばれる複製方法です。そして、これが多くのプログラマーが陥りやすい罠の根源となります。
シャローコピー（Shallow Copy）とは？
シャローコピーとは、配列そのものは新しく複製されるものの、その配列が持つ要素が「参照型」の場合、その参照先オブジェクト自体は複製されず、元の配列と同じオブジェクトを参照し続けるコピーのことを指します。
言葉だけでは分かりにくいので、具体的な例を見てみましょう。
class MyObject {
int value;
public MyObject(int value) {
this.value = value;
}
@Override
public String toString() {
return "MyObject{" + "value=" + value + '}';
}
}
public class ShallowCopyExample {
public static void main(String[] args) {
// オブジェクト配列の作成
MyObject[] originalArray = {
new MyObject(1),
new MyObject(2),
new MyObject(3)
};
// clone()メソッドでシャローコピーを実行
MyObject[] copiedArray = originalArray.clone();
System.out.println("--- コピー直後 ---");
System.out.println("Original Array[0]: " + originalArray[0]); // MyObject{value=1}
System.out.println("Copied Array[0]: " + copiedArray[0]); // MyObject{value=1}
// 参照が同じか確認 (同じメモリ上のオブジェクトを指しているか)
System.out.println("originalArray[0] == copiedArray[0]: " + (originalArray[0] == copiedArray[0])); // true
// コピー元配列の要素（参照先オブジェクト）を変更
originalArray[0].value = 99;
System.out.println("\n--- originalArray[0].value を変更後 ---");
System.out.println("Original Array[0]: " + originalArray[0]); // MyObject{value=99}
System.out.println("Copied Array[0]: " + copiedArray[0]); // MyObject{value=99} (ここが問題！)
// 別の要素は独立しているか (配列自体は別物)
originalArray[1] = new MyObject(100); // 元の配列の要素を新しいオブジェクトで上書き
System.out.println("\n--- originalArray[1] を新しいオブジェクトで上書き後 ---");
System.out.println("Original Array[1]: " + originalArray[1]); // MyObject{value=100}
System.out.println("Copied Array[1]: " + copiedArray[1]); // MyObject{value=2} (こちらは変更されていない)
System.out.println("originalArray[1] == copiedArray[1]: " + (originalArray[1] == copiedArray[1])); // false
}
}
上記のコードのポイントは、originalArray[0].value = 99;と変更したにもかかわらず、copiedArray[0]のvalueも99になっている点です。これは、originalArray[0]とcopiedArray[0]が、同じMyObject{value=1}というインスタンスを指していたためです。配列自体は複製されましたが、その配列が持つ「参照」は複製されず、元と同じ参照を共有している状態なのです。
これを図でイメージすると以下のようになります。
元の配列 (originalArray)
+---+ +---+ +---+
| ref1|-->| ObjA| | ObjB| | ObjC|
+---+ +---+ +---+
| ref2|----^
+---+
| ref3|----^
+---+
シャローコピー後の配列 (copiedArray)
+---+ +---+
| ref1'|-->| ObjA| (← ObjAは元の配列と共有されている！)
+---+ +---+
| ref2'|----^
+---+
| ref3'|----^
+---+
見ての通り、originalArrayとcopiedArrayは別々の配列オブジェクトですが、それぞれが保持する参照（ref1とref1'など）が、同じオブジェクト（ObjAなど）を指している状態です。
ディープコピー（Deep Copy）とは？
ディープコピーとは、配列そのものだけでなく、その配列が保持する参照先のオブジェクトも再帰的に全て複製し、完全に独立した新しいオブジェクト群としてコピーすることを指します。
ディープコピーを実行すれば、元の配列の要素を変更しても、コピー後の配列には一切影響が及びません。
class MyObject implements Cloneable { // Cloneableインターフェースを実装
int value;
String name; // 複雑なオブジェクトを想定
public MyObject(int value, String name) {
this.value = value;
this.name = name;
}
// ディープコピーのためには、自身のclone()メソッドも適切に実装する必要がある
@Override
public MyObject clone() {
try {
// シャローコピーを実行 (プリミティブ型は値渡し、参照型は参照渡し)
MyObject cloned = (MyObject) super.clone();
// ここで参照型のフィールドがあれば、それもディープコピーする
// 今回の例ではStringは不変なので、そのまま参照で問題ないが、
// もし可変なオブジェクト（例: List<String>）であれば、
// cloned.listField = new ArrayList<>(this.listField); のように再構築が必要
return cloned;
} catch (CloneNotSupportedException e) {
throw new AssertionError(); // Cloneableを実装しているので発生しない
}
}
@Override
public String toString() {
return "MyObject{" + "value=" + value + ", name='" + name + '\'' + '}';
}
}
public class DeepCopyExample {
public static void main(String[] args) {
MyObject[] originalArray = {
new MyObject(1, "Alpha"),
new MyObject(2, "Beta")
};
// ディープコピー (手動で要素ごとにclone()を呼び出す)
MyObject[] copiedArray = new MyObject[originalArray.length];
for (int i = 0; i < originalArray.length; i++) {
if (originalArray[i] != null) {
copiedArray[i] = originalArray[i].clone(); // 各要素をディープコピー
}
}
System.out.println("--- コピー直後 ---");
System.out.println("Original Array[0]: " + originalArray[0]);
System.out.println("Copied Array[0]: " + copiedArray[0]);
// 参照が異なることを確認
System.out.println("originalArray[0] == copiedArray[0]: " + (originalArray[0] == copiedArray[0])); // false
// コピー元配列の要素（参照先オブジェクト）を変更
originalArray[0].value = 99;
originalArray[0].name = "Gamma";
System.out.println("\n--- originalArray[0].value を変更後 ---");
System.out.println("Original Array[0]: " + originalArray[0]); // MyObject{value=99, name='Gamma'}
System.out.println("Copied Array[0]: " + copiedArray[0]); // MyObject{value=1, name='Alpha'} (変更されていない！)
}
}
この例では、originalArray[0].value = 99;と変更しても、copiedArray[0]のvalueは元の1のままです。これは、originalArray[0]とcopiedArray[0]が、それぞれ異なるMyObjectのインスタンスを指しているためです。
これを図でイメージすると以下のようになります。
元の配列 (originalArray)
+---+ +---+
| ref1|-->| ObjA|
+---+ +---+
| ref2|----^
+---+
ディープコピー後の配列 (copiedArray)
+---+ +---+
| ref1'|-->| ObjA'| (← ObjA'はObjAとは全く別の新しいオブジェクト！)
+---+ +---+
| ref2'|----^
+---+
完全に独立した状態が保たれているのが分かりますね。
ディープコピーの実装方法
ディープコピーはシャローコピーと比べて複雑で、いくつかの実装パターンがあります。
要素ごとに手動で新しいインスタンスを生成し、フィールドをコピーする（最も一般的で安全）
- 上記の
DeepCopyExampleのように、ループを使って一つ一つの要素に対してnewキーワードで新しいインスタンスを作成し、元のオブジェクトのフィールド値をコピーします。 - もし要素オブジェクト自身が他のオブジェクトを参照している場合（ネストされたオブジェクト）、その参照先オブジェクトも再帰的にディープコピーする必要があります。
- 複雑なオブジェクトグラフでは非常に手間がかかりますが、最も制御が効き、安全な方法です。
- 上記の
Cloneableインターフェースとclone()メソッドの実装- 各クラスが
Cloneableインターフェースを実装し、publicなclone()メソッドをオーバーライドする必要があります。 Object.clone()はシャローコピーを実行するため、参照型のフィールドがある場合は、そのフィールドも手動でディープコピーするようにclone()メソッド内で記述する必要があります。- この方法は、Javaの設計原則（特にコンストラクタを使用しないオブジェクト生成）に反する部分があり、注意深く実装しないとバグの温床になりがちです。筆者の経験上、あまり推奨されません。
- 各クラスが
シリアライズ/デシリアライズを利用する
- 対象となるクラスが
Serializableインターフェースを実装している場合、オブジェクトをバイトストリームにシリアライズし、それをデシリアライズすることで、オブジェクトグラフ全体をディープコピーできます。 - 利点: 比較的簡単に実装でき、ネストされたオブジェクトも自動的にディープコピーされる。
- 欠点:
- パフォーマンスが非常に低い（I/O処理が伴うため）。
- すべてのクラスが
Serializableである必要がある。 transientフィールドはコピーされない。- Javaの内部的なシリアライズメカニズムに依存するため、将来的な互換性やセキュリティのリスクも考慮する必要がある。
- 緊急時や一時的な利用、またはプロトタイプでの利用にとどめるのが賢明です。
import java.io.*; class MyObjectSerializable implements Serializable { int value; String name; // transient List<String> transientList; // シリアライズされないフィールド public MyObjectSerializable(int value, String name) { this.value = value; this.name = name; } @Override public String toString() { return "MyObjectSerializable{" + "value=" + value + ", name='" + name + '\'' + '}'; } } public class DeepCopySerialization { public static <T extends Serializable> T deepCopy(T object) throws IOException, ClassNotFoundException { try (ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos)) { oos.writeObject(object); try (ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); ObjectInputStream ois = new ObjectInputStream(bis)) { return (T) ois.readObject(); } } } public static void main(String[] args) throws IOException, ClassNotFoundException { MyObjectSerializable[] originalArray = { new MyObjectSerializable(1, "Alpha"), new MyObjectSerializable(2, "Beta") }; MyObjectSerializable[] copiedArray = deepCopy(originalArray); System.out.println("--- コピー直後 ---"); System.out.println("Original Array[0]: " + originalArray[0]); System.out.println("Copied Array[0]: " + copiedArray[0]); System.out.println("originalArray[0] == copiedArray[0]: " + (originalArray[0] == copiedArray[0])); // false originalArray[0].value = 99; originalArray[0].name = "Gamma"; System.out.println("\n--- originalArray[0].value を変更後 ---"); System.out.println("Original Array[0]: " + originalArray[0]); System.out.println("Copied Array[0]: " + copiedArray[0]); // 変更されていない！ } }- 対象となるクラスが
外部ライブラリの利用
- Apache Commons Langの
SerializationUtils.clone()など、ディープコピーをサポートするライブラリが存在します。これらは内部的にシリアライズを利用していることが多いです。 - 多くの場合は、上記のシリアライズ方式の便利版と考えて良いでしょう。同様のメリット・デメリットがあります。
- 一部のプロファイリングツールやJVMエージェントは、オブジェクトグラフを走査してディープコピーを生成する機能を提供している場合もありますが、これは特殊なケースです。
- Apache Commons Langの
多次元配列の複製
多次元配列（例: int[][]）の場合、さらに注意が必要です。Javaの多次元配列は、「配列の配列」として扱われます。
多次元配列のシャローコピー
System.arraycopy()やArrays.copyOf()、clone()などで多次元配列を複製すると、それは「外側の配列」のみがシャローコピーされます。つまり、内側の配列（各行）への参照は共有されたままになります。
import java.util.Arrays;
public class MultiDimArrayShallow {
public static void main(String[] args) {
int[][] originalMatrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// シャローコピー (外側の配列のみ複製)
int[][] copiedMatrix = originalMatrix.clone();
System.out.println("--- コピー直後 ---");
System.out.println("Original Matrix[0]: " + Arrays.toString(originalMatrix[0]));
System.out.println("Copied Matrix[0]: " + Arrays.toString(copiedMatrix[0]));
System.out.println("originalMatrix[0] == copiedMatrix[0]: " + (originalMatrix[0] == copiedMatrix[0])); // true (参照が同じ)
// 元の配列の要素（内側の配列）を変更
originalMatrix[0][0] = 99;
System.out.println("\n--- originalMatrix[0][0] を変更後 ---");
System.out.println("Original Matrix[0]: " + Arrays.toString(originalMatrix[0])); // [99, 2, 3]
System.out.println("Copied Matrix[0]: " + Arrays.toString(copiedMatrix[0])); // [99, 2, 3] (変更が反映されてしまう)
// 外側の配列要素を新しいものに置き換えた場合
originalMatrix[1] = new int[]{100, 101, 102};
System.out.println("\n--- originalMatrix[1] を新しい配列で上書き後 ---");
System.out.println("Original Matrix[1]: " + Arrays.toString(originalMatrix[1])); // [100, 101, 102]
System.out.println("Copied Matrix[1]: " + Arrays.toString(copiedMatrix[1])); // [4, 5, 6] (こちらは変更されていない)
System.out.println("originalMatrix[1] == copiedMatrix[1]: " + (originalMatrix[1] == copiedMatrix[1])); // false
}
}
この動作は、オブジェクト配列のシャローコピーと同じ原理です。各行の配列オブジェクトが、外側の配列の要素として扱われるため、その参照がコピーされるのです。
多次元配列のディープコピー
多次元配列を完全に独立した状態に複製するには、各行（内側の配列）も個別に複製する必要があります。
import java.util.Arrays;
public class MultiDimArrayDeep {
public static void main(String[] args) {
int[][] originalMatrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// ディープコピー
int[][] copiedMatrix = new int[originalMatrix.length][];
for (int i = 0; i < originalMatrix.length; i++) {
copiedMatrix[i] = Arrays.copyOf(originalMatrix[i], originalMatrix[i].length); // 各行を個別にコピー
}
System.out.println("--- コピー直後 ---");
System.out.println("Original Matrix[0]: " + Arrays.toString(originalMatrix[0]));
System.out.println("Copied Matrix[0]: " + Arrays.toString(copiedMatrix[0]));
System.out.println("originalMatrix[0] == copiedMatrix[0]: " + (originalMatrix[0] == copiedMatrix[0])); // false (参照が異なる)
// 元の配列の要素（内側の配列）を変更
originalMatrix[0][0] = 99;
System.out.println("\n--- originalMatrix[0][0] を変更後 ---");
System.out.println("Original Matrix[0]: " + Arrays.toString(originalMatrix[0])); // [99, 2, 3]
System.out.println("Copied Matrix[0]: " + Arrays.toString(copiedMatrix[0])); // [1, 2, 3] (変更が反映されない！)
}
}
このように、多次元配列の場合は、外側の配列を複製し、さらに内側の配列を一つずつ複製するという二段階のプロセスが必要になります。
パフォーマンスの考慮と最適な選択
各複製方法には、パフォーマンスの特性があります。一般的に言われる傾向を理解し、適切な選択をすることが重要です。
パフォーマンス比較（一般的な傾向）
System.arraycopy()/Arrays.copyOf():- 最も高速です。これらはネイティブコードで実装されており、JVMの最適化の恩恵を最大限に受けます。プリミティブ型配列のコピーであれば、ほぼ間違いなく最速の選択肢です。
clone():System.arraycopy()と同等か、わずかに劣る程度のパフォーマンスを発揮します。内部実装も非常に似ています。
- forループ:
- プリミティブ型配列の単純なコピーであれば、
System.arraycopy()などより遅くなる傾向があります。しかし、要素数が非常に少ない場合や、コピー中に何らかの追加処理を挟む必要がある場合は、十分選択肢になります。JVMのJITコンパイラによって最適化されることもあります。
- プリミティブ型配列の単純なコピーであれば、
- ストリームAPI (
.toArray()):- 簡潔に書けますが、純粋なコピー処理だけを見ると、ストリームの生成や終端操作のオーバーヘッドがあるため、
System.arraycopy()などよりもパフォーマンスが劣る傾向があります。特に要素数が少ない場合や、複雑なパイプライン処理がない場合は、その差が顕著になることがあります。ただし、並列ストリームを利用すれば、マルチコア環境下で大量データに対しては有利になる可能性もあります。
- 簡潔に書けますが、純粋なコピー処理だけを見ると、ストリームの生成や終端操作のオーバーヘッドがあるため、
- シリアライズ/デシリアライズによるディープコピー:
- I/O処理を伴うため、最もパフォーマンスが悪いです。安易な利用は避けるべきです。
どの方法を選ぶべきか？ – プロの視点
私の経験に基づくと、Java配列の複製は、以下の優先順位と考慮事項で選択するのが良いでしょう。
プリミティブ型配列の場合:
System.arraycopy()またはArrays.copyOf()を最優先で検討します。- これらは最も高速で、コードも簡潔です。ほとんどの場合、これで十分です。
clone()も良い選択肢ですが、Arrays.copyOf()の方が直感的で、長さの調整もできるため、多くの場合で優位性があります。
参照型配列の「シャローコピー」で十分な場合:
System.arraycopy()またはArrays.copyOf()を選択します。- 「シャローコピーで十分」とは、配列内のオブジェクト自体は変更しない（不変オブジェクト）、または変更されても問題ない（新しいオブジェクトに差し替えるだけなど）場合を指します。
- 例えば、
String配列のコピーはシャローコピーで問題ありません。なぜならStringオブジェクトは不変（immutable）であり、一度生成されたStringインスタンスが変更されることはないからです。 - オブジェクトの参照だけを複製し、新しい配列自体は独立させたい、という明確な意図がある場合です。
参照型配列の「ディープコピー」が必要な場合:
- 手動での要素ごとのコピー（新しいインスタンスの生成と値のコピー） を最優先で検討します。
- これは最も安全で、制御が効き、かつパフォーマンスと可読性のバランスが取れた方法です。
- 要素のオブジェクトがさらにネストされたオブジェクトを持っている場合は、そのネストされたオブジェクトも手動でディープコピーする再帰的な処理が必要になります。
clone()メソッドを使う場合は、対象クラスがCloneableを実装し、かつclone()メソッド内で参照型のフィールドを適切にディープコピーするように実装されていることを確認する必要があります。これは複雑でバグを招きやすいので、慎重に。- シリアライズは、パフォーマンスが重要でない、かつ手動でのディープコピーが非常に複雑になる場合に、最後の手段として検討する程度に留めるべきです。
複製と同時に変換やフィルタリングを行いたい場合:
- Java 8以降であれば、ストリームAPIが非常に強力な選択肢になります。コードの簡潔さと表現力は抜群です。
- ただし、純粋なコピーよりもパフォーマンスが劣る可能性があるため、大規模データで厳密なパフォーマンス要件がある場合は、慎重にプロファイリングを行うべきです。
不変オブジェクトの活用によるコピーの回避
プロとして最も推奨したいのは、「そもそもコピーが必要な状況を減らす」という設計アプローチです。 もし配列の要素となるオブジェクトが不変（immutable）であれば、シャローコピーで十分なケースが大幅に増えます。なぜなら、たとえ参照が共有されていても、その参照先のオブジェクト自体が変更されることがないからです。
例えば、List<String>をList<String>に複製する場合、要素のStringは不変なので、新しいArrayListを作成して元のリストの要素を追加するだけで、実質的なディープコピーとして機能します（要素のString参照は共有されるが、String自体は変更されないため問題ない）。
設計段階から不変性（Immutability）を意識することで、コードの安全性と理解しやすさが飛躍的に向上し、ディープコピーの複雑さから解放されることもあります。
よくある落とし穴と注意点
1. = （代入演算子）は複製ではない！
冒頭でも触れましたが、int[] newArray = originalArray;はコピーではありません。これは、newArrayとoriginalArrayが同じメモリ上の配列オブジェクトを指すようになるだけであり、片方を変更するともう片方にも影響します。これは「参照の共有」であり、意図しないバグの温床となります。
2. 配列とGenericsの組み合わせに注意
Javaの配列はGenericsと相性が悪いです。例えば、List<String>[]のようなGenerics型を持つ配列を直接作成することはできません（new List<String>[10]はコンパイルエラー）。これは、実行時型情報（reification）がないためです。
代替案としてList<?>[]やObject[]を使用したり、ArrayList<List<String>>のようにリストのリストとして扱う方が一般的です。
もしGenericsを含む配列をコピーする必要がある場合、型安全性の問題を考慮し、キャストの安全性や、コピー後の要素の型チェックに注意を払う必要があります。
3. null要素の扱い
配列の要素がnullである場合、シャローコピーではnull参照がそのままコピーされます。ディープコピーの場合、nullの要素に対してclone()メソッドを呼び出すとNullPointerExceptionが発生するため、コピー処理中にnullチェックを行う必要があります。
4. clone()メソッドの一般的な落とし穴
Object.clone()はprotectedメソッドであるため、そのままでは外部から呼び出せません。通常、publicでオーバーライドし、Cloneableインターフェースを実装する必要があります。また、clone()メソッドの契約は複雑で、一貫性のある正しい実装は困難を伴います。Joshua Bloch氏の『Effective Java』でも「Cloneableは壊れたデザインである」と指摘されており、特別な理由がない限り、手動でのコピーコンストラクタやファクトリメソッド、またはシリアライズ方式を推奨しています。
ただし、配列のclone()メソッドに関しては、Java言語仕様で特別に扱いが簡素化されており、Cloneableインターフェースの実装やCloneNotSupportedExceptionのハンドリングは不要です。 しかし、これがオブジェクト配列のシャローコピーであるという根本的な問題は変わりません。
まとめ：あなたのJava配列複製は、もう大丈夫！
この記事では、Java配列の複製について、多角的な視点から深く掘り下げてきました。
- 配列の複製が必要な理由を理解すること。
forループ、System.arraycopy()、Arrays.copyOf()、clone()、ストリームAPIといった主要な複製方法とその特性を把握すること。- そして何よりも、シャローコピーとディープコピーの明確な違いとその影響を心から理解することが、安全で堅牢なJavaアプリケーションを構築する上で不可欠です。
プロのブロガーとして、私は声を大にして言いたいです。「配列を複製する際は、まずその配列がプリミティブ型か参照型か、そして参照型であればシャローコピーで良いのか、それともディープコピーが必要なのかを明確に自問自答してください。」この問いかけが、あなたのコードをバグから守り、将来のメンテナンスコストを削減する第一歩となるでしょう。
ほとんどのケースでは、プリミティブ型配列や参照型配列のシャローコピーであれば、Arrays.copyOf()やSystem.arraycopy()がシンプルで高速な選択肢となります。しかし、参照型配列のディープコピーが必要な場合は、安易な解決策に飛びつかず、手動での要素ごとのコピーや、オブジェクトの不変性を考慮した設計を心がけてください。
これであなたのJava配列複製に関する理解は、格段に深まったはずです。自信を持って、より質の高いJavaプログラミングを楽しんでください！
I love codes. I also love prompts (spells). But I get a lot of complaints (errors). I want to be loved by both of you as soon as possible.
