[Java] 2次元配列を正しくコピーする(単純な代入はダメ)

Javaで2次元配列を正しくコピーするには、単純な代入ではなく、各行を個別にコピーする必要があります。

単純な代入は参照をコピーするだけで、元の配列が変更されるとコピー先も影響を受けます。

正しい方法としては、forループを使って各行をSystem.arraycopyやArrays.copyOfでコピーするか、cloneメソッドを使用します。

これにより、元の配列とコピー先が独立した状態になります。

この記事でわかること

2次元配列のコピー方法の違い
シャローコピーとディープコピーの特性
コピー時の注意点と対処法
配列のコピーを活用する場面
効率的なコピー方法の選択肢

目次から探す

2次元配列のコピーにおける基本的な考え方

Javaにおける2次元配列は、配列の配列として実装され、行と列の形式でデータを格納します。

2次元配列をコピーする際には、単純な代入を行うと、元の配列とコピー先の配列が同じメモリを参照するため、片方の変更がもう片方に影響を及ぼすことになります。

このため、正しいコピー方法を選択することが重要です。

コピーには主にシャローコピーとディープコピーの2つの方法があり、それぞれの特性を理解することで、適切な方法を選択することができます。

特に、データの独立性が求められる場合には、ディープコピーが必要です。

2次元配列のシャローコピー

シャローコピーの定義

シャローコピーとは、配列の参照をコピーする方法です。

元の配列とコピー先の配列は、同じメモリ領域を参照するため、片方の配列の要素を変更すると、もう片方の配列にも影響が及びます。

これは、配列の要素がオブジェクトの場合に特に重要です。

シャローコピーの実装例

以下は、Javaにおける2次元配列のシャローコピーの実装例です。

public class App {
    public static void main(String[] args) {
        // 元の2次元配列を定義
        int[][] originalArray = {
            {1, 2, 3},
            {4, 5, 6}
        };
        // シャローコピーを作成
        int[][] shallowCopyArray = originalArray;
        // コピー先の配列の要素を変更
        shallowCopyArray[0][0] = 10;
        // 元の配列とコピー先の配列を出力
        System.out.println("元の配列:");
        for (int[] row : originalArray) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
        System.out.println("コピー先の配列:");
        for (int[] row : shallowCopyArray) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
    }
}

元の配列:
10 2 3 
4 5 6 
コピー先の配列:
10 2 3 
4 5 6

シャローコピーのメリットとデメリット

スクロールできます

メリット	デメリット
メモリの使用量が少ない	元の配列とコピー先が同じ参照を持つため、変更が影響し合う
コピー処理が高速	オブジェクトの変更が元の配列に影響を与える可能性がある

シャローコピーが適しているケース

元の配列とコピー先の配列が同じデータを共有しても問題ない場合
メモリ使用量を抑えたい場合
配列の要素が不変オブジェクトである場合(例：文字列など)

2次元配列のディープコピー

ディープコピーの定義

ディープコピーとは、元の配列の要素をすべて新しいメモリ領域にコピーする方法です。

これにより、元の配列とコピー先の配列は独立した存在となり、一方の変更がもう一方に影響を与えることはありません。

特に、配列の要素がオブジェクトの場合に重要です。

ディープコピーの実装方法

forループを使ったコピー

以下は、forループを使用して2次元配列をディープコピーする方法です。

public class App {
    public static void main(String[] args) {
        // 元の2次元配列を定義
        int[][] originalArray = {
            {1, 2, 3},
            {4, 5, 6}
        };
        // ディープコピーを作成
        int[][] deepCopyArray = new int[originalArray.length][];
        for (int i = 0; i < originalArray.length; i++) {
            deepCopyArray[i] = new int[originalArray[i].length];
            for (int j = 0; j < originalArray[i].length; j++) {
                deepCopyArray[i][j] = originalArray[i][j];
            }
        }
        // コピー先の配列の要素を変更
        deepCopyArray[0][0] = 10;
        // 元の配列とコピー先の配列を出力
        System.out.println("元の配列:");
        for (int[] row : originalArray) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
        System.out.println("コピー先の配列:");
        for (int[] row : deepCopyArray) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
    }
}

