Sortieren eines mehrdimensionalen Arrays

[DorFey]

Grüß euch!

Ich stehe vor folgendem Problem (und scheitere bereits seit einigen Stunden an dessen Lösung):

Mein Code:

                    public void bildeArray(){
                        Integer[][] wertungArr = new Integer[5][3];
                        wertungArr[0][0]=karte1S1;
                        wertungArr[1][0]=karte2S1;
                        wertungArr[2][0]=karte3S1;
                        wertungArr[3][0]=karte4S1;
                        wertungArr[4][0]=karte5S1;
                        wertungArr[0][1]=katkarte1S1;
                        wertungArr[1][1]=katkarte2S1;
                        wertungArr[2][1]=katkarte3S1;
                        wertungArr[3][1]=katkarte4S1;
                        wertungArr[4][1]=katkarte5S1;
                        wertungArr[0][2]=indexkarte1S1;
                        wertungArr[1][2]=indexkarte2S1;
                        wertungArr[2][2]=indexkarte3S1;
                        wertungArr[3][2]=indexkarte4S1;
                        wertungArr[4][2]=indexkarte5S1;

                        List <Integer[]> l1 = Arrays.asList(wertungArr);
                        Collections.sort(l1);
                        wertungArr = l1.toArray(new Integer[0][0]);
}

Ich möchte ein Array sortieren, bekomme jedoch folgende Fehlermeldung:

error: no suitable method found for sort(List<Integer[]>)
                        Collections.sort(l1);
                                   ^
    method Collections.<T#1>sort(List<T#1>) is not applicable
      (inferred type does not conform to upper bound(s)
        inferred: Integer[]
        upper bound(s): Comparable<? super Integer[]>)
    method Collections.<T#2>sort(List<T#2>,Comparator<? super T#2>) is not applicable
      (cannot infer type-variable(s) T#2
        (actual and formal argument lists differ in length))
  where T#1,T#2 are type-variables:
    T#1 extends Comparable<? super T#1> declared in method <T#1>sort(List<T#1>)
    T#2 extends Object declared in method <T#2>sort(List<T#2>,Comparator<? super T#2>)

Vielleicht hat jemand die eine oder andere Idee dazu.

 

[httpdigest]

Ich glaube, zu allererst hast du ein konzeptuelles Problem zu lösen: Was bedeutet es denn, ein zweidimensionales Array, bzw. ein Array von Arrays, zu "sortieren"?
Also angenommen, du hast [[2, 5, 1], [5, 2, 7], [4, 5, 8]]. Was soll denn jetzt das Ergebnis einer "Sortierung" sein?

 

[White_Fox]

Bist du dir sicher, daß du ein Array verwenden willst? Und nicht lieber z.B. SortedMap?
Davon abgesehen deucht mir, daß du da allerhand Zeugs in Klassen auslagern willst. Ansonsten ist es eher selten, daß man mit Arrays arbeiten will - vor allem mit mehrdimensionalen.
Beschreibe doch mal dein Problem genauer - was willst du darstellen?

 

[DorFey]

Ich würde die Werte gerne größenmäßig nach der 3. Spalte sortieren. Die Werte der 1. und 2. Spalte stehen mit jenen der 3.ten in Verbindung und sollen daher dem entsprechenden Wert der 3. Spalte zugeordnet bleiben.

Sortierte Reihenfolge wären also:
[2,5,1]
[5,2,7]
[4,5,8]

Ist ein Code für Kartenspiel-app wobei:
1.Spalte: Kartennummern von 0 bis 55
2.Spalte: Kategorien von 0 bis 6
3.Spalte: Punkte von -1 bis 10)

Hat den Hintergrund: ich möchte eine automatische Auswertung machen mit einem Zuordnungsschema mit z.B:

WENN ((indexkarte1+indexkarte2+indexkarte3+indexkarte4)==36 && indexkarte1==indexkarte2 && indexkarte2==indexkarte3 && indexkarte3==indexkarte4 ; DANN: Spielpunkte= x; Sonst: ...etc. )

 

[httpdigest]

Denke nicht in "Tabellenform", sondern in Klassen. Schreibe also eine Klasse für alle Informationen, die "zusammengehören":

import java.util.*;
public class Karte {
  public static Comparator<Karte> BY_PUNKTE = Comparator.comparing(Karte::getPunkte);
  private final int kartennummer;
  private final int kategorie;
  private final int punkte;
  public Karte(int kartennummer, int kategorie, int punkte) {
    this.kartennummer = kartennummer;
    this.kategorie = kategorie;
    this.punkte = punkte;
  }
  public int getKartennummer() {
    return kartennummer;
  }
  public int getKategorie() {
    return kategorie;
  }
  public int getPunkte() {
    return punkte;
  }
  public String toString() {
    return "{kartennummer=" + kartennummer + ", kategorie=" + kategorie + ", punkte=" + punkte + "}";
  }

  public static void main(String[] args) {
    List<Karte> karten = Arrays.asList(
        new Karte(2, 5, 1),
        new Karte(5, 2, 7),
        new Karte(4, 5, 8));
    karten.sort(BY_PUNKTE);
    for (Karte karte : karten)
      System.out.println(karte);
  }
}

 

[DorFey]

@White_Fox

hab leider noch wenig Hintergrundwissen zu java auf dem ich aufbauen kann / sehr wenig Programmiererfahrung.
Programmiere daher noch relativ umständlich glaube ich.

Im Prinzip habe ich das Programm bis jetzt so ausgestaltet:

1) Array[][] mit Kartennummer , Kartenkategorie, Kartenpunkte erstellt
2) Array mit collections.shuffle zufällig sortiert
3) Die Werte aus dem sortierten Array nach der entsprechend der zufällig sortieren Reihe extrahiert um Karten aus "drawables" zu laden und in imageViews der .xml darzustellen. (in etwa so:

int imCard1S1 = getResources().getIdentifier("card" + intArr2[0][0], "drawable", getPackageName());
card1S1.setImageResource(imCard1S1);

4) onClickListener bei buttons und bei Klick auf die Karten, wobei bei einem Klick auf eine Karte, die Karte aus der Hand mit der neuen vom Stapel getauscht wird.
5) automatische Auswertung nach n Spielzügen (mit noch ungelösten Problemen)

---

 

[DorFey]

@httpdigest

danke,
Klingt nach einem guten (und auch notwendigen) Ansatz. Werde das morgen mit dem Beispiel mal durcharbeiten.

Mein Code wird langsam auch unübersichtlich und da lässt sich sicher vieles davon einsparen (bei gleicher oder besserer Funktionalität).

 

[White_Fox]

hab leider noch wenig Hintergrundwissen zu java auf dem ich aufbauen kann / sehr wenig Programmiererfahrung.
Programmiere daher noch relativ umständlich glaube ich.

Kein Ding...das ist halt so, wenn man anfängt. Deswegen schreiben wir ja auch.

Ich würde dir raten, dir über folgendes klar zu werden:

• Was für Objekte hast du?
• Welche Funktion haben sie?
• Welche Namen kann ich ihnen geben?

Ich würde anhand deiner Beschreibung sagen, daß du mindestens eine Klasse 'Card' (bzw. viele Card-Objekte) hast. Und ich mutmaße mal, daß noch eine Klasse 'CardStack' sinnvoll wäre.
Ich mutmaße weiter: Du baust ein Kartenspiel, und jeden Kartenwert darf es nur genau einmal geben. Vielleicht auch zweimal, aber du willst ganz sicher nicht beliebig viele Karten beliebiger Werte herstellen können. Es wäre also sinnvoll, das Erzeugen von Karten irgendwie zu beschränken.

Noch ein paar Hinweise/Tipps:

• Programmiere in Englisch. Ich selber habe auch mal angefangen, Variablen und Klassen in Deutsch zu benennen. Ich stehe (zumindest seit nach der Schule) mit Englisch nicht unbedingt auf Kriegsfuß, hasse Anglizismen jedoch über alles. Dennoch hab ich mir das Deutschprogrammieren irgendwann abgewöhnt, denn: Unklarheit in der Sprache -> Unklarheit im Denken.
• Wenn du dir Gedanken darüber machst was für Objekte du hast: Denke nicht zu wenig über die Namen der Klassen nach. Alles steht und fällt mit der Benamsung von Klassen und Methoden. Man mag es nicht glauben, aber so ist es tatsächlich.

 

[temi]

Ein kurzes Beispiel für Karten, hier aus dem Forum:

public enum Farbe {
    KREUZ("Kreuz"), PIK("Pik"), HERZ("Herz"), KARO("Karo");

    private String info;

    Farbe(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return info;
    }
}

public enum Wert {

    SIEBEN("7"), ACHT("8"), NEUN("9"), ZEHN("10"), BUBE("Bube"), DAME("Dame"), KOENIG("König"), AS("As");

    private String info;

    Wert(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return info;
    }
}

public class Karte {

    private final Farbe farbe;
    private final Wert wert;

    public Karte(Farbe farbe, Wert wert) {
        this.farbe = farbe;
        this.wert = wert;
    }

    public Farbe getFarbe() {
        return farbe;
    }

    public Wert getWert() {
        return wert;
    }

    @Override
    public String toString() {
        return farbe + " " + wert;
    }
}

und ein (gemischtes) Kartenspiel dazu:

public class Blatt {

    private final Deque<Karte> karten;

    public Blatt() {
        karten = new ArrayDeque<>();
        karten.addAll(erzeugeGemischteKarten());
    }

    private List<Karte> erzeugeGemischteKarten() {

        List<Karte> ergebnis = new ArrayList<>();

        for (Farbe farbe : Farbe.values()){
            for (Wert wert : Wert.values()) {
                ergebnis.add(new Karte(farbe, wert));
            }
        }

        Collections.shuffle(ergebnis);

        return ergebnis;
    }

    public Karte naechsteKarte() {
        return karten.poll();
    }

    public List<Karte> gebeKarten(final int anzahl) {

        int i = 0;

        List<Karte> ergebnis = new ArrayList<>();

        while (!karten.isEmpty() && i++ < anzahl) {
            ergebnis.add(naechsteKarte());
        }

        return ergebnis;
    }
}