Referenzen

scratchy1

Bekanntes Mitglied
Hallo Leute,
ich habe folgenden Code
Java:
package gameOfLife;

public class GameOfLife {
    boolean[][] feld = { { false, false, false, false, false }, { false, false, true, false, false },
            { false, false, true, false, false }, { false, false, true, false, false },
            { false, false, false, false, false } };

    public static void main(String[] args) {
        GameOfLife myGame = new GameOfLife();
        for (int i = 0; i < 10; i++) {
            myGame.nextGeneration();
            myGame.print();
            System.out.println();
        }
    }

    void print() {
        for (int i = 0; i < feld.length; i++) {
            for (int j = 0; j < feld[i].length; j++) {
                if (feld[i][j] == true)
                    System.out.print("o ");
                else
                    System.out.print(". ");
            }
            System.out.println();
        }
    }

    void nextGeneration() {
        /*
         * 1 Eine lebende Zelle lebt auch in der Folgegeneration, wenn genau zwei oder
         * drei der acht benachbarten Zellen in der aktuellen Generation leben. 2 Eine
         * lebende Zelle stirbt in der Folgegeneration an Einsamkeit oder
         * Überbevölkerung, wenn in der aktuellen Generation weniger als zwei oder mehr
         * als drei der acht Nachbarzellen leben. 3 Eine tote Zelle wird in der
         * Folgegeneration lebendig, wenn genau drei ihrer acht Nachbarn in der
         * aktuellen Generation lebendig sind. 4 Unabhängig von den obigen drei Regeln
         * sind die Randzellen (also diejenigen Zellen, die nicht genau acht Nachbarn
         * haben) immer tot. Da Sie für die Berechnung aller Zellen der Folgegeneration
         * noch Zugriff auf die Zustände der aktuellen Generation benötigen, sollten Sie
         * die Zustände der Folgegeneration zunächst in ein neues, zweidimensionales
         * boolean-Array gleicher Gröÿe schreiben. Ihre Implementierung sollte nach
         * Möglichkeit unabhängig von der Grösse der Zellkultur funktionieren; Sie
         * dürfen aber von einer rechteckigen Zellkultur ausgehen.
         */
        
      
        boolean[][] feld2 = new boolean[feld.length][];

       

        for (int s = 0; s < feld.length; s++) {
             
            feld2[s] = new boolean[feld.length];

            System.out.println();
        }

        int anzahllebendnachbarn = 0;
       

        // anzahllebendnachbarnüberprüfung

        for (int u = 1; u < feld2.length - 1; u++) {
            for (int v = 1; v < feld2[u].length - 1; v++) {
                boolean[] arr = { feld[u + 1][v], feld[u][v + 1], feld[u + 1][v + 1], feld[u - 1][v], feld[u][v - 1],
                        feld[u - 1][v - 1], feld[u - 1][v + 1], feld[u + 1][v - 1] };
                for (boolean elem : arr) {
                    if (elem == true) {
                        anzahllebendnachbarn = anzahllebendnachbarn + 1;

                    }
                }
                if (anzahllebendnachbarn < 4 && anzahllebendnachbarn > 1) {
                    feld2[u][v] = true;
                }
                if (feld[u][v] == false && anzahllebendnachbarn == 3) {// 3.Bedingung
                    feld2[u][v] = true;

                }
                if (anzahllebendnachbarn == 2 || anzahllebendnachbarn == 3) {// 1.Bedingung
                    feld2[u][v] = true;

                }
                if (anzahllebendnachbarn < 2 || anzahllebendnachbarn > 3) {// 2.Bedingung
                    feld2[u][v] = false;

                }
            }
        }
        //hier code eingeben
        this.feld=feld2;
        //for(int i=0;i<feld2.length;i++) {
        //this.feld[i]=feld2[i];
           
       
        }
       
       
       
    }
}
Vielleicht kennt jemand von euch das Spiel des Lebens.
Ich hab in der Klasse ein Array feld deklariert. In der Methode nextGeneration() baue ich mir ein 2. Array feld2, in dem ich die Änderungen von feld eintrage.
Damit ich nun das Spiel über mehrere Generationen laufen lassen kann, will ich die Referenz von feld zu "Array1" "umverlegen" zu dem Array, das feld2 referenziert.

bei "hier code eingeben"
hab ich 2 Dinge ausprobiert.
this.feld=feld2 sollte die Sache für mich schaukeln. Ich weiss, dass das dann noch nicht fertig ist, aber ich wollt erstmal nur die 1. Zeile richtig haben.
 

httpdigest

Top Contributor
Aha. Effizienter wäre es wohl, einfach nur immer mit zwei Arrays zu arbeiten und ping-pong mit diesen beiden Arrays zu spielen, statt immer wieder ein neues Array zu erzeugen, um das sich der Garbage Collector dann später kümmern darf.
 

scratchy1

Bekanntes Mitglied
Hi Leute,
ja einen Fehler hab ich schonmal: ich überprüfe in den Bedingungen nicht, ob betreffende Zelle lebt :)
Hier die Korrektur (ja, da ist dann noch mindestens ein weiterer Fehler, den ich vielleicht durch hinstarren erkenne):
@httpdigest: Ersteres von Dir erwähntes wird doch gemacht, oder nicht?
Java:
package gameOfLife;

public class GameOfLife {
    boolean[][] feld = { { false, false, false, false, false }, { false, false, true, false, false },
            { false, false, true, false, false }, { false, false, true, false, false },
            { false, false, false, false, false } };

    public static void main(String[] args) {
        GameOfLife myGame = new GameOfLife();
        for (int i = 0; i < 10; i++) {
            myGame.nextGeneration();
            myGame.print();
            System.out.println();
        }
    }

    void print() {
        for (int i = 0; i < feld.length; i++) {
            for (int j = 0; j < feld[i].length; j++) {
                if (feld[i][j] == true)
                    System.out.print("o ");
                else
                    System.out.print(". ");
            }
            System.out.println();
        }
    }

    void nextGeneration() {
        /*
         * 1 Eine lebende Zelle lebt auch in der Folgegeneration, wenn genau zwei oder
         * drei der acht benachbarten Zellen in der aktuellen Generation leben. 2 Eine
         * lebende Zelle stirbt in der Folgegeneration an Einsamkeit oder
         * Überbevölkerung, wenn in der aktuellen Generation weniger als zwei oder mehr
         * als drei der acht Nachbarzellen leben. 3 Eine tote Zelle wird in der
         * Folgegeneration lebendig, wenn genau drei ihrer acht Nachbarn in der
         * aktuellen Generation lebendig sind. 4 Unabhängig von den obigen drei Regeln
         * sind die Randzellen (also diejenigen Zellen, die nicht genau acht Nachbarn
         * haben) immer tot. Da Sie für die Berechnung aller Zellen der Folgegeneration
         * noch Zugriff auf die Zustände der aktuellen Generation benötigen, sollten Sie
         * die Zustände der Folgegeneration zunächst in ein neues, zweidimensionales
         * boolean-Array gleicher Gröÿe schreiben. Ihre Implementierung sollte nach
         * Möglichkeit unabhängig von der Grösse der Zellkultur funktionieren; Sie
         * dürfen aber von einer rechteckigen Zellkultur ausgehen.
         */
      
        boolean[][] feld2 = new boolean[feld.length][];

     

        for (int s = 0; s < feld.length; s++) {
            
            feld2[s] = new boolean[feld.length];

            System.out.println();
        }

        int anzahllebendnachbarn = 0;
       

        // anzahllebendnachbarnüberprüfung

        for (int u = 1; u < feld2.length - 1; u++) {
            for (int v = 1; v < feld2[u].length - 1; v++) {
                boolean[] arr = { feld[u + 1][v], feld[u][v + 1], feld[u + 1][v + 1], feld[u - 1][v], feld[u][v - 1],
                        feld[u - 1][v - 1], feld[u - 1][v + 1], feld[u + 1][v - 1] };
                for (boolean elem : arr) {
                    if (elem == true) {
                        anzahllebendnachbarn = anzahllebendnachbarn + 1;

                    }
                }
                if (anzahllebendnachbarn < 4 && anzahllebendnachbarn > 1 && feld[u][v]==true){
                    feld2[u][v] = true;
                }
                if (feld[u][v] == false && anzahllebendnachbarn == 3) {// 3.Bedingung
                    feld2[u][v] = true;

                }
                if ((anzahllebendnachbarn == 2 || anzahllebendnachbarn == 3)&&(feld[u][v]==true)) {// 1.Bedingung
                    feld2[u][v] = true;

                }
                if ((anzahllebendnachbarn < 2 || anzahllebendnachbarn > 3)&&(feld[u][v]==true)) {// 2.Bedingung
                    feld2[u][v] = false;

                }
            }
        }
        //hier code eingeben
        //this.feld=feld2; besser
        feld=feld2;
 
    }
}
 

httpdigest

Top Contributor
@httpdigest: Ersteres von Dir erwähntes wird doch gemacht, oder nicht?
Nein. Du erzeugst jedesmal bei jedem Aufruf von nextGeneration() ein neues Array. Was ich meine, ist, einmal und nur ein einziges Mal, zwei Arrays zu erzeugen und sich diese zu speichern und zwischen beiden hinundherzuwechseln. Was ich meine ist nicht, jedesmal ein neues Array zu erzeugen und das alte wegzuschmeissen.
 

scratchy1

Bekanntes Mitglied
Achso, Du hast Recht. Kann ich dann
Java:
boolean[][] feld2 = new boolean[feld.length][];

     

        for (int s = 0; s < feld.length; s++) {
            
            feld2[s] = new boolean[feld.length];

            
        }
einfach ausserhalb der Methode schreiben?
 

scratchy1

Bekanntes Mitglied
Debuggen hat mir mein Sensei verboten, da ich noch ein low-level-Ninja bin. Und Variablen ausgeben, das hab ich mal bei der ersten if-Abfrage mit System.out.println(feld2) probiert und es kommt [[Z@e73f9ac raus. Wie (wenn mein Versuch nicht korrekt ist) und an welcher Stelle könnt ichs noch probieren?
 

Meniskusschaden

Top Contributor
mit System.out.println(feld2) probiert und es kommt [[Z@e73f9ac raus. Wie ... könnt ichs noch probieren?
Das ist nur die Speicheradresse des Arrays und hilft nicht wirklich weiter. Den Inhalt könntest du z.B. so ausgeben: System.out.println(Arrays.deepToString(feld2));
an welcher Stelle könnt ichs noch probieren?
Das ist schon eine gute Stelle. Außer "wie?" und "wo?" solltest du aber auch über das "was?" nachdenken.

BTW: Du solltest vielleicht in Erwägung ziehen, deinen Sensei abzuschießen oder dich zumindest über ihn hinweg zu setzen.;) Wenn es nicht so läuft, wie man erwartet, ist es immer gut, sich Klarheit über die Fakten zu verschaffen. Da du gerade so ein Problem hast, ist das die ideale Gelegenheit, sich mit dem Debugger zu beschäftigen. Generell empfehle ich beim Umgang mit Autoritäten, nichts nur deshalb hinzunehmen, weil es von einer Autorität stammt, sondern nur dann, wenn die Begründung schlüssig ist.
 

mihe7

Top Contributor
Debuggen hat mir mein Sensei verboten, da ich noch ein low-level-Ninja bin.
ROFL. Wie muss man sich das vorstellen? Da sitzt einer mit langem, weißen Bart, bekleidet in dunkelblauem Gewande neben Dir vor dem Computer im Schneidersitz, hält sich das Schwert vors Gesicht, schließt die Augen und murmelt geheimnisvoll: "Scratchy-san! <rhetorische Pause> Der großen Macht des Debuggers bist Du noch nicht gewachsen. Nutzt Du ihn, zeigst Du Dich Deines Senseis nicht würdig. Hurz!"
 

scratchy1

Bekanntes Mitglied
Hallo Leudde,
Ok, ich schaue mir auf youtube ein paar clips zum Debuggen an und probiers morgen. :)
@mihe7: Deine Vorstellung ist wirklich lustig. Aber unterm Fittich des Senseis verwandelt sich, was mich betrifft jedes Grinsen in eine Grimasse ;) Sensei muss mich manchmal schmoren lassen und hart sein, so werde ich denn nunmal geschliffen. Du kannst Dir das so vorstellen, dass die Musik von Oxygene 2 läuft, während sich die Schlange im Schatten des Adlers begibt (Mal sehen, ob ich den Fehler finde ;)).
 

scratchy1

Bekanntes Mitglied
Ha, Leute, vielen Dank für den Tipp mit dem Debuggen. Ich hab den Fehler gefunden:
Ich muss zu jeder Zelle, nachdem ich ihre lebenden Nachbarn gezählt habe, den Zähler wieder auf 0 setzen, sonst wird das ein Gewusel. ;) Super geil.
@mihe7: was ist jdb?
 

scratchy1