元の配列:
1 2 3 
4 5 6 
コピー先の配列:
10 2 3 
4 5 6

System.arraycopyを使ったコピー

System.arraycopyメソッドを使用してディープコピーを行う方法です。

public class App {
    public static void main(String[] args) {
        // 元の2次元配列を定義
        int[][] originalArray = {
            {1, 2, 3},
            {4, 5, 6}
        };
        // ディープコピーを作成
        int[][] deepCopyArray = new int[originalArray.length][];
        for (int i = 0; i < originalArray.length; i++) {
            deepCopyArray[i] = new int[originalArray[i].length];
            System.arraycopy(originalArray[i], 0, deepCopyArray[i], 0, originalArray[i].length);
        }
        // コピー先の配列の要素を変更
        deepCopyArray[0][0] = 10;
        // 元の配列とコピー先の配列を出力
        System.out.println("元の配列:");
        for (int[] row : originalArray) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
        System.out.println("コピー先の配列:");
        for (int[] row : deepCopyArray) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
    }
}

元の配列:
1 2 3 
4 5 6 
コピー先の配列:
10 2 3 
4 5 6

Arrays.copyOfを使ったコピー

Arrays.copyOfメソッドを使用してディープコピーを行う方法です。

import java.util.Arrays;
public class App {
    public static void main(String[] args) {
        // 元の2次元配列を定義
        int[][] originalArray = {
            {1, 2, 3},
            {4, 5, 6}
        };
        // ディープコピーを作成
        int[][] deepCopyArray = new int[originalArray.length][];
        for (int i = 0; i < originalArray.length; i++) {
            deepCopyArray[i] = Arrays.copyOf(originalArray[i], originalArray[i].length);
        }
        // コピー先の配列の要素を変更
        deepCopyArray[0][0] = 10;
        // 元の配列とコピー先の配列を出力
        System.out.println("元の配列:");
        for (int[] row : originalArray) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
        System.out.println("コピー先の配列:");
        for (int[] row : deepCopyArray) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
    }
}

元の配列:
1 2 3 
4 5 6 
コピー先の配列:
10 2 3 
4 5 6

cloneメソッドを使ったコピー

cloneメソッドを使用してディープコピーを行う方法です。

public class App {
    public static void main(String[] args) {
        // 元の2次元配列を定義
        int[][] originalArray = {
            {1, 2, 3},
            {4, 5, 6}
        };
        // ディープコピーを作成
        int[][] deepCopyArray = originalArray.clone();
        // 各行を個別にクローン
        for (int i = 0; i < deepCopyArray.length; i++) {
            deepCopyArray[i] = deepCopyArray[i].clone();
        }
        // コピー先の配列の要素を変更
        deepCopyArray[0][0] = 10;
        // 元の配列とコピー先の配列を出力
        System.out.println("元の配列:");
        for (int[] row : originalArray) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
        System.out.println("コピー先の配列:");
        for (int[] row : deepCopyArray) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
    }
}

元の配列:
1 2 3 
4 5 6 
コピー先の配列:
10 2 3 
4 5 6

ディープコピーのメリットとデメリット

スクロールできます

メリット	デメリット
元の配列とコピー先が独立している	メモリ使用量が増加する
変更が互いに影響しない	コピー処理が遅くなる可能性がある

ディープコピーが必要なケース

元の配列とコピー先の配列が異なるデータを持つ必要がある場合
配列の要素がオブジェクトであり、変更が他に影響を与えないようにしたい場合
データの整合性を保つために、元のデータを変更せずに新しいデータを作成したい場合

2次元配列のコピーにおける注意点

配列のサイズが異なる場合の対処

2次元配列をコピーする際、元の配列とコピー先の配列のサイズが異なる場合には注意が必要です。

特に、元の配列の行数や列数が異なる場合、単純なコピーではエラーが発生します。

このような場合、コピー先の配列を適切なサイズで初期化し、必要な要素のみをコピーする必要があります。

以下は、サイズが異なる場合の対処法の例です。

