Vergleich von Array-Inhalten

Zeppi

Zeppi

Aktives Mitglied
Moin,
ich habe einen Konstruktor geschrieben, in dem überprüft wird, ob dieser Array-Inhalt schon einmal vergeben wurde. Dazu habe ich aber ein paar Fragen.
[CODE lang="java" title="class Position"]public Positionen(int ANZAHL, int X, int Y) {
x = new Koordinate[ANZAHL];
for (int i = 0; i < ANZAHL; i++) {
x = new Koordinate(X,Y);
for (int j = 0; j < i; j++) {
if (x.equals(x[j])) {
System.out.println("doppelt" + i);
i--;
}
}
}
}[/CODE]
[CODE lang="java" title="class Koordinate"]public boolean equals(Koordinate vgl) {
return this.x ==vgl.x && this.y==vgl.y;
}[/CODE]
Wenn ich jetzt alles ausführe, werden mir alle (10) Werte ausgegeben, auch wenn welche doppelt sind, werden am Ende 10 verschiedene Werte zurückgegeben, plus den markierten doppelten Wert. Aber wo genau wird dann der Wert, der doppelt ist, ersetzt? Außerdem steht doch in x[i] und x[j] das gleiche oder? Wird als erstes x[i] gefüllt, oder wird jeder Wert erstmal reingetan und gleich verglichen und danach der zweite Wert etc.? Sind nicht beim ersten Durchgang die Werte von x[i] und x[j] automatisch gleich? Denn dann steht doch beim ersten Durchgang x[0] und x[0] und die müssten ja gleich sein. //Vermutlich steht doch am Anfangt nicht das Gleiche, da i-- und j++ geht.

Vielleicht kann mir das ja jemand kurz erklären.
Danke Zeppi
 
Zuletzt bearbeitet:
Also was erst einmal auffällt:

a) equals Methode überschreibt nicht Object.equals: Da deine Methode eine andere Signatur hat, wird die Methode nicht überschrieben. Daher bitte beim Überschreiben einer Methode immer eine @Overrides Annotation - dann kann geprüft werden, dass wirklich eine Methode überschrieben wird und Du bekommst eine entsprechende Meldung, wenn das nicht der Fall ist.

b) Java Naming Convenmtions - es ist üblich, Variablen und Parameter klein zu schreiben, also anzahl, x, y ... Dann ggf. sinnvolle Namen vergeben - es ist extrem mangelhaft, mehrere variablen mit eigentlich gleichem Namen zu haben ... Du hast x, X, ... Damit sind Fehler vorprogrammiert!

c) for ist meiner Meinung nach eine zählschleife und die Zählvariable innerhalb des Blockes zu verändern ist ein sehr schlechter Stil, denn sowas wird in der Regel nicht erwartet. Da wäre dann mein Tipp, z.B. auf eine while Schleife zu wechseln.

Zu Deiner Verständnisfrage: Hast Du den Code nicht geschrieben? Geh den Code doch einmal durch, entweder auf einem Zettel oder mit dem Debugger ... oder gibt mehr Text aus, damit Du den Code nachvollziehen kannst. Das ist etwas, das Du auf jeden Fall als Übung machen solltest, denn nur so vertieft sich das auch wirklich.
Aber um es auch schnell zu beantworten:
In der Äußeren Schleife geht es um das Füllen - eine Koordinate nach der anderen ...
in der Inneren Schleife wird dann für jede neu hinzugefügte Koordinate geprüft, ob diese schon vorhanden ist.
Und bei x und x[j] ist das i doch immer ungleich dem j - denn so ist ja die innere Schleife ausgewählt ... wenn i = 0 ist, dann geht die Schleife von j = 0 an, aber nur so lange, wie j < 0 - und das ist nie der Fall, also bei i = 0 wird die innere Schleife nie ausgeführt.
Bei i = 1 wird die innere Schleife nur für j = 0 ausgeführt.
Bei i = 2 wird die innere Schleife für j = 0 und 1 ausgeführt....
 
Der Name der Klasse ist "Positionen", oder?

Dem Konstruktor übergibst du allerdings nur genau eine Position X,Y, die du dann ANZAHL-mal in das Array x einfügst.

Dieses Array x wird beim Aufruf des Konstruktors neu erzeugt und ist damit erstmal leer.