Bekanntes Mitglied
Der Java-Debugger für die Kommandozeile. Ist pur besser zur Selbstkasteiung geeignet, als ein in die IDE integrierter Debugger.;)
Oh da muss man bestimmt ein gutes Gedächtnis für haben.
Wo ist er denn der erklärende oder zeigende? :rolleyes:
Das muss geheim bleiben. Wenn der weiss/wüsste was ich hier treibe, liegen meine Überlebenschancen während des Weges noch mehr in seinem Ermessen, als sie es ohnehin schon sind. Das wird dann vielleicht nur noch pi mal Daumen abgeschätzt ;)
Habt ihr denn nicht "Die Schlange im Schatten des Adlers" gesehen, was da der Sensei mit seinem "Schützling" so alles anstellt, wenn der mal ne Abkürzung sucht?
 

mihe7

Top Contributor
Dort ist er nicht derjenige, der einem Schüler Wissen oder Können vermittelt, sondern derjenige, der den Weg zeigt.
Bei uns nennt man das Wegweiser, steht an jeder Ecke und kostet nur einmalig was :D

Oh da muss man bestimmt ein gutes Gedächtnis für haben.
Vor allem muss man gute Nerven haben. "Scratchy-san - in der Ruhe liegt die Kraft." Wie bekomme ich diese Bilder nur wieder aus meinem Kopf?!?
 

scratchy1

Bekanntes Mitglied
Es ist der Weg und nicht das Wissen, weil das Wissen durch den Weg kommen kann, aber den sowiesoigen Nebeneffekt der Formung hat.
 

scratchy1

Bekanntes Mitglied
Nimm mein Avatar: Wissen ist versiegbar (Wasser). Wenn man die Löcher am Körper zustöpselte, hätte man die Form verändert, was die Grundlage bietet, das Wasser etwas länger zu halten (Was sind schon menschliche Zeiträume).;)
 

scratchy1

Bekanntes Mitglied
He Leudde,
um in Trance zu kommen, braucht ihr keinen Fusel/Zeugs. 30 mal schnell und tief hintereinander ein-und ausatmen, dann die Luft so lange wie möglich anhalten.
 

scratchy1

Bekanntes Mitglied
Das ist nur die Speicheradresse des Arrays und hilft nicht wirklich weiter. Den Inhalt könntest du z.B. so ausgeben: System.out.println(Arrays.deepToString(feld2));
Hi Meniskusschaden und co.
Ich soll mal das Array so ausgeben, dass man die Struktur erkennt, also so schreiben, dass sie mit beliebigen "vollständigen" zweidimensionalen boolean[][]-Arrays zurechtkommt.

Habt ihr eine Idee, wie ich das machen könnt? mit der deepToString() ist mir das zu unübersichtlich.
Mir fiele nur (Ich nenn das Arrays mal candidate)
Java:
for (boolean[] zeile : candidate) {

            for (boolean elem : zeile) {

                System.out.print(elem);

            }
            System.out.println();
        }
 

scratchy1

Bekanntes Mitglied
Hier ist mein Versuch eines Tests unabhängig von der Arraygröße (jetzt kann man den Gesamtzusammenhang vielleicht besser sehen):
Java:
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 } };
    }

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

        // Hier Ihr Code zum duplizieren der Struktur
        boolean[][] kopie = new boolean[original.length][];
        for (int i = 0; i < original.length; i++) {
            kopie[i] = new boolean[original[i].length];
            for (int j = 0; j < original[i].length; j++) {
                kopie[i][j] = original[i][j];

            }
        }
        kopie = original;
        return kopie;

    }

    private static void printArray(boolean[][] candidate) {
        // System.out.println(Arrays.deepToString(candidate));
        // Hier Code, der den Array so ausgibt,
        // dass man die Struktur erkennt
        for (boolean[] zeile : candidate) {

            for (boolean elem : zeile) {

                System.out.print(elem);

            }
            System.out.println();
        }
    }

    duplicateStructure(bsp);
    printArray(kopie);
 }
}
 
Zuletzt bearbeitet:

scratchy1

