Probleme mit Array bzw. ArrayList

[fagune]

Hallo zusammen,

ich programmiere gerade in einer Gruppe eine Netzwerkspielumsetzung des Kartenspiels SET!. Dafür arbeite ich zur Zeit an einem Trainer, der 12 Karten auslegt und der Spieler alle möglichen SET!s finden soll. Dafür muss ich die Ausgewählten gültigen SET!s speichern. Und da will es irgendwie nicht so richtig.

Ich habe für jede Spielkarte ein MouseListener der an einer bestimmten Position in einem 12er-Array eine 1 setzt, wenn sie ausgewählt ist und sonst eine 0 da steht. Das heißt ich habe bei einem gültigen SET 3 einsen in dem Array. Jetzt übergebe ich das Array an eine ArrayList mit add( int , 12er-Array ). So weit klappt alles. Jetzt soll aber geprüft innerhalb der ArrayList geprüft werden, ob das gerade hinzugefügte Array schon vorhanden ist oder nicht. Wenn es vorhanden sein sollte, soll es removed werden. Ich habe es mit mit einer for (int i=0,i<ArrayList.size();i++) und if (i != o && ArrayList.indexOf(i) == ArrayList.indexOf(o)) versucht, wobei o die Laufvariable für die gültigen SET!s ist. Bei dem ersten Set funktioniert das auch ohne Probleme, wenn ich aber ein 2. gültiges SET auswähle, bekomme ich die Meldung, dass das SET schon vorhanden ist.

Weiß jemand was ich falsch mache oder gibt es eine einfacheren Weg für die Abfrage?

Im Voraus vielen Dank für eure Hilfe

Gruß,
Lars

 

[SlaterB]

> if (i != o && ArrayList.indexOf(i) == ArrayList.indexOf(o))

i und o sind Zahlen? was soll denn bei ArrayList.indexOf(i) rauskommen? in der Liste sind doch keine Zahlen, sondern Arrays,
musst du nicht eher etwas in der Richtung von
vergleicheArrays(list.get(i), list.get(o)) ;
programmieren?
ziemlich unverständlich alles

allgemein noch der Tipp: wenn du ein Array in eine Liste ein oder mehrfach einfügst und danach die alte Array-Variable veränderst, dann ist auch in der Liste das neue geänderte Array drin, es wird nur eine Referenz gespeichert, keine Kopie angelegt,
irgendwann musst du ein neues Array erstellen

 

[fagune]

Vielen Dank für die Antwort,

ich hab noch nicht so wirkliche viele Programmiererfahrungen, deswegen war das auch einfach auf gut Glück geschrieben.
Gibt es denn einen besseren/ einfacheren Weg für die Aufgabe?
also müsste der vergleich in etwa so aussehen : if ( i != o && list.get(i) == list.get(o)) wenn ich jeweils ein eigenes array erzeugt habe? das (i !=o) muss da hin, weil es ja nicht das aktuelle array kontrollieren soll, da es sonst immer vorhanden wäre.

Gruß,
Lars

 

[SlaterB]

wie soll ich dein Programm beurteilen, ich schrieb ja schon dass ich kaum was verstehe,

aber so allgemein gesprochen:
zwei verschiende Array-Objekte werden nie == sein, ob sie den gleichen Inhalt haben muss aber noch verglichen werden,
in einer Schleife jedes Feld einzeln vergleichen

 

[fagune]

Mal gucken, ob ich es verständlicher erklären kann.

Also ich habe ein int-Array, da stehen 12 Zahlen drin (9x0 und 3x1). Jetzt brauche ich eine Möglichkeit 1. um das Array zu speichern und 2. die gespeicherten Arrays mit dem neuen zu vergleichen, damit es nicht gespeichert wird.

Ich kann mir vorher aber nicht einfach Arrays anlegen, denn die Anzahl an Arrays die ich brauche variiert mit jedem Spielfeldupdate.

Hilft das?

Lars

 

