vollständige und unvollständige Arrays ausgeben

[scratchy1]

Hallo Leute,
ich hab es schonmal separat geschafft, jeweils vollständige und unvollständige Arrays auszugeben. Ist ein Array "unvollständig", so meine ich damit Arrays der Sorte boolean[3][]b
und mit "vollständigen" Solche der Art
boolean[][] bsp = { { true }, { false, false, false, true }, { false, true } };
Ich wollte auch mal ein solches mit unregelmässiger 2. Dimension erstellen.
Bei boolean[3][]b sollte die Ausgabe so aussehen:
{
{}
{}
{}
}
und bei boolean[][] bsp
{
{ true }
{ false false false true }
{ false true }
}
Nun bekomme ich aber bei beiden
{
{}
{}
{}
}
vielleicht, weil sowohl bei vollständigen als auch bei unvollständigen Arrays die "äusseren"
Arrays vorerst immer die null-Referenz haben. Hier ist mein Code:

public class ArrayStrukturTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // Fall 1 Quadratischen Array erstellen,
        // Struktur mittels duplicateStucture duplizieren
        // und das Ergebnis mitteld printArray ausgeben

        // Fall 2 Rechteckigen Array erstellen,
        // Struktur mittels duplicateStucture duplizieren
        // und das Ergebnis mitteld printArray ausgeben

        // Fall 3 Array mit unregelmäßiger zweiter Dimension erstellen
        // Struktur mittels duplicateStucture duplizieren
        // und das Ergebnis mitteld printArray ausgeben

        boolean[][] bsp = { { true }, { false, false, false, true }, { false, true } };
        duplicateStructure(bsp);
        printArray(duplicateStructure(bsp));
        boolean[][] b = new boolean[3][];
        duplicateStructure(b);
        printArray(duplicateStructure(b));
    }

    private static boolean[][] duplicateStructure(boolean[][] original) {

        // Hier Ihr Code zum duplizieren der Struktur
        boolean[][] kopie = new boolean[original.length][];

        return kopie;

    }

    private static void printArray(boolean[][] candidate) {
        // Hier Code, der den Array so ausgibt,
        // dass man die Struktur erkennt
        System.out.println("{");
                for (int i = 0; i < candidate.length; i++) {
                    if (candidate[i] != null) {
                    for(int j=0;j<candidate[i].length;j++) {
                   
                        System.out.println("{"+(candidate[i][j])+"}");
                    }
                       

                    }else{
                       
                        for (int k = 1; k <= Math.sqrt(candidate.length); k++) {

                            System.out.println("{}");

                        }
                       

                    }

               
        }
                System.out.println("}");           
    }
                 
 }

 

[mrBrown]

Was soll denn das duplicateStructure machen? Ich bin mir ziemlicher sicher, dass es nicht das machen soll, was es jetzt macht...


Und warum willst du die "Struktur" eines Arrays kopieren, nur um es auszugeben?

 

[scratchy1]

Also eigentlich will ich Arrays aller Art kopieren können und gebe sie aus, um zu sehen, ob es klappt.

 

[mrBrown]

Dann setz doch erstmal beide Schritte (ausgeben und kopieren) getrennt voneinander um.
Aktuell hast du eine kaputte Kopier- und eine kaputte Ausgabefunktion, dass dabei immer was falsches rauskommt und du den Fehler nicht findest ist doch klar.

 

[scratchy1]

In der main-Methode rufe ich ja auch beides getrennt voneinander auf. Und bei boolean[3][]-Arrays funktioniert es ja auch. ich kopiere, dann gebe ich aus und es geht. Das gleiche versuche ich ja dann auch mit dem boolean[][]bsp-Array, aber da wird nicht erkannt, dass dort die "äusseren" Arrays nicht die null-Referenz haben und deswegen anders ausgegeben werden sollen.

 

[mrBrown]

In der main-Methode rufe ich ja auch beides getrennt voneinander auf.

Nein. Du rufst die Ausgabe-Methode mit dem Ergebnis der Kopier-Methode auf.
Wenn eine der beiden Teile falsch ist, ist auch das Gesamtergebnis falsch, aber du wirst niemals finden, welches.

Der einzeln stehende Aufruf von duplicateStructure ist btw. Unsinn, der gibt was zurück, was du dann wegschmeißt,

Und bei boolean[3][]-Arrays funktioniert es ja auch. ich kopiere, dann gebe ich aus und es geht.

