Guten Tag,
ich möchte hier meine Methode zur tiefen Kopie eines Arrays unbekannter Dimension und unbekannten Typs vorstellen. Damit die Kritik mir gegenüber rational und konstruktiv ausfällt, bitte ich potenzielle Antwortgeber, ihre Verbesserungsvorschläge detailreich zu präsentieren und nicht nur allgemein zu beschreiben. Antworten wie "Verwende doch ... oder ..., damit geht es leichter!" sind völlig fehl am Platz. Falls ihr prinzipiell eine elegantere Lösung parat habt, prüft diese bitte ordentlich auf Fehler. Vielen Dank im Voraus für die Berücksichtigung des hier Geschriebenen.
Simples Interface, welches die Methode der tiefen Kopie für einen komplexen Datentypen bereitstellt:
Kopie.Java
Die
aus
ist protected. Auf diese kann von Außen nicht zu gegriffen werden. Folglich können generische Typen, die hier zwingend notwendig sind, auch nicht darauf zugreifen.
Eine Testklasse, welche das Interface implementiert, die Methode des Kopierens korrekt umsetzt und eine neue Instanz des Typs zurückgibt:
TestKlasse.java
Die Hauptklasse, welche die generische Methode der tiefen Arraykopie durchführt! Eine Methode, welche nur rekursiv funktionieren kann! Bzw. Rekursion und Iteration kombiniert.
Sicher kann man die Verzweigungen zusammenfassen. Ich wollte hier dem Benutzer der Methode hinreichend auf seine Fehler hinweisen.
ich möchte hier meine Methode zur tiefen Kopie eines Arrays unbekannter Dimension und unbekannten Typs vorstellen. Damit die Kritik mir gegenüber rational und konstruktiv ausfällt, bitte ich potenzielle Antwortgeber, ihre Verbesserungsvorschläge detailreich zu präsentieren und nicht nur allgemein zu beschreiben. Antworten wie "Verwende doch ... oder ..., damit geht es leichter!" sind völlig fehl am Platz. Falls ihr prinzipiell eine elegantere Lösung parat habt, prüft diese bitte ordentlich auf Fehler. Vielen Dank im Voraus für die Berücksichtigung des hier Geschriebenen.
Simples Interface, welches die Methode der tiefen Kopie für einen komplexen Datentypen bereitstellt:
Kopie.Java
Java:
public interface Kopie {
public Kopie getKopie();
}
Code:
.clone()
Code:
ObjectEine Testklasse, welche das Interface implementiert, die Methode des Kopierens korrekt umsetzt und eine neue Instanz des Typs zurückgibt:
TestKlasse.java
Java:
public class TestKlasse implements Kopie {
char charakter;
/* Anfang: Konstruktoren */
public TestKlasse(char charakter) {
this.charakter = charakter;
}
// Standardkonstruktor
public TestKlasse() {
this('0');
}
// Kopierkonstruktor
public TestKlasse(TestKlasse Original) {
this.charakter = Original.getCharakter();
}
/* Ende: Konstruktoren */
/* Anfang: Setter */
public void setZahlenwert(char charakter) {
this.charakter = charakter;
}
/* Ende: Setter */
/* Anfang: Getter */
public char getCharakter() {
return charakter;
}
/* Ende: Getter */
@Override
public Kopie getKopie() {
TestKlasse echteKopie = new TestKlasse(this.charakter);
return echteKopie;
}
}Die Hauptklasse, welche die generische Methode der tiefen Arraykopie durchführt! Eine Methode, welche nur rekursiv funktionieren kann! Bzw. Rekursion und Iteration kombiniert.
Java:
/******************************
* *
* @author Tim Lehmann *
* Datum 18.12.2013 *
* *
******************************/
public class Steuerung {
public static void main(String[] args) {
ausfuehren();
}
public static void ausfuehren() {
/* Anfang: getestete fehleranfaellige Uebergabeparameter */
int int_var = 0;
int[] int_Array_var = new int[1];
Object Object_var = new Object();
Object[] Object_Array_var = new Object[1];
TestKlasse testKlasse_var = new TestKlasse('a');
TestKlasse[] testKlasse_array_var = new TestKlasse[1];
/* Ende: getestete fehleranfaellige Uebergabeparameter */
TestKlasse tk[][][] = new TestKlasse[2][3][3];
tk[0][0][0] = new TestKlasse('0');
tk[0][0][1] = new TestKlasse('1');
tk[0][0][2] = new TestKlasse('2');
tk[0][1][0] = new TestKlasse('3');
tk[0][1][1] = new TestKlasse('4');
tk[0][1][2] = new TestKlasse('5');
tk[0][2][0] = new TestKlasse('6');
tk[0][2][1] = new TestKlasse('7');
tk[0][2][2] = new TestKlasse('8');
tk[1][0][0] = new TestKlasse('a');
tk[1][0][1] = new TestKlasse('b');
tk[1][0][2] = new TestKlasse('c');
tk[1][1][0] = new TestKlasse('d');
tk[1][1][1] = new TestKlasse('e');
tk[1][1][2] = new TestKlasse('f');
tk[1][2][0] = new TestKlasse('g');
tk[1][2][1] = new TestKlasse('h');
tk[1][2][2] = new TestKlasse('i');
TestKlasse tk_flache_kopie[][][] = TiefeArrayKopie(tk);
// Ausgabe
for (int z = 0; z < tk.length; z++) {
for (int y = 0; y < tk[0].length; y++) {
for (int x = 0; x < tk[0][0].length; x++) {
System.out.print(tk[z][y][x].getCharakter() + " ");
}
System.out.println();
}
System.out.println("\n");
}
for (int z = 0; z < tk.length; z++) {
for (int y = 0; y < tk[0].length; y++) {
for (int x = 0; x < tk[0][0].length; x++) {
System.out.print(tk_flache_kopie[z][y][x].getCharakter()
+ " ");
}
System.out.println();
}
System.out.println("\n");
}
}
@SuppressWarnings("unchecked")
public static <T> T TiefeArrayKopie(T Array) {
String Fehlermeldung = null;
T Kopie = null;
// Uebergabeparameter ist ein Array
if (Array.getClass().isArray()) {
// Pruefen, ob Array Typen eines komplexen Datentypen beinhaltet
// Meines Wissens nach, nur ueber die Auswertung der Zeichenkette
// moeglich.
// Das 'L' in ".getClass().toString()" steht fuer einen komplexen
// Datentypen
if (Array.getClass().toString().matches("^.*?\\[L.*\\;")) {
int arraybereite = ((T[]) Array).length;
Kopie = (T) ((T[]) Array).clone();
// Iterativ alle Elemente dieses Arrays durchlaufen
for (int z1 = 0; z1 < arraybereite; z1++) {
// Untere Dimension enthaelt keine nicht instanziierte
// Elemente (null-Werte)
if (((T[]) Array)[z1] != null) {
// Untere Dimension enthaelt ebenfalls Arrays
if (((T[]) Array)[z1].getClass().isArray()) {
// Rekursiver Aufruf der Methode
((T[]) Kopie)[z1] = TiefeArrayKopie(((T[]) Kopie)[z1]);
}
// Untere Dimension enthaelt keine Arrays
else {
// Untersten Elemente des Arrays implementieren die
// Schnittstelle zur tiefen Kopie
if (((T[]) Array)[0] instanceof Kopie) {
for (int z = 0; z < arraybereite; z++) {
((T[]) Kopie)[z] = (T) ((Kopie) ((T[]) Kopie)[z])
.getKopie();
}
// Untersten Elemente des Arrays implementieren
// keine Schnittstelle zur tiefen Kopie
} else {
Fehlermeldung = "Elemente des Uebergabeparameters impelementieren nicht die noetige Schnittstelle!";
}
}
}
// Untere Dimension enthaelt nicht instanziierte Elemente
else {
Fehlermeldung = "Uebergabeparameter enthält nicht instanziierte Elemente (null Werte)";
}
}
// Array enthaelt keine komplexen Datentypen
} else {
Fehlermeldung = "Uebergabeparameter darf kein Array primitiver Datentypen sein!";
}
// Uebergabeparameter ist kein Array
} else {
Fehlermeldung = "Uebergabeparameter muss ein Array sein!";
}
// Wurf der Ausnahme
if (Fehlermeldung != null) {
throw new IllegalArgumentException(Fehlermeldung);
}
return Kopie;
}
}Sicher kann man die Verzweigungen zusammenfassen. Ich wollte hier dem Benutzer der Methode hinreichend auf seine Fehler hinweisen.
Zuletzt bearbeitet:
