Mir ist beim experimentieren etwas aufgefallen:Java ist auch eine Insel hat gesagt.:Wollen wir eine Kopie eines Arrays mit gleicher Größe und gleichem Elementtyp schaffen, so nutzen wir dazu die Objektmethode clone(). Sie klont – in unserem Fall kopiert – die Elemente des Array-Objekts in ein neues.
Java:
package arrays;
public class Arrays
{
public static void main(String[] args)
{
int[][] zweidimensional = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[] eindimensional = {1, 2, 3, 4, 5, 6, 7, 8, 9};
System.out.println("--------------------------Ausgangssituation"
+ "\n");
druckeZweidimensional(zweidimensional);
druckeEindimensional(eindimensional);
System.out.println("--------------------------Testversuch: Eindimensional.clone()"
+ "\n");
/**
* Beim Verweis auf ein Array wird im Fall einer Aenderung im
* Verweisarray der Wert an Ort und Stelle im "Originalarray" ebenso
* geaendert. Erst bei einer Kopie, welche mit array.clone() erstellt
* wurde, kann von eigenstaendigen Array ausgegangen werden.
*
* a) Auf das Original-Array zeigen nun zwei Variablen;
* b) Ein eigenstaendiges Array wird mit array.clone() erstellt
* c) Die zweite Variable des Original-Arrays wird geaendert, sprich das
* Original-Array ebenso
*
* Wie auch in diesem Beispiel funktioniert alles so wie beschrieben,
* bei Original- und Verweis-Array wird die erste Indexvariable
* geaendert.
*/
//a
int[] verweisAufEindimensional = eindimensional;
//b
int[] kopieEindimensional = eindimensional.clone();
//c
verweisAufEindimensional[0] = 100;
druckeEindimensional(eindimensional);
druckeEindimensional(verweisAufEindimensional);
druckeEindimensional(kopieEindimensional);
System.out.println("--------------------------Testversuch: Eindimensional System.arraycopy"
+ "\n");
int[] eindimens = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] eindimensA = eindimens;
int[] eindimensB = eindimens;
System.arraycopy(eindimens, 0, eindimensB, 0, eindimens.length);
eindimensA[0] = 100;
druckeEindimensional(eindimens);
druckeEindimensional(eindimensA);
druckeEindimensional(eindimensB);
System.out.println("--------------------------Testversuch: Zweidimensional.clone()"
+ "\n");
/**
* eben die gleiche Vorgehensweise wende ich auf ein zweidimensionales
* Array an, jedoch ist das Ergebnis ein anderes. der Wert wird in allen
* Arrays geaendert.
*/
int[][] verweisAufZweidimensional = zweidimensional;
int[][] kopieZweidimensional = zweidimensional.clone();
verweisAufZweidimensional[0][0] = 100;
druckeZweidimensional(zweidimensional);
druckeZweidimensional(verweisAufZweidimensional);
druckeZweidimensional(kopieZweidimensional);
System.out.println("--------------------------Testversuch: Eigene Methode"
+ "\n");
//
int[][] test = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[][] testA = test;
int[][] testB = arraycopy(test);
testA[0][0] = 100;
druckeZweidimensional(test);
druckeZweidimensional(testA);
druckeZweidimensional(testB);
System.out.println("--------------------------Testversuch: Zweidimensional System.arraycopy"
+ "\n");
int[][] systemMethodeArrayCopy = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[][] systemA = systemMethodeArrayCopy;
int[][] systemB = systemMethodeArrayCopy;
System.arraycopy(systemMethodeArrayCopy, 0, systemB, 0, systemMethodeArrayCopy.length);
systemA[0][0] = 100;
druckeZweidimensional(systemMethodeArrayCopy);
druckeZweidimensional(systemA);
druckeZweidimensional(systemB);
}
static void druckeZweidimensional(int[][] array)
{
System.out.println("Zweidimensional");
for (int x = 0; x < array.length; x++) {
for (int y = 0; y < array[x].length; y++) {
if (y < array[y].length - 1) {
System.out.print(array[x][y] + ", ");
} else {
System.out.print(array[x][y]);
}
}
System.out.println();
}
}
static void druckeEindimensional(int[] array)
{
System.out.println("Eindimensional");
for (int i = 0; i < array.length; i++) {
if (i < array.length - 1) {
System.out.print(array[i] + ", ");
} else {
System.out.print(array[i]);
}
}
System.out.println();
}
static int[][] arraycopy(int[][] array)
{
int[][] uebergabe = new int[array.length][array[0].length];
for (int x = 0; x < array.length; x++) {
for (int y = 0; y < array[x].length; y++) {
uebergabe[x][y] = array[x][y];
}
}
return uebergabe;
}
}
//Konsolenausgabe
--------------------------Ausgangssituation
Zweidimensional
1, 2, 3
4, 5, 6
7, 8, 9
Eindimensional
1, 2, 3, 4, 5, 6, 7, 8, 9
--------------------------Testversuch: Eindimensional.clone()
Eindimensional
100, 2, 3, 4, 5, 6, 7, 8, 9
Eindimensional
100, 2, 3, 4, 5, 6, 7, 8, 9
Eindimensional
1, 2, 3, 4, 5, 6, 7, 8, 9
--------------------------Testversuch: Eindimensional System.arraycopy
Eindimensional
100, 2, 3, 4, 5, 6, 7, 8, 9
Eindimensional
100, 2, 3, 4, 5, 6, 7, 8, 9
Eindimensional
100, 2, 3, 4, 5, 6, 7, 8, 9
--------------------------Testversuch: Zweidimensional.clone()
Zweidimensional
100, 2, 3
4, 5, 6
7, 8, 9
Zweidimensional
100, 2, 3
4, 5, 6
7, 8, 9
Zweidimensional
100, 2, 3
4, 5, 6
7, 8, 9
--------------------------Testversuch: Eigene Methode
Zweidimensional
100, 2, 3
4, 5, 6
7, 8, 9
Zweidimensional
100, 2, 3
4, 5, 6
7, 8, 9
Zweidimensional
1, 2, 3
4, 5, 6
7, 8, 9
--------------------------Testversuch: Zweidimensional System.arraycopy
Zweidimensional
100, 2, 3
4, 5, 6
7, 8, 9
Zweidimensional
100, 2, 3
4, 5, 6
7, 8, 9
Zweidimensional
100, 2, 3
4, 5, 6
7, 8, 9
Erfolge zweidimensional: nur eigene Methode
Warum erstellt weder die
clone()
noch arraycopy()
eine eigenständige Kopie eines zweidimensionalen Arrays?