Was hast du eigentlich vor?

Eine, anhand der Namensgebung, sinnvolle Vorgehensweise wäre vermutlich:

  • Ein Konstruktor, der die Anzahl der möglichen Positionen übernimmt und das Array entsprechend initialisiert.
  • Eine Methode addPosition(), die eine Koordinate hinzufügt und vorher prüft, ob es diese Position schon gibt.
 
Zuletzt bearbeitet:
Ach und noch eine Kleinigkeit, die man in seine Überlegungen einbeziehen kann: Der Konstruktor nimmt drei int-Parameter, es ist also schwierig zu erkennen, welche Funktion die jeweilige Stelle einnimmt. Ist es die Anzahl oder ein Koordinaten-Bestandteil?
Da du bereits einen expliziten Typen für eine Position hast, ist es besser diesen hier gleich zu verwenden, um das eindeutiger zu machen: public Positionen(int anzahl, Koordinate koordinate). Allerdings gilt weiterhin, was ich oben geschrieben hatte.
 
Zeppi hat gesagt.:
Danke für die ausführliche Antwort. Doch ich habe den Code geschrieben, bzw. der ist abgeleitet aus einer Aufgabe aus einer Vorlesung.
Zum Vergrößern anklicken....
Ich hoffe, das ist nicht falsch angekommen.... Ich wollte Dir da nichts unterstellen. Das "abgeleitet von einer Aufgabe" erklärt meinen Eindruck.

Zum einen hoffe ich, dass die Erklärung etwas weiter geholfen hat, aber ich möchte die Gelegenheit noch einmal nutzen um Dir die praktische Übung ans Herz zu legen. Speziell das:
oder mit dem Debugger ... oder gibt mehr Text aus
Zum Vergrößern anklicken....
Hintergrund ist, dass Du Dir so selbst gewisse Dinge schneller erarbeiten kannst und mit dem "Herum Spielen" vertiefst Du Dein Verständnis!

Wir beantworten Dir hier gerne alle Fragen und helfen weiter - aber ich schaue auch immer, ob ich evtl. Dinge sehe, die vertieft werden könnten um einem Fragesteller generell weiter zu helfen. Und dieser Punkt ist mir etwas aufgefallen.

Also konkret wären die Punkte:
a) Wenn Du eine IDE nutzt (Eclipse, IntelliJ, ..) dann hat die IDE bestimmt einen integrierten Debugger - der kann sehr hilfreich bei praktischen Aufgaben sein. Daher ruhig einmal anschauen.
b) Schau einfach einmal, was Du alles an Informationen ausgeben kannst. Dann bekommst Du ein ganze Menge Ausgabe, die Dir zeigt, was wann passiert. Also innerhalb des Schleifenblocks kannst Du etwas ausgeben wie: "Schleifendurchgang: i := " + i ... oder auch Zuweisungen ausgeben, wenn Du also x[i] etwas zuweist, dann kannst Du eine Ausgabe erzeugen a.la. "x[i=" + i + "] = " + x[i]
(Jeweils einfach mal angegeben, was in einem System.out.println übergeben werden könnte ...)

Und dann generell der Aufruf: Spiel etwas mit dem Code. Wenn Dir Ideen kommen, was Du anpassen könntest, dann mach es. Ändere eine for Schleife in eine While Schleife, verändere die Namen von Variablen, Schiebe Teile vom Code in eine Methode, ...
Ggf: Wenn Du sowas manuell hin bekommen hast, dann könntest Du auch die Mittel der IDE anschauen. Die bieten dafür auch viele Möglichkeiten.

Das einfach nur, um meine Sicht noch etwas zu erläutern.
 
kneitzel hat gesagt.:
In der Äußeren Schleife geht es um das Füllen - eine Koordinate nach der anderen ...
in der Inneren Schleife wird dann für jede neu hinzugefügte Koordinate geprüft, ob diese schon vorhanden ist.
Zum Vergrößern anklicken....
Verstehe nicht, wie das gehen soll. Es wird ja nur eine Koordinate übergeben... Wo ist denn da das "eine Koordinate nach der anderen"?
 