Naja, das Ergebnis davon würden die meisten als völlig falsch bezeichnen.

Ein boolean[3][] ist {null, null, null}, bei dir ergibt das {{},{},{}} (wobei das nur Zufall ist, da die Ausgabefunktion kaputt ist, versuch das ganze mal mit 4 statt 3...).

Das gleiche versuche ich ja dann auch mit dem boolean[][]bsp-Array, aber da wird nicht erkannt, dass dort die "äusseren" Arrays nicht die null-Referenz haben und deswegen anders ausgegeben werden sollen.

Hat nichts mit "nicht erkannt" in der Ausgabe-Funktion zu tun, sondern liegt an der völlig unvollständigen kopier-Funktion.
Da sind eben null-Referenzen (wobei die meisten die eher als die inneren Arrays bezeichnen würden, und nicht als die "äußeren"), und innerhalb der Ausgabe wird der else-Zweig ausgeführt (dessen Ausgabe aber wie gesagt nur zufällig für den Fall in eine "richtige" Richtung weißt).

Wie gesagt: entwickle beide Funktionen getrennt voneinander. Schreib erst die Ausgabe fertig, ohne irgendwo irgendwas zu kopieren, und wenn die korrekt funktioniert, machst du dich an das kopieren. Aktuell ist beides Fehlerhaft.

 

[scratchy1]

Cool, danke. Ich hab meine printArray-Methode vorgestern ausprobiert und sie war falsch. Dann funktioniert die Methode auch nicht mit dem Ergebnis der Kopier-Methode. D.h. ich machte mich nun auf, die printArray-Methode korrekt zu schreiben. Diese lautet nun

private static void printArray(boolean[][] candidate) {
        // Hier Code, der den Array so ausgibt,
        // dass man die Struktur erkennt
        System.out.println("{");
                for (int i = 0; i < candidate.length; i++) {
                    if (candidate[i] != null) {
                        System.out.println("{");
                    for(int j=0;j<candidate[i].length;j++) {
                   
                        System.out.println(candidate[i][j]);
                    }
                    System.out.println("}");

                    }else{
                       
                        for (int k = 1; k <= Math.sqrt(candidate.length); k++) {

                            System.out.println("{}");

                        }
                       

                    }

               
        }
                System.out.println("}");           
    }

So und nun schau ich mir mal die Kopiermethode duplicateStructure als nächstes an.

 

[mrBrown]

Die ist immer noch nicht richtig, hast du es mal mit new boolean[4][] versucht?

 

[scratchy1]

So, nun eine etwas übersichtlichere prinArray-Methode

private static void printArray(boolean[][] candidate) {
        // Hier Code, der den Array so ausgibt,
        // dass man die Struktur erkennt
        System.out.println("{");
                for (int i = 0; i < candidate.length; i++) {
                    if (candidate[i] != null) {
                        System.out.print("{");
                    for(int j=0;j<candidate[i].length;j++) {
                   
                        System.out.print(candidate[i][j]);
                    }
                    System.out.print("}");

                    }else{
                       
                        for (int k = 1; k <= Math.sqrt(candidate.length); k++) {

                            System.out.println("{}");

                        }
                       

                    }

               
        }
                System.out.println("}");           
    }

 

[mrBrown]

Ist zwischen den beiden Versionen irgendein auffälliger Unterschied?

Mit „übersichtlich“ haben die nun beide wahrlich nichts zu tun...

 

[scratchy1]

Achso ne, der else-Zweig ist noch falsch,...

 

[scratchy1]

So, jetzt aber. Jetzt gehts auch mit boolean[4][]c

private static void printArray(boolean[][] candidate) {
        // Hier Code, der den Array so ausgibt,
        // dass man die Struktur erkennt
        System.out.println("{");
                for (int i = 0; i < candidate.length; i++) {
                    if (candidate[i] != null) {
                        System.out.print("{");
                    for(int j=0;j<candidate[i].length;j++) {
                   
                        System.out.print(candidate[i][j]);
                    }
                    System.out.print("}");

                    }else{
                       
                       
                         
                            System.out.println("{}");

                        }
                       

                   

               
        }
                System.out.println("}");           
    }
                 
 }

mit
{
{}
{}
{}
{}
}
als Ausgabe, wo der else-Zweig durchlaufen wird und sonst klappt es auch für Referenzen, die nicht leer sind.