public class App {
    public static void main(String[] args) {
        // 元の2次元配列を定義
        int[][] originalArray = {
            {1, 2, 3},
            {4, 5, 6}
        };
        // コピー先の配列を異なるサイズで初期化
        int[][] copyArray = new int[3][2]; // 行数3、列数2の配列
        // 元の配列の要素をコピー
        for (int i = 0; i < originalArray.length; i++) {
            for (int j = 0; j < originalArray[i].length; j++) {
                if (i < copyArray.length && j < copyArray[i].length) {
                    copyArray[i][j] = originalArray[i][j];
                }
            }
        }
    }
}

多次元配列のコピーにおけるパフォーマンスの考慮

多次元配列のコピーは、特に大きな配列の場合、パフォーマンスに影響を与える可能性があります。

ディープコピーを行う際には、各要素を個別にコピーする必要があるため、時間がかかることがあります。

パフォーマンスを最適化するためには、以下の点を考慮することが重要です。

必要なコピーの範囲を限定する: 全体をコピーするのではなく、必要な部分だけをコピーする。
適切なコピー方法を選択する: System.arraycopyやArrays.copyOfなど、効率的なメソッドを使用する。
メモリ使用量を考慮する: 大きな配列をコピーする際は、メモリの使用量にも注意を払い、必要に応じてメモリ管理を行う。

不変オブジェクトを使ったコピーの利点

不変オブジェクト(Immutable Object)を使用することで、配列のコピーに関する問題を軽減できます。

不変オブジェクトは、一度作成されるとその状態を変更できないため、シャローコピーやディープコピーの必要がなくなります。

以下は、不変オブジェクトを使ったコピーの利点です。

データの整合性が保たれる: 不変オブジェクトは変更できないため、元のデータが意図せず変更されることがありません。
パフォーマンスの向上: コピーの必要がないため、メモリ使用量や処理時間を削減できます。
スレッドセーフ: 不変オブジェクトは、複数のスレッドから同時にアクセスされても安全です。

不変オブジェクトを使用することで、配列のコピーに関する複雑さを軽減し、より安全で効率的なプログラムを実現できます。

応用例：2次元配列のコピーを活用する場面

配列のソート後に元の配列を保持する

配列をソートする際、元の配列を保持しておくことが重要な場合があります。

ディープコピーを使用することで、ソート後も元のデータを保持できます。

以下は、元の配列を保持しつつソートを行う例です。

import java.util.Arrays;
public class App {
    public static void main(String[] args) {
        // 元の2次元配列を定義
        int[][] originalArray = {
            {3, 2, 1},
            {6, 5, 4}
        };
        // 元の配列をディープコピー
        int[][] copyArray = new int[originalArray.length][];
        for (int i = 0; i < originalArray.length; i++) {
            copyArray[i] = Arrays.copyOf(originalArray[i], originalArray[i].length);
        }
        // ソートを行う
        for (int[] row : copyArray) {
            Arrays.sort(row);
        }
        // 元の配列とソート後の配列を出力
        System.out.println("元の配列:");
        System.out.println(Arrays.deepToString(originalArray));
        System.out.println("ソート後の配列:");
        System.out.println(Arrays.deepToString(copyArray));
    }
}

元の配列:
[[3, 2, 1], [6, 5, 4]]
ソート後の配列:
[[1, 2, 3], [4, 5, 6]]

配列の一部を変更しても元の配列に影響を与えない

特定の要素を変更したいが、元の配列には影響を与えたくない場合、ディープコピーを使用することで解決できます。

以下は、配列の一部を変更する例です。

import java.util.Arrays;

public class App {
    public static void main(String[] args) {
        // 元の2次元配列を定義
        int[][] originalArray = {
                { 1, 2, 3 },
                { 4, 5, 6 }
        };
        // ディープコピーを作成
        int[][] copyArray = new int[originalArray.length][];
        for (int i = 0; i < originalArray.length; i++) {
            copyArray[i] = Arrays.copyOf(originalArray[i], originalArray[i].length);
        }
        // コピー先の配列の一部を変更
        copyArray[0][0] = 10;
        // 元の配列と変更後の配列を出力
        System.out.println("元の配列:");
        System.out.println(Arrays.deepToString(originalArray));
        System.out.println("変更後の配列:");
        System.out.println(Arrays.deepToString(copyArray));
    }
}

