X Werte in ArrayList von Point Objekte alle gleich ?

[dutchman79]

Ich habe eine ArrayList mit Stützstellen befüllt. ( double x, double y)

Also ArrayList <Stützstelle> stützstellen = new ArrayList<Stützstelle>();

Alle x Werte der Stützstellen müssen unterschiedlich sein, das möchte ich überprüfen, wenn nicht, Exception werfen.

Wenn alle y Werte gleich sind möchte ich nur ein Warnungtext ausgeben.

Ich benutze die Stützstellen letzendlich um linear zu interpolieren, deswegen diese Meldungen.

Kann mir jemand weiterhelfen ?

 

[bygones]

was ist deine Frage ?

wie du deine Warnungen ausgeben kannst ? wie du überprüfen kannst, dass kein x wert gleich ist ? dass alle y gleich sind ?

 

[dutchman79]

Alle Fragen die du erwähnt hast ....

 

[nrg]

du könntest die Liste in ein Set übernehmen und dann kucken, ob die Größen der Liste und des Sets sich unterscheiden. dazu solltest du in der Klasse Stützstelle (btw. sollte man imho Umlaute in Klassennamen verhindern) equals und hashcode überschreiben. Eine andere Möglichkeit wäre das einfach selbst zu überprüfen. Dazu würde ich die Liste erst mal Sortierten. Dafür musst du in Stützstelle Comparable implementieren und die compareTo überschreiben. Dann durchiterieren und den aktuellen Index immer mit dem Folgeindex vergleichen.

Die Frage, die ich mir noch stelle: willst du überhaupt Dubletten zulassen?? Wenn nein, würde ich sofort ein Set nehmen.

 

[dutchman79]

Okay,

Da verstehe ich noch wenig von.

x Werte dürfen nicht doppelt vorkommen, y Werte wohl.

Bis jetzt habe ich nach mühsame Arbeit (weil ich es nicht verstehe) Comparable implementiert in der Stuetzstelle Klasse, und deswegen kann ich die x Werte wohl schonmal nach Größe sortieren

 

[nrg]

hast du die compareTo-Methode überschrieben? Dann kannst du das Ding ja mal Sortieren. Wenn deine Grundreihenfolge wichtig ist, würde ich mir diese merken oder wenn die Liste nicht so groß ist vorher kopieren.

Dann einfach sowas in der Art (keine Garantie - einfach so in Browser getippt):

		for (int i = 0; i < list.size()-1; i++) {
			Stuetzstelle current = list.get(i);
			Stuetzstelle next = list.get(i+1);
			if (current.getX() == next.getX())
				throw new IllegalArgumentException("Identische X-Werte gefunden");
			if (current.getY() == next.getY())
				System.out.println("Warnung: identische Y-Werte gefunden");
		}

Voraussetzung sind natürlich die getter in der Klasse Stuetzstelle

 

[Andi_CH]

eine Stützstelle ist (TO korrigier mich bitte wenn ich falsch liege) das y zu einem eindeutigen x
( ich meine y = f(x) )

x muss eindeutig sein -> HashMap<Double, Double> (Double an erster Stelle ist aber gefährlich ;-) )

Du kannst einfach einfügen und der letzte Wert bleibt gespeichert.
Exceptions kannst du manuell auslösen

	private static HashMap<Integer, Double> s = new HashMap<Integer, Double>();
	public static void main(String[] args) throws Exception {
		s.put(1, 1.0);
		s.put(2, 3.0);
		s.put(2, 2.0); // jetzt ist bei 2 der Wert 2.0 gespeichert, 3.0 ist weg
		// oder du machst das
		if (s.containsKey(2))
			throw new Exception();
	}

 

[nrg]

(Double an erster Stelle ist aber gefährlich ;-) )

warum? nur weil nicht jeder Double dezimal 100% darstellbar ist, hat er doch trotzdem einen eindeutigen HashCode. oder stehe ich jetzt irgendwo auf dem Schlauch

 

[bygones]

map wuerde ich hier nicht nehmen, durch das put überschreibst du einen bestehenden Eintrag und hast kein direktes Feedback.

Aber der Ansatz dass schon beim einfügen zu checken halte ich für richtig.

Ich würde in der Klasse im Hintergrund ein Set nehmen, dies erlaubt ja per se keine Duplikate. Das add beim Set gibt als Rückgabewert dann true (wurde reingenommen) bzw false (gabs schon) zurück. Darauf kannst du reagieren und deine Exception werfen.
Das für die x Werte

EDIT: und bitte übernehme nicht das Übel von [c]throw Exception[/c] - man sollte immer eine konkrete Exception nehmen und nicht Exception als Typ

 

[dutchman79]

Okay, danke für alle Hilfe.
Bis jetzt habe ich :

public class Stuetzstelle implements Comparable<Stuetzstelle> {
	double x;
	double y;

	Stuetzstelle(double x, double y) {
		this.x = x;
		this.y = y;
	}
	public int compareTo(Stuetzstelle o) {
		if (o.x < this.x) {
			return 1;
		} else if (o.x > this.x) {
			return -1;
		} else {
			return 0;
		}

	}
}
public class MgRulesCompliance implements Imessgroessen {

	// ArrayList mit allen Stuetzpunkten
	ArrayList<Stuetzstelle> stuetzstellen;
	double x0, x1, y0, y1; // Definitionsbereich x0 bis x1, Wertebereich y0 bis y1

	// Konstruktor
	public MgRulesCompliance(double x0, double x1, double y0, double y1,
			ArrayList<Stuetzstelle> stuetzstellen) throws IllegalArgumentException {

		// Ueberpruefung ob die x Werte der Stuetzstellen unterschiedlich sind
		for (int i = 0; i < stuetzstellen.size() - 1; i++) {
			if (stuetzstellen.get(i).x == stuetzstellen.get(i + 1).x) {
				throw new IllegalArgumentException(
						"Stuetzstellen mit gleichem x Wert vorhanden.");
			}
		}
		// Ueberpruefung ob es mehr als 2 Stuetzstellen gibt (notwendige
		// Bedingung)
		if (stuetzstellen.size()<=1) {
			throw new IllegalArgumentException("Nur eine Stuetzstelle vorhanden.");
		} else {
			Collections.sort(stuetzstellen);
			this.stuetzstellen = stuetzstellen;
			this.x0 = x0;
			this.x1 = x1;
			this.y0 = y0;
			this.y1 = y1;
		}

 

[nrg]

aus dem Namen MgRulesCompliance geht jetzt nicht unbedingt der Nutzen der Klasse hervor aber warum schreibst du dort nicht einfach eine add-Methode und überprüfst das da? Ansonsten habe ich dir oben ein kleines Beispiel geschrieben, wie es vllt mit sort klappen könnte. Ahja IllegalArgumentException ist eine unchecked-Exception und muss nicht geworfen werden.

edit: würde in deine compareTo noch y einbinden.

 

[dutchman79]

MgRulesCompliance ist eine von 4 Klassen die alle eine andere ArrayList mit Stützstellen übergeben bekommen und die alle 4 das Interface IMessgroessen implementieren.

Das Interface IMessgroessen hat 3 Methoden.