Danke für deine Tipps. Ich werde mich mal ran setzen und den Debugger ausprobieren bzw. mich mal einlesen, wie genau der funktioniert. Ich finde es sehr gut, dass Du dir für jeden so viel Zeit nimmst und wirklich versuchst es zu erklären, bis man es sehr gut versteht. Außerdem sind Deine Tipps (wie jetzt auch schon wieder) immer sehr hilfreich/lehrreich und machen das Java lernen auf jedenfall
kneitzel hat gesagt.:
Ich hoffe, das ist nicht falsch angekommen.... Ich wollte Dir da nichts unterstellen. Das "abgeleitet von einer Aufgabe" erklärt meinen Eindruck.

Zum einen hoffe ich, dass die Erklärung etwas weiter geholfen hat, aber ich möchte die Gelegenheit noch einmal nutzen um Dir die praktische Übung ans Herz zu legen. Speziell das:

Hintergrund ist, dass Du Dir so selbst gewisse Dinge schneller erarbeiten kannst und mit dem "Herum Spielen" vertiefst Du Dein Verständnis!

Wir beantworten Dir hier gerne alle Fragen und helfen weiter - aber ich schaue auch immer, ob ich evtl. Dinge sehe, die vertieft werden könnten um einem Fragesteller generell weiter zu helfen. Und dieser Punkt ist mir etwas aufgefallen.

Also konkret wären die Punkte:
a) Wenn Du eine IDE nutzt (Eclipse, IntelliJ, ..) dann hat die IDE bestimmt einen integrierten Debugger - der kann sehr hilfreich bei praktischen Aufgaben sein. Daher ruhig einmal anschauen.
b) Schau einfach einmal, was Du alles an Informationen ausgeben kannst. Dann bekommst Du ein ganze Menge Ausgabe, die Dir zeigt, was wann passiert. Also innerhalb des Schleifenblocks kannst Du etwas ausgeben wie: "Schleifendurchgang: i := " + i ... oder auch Zuweisungen ausgeben, wenn Du also x[i] etwas zuweist, dann kannst Du eine Ausgabe erzeugen a.la. "x[i=" + i + "] = " + x[i]
(Jeweils einfach mal angegeben, was in einem System.out.println übergeben werden könnte ...)

Und dann generell der Aufruf: Spiel etwas mit dem Code. Wenn Dir Ideen kommen, was Du anpassen könntest, dann mach es. Ändere eine for Schleife in eine While Schleife, verändere die Namen von Variablen, Schiebe Teile vom Code in eine Methode, ...
Ggf: Wenn Du sowas manuell hin bekommen hast, dann könntest Du auch die Mittel der IDE anschauen. Die bieten dafür auch viele Möglichkeiten.

Das einfach nur, um meine Sicht noch etwas zu erläutern.
Zum Vergrößern anklicken....
Danke für deine Tipps. Ich werde mich mal ran setzen und den Debugger ausprobieren bzw. mich mal einlesen, wie genau der funktioniert. Ich finde es sehr gut, dass Du dir für jeden so viel Zeit nimmst und wirklich versuchst es zu erklären, bis man es sehr gut versteht. Außerdem sind Deine Tipps (wie jetzt auch schon wieder) immer sehr hilfreich/lehrreich und machen das Java lernen noch spaßiger 🙂
 
temi hat gesagt.:
Verstehe nicht, wie das gehen soll. Es wird ja nur eine Koordinate übergeben... Wo ist denn da das "eine Koordinate nach der anderen"?
Zum Vergrößern anklicken....
Ich weiß nicht genau was du meinst, aber vielleicht hilft Dir der Code-Schnipsel weiter, den ich vorher hier nicht aufgelistet habe.
[CODE lang="java" title="Hier die komplette Klasse Koordinate"]public class Koordinate {
private int x;
private int y;

public int getX() {
return x;
}
public int getY() {
return y;
}

public Koordinate(int X, int Y) {
java.util.Random zufall = new java.util.Random();
this.x= zufall.nextInt(X); //X und Y werden in der main-Methode ein Wert zugewiesen (in dem Fall 9 und 7)
this.y= zufall.nextInt(Y);
}
public boolean equals(Koordinate vgl) {
return this.x ==vgl.x && this.y==vgl.y;
}
public String toString() {
return " " + this.x +"," +this.y;
}
}
[/CODE]
Und es wird ja pro Schleifendurchlauf die Klasse aufgerufen und dann jeweils eine random Zahl übergeben etc.
Außerdem muss ich sagen, dass ich eine schlechte Wahl bezüglich der Variablen getroffen habe.
 
