it-swarm.com.de

Wie kopiere ich ein 2-dimensionales Array in Java?

Ich muss eine Kopie eines ziemlich großen zweidimensionalen Arrays für ein Projekt erstellen, an dem ich arbeite. Ich habe zwei 2D-Arrays:

int[][]current;
int[][]old;

Ich habe auch zwei Methoden zum Kopieren. Ich muss das Array kopieren, da der Strom regelmäßig aktualisiert wird.

public void old(){
  old=current
}

und

public void keepold(){
  current=old
}

Dies funktioniert jedoch nicht. Wenn ich old anrief, aktualisiere ich current und rufe keepold an. Current ist nicht gleich, wie es ursprünglich war. Warum sollte das sein?

Vielen Dank

31
badcoder

current=old oder old=current bewirkt, dass sich die beiden Arrays auf dasselbe beziehen. Wenn Sie anschließend current ändern, wird old ebenfalls geändert. Um den Inhalt eines Arrays in ein anderes Array zu kopieren, verwenden Sie die for-Schleife

for(int i=0; i<old.length; i++)
  for(int j=0; j<old[i].length; j++)
    old[i][j]=current[i][j];

PS: Bei einem eindimensionalen Array können Sie die Erstellung einer eigenen for-Schleife vermeiden, indem Sie Arrays.copyOf verwenden.

37
Louis Rhys
/**
 * Clones the provided array
 * 
 * @param src
 * @return a new clone of the provided array
 */
public static int[][] cloneArray(int[][] src) {
    int length = src.length;
    int[][] target = new int[length][src[0].length];
    for (int i = 0; i < length; i++) {
        System.arraycopy(src[i], 0, target[i], 0, src[i].length);
    }
    return target;
}

Kann dieser Code geändert werden, um n-dimensionale Arrays von Objekten zu unterstützen?

Sie müssen beliebige Längen von Arrays unterstützen und prüfen, ob Quelle und Ziel die gleichen Abmessungen haben. und Sie müssten auch jedes Element jedes Arrays rekursiv kopieren, falls das Objekt auch ein Array ist.

Es ist schon eine Weile her, seit ich das gepostet habe, aber ich habe ein Schönes Beispiel gefunden, um eine n-dimensionale Array-Klasse zu erstellen. Die Klasse nimmt im Konstruktor keine oder mehrere ganze Zahlen an und gibt die jeweilige Größe jeder Dimension an. Die Klasse verwendet ein darunter liegendes flaches array Object[] und berechnet den Index jedes Elements anhand der Dimensionen und eines Arrays von Multiplikatoren. (So ​​werden Arrays in der Programmiersprache C ausgeführt.) 

Das Kopieren einer Instanz von NDimensionalArray wäre so einfach wie das Kopieren eines anderen 2D-Arrays, obwohl Sie feststellen müssen, dass jedes NDimensionalArray-Objekt die gleichen Abmessungen hat. Dies ist wahrscheinlich der einfachste Weg, da es keine Rekursion gibt, was die Darstellung und den Zugriff wesentlich vereinfacht.

22
mbomb007

Ich habe es gelöst, eine einfache Funktion zu schreiben, um mehrdimensionale int-Arrays mit System.arraycopy zu kopieren

public static void arrayCopy(int[][] aSource, int[][] aDestination) {
    for (int i = 0; i < aSource.length; i++) {
        System.arraycopy(aSource[i], 0, aDestination[i], 0, aSource[i].length);
    }
}

oder eigentlich habe ich es für meinen Anwendungsfall verbessert:

/**
 * Clones the provided array
 * 
 * @param src
 * @return a new clone of the provided array
 */
public static int[][] cloneArray(int[][] src) {
    int length = src.length;
    int[][] target = new int[length][src[0].length];
    for (int i = 0; i < length; i++) {
        System.arraycopy(src[i], 0, target[i], 0, src[i].length);
    }
    return target;
}
6
Daniel Backman

Sie können auch wie folgt vorgehen:

public static int[][] copy(int[][] src) {
    int[][] dst = new int[src.length][];
    for (int i = 0; i < src.length; i++) {
        dst[i] = Arrays.copyOf(src[i], src[i].length);
    }
    return dst;
}
3
Johnny Lim

Seit Java 8 unter Verwendung der Streams-API:

int[][] copy = Arrays.stream(matrix).map(r -> r.clone()).toArray(int[][]::new);

r verweist auf eine row in der 2D-Matrix.

1

Mit Java 8 kann dies erledigt werden

`int[][] destination=Arrays.stream(source)
                    .map(a ->  Arrays.copyOf(a, a.length))
                    .toArray(int[][]::new);
1
Rakesh Chauhan

So können Sie dies mithilfe von Schleifen tun.

public static int[][] makeCopy(int[][] array){
    b=new int[array.length][];

    for(int row=0; row<array.length; ++row){
        b[row]=new int[array[row].length];
        for(int col=0; col<b[row].length; ++col){
            b[row][col]=array[row][col];
        }
    }
    return b;
}
0
current = old ;

Bei Zuweisungsoperationen werden keine Elemente eines Arrays in ein anderes kopiert. Sie lassen nur die current-Matrix auf die old-Matrix verweisen. Sie müssen eine für Mitglieder sinnvolle Kopie erstellen.

0
Mahesh

Arrays in Java sind Objekte und alle Objekte werden als Referenz übergeben . Um ein Array wirklich zu "kopieren", müssen Sie, anstatt einen anderen Namen für ein Array zu erstellen, ein neues Array erstellen und alle Werte überschreiben. Beachten Sie, dass System.arrayCopy 1-dimensionale Arrays vollständig, jedoch NICHT 2-dimensionale Arrays kopiert. Der Grund ist, dass ein 2D-Array tatsächlich ein 1D-Array von 1D-Arrays ist und ArrayCopy über Zeiger auf dieselben internen 1D-Arrays kopiert.

0
Sajid

Ich verwende diese Funktion:

public static int[][] copy(final int[][] array) {
    if (array != null) {
        final int[][] copy = new int[array.length][];

        for (int i = 0; i < array.length; i++) {
            final int[] row = array[i];

            copy[i] = new int[row.length];
            System.arraycopy(row, 0, copy[i], 0, row.length);
        }

        return copy;
    }

    return null;
}

Der große Vorteil dieses Ansatzes ist, dass er auch Arrays kopieren kann, die nicht die gleiche Zeilenanzahl haben, wie zum Beispiel:

final int[][] array = new int[][] { { 5, 3, 6 }, { 1 } };
0
Niklas