元の配列:
[[1, 2, 3], [4, 5, 6]]
変更後の配列:
[[10, 2, 3], [4, 5, 6]]

配列のバックアップを作成する

データの損失を防ぐために、配列のバックアップを作成することが重要です。

ディープコピーを使用することで、元の配列の状態を保持したままバックアップを作成できます。

import java.util.Arrays;

public class App {
    public static void main(String[] args) {
        // 元の2次元配列を定義
        int[][] originalArray = {
            {1, 2, 3},
            {4, 5, 6}
        };
        // バックアップを作成
        int[][] backupArray = new int[originalArray.length][];
        for (int i = 0; i < originalArray.length; i++) {
            backupArray[i] = Arrays.copyOf(originalArray[i], originalArray[i].length);
        }
        // 元の配列を変更
        originalArray[0][0] = 10;
        // バックアップと元の配列を出力
        System.out.println("元の配列:");
        System.out.println(Arrays.deepToString(originalArray));
        System.out.println("バックアップ:");
        System.out.println(Arrays.deepToString(backupArray));
    }
}

元の配列:
[[10, 2, 3], [4, 5, 6]]
バックアップ:
[[1, 2, 3], [4, 5, 6]]

配列の一部をコピーして新しい配列を作成する

元の配列の一部を新しい配列として作成したい場合、ディープコピーを使用することで特定の部分だけをコピーできます。

以下は、配列の一部をコピーする例です。

import java.util.Arrays;

public class App {
    public static void main(String[] args) {
        // 元の2次元配列を定義
        int[][] originalArray = {
            {1, 2, 3},
            {4, 5, 6}
        };
        // 一部をコピーして新しい配列を作成
        int[][] newArray = new int[1][];
        newArray[0] = Arrays.copyOf(originalArray[1], originalArray[1].length); // 2行目をコピー
        // 元の配列と新しい配列を出力
        System.out.println("元の配列:");
        System.out.println(Arrays.deepToString(originalArray));
        System.out.println("新しい配列:");
        System.out.println(Arrays.deepToString(newArray));
    }
}

元の配列:
[[1, 2, 3], [4, 5, 6]]
新しい配列:
[[4, 5, 6]]

よくある質問

シャローコピーとディープコピーの違いは何ですか？

シャローコピーは、元の配列の参照をコピーする方法であり、元の配列とコピー先の配列が同じメモリを参照します。

そのため、一方の配列の要素を変更すると、もう一方にも影響が及びます。

一方、ディープコピーは、元の配列の要素をすべて新しいメモリ領域にコピーするため、元の配列とコピー先の配列は独立した存在となります。

これにより、一方の変更が他方に影響を与えることはありません。

cloneメソッドはディープコピーを行いますか？

cloneメソッドは、配列のシャローコピーを行います。

つまり、配列の参照をコピーするため、元の配列とコピー先の配列は同じメモリを参照します。

ただし、2次元配列の場合、各行を個別にクローンすることでディープコピーを実現することができます。

したがって、cloneメソッドを使用する際は、必要に応じて各要素を手動でクローンする必要があります。

2次元配列のコピーでパフォーマンスを最適化する方法は？

2次元配列のコピーでパフォーマンスを最適化するためには、以下の方法が考えられます。

必要な範囲のみをコピーする: 全体をコピーするのではなく、必要な部分だけをコピーすることで、処理時間を短縮できます。
効率的なコピー方法を選択する: System.arraycopyやArrays.copyOfなど、パフォーマンスの良いメソッドを使用することで、コピー処理を高速化できます。
メモリ使用量を考慮する: 大きな配列を扱う場合、メモリの使用量を抑えるために、必要に応じてメモリ管理を行うことが重要です。

特に、不要な配列を早めに解放することがパフォーマンス向上につながります。