Genau das hatte ich noch im Hinterkopf - das hattest Du schon einmal im Forum gepostet.

Aber das zeigt sehr schön, dass es wichtig ist, Variablen und Parameter gut zu benennen. X und Y sind hier ja eher maxX und maxY oder so.
 
Zeppi hat gesagt.:
Ich weiß nicht genau was du meinst, aber vielleicht hilft Dir der Code-Schnipsel weiter, den ich vorher hier nicht aufgelistet habe.
Zum Vergrößern anklicken....
Ja, jetzt ist es klar. Es ist gar keine Koordinate, die dem Konstruktor übergeben wird, sondern Grenzen. Die Koordinaten werden dann innerhalb der Grenzen zufällig erzeugt. Dieser Teil hat mir gefehlt. 😉

Eine Möglichkeit, die Klasse Koordinate etwas klarer zu gestalten, wäre eine statische Methode für die Erzeugung der Zufallskoordinate zu verwenden:
Java: 
public class Koordinate {
    private int x;
    private int y;
 
    public int getX() {
        return x;
    }
    public int getY() {
        return y;
    }

    // Erzeugt eine bestimmte Koordinate
    public Koordinate(int x, int y) {
        this.x = x;
        this.y = y;
    }
   
    // Erzeugt eine zufällige Koordinate
    public static Koordinate generateRandom(int maxX, int maxY) {
        Random random = new Random();
        return new Koordinate(random.nextInt(maxX), random.nextInt(maxY));
    }

// dann im weiteren Code

Koordinate koord = Koordinate.generateRandom(10, 10);

Damit ist die Klasse Koordinate das, was man von ihr erwartet, nämlich eine Klasse, die eine Koordinate repräsentiert. Zusätzlich bietet sie eine Methode, um eine zufällige Instanz von sich selbst zu erzeugen.
 
Zuletzt bearbeitet:
temi hat gesagt.:
Ja, jetzt ist es klar. Es ist gar keine Koordinate, die dem Konstruktor übergeben wird, sondern Grenzen. Die Koordinaten werden dann innerhalb der Grenzen zufällig erzeugt. Dieser Teil hat mir gefehlt. 😉

Eine Möglichkeit, die Klasse Koordinate etwas klarer zu gestalten, wäre eine statische Methode für die Erzeugung der Zufallskoordinate zu verwenden:
Java: 
public class Koordinate {
    private int x;
    private int y;

    public int getX() {
        return x;
    }
    public int getY() {
        return y;
    }

    // Erzeugt eine bestimmte Koordinate
    public Koordinate(int x, int y) {
        this.x = x;
        this.y = y;
    }
  
    // Erzeugt eine zufällige Koordinate
    public static Koordinate generateRandom(int maxX, int maxY) {
        Random random = new Random();
        return new Koordinate(random.nextInt(maxX), random.nextInt(maxY));
    }

// dann im weiteren Code

Koordinate koord = Koordinate.generateRandom(10, 10);

Damit ist die Klasse Koordinate das, was man von ihr erwartet, nämlich eine Klasse, die eine Koordinate repräsentiert. Zusätzlich bietet sie eine Methode, um eine zufällige Instanz von sich selbst zu erzeugen.
Zum Vergrößern anklicken....
Klasse, werde ich einbauen.
 
Ach so, die equals() Methode von Koordinate ist noch nicht richtig. Damit überschreibst du nicht das equals() von Object, sondern überlädst es.

Die Signatur lautet public boolean equals(Object obj). Und immer schön @Override verwenden, wenn du etwas überschreiben möchtest.
Java: 
@Override
public boolean equals(Object obj) {
    // dein Code
}

@Override
public String toString() {
    // dein Code
}
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Kurze Frage zur Sortierung von Array-Inhalten
Antworten: 5
Fenster mit Inhalten aus einem Array Füllen
Antworten: 4
Resize von ScrollPane Inhalten
Antworten: 2
Problem beim Zeichen von Inhalten
Antworten: 4
Übernehmen von Inhalten aus Zellen in JTables ohne Return
Antworten: 7

Zurück
Oben