Bekanntes Mitglied
So hier nun ohne Fehlermeldungen:
Java:
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));
    }

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

        // Hier Ihr Code zum duplizieren der Struktur
        boolean[][] kopie = new boolean[original.length][];
        for (int i = 0; i < original.length; i++) {
            kopie[i] = new boolean[original[i].length];
            for (int j = 0; j < original[i].length; j++) {
                kopie[i][j] = original[i][j];

            }
        }
        kopie = original;
        return kopie;

    }

    private static void printArray(boolean[][] candidate) {
        // System.out.println(Arrays.deepToString(candidate));
        // Hier Code, der den Array so ausgibt,
        // dass man die Struktur erkennt
        for (boolean[] zeile : candidate) {

            for (boolean elem : zeile) {

                System.out.print(elem);

            }
            System.out.println();
        }
    }

}
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
K Hab ich dass so richtig erklärt (Objekte und Referenzen)? Java Basics - Anfänger-Themen 5
B Erste Schritte Frage zu Instanzierung und Referenzen Java Basics - Anfänger-Themen 8
M Referenzen zuweisen und wird gleichzeitig ausgeführt Java Basics - Anfänger-Themen 6
B JaxB - Unique Name updaten / Referenzen in XML Java Basics - Anfänger-Themen 0
B Objekt kopieren und sämtliche Referenzen von diesem Objekt? Java Basics - Anfänger-Themen 3
B JaxB - Referenzen erstellen? Java Basics - Anfänger-Themen 2
Zrebna Frage zum "Referenzen-konzept" in Java Java Basics - Anfänger-Themen 8
B Datenbank: Entity mit vielen Referenzen? Ansatz so ok? Java Basics - Anfänger-Themen 8
O Referenzen Java Basics - Anfänger-Themen 2
A Variablen Verständnisfrage bzgl. Variablen/Referenzen Java Basics - Anfänger-Themen 3
A Variablen Referenzen Java Basics - Anfänger-Themen 6
A GUI-Bedienelemente mit Zeiger/Referenzen-Array veralten Java Basics - Anfänger-Themen 4
K Operatoren 2D Int Array auf Null-Referenzen prüfen Java Basics - Anfänger-Themen 18
F Referenzen zwischen Methoden Java Basics - Anfänger-Themen 5
T Klassen Referenzen auf Klassen / Objekte Java Basics - Anfänger-Themen 5
J OOP Ein Fahrrad - zwei Besitzer: Zwei Referenzen auf ein Objekt Java Basics - Anfänger-Themen 43
C Referenzen zu Instanzen einer Klasse im Array Java Basics - Anfänger-Themen 8
K Collections Auf Referenzen in ArrayList zugreifen? Java Basics - Anfänger-Themen 3
B ArrayList.clear - Daten in allen Referenzen weg Java Basics - Anfänger-Themen 2
L Grundlegende Verständnisfrage Hasmap Referenzen Java Basics - Anfänger-Themen 4
C OOP Referenzen-Problem Java Basics - Anfänger-Themen 3
N Referenzen Problem Java Basics - Anfänger-Themen 2
K Referenzen - 2ter Versuch Java Basics - Anfänger-Themen 17
M Instanzen, Referenzen und Collections Java Basics - Anfänger-Themen 3
C Referenzen in Java Java Basics - Anfänger-Themen 11
J Referenzen vergleichen Java Basics - Anfänger-Themen 8
M Referenzen verschieben Java Basics - Anfänger-Themen 2
J Mehrere Referenzen auf ein Objekt Java Basics - Anfänger-Themen 6
M Referenzen Java Basics - Anfänger-Themen 11
G Netzwerk: RMI Objekt-Referenzen Java Basics - Anfänger-Themen 2
I clone() und Referenzen Java Basics - Anfänger-Themen 25
A Referenzen zu festen Werten machen? Java Basics - Anfänger-Themen 5
F Referenzen Java Basics - Anfänger-Themen 7
H Problem mit Events bzw. Referenzen Java Basics - Anfänger-Themen 4
M Zugriff auf Textfelder über Referenzen? Java Basics - Anfänger-Themen 3
F ArrayList! Pointer, Referenzen! Java Basics - Anfänger-Themen 4
K Verständnisfrage Collection, ArrayList und Referenzen Java Basics - Anfänger-Themen 4
H Begriff: Objekt enthält Referenzen Java Basics - Anfänger-Themen 3
J Referenzen Java Basics - Anfänger-Themen 5
P HashSet und Referenzen Java Basics - Anfänger-Themen 9
G Speicherung von Referenzen auf Instanzen Java Basics - Anfänger-Themen 5
T Referenzen. Java Basics - Anfänger-Themen 5
Z Referenzen in LinkedList Java Basics - Anfänger-Themen 3
F Referenzen in Java - Fehlerpotenzial ! Java Basics - Anfänger-Themen 5
G Instanzen und Referenzen Java Basics - Anfänger-Themen 5
G array auf null-referenzen überprüfen ! Java Basics - Anfänger-Themen 9
G Referenzen Java Basics - Anfänger-Themen 5

Ähnliche Java Themen

Neue Themen


Oben