[Landei]

Zwei Arrays vergleichst du "inhaltsmäßig" mit java.util.Arrays.equals()

 

[SlaterB]

> Hilft das?

ich habe doch geschrieben dass ich das vermute und dann entsprechende Tipps gegeben,
oder ist mein Text auch unverständlich?

 

[fagune]

Ist denn eine ArrayList eine gute Möglichkeit die vorhandenen Arrays zu speichern? Denn dafür müsste ich so wie ich es verstanden habe, alle Arrays vorher initialisieren und später ihren Wert zuweisen? Das ist aber schwer, da ich den absoluten Maximalwert nicht kenne und er sich ständig ändert und ich will nicht unbedingt Arrays anlegen, damit es für den worst case funktioniert.

Wie sieht es mit einer Hashmap aus? Ich weiß nicht genau, was das ist, aber ich habe es öfters in Verbinung mit ArrayList als eine Art Alternative gelesen, wenn ich es richtig verstanden habe.
Oder ließe sich das mit einem 2D-Array lösen? Dabei könnte ich die Spaltenbreite mit dem Wert dem Maximalwert für jedes neue Spielfeld festlegen und den Zeilen 1-12 die vorhandenen Werte des Arrays übergeben. Aber kann ich dann die erste Zeile durchlaufen und jeweils die Spalte von 1-12 vergleichen, ob sie gleich sind?

 

[Landei]

Eine List ist genau das: Eine Liste von Werten. Eine Map (auch Dictionary oder assoziatives Array genannt) legt für einen "Schlüssel" einen Wert fest - etwa so wie im Telefonbuch unter einem Namen (als Schlüssel) eine Telefonnummer (als Wert) hinterlegt ist.

 

[fagune]

Aber wenn ich mit einer ArrayList arbeite, muss ich die Arrays, die ich speichern will, vorher initialisieren, oder? Da ich aber erst nach einem Spielfeldupdate weiß, wie viele Arrays ich brauche fällt die Möglichkeit weg, oder kennt da jemand eine Lösung Arrays dynamisch zu erzeugen?

Ich habe mir eine andere Möglichkeit überlegt:
Würde es funktionieren, wenn ich die Stellen, die 1 sind aus meinem 12er-Array auslese und in ein 3er-Array übergebe und einer int die 3 Werte zuweise. Wenn ich jetzt mit dem Spielfeldupdate ein Array erzeuge, was so viele Stellen hat, wie ich benötige, müsste ich doch mit einer Schleife jeder Position die int mit aktuellem Wert zuweisen können? Oder wird dabei auch nicht der Wert selber im Array gespeichert, sondern die Referenz auf die int? Wenn das funktionieren sollte, müsste ich doch in einer Schleife abfragen können, ob an einer Position im Array der Wert schon vorhanden ist?

Lars

 

[SlaterB]

> oder kennt da jemand eine Lösung Arrays dynamisch zu erzeugen?

immer dieses ungenaue Gerede, deine Sätze ergeben irgendwie meistens keinen Sinn oder ich kann ihn nicht erkennen
gib doch konkrete Beispiele oder Programmcode

die Länge eines einzelnen Arrays kann man beliebig wählen: new int[4] oder new int[3000], ist das dynamisch genug?

wichtig zu 'dynamisch' ist eher die längerfristige Speicherung,
wenn du variabel viele Arrays oder sonstige Einzelobjekte erzeugst und diese speichern willst, dann wäre ein vorher erstelltes Array mit fester Länge schlecht,
aber diese Objekte speicherst du ja richtigerweise schon in einer ArrayList mit sich ändernder Größe

edit:
zur zweiten Hälfte deines Postings:
ints werden immer nur als Werte gespeichert, keine Referenz,
und wie du die Arrays aufbaust musst du dir wohl überlegen, 3er oder größer, alles scheint denkbar,
schwer von außen reinzureden

 

[fagune]

das mit der länge der arrays ist mir bekannt und stellt auch nicht unbedingt ein Problem dar.
dynamisch heißt hier für mich, dass zb. mit jedem spielfeldupdate = neuer kartensatz mit neuer anzahl an gültigen karten-konstellationen, mit einer schleife so viele arrays erzeugt werden, wie ich sie brauche ( array1, array2, array3, ... ) damit ich unterschiedliche arrays für die arraylist habe.


ich habe halt einen button und wenn ich den drücke holt der sich das 12er-array und kontrolliert ob genau 3 x 1 vorhanden ist, wenn das der fall ist, lese ich die stellen an denen eine 1 steht in ein neues 3er-array ein. bis hier hin ist alles klar.

das problem ist jetzt, dass es eine bestimmte anzahl an gültigen 1er-konstellationen gibt. damit der spieler nicht einfach eine konstellation immer wieder auswählen kann, will ich das 3er-array irgendwie speichern und mit den vorhandenen abgleichen, sodass der spieler alle gültigen konstellationen finden muss, damit es zu einem spielfeldupdate kommt.

 

[SlaterB]

> bis hier hin ist alles klar. das problem ist jetzt,

dahinter taucht nichts von dynamischen Arrays oder sonst wie auf, falls 'bestimmte anzahl an gültigen 1er-konstellationen' sich nicht vernebelt darauf bezieht,
aber ich soll nicht soviel meckern,

seit dem allerersten Posting ist mir völlig klar bzw. habe ich vermutet weil es das wahrscheinliche ist:
du erstellst Arrays mit Positionen, speicherst diese in eine Liste und willst z.B. eine aktuelle neue mit den vorhandenen vergleichen,

seitdem ist für mich persönlich noch nichts neues dazugekommen, eine Frage sehe ich nicht,
hier mal ein Testprogramm, vielleicht reicht dir das schon oder du kannst von dort aus auf was anderes hinweisen:

public class Test {
    public static void main(String[] args) {
        List<int[]> list = new ArrayList<int[]>();
        for (int i = 0; i < 30; i++)   {
            int[] neuePos = new int[10];
            int index = (int)(Math.random() * 10);
            neuePos[index] = 9;
            System.out.println("i: " + i + ", neues Array: " + Arrays.toString(neuePos));
            list.add(neuePos);
            for (int j = 0; j < i; j++) {
                int[] old = list.get(j);
                if (Arrays.equals(neuePos, old))   {
                    System.out.println("neues Array gibts schon an Position " + j);
                }
            }
        }
    }
}

 

[fagune]

vielen dank,

danach habe ich gesucht. ich wusste halt nicht, wie ich die arrays mit einem index versehe und auch noch vergleichen kann.

mit dem meckern ist nicht schlimm. es hilft ja in zukunft hoffentlich besser zu formulieren. ich wollte es halt auch lieber erstmal ohne codeausschnitte versuchen, da ich sonst sehr viele zeilen hätte posten müssen und das sehr unübersichtlich gewesen wäre.

noch mal vielen dank.

 

[fagune]

ich bekomme es immer noch nicht richtig hin und ich sehe bzw. verstehe den fehler nicht.
ich glaube ich habe noch was falsch verstanden, denn wenn ich mir list.get(j) ausgeben lasse, wird die position o immer mitausgegeben und ist deshalb immer gleich.

List<int[]> list = new ArrayList<int[]>();

...

private JPanel getTrainingsMaxPanel()
    {
        if (TrainingsMaxPanel==null)
        {
            TrainingsMaxPanel = new JPanel(new BorderLayout());
            final int neuePos[] = new int[12];
            ...
            ActionListener SET2Action = new ActionListener()
            {
                public void actionPerformed(ActionEvent e)
                {
                    if (trainingField.getSelectedCardsCount()!=3)
                    {
                        errorMessage("Es sollen 3 Karte ausgewaehlt sein");
                    }
                    else
                    {
                        if (!trainingField.checkSetSelectedCards(false))
                        {
                            errorMessage("Das war kein SET!");
                            unselectCards();
                        }
                        else
                        {
                            int m = 0;
                            
                            for (int k=0;k<12;k++)    //Hier werden aus den 12 int die 3 1en ausgelesen
                            {                                // und die position als array gespeichert 
                                if (karten[k] != 0)
                                {
                                    stapel[m]= k;
                                    m++;
                                }
                            }

                            a = Integer.parseInt(String.valueOf(stapel[0])+String.valueOf(stapel[1])+String.valueOf(stapel[2]));
                                                         // die 3 positionen werden als eine int gespeichert
                            index = 0;
                            neuePos[index] = o;  // o ist eine laufvariable die mit jedem richtigen SET 
                                                         // hochgezählt wird
                            list.add(neuePos);

                            for (int j = 0; j < o; j++)
                            {
                                int old[] = list.get(j);
                                if (Arrays.equals(neuePos, old))
                                {
                                    gleichheit = gleichheit+1;
                                    list.remove(neuePos);  // wenn neuePos schon in der arraylist vorhanden, 
                                                                   // dann wieder rausschmeißen
                                }
                                else
                                {
                                    gleichheit = gleichheit+0;
                                }
                            }

 

[SlaterB]

wie schon in der allerersten Antwort weise vorausgesehen :

allgemein noch der Tipp: wenn du ein Array in eine Liste ein oder mehrfach einfügst und danach die alte Array-Variable veränderst, dann ist auch in der Liste das neue geänderte Array drin, es wird nur eine Referenz gespeichert, keine Kopie angelegt,
irgendwann musst du ein neues Array erstellen

das final-Array neuePos ist schlecht, ist immer dasselbe,
erstelle erst im ActionListener das Array, dann ist es zwangsweise immer ein neues

viel passiert mit dem Array bisher aber sowieso nicht, nur
> neuePos[index] = o;
mit index immer 0,
ob sich o (ohhhhh, nicht Zero, ziemlich ungünstiger Variablenname) zwischendurch verändert, ist nicht zu erkennen,
bleibt o gleich, so sind auch alle Arrays gleich

 

[fagune]

o ist nicht immer null!
o wird hochgezählt, wenn der spieler ein gültiges SET gefunden hat und es noch nicht vorgekommen ist.

wenn ich neuePos im ActionListener erzeuge finde ich, mit dem Code wie er jetzt ist, aber nie ein doppeltes?

 

[SlaterB]

was bei immer hochgezählten o durchaus hinkommen kann,

zu diesem Probleme sehe ich aus dem Code heraus keine Ursache, aber:

mach es dir doch einfach, gib alle Elemente mit
System.out.println(Arrays.toString(array)) aus bzw. schaue dir nur den index 0 an, alle anderen Elemente im Array sind ja leer,

wenn du weist, dass du am Anfang ein Array mit 5 eingefügt hast,
später aber die Ausgabe
"füge neues Array 17 ein, vorhandene Arrays sind 1, 4, 12, 15, "
liest, ja dann kannst du dich wirklich wundern,

schau dir nochmal mein Programm an, da kann man am Ende komplett nachlesen, was alles passiert ist, es gibt keine Überraschungen

falls du selber nicht weiterkommst müsstest du für mich mehr Code, am besten gar ein vollständiges kleines Testprogramm posten,
idealerweise dann auch was man in Reihenfolge eintippen und klicken muss, bis es zum Fehler kommt

 

[fagune]

als ausgabe erhalte ich wenn ich mir beide ausgeben lasse
für j mehrere durchläufe an denen die aktuelle int immer eine position hochsetzt bis j = o-1. der rest ist immer null.
und bei o steht die aktuelle int an der position o und hier ist der rest auch immer null.

 

[SlaterB]

> für j mehrere durchläufe an denen die aktuelle int immer eine position hochsetzt bis j = o-1.

was ist bloss die Aussage dieses Satzes?

und was ist nun rausgekommen, wie gehts weiter, ist eine Frage offen?
sind alle Arrays nahcgeprüft verschieden?, dann weißt du doch sicher warum oder soll ich jetzt sagen:
als nächstes finde heraus wann wo warum welches Array mit welchem Inhalt eingefügt wird (die vorherigen Durchgänge mit ihrem o)
zu allen Zeiten des Programms solltest du überall wissen was passiert, entweder durch Intelligenz oder durch Logausgaben
"füge nun Array sowieo ein wobei o gerade sowieso ist usw."

das ist doch alles offensichtlich, habe ich auch schon x-mal erwähnt, was ist eigentlich die Frage?

 

[fagune]

[125, 125, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] O 1 \ ist richtig, da schon vorhanden
[125, 125, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] J 0 /
[125, 210, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] O 1 \ ist falsch, da es ein neuer wert ist
[125, 210, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] J 0 /

Das ist eine Ausgabe die ich erhalte, wenn das Array wie in dem Code als final deklariert wird

So sieht es aus, wenn es nicht final ist

[0, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] O 1 \ laut if-schleife sind die einträge nicht gleich,
[34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] J 0 / sollten sie aber sein
[0, 0, 6710, 0, 0, 0, 0, 0, 0, 0, 0, 0] O 2 \
[34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] J 0 lauf if-schleife sind die einträge nicht gleich,
[0, 0, 6710, 0, 0, 0, 0, 0, 0, 0, 0, 0] O 2 sollen sie auch nicht sein
[0, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] J 1 /
[0, 0, 0, 6710, 0, 0, 0, 0, 0, 0, 0, 0] O 3 \
[34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] J 0 hier müsste die if schleife bei O 3 und J 2 eig. erkennen,
[0, 0, 0, 6710, 0, 0, 0, 0, 0, 0, 0, 0] O 3 dass die einträge gleich sind. passiert aber nicht und
[0, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] J 1 ich verstehe nicht warum
[0, 0, 0, 6710, 0, 0, 0, 0, 0, 0, 0, 0] O 3
[0, 0, 6710, 0, 0, 0, 0, 0, 0, 0, 0, 0] J 2 /

 

[SlaterB]

erstmal: if-schleife.de

so, gehe ich jetzt recht in der Annahme, dass du möchtest, dass die Arrays
0, 34, 0, ...
34, 0, 0, ...
gleich sein sollen?
na das ist ja mal eine Information sag das doch

dass die Arrays standardmäßig nicht gleich SIND ist doch sonnenklar, es sind doch unterschiedliche Werte an Position 0 und 1

wenn du auch noch die Werte an den Positionen hin und her schieben willst musst du eine komplexe Vergleichsmethode schreiben,
das kann ganz schön aufwendig werden, als erste spontane Idee schlage ich vor, für einen Vergleich die beiden Arrays zu kopieren, jeweils zu sortieren und dann normal zu vergleichen?

geht es in die Richtung oder soll ich weiter beliebiges raten?
das Posten der Ausgabe ist aber schon ein echter Fortschritt, da muss ich dich loben

sonst wäre ich ja nie auf die Idee gekommen dass du
[0, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
gleich haben möchtest

 

[fagune]

das ist die richtung.

also müsste ich eig doch nur in der kopie des array o die position des eintrages eins nach unten setzen, oder?

 

[SlaterB]

> also müsste ich eig doch nur in der kopie des array o die position des eintrages eins nach unten setzen, oder?

worum gehts gerade, was die Kopie des Arrays?

beziehst du dich auf die von mir angesprochene Situation des Vergleichs zweier Arrays, wo ich allerdings von Kopie beider Arrays sprach?
allgemein klingt das duchaus besser als gar nix zu machen, aber wird es immer reichen, irgendeinen Index nur um 1 zu senken?
kann der Abstand nicht größer sein, kann es es nicht verschiedene Elemente zu vergleichen geben?
ich weiß ja wenig davon, was dein Programm überhaupt macht, aber wenn du auch

2, 12, 600, 45, 74
und
74,12, 45, 2, 600
als gleich erkennen willst, wird es mit manuellem Index-Verschieben schwer

deshalb mein Vorschlag: beide Arrays je für sich sortieren auf
2, 12, 45, 74, 600
2, 12, 45, 74, 600
da ist es wieder leicht(er), einen Unterschied oder Gleichheit festzustellen

 

[fagune]

ich hab den code im actionlistener geändert

for (int j = 0; j < o; j++)
{
       int old[] = list.get(j);

       int copyold[]= new int[12];
       System.arraycopy(old, 0, copyold, 0, 12);
       int copyneuePos[] = new int[12];
       System.arraycopy(neuePos, 0, copyneuePos, 0, 12);

       java.util.Arrays.sort( copyold );
       java.util.Arrays.sort( copyneuePos );

       System.out.println(Arrays.toString(copyneuePos)+"  O "+ o);
       System.out.println(Arrays.toString(copyold)+"  J "+ j);
                                
       if (Arrays.equals (copyneuePos, copyold))
[/JAVa]
aber es will immer noch nicht. 

die ausgabe war:

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2710]  O 1 \ wurde richtig erkannt
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2710]  J 0  /
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 39]  O 1    \ ist lauf if-abfrage auch gleich
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2710]  J 0  /

 

[SlaterB]

dies kann ich nicht nachvollziehen, in folgendem Testprogramm kommt false raus

public class Test {
    public static void main(String[] args)  {
        int neuePos[] = new int[]   {39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
        int old[] = new int[]    {0, 2710, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

        int copyold[] = new int[12];
        System.arraycopy(old, 0, copyold, 0, 12);
        int copyneuePos[] = new int[12];
        System.arraycopy(neuePos, 0, copyneuePos, 0, 12);

        java.util.Arrays.sort(copyold);
        java.util.Arrays.sort(copyneuePos);

        System.out.println(Arrays.toString(copyneuePos) + "  O " + 1);
        System.out.println(Arrays.toString(copyold) + "  J " + 0);
        System.out.println("equal?: " + Arrays.equals(copyneuePos, copyold));
    }
}

deinem Code nach dürfte der if-Block ganz unten nicht ausgeführt werden,
ich weiß aber nicht was du sonst noch vielleicht an anderen Stellen machst und deshalb auf falsche Ergebnisse stößt,

mehr Code posten, idealerweise vollständiges Programm

noch zwei Hinweise

if (false) 
  befehl1; // wird nicht ausgeführt
  befehl2; // wird ausgeführt!


if (false); {
  befehl1; // wird ausgeführt!
  befehl2; // wird ausgeführt!
}


if (false) {
  befehl1; // wird nicht ausgeführt
  befehl2; // wird nicht ausgeführt
}

 

[fagune]

jetzt hab ich es endlich

for (int j = 0; j < o; j++)
{
     int old[] = list.get(j);
     int copyold[]= new int[12];
     System.arraycopy(old, 0, copyold, 0, 12);
     int copyneuePos[] = new int[12];
     System.arraycopy(neuePos, 0, copyneuePos, 0, 12);

     java.util.Arrays.sort( copyold );
     java.util.Arrays.sort( copyneuePos );
     System.out.println(Arrays.toString(copyneuePos)+"  O "+ o);
     System.out.println(Arrays.toString(copyold)+"  J "+ j);
                                
     if (Arrays.equals (copyneuePos, copyold))
     {
           gleichheit = gleichheit+1;
           list.remove(neuePos);
     }
     else
     {
           gleichheit = gleichheit+0;
     }
}

ich hatte vergessen gleichheit zurück auf 0 zu setzen, damit war es immer !=0, so bald ich 1mal die selben karten ausgewählt hatte.

vielen dank für die geduld und hilfe

Lars