Verschachtelte ListIteratoren um in zwei Listen hin und herzugehen

Status
Nicht offen für weitere Antworten.

Jay1980

Bekanntes Mitglied
Servus,

das überfordert mich gerade etwas:

Ich habe eine Punktemenge in einer ArrayList<Point>. Nun soll ich da einmal in einer Richtung nacheinander durchgehen und immer wenn der Punkt eine bestimmte Eigenschaft hat, soll ich ihn mit dem letzten und vorletzten der Collection vergleichen.

Wenn dann der Vergleich positiv ausfällt, soll ich den Punkt in einer anderen Collection einfügen. In dieser anderen Collection muss ich dann auch Punkte rausschmeissen und einfügen.

Ich habe es erst versucht mit while Schleifen und Laufvariablen (vorher mit Arrays dann mit Collections) zu machen, scheiterte aber wegen vieler Nullpointer und entdeckte nun den ListIterator. Der scheint mir da viel ab zu nehmen, aber das ist für mich Neuland.

Bin ich da auf der richtigen Spur, wenn ich mal was fertiges habe, dann poste ich den Code hier, so wird mein Problem wohl besser sichtbar?

EDIT/UPDATE: kompilierbares Beispiel siehe zweite und dritter Post!
 
Zuletzt bearbeitet:

HLX

Top Contributor
...wenn ich mal was fertiges habe, dann poste ich den Code hier, so wird mein Problem wohl besser sichtbar?

Ja das wäre gut.

Hier schonmal zwei Beispiele mit ArrayList<Point>:
Code:
for(int i = 0; i < list.size(); i++) {
     Point p = list.get(i);
     ...
}
(java.util.Iterator)
Code:
for(Iterator<Point> iter = list.iterator();iter.hasNext();) {
     Point p = iter.next();
     ...
}
 

Jay1980

Bekanntes Mitglied
Sodala,

ich habe nun mal einen Testfall angelegt, leider kompiliert der nicht. Dazu noch einen Screenshot, damit man sieht um was es geht. Im Quelltext sind auch Kommentare.

Die rot eingekreisten Punkte sind die, die im Konstruktor ankommen, die grün eingekreisten die Extremwerte die für das Viertel wichtig sind. Jetzt soll von einem Extrempunkt durch die Punkte gegangen werden. Wenn man einen neuen Punkt hat, muss man umdrehen und seine beiden Vorgänger nehmen, um zu entscheiden, ob die alten konvexen Punkte noch 'aktuell' sind.

Wenn man nämlich drei Punkte (a, b, c) hat kann man durch den Rechts-Links-Test (die Methoden sind neben der computeConvexPoints()-Methode auch in der Klasse) sagen, ob c rechts oder Links von der Geraden ab liegt.

Danke, wenn einer einen Tipp hat, sofern jemand sich das ansehen will, es aber zeitintensiver ist, zahl ich auch gern was dafür, wie gesagt, ich bin da aktuell seit vielen Stunden dran und komm nicht weiter. Dazu muss ich den Ansatz ja auch perfekt blicken, also wenn einer mir das erklären will schickt mir kurz eine PN wegen dem Geld - muss mit meinem Studentensäckel vorher schauen, inwieweit ich mir da die 'Nachhilfe' leisten kann.

Hier die beiden Klassen:
+ JobaQuarterConvexHull
Java:
package test003;

import java.awt.Point;
import java.util.ArrayList;
import java.util.ListIterator;

import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

public class JobaQuarterConvexHull 
{
	Point startPoint;
	Point endPoint;
	Point currentPoint;
	Point currentConvexPoint;
		
	ArrayList<Point> outlinePoints;
	ArrayList<Point> convexPoints;
	ListIterator<Point> litout;
	ListIterator<Point> litcon;
	
	JobaQuarterConvexHull( ArrayList<Point> outlineP, Point start, Point end )
	{
		outlinePoints = new ArrayList<Point>();
		outlinePoints.add( new Point(start) );
		outlinePoints.addAll( outlineP );
		outlinePoints.add( end );
		litout = outlinePoints.listIterator();
		
		convexPoints = new ArrayList<Point>();
		startPoint = new Point( (int)start.getX(), (int)start.getY() );
		endPoint = new Point( (int)end.getX(), (int)end.getY() );
		litcon = convexPoints.listIterator();
		
		computeConvexPoints();
	}
	
	
	private void computeConvexPoints()
	{	
		String dbg = new String();
		dbg += "Bin in der Methode computeConvexPoints()....\n";
		
		// ++++ Start Stegreifberechnungen für convexPoints, die zum Ausbruch aus der Methode führen
		if ( outlinePoints.size() == 0 )
		{
			litcon.add(startPoint);
			litcon.add(endPoint);
			return;
		}
		
		if ( outlinePoints.size() == 1 )
		{
			litcon.add(startPoint);
			currentPoint = litout.next();
			boolean erg = isLeftToLine(startPoint, endPoint, currentPoint);
			if ( erg == true )
			{
				litcon.add(currentPoint);
			}
			litcon.add(endPoint);
			return;
		}
		// ---- Ende Stegreifberechnungen
		
		
		// ++++ Start Gehe-Vorwärts-Algorithmus
		int loopCounter = 0;
		while ( litout.hasNext() == true && loopCounter < 100  )
		{
			loopCounter++;
			dbg += "Trete in die Schleife ein, litout hasNext(), loopCounter bei " + loopCounter + " ...\n";
			
			dbg += "	+-----------------------------------------+\n";
			dbg += "	| Collection: outlinePoints .... \n";
			dbg += " 	+-----------------------------------------+\n";
			for (Point p : outlinePoints )
			{
				dbg += " 	| P ( " + p + ");\n";
			}
			dbg += " 	+-----------------------------------------+\n";
			
			dbg += "	+-----------------------------------------+\n";
			dbg += "	| Collection: convexPoints .... \n";
			dbg += " 	+-----------------------------------------+\n";
			for (Point p : convexPoints )
			{
				dbg += " 	| P ( " + p + ");\n";
			}
			dbg += " 	+-----------------------------------------+\n";
			
			// nimm den nächsten Punkt der outlinePoints als aktuellen Punkt 
			currentPoint = new Point(litout.next()); // Punkt als Kopie damit er Teil der Outline bleibt
			
			dbg += "Nehme als currentPoint litout.next(), hier P ( " + currentPoint + " ); \n";
			
			// erstmal aufnehmen und currentConvexPoint setzen mit einer Kopie
			currentConvexPoint = new Point(currentPoint);
			litcon.add(currentConvexPoint);
			
			dbg += "Bilde currentConvexPoint als Kopie von currentPoint, hier " + currentPoint + ".\n";
			dbg += "Nehme currentConvexPoint mit litcon.add in die convexPoints-Collection auf, hier " + currentConvexPoint + ".\n";
			
			dbg += "( +++ Check aktuelle convexPoints-Liste: ";
			for (Point p : convexPoints )
			{
				dbg += "| P ( " + p + "); ";
			}
			dbg += " +++)\n";
			
			// +++++++ Start Walk-Back-Mechanismus
			
			// +++++++ Stegreifberechnungen für convexPoints, die zum Abbruch der Aussen-Schleife und damit der Berechnung aller Punkte führen, sollte sich identisch mit return-Aufruf verhalten
			
			// +++++++ Stegreifberechnungen für convexPoints, die zum Abbruch der Aussen-Schleifen-Iteration führen und damit der Berechnung für den currentPoint aus outlinePoints
			if ( convexPoints.size() == 0 )
			{
				// nimm erstmal den Extrempunkt rein
				litcon.add(startPoint);
				continue; // nimm nächsten Punkt
			}
			
			if ( convexPoints.size() == 1 )
			{
				// da liegt dann nur der Startpunkt drin, da hole mal den nächsten Punkt, bei 2 greift dann ein 
				// anderer Zweig
				continue;
			}
			
			if ( convexPoints.size() == 2 )
			{
				// prüfe den currentConvexPoint gegen Start und Ende und entscheide ob er drin bleiben darf
				// es müssen noch weitere Punkte kommen, da sonst bereits der Stegreifzweig outlinePoints == 1 griefe :-)
				Point a = startPoint; // ist auch schon drin
				Point b = endPoint;
				Point c = currentConvexPoint;
				
				boolean erg = isLeftToLine(a, b, c);
				if ( erg == true )
				{
					litcon.add(currentConvexPoint);
					continue; // nächsten Punkt holen der dann ja gleich ein neuer currentConvexPoint wird
				}
				else 
				{
					// Punkt nicht aufnehmen und neuen holen 
					continue;
				}
			}
			
			// +++++++ Walkback-Algorithmus, nur wenn Stegreifberchnungen nicht greifen 
			// Neuaufnahme fordert Walkback, convexPoints.size() ist mindestens 3, 
			int loopTwoCounter = 0;
			while ( litcon.hasPrevious() == true )
			{
				loopTwoCounter++;
				dbg += "\n*** Eintritt in die while-innen-Schleife zum Walkback, loopTwoCounter bei " + loopTwoCounter + " ...\n";
				
				// Stegreifberechnungen um die Aussage für den currentConvexPoint zu treffen
				if ( convexPoints.size() == 2 )
				{
					// hier liegen der Startpunkt und der erste Punkt drin, da kann man dann aus dieser
					// Schleife ausbrechen, dann wird diese Sache vom Stegreifzweig der eine Hierachie 
					// weiter oben liegenden Schleife behandelt
					break;
				}
				
				// Standardalgorithmus Walkback
				// nimm den letzten und vorletzten Punkt von litcon als Kind und Enkel
				Point currentConvexPointChild;
				Point currentConvexPointGrandChild;
				
				currentConvexPointChild = litcon.previous(); 
				dbg += "Nimm litcon.previous() hier " + currentConvexPointChild + " als currentConvexPointChild.\n";
				
				currentConvexPointGrandChild = litcon.previous();
				dbg += "Nimm litcon.previous() hier " + currentConvexPointGrandChild + " als currentConvexPointGrandChild.\n";	
				
				// Pruefe 
				Point a = currentConvexPoint;
				Point b = currentConvexPointChild;
				Point c = currentConvexPointGrandChild;
				
				boolean erg = isRightToLine(a, b, c);
				if ( erg == true )
				{
					// das letzte gelieferte des litcon ist das GrandChild, also vorher noch einmal nach vorne um bei previous zu landen
					Point pointToDelete = litcon.next();
					litcon.remove();
				}
				else
				{
					// Punkt liegt innerhalb, dann muss nichts gelöscht werden
					// aus dem Walkback kann man weg, man kann sogar aus
					break;
				}
				
			} // Ende while innen
			
		}
		// while aussen durch
		// adde letzten Punkt zu den convexPoints
		litcon.add(endPoint);
		
		JTextArea jta = new JTextArea(dbg, 30, 80);
		JScrollPane jsp = new JScrollPane(jta);
		JOptionPane.showMessageDialog(null, jsp);
	}
	
	
	public ArrayList<Point> getConvexPoints()
	{
		return convexPoints;
	}
	
	private boolean isRightToLine(Point a, Point b, Point c )
	{
		// Strecke a nach b, Punkt c ist der zu testende Punkt
		double d = ( ( c.getX() - a.getX() ) * ( c.getY() + a.getY() ) + ( b.getX() - c.getX() ) * ( b.getY() + c.getY() ) + ( a.getX() - b.getX() ) * ( a.getY() + b.getY() ) );
		
		// Testfall a = 200,200; b = 200, 100; c = 400, 200; also Marschrichtung wie im Quadrant 1, passt
		if ( d > 0 ) 
		{
			//JOptionPane.showMessageDialog(null, "d ist groesser 0, Punkt liegt rechts der Geraden.");
			return true;
		}
		else if ( d < 0 )
		{
			//JOptionPane.showMessageDialog(null, "d ist kleiner 0, Punkt liegt links der Geraden.");
			return false;
		}
		else if ( d == 0 )
		{
			//JOptionPane.showMessageDialog(null, "d ist 0, Punkt liegt auf der Geraden.");
			return false;
		}
		else {}
		
		return false;
	}
	
	private boolean isLeftToLine( Point a, Point b, Point c )
	{
		// Strecke a nach b, Punkt c ist der zu testende Punkt
		double d = ( ( c.getX() - a.getX() ) * ( c.getY() + a.getY() ) + ( b.getX() - c.getX() ) * ( b.getY() + c.getY() ) + ( a.getX() - b.getX() ) * ( a.getY() + b.getY() ) );
		
		// Testfall a = 200,200; b = 200, 100; c = 400, 200; also Marschrichtung wie im Quadrant 1, passt
		if ( d < 0 ) 
		{
			//JOptionPane.showMessageDialog(null, "d ist kleiner 0, Punkt liegt links der Geraden.");
			return true;
		}
		else if ( d > 0 )
		{
			//JOptionPane.showMessageDialog(null, "d ist groesser 0, Punkt liegt rechts der Geraden.");
			return false;
		}
		else if ( d == 0 )
		{
			//JOptionPane.showMessageDialog(null, "d ist 0, Punkt liegt auf der Geraden.");
			return false;
		}
		else {}
		
		return false;
	}
}

+ Main
Java:
package test003;

import java.awt.Point;
import java.util.ArrayList;

public class Main 
{
	public static void main( String[] args)
	{
		
		ArrayList<Point> minxtominyOutlinePoints = new ArrayList<Point>();
		
		minxtominyOutlinePoints.add(new Point(38, 232));
		minxtominyOutlinePoints.add(new Point(40, 196));
		minxtominyOutlinePoints.add(new Point(54, 177));
		minxtominyOutlinePoints.add(new Point(84, 168));
		minxtominyOutlinePoints.add(new Point(114, 163));
		minxtominyOutlinePoints.add(new Point(152, 161));
		minxtominyOutlinePoints.add(new Point(170, 127));
		minxtominyOutlinePoints.add(new Point(191, 111));
		minxtominyOutlinePoints.add(new Point(208, 110));
		minxtominyOutlinePoints.add(new Point(212, 417));
		minxtominyOutlinePoints.add(new Point(215, 96));
		minxtominyOutlinePoints.add(new Point(224, 25));
		
		Point minXSoFar = new Point(24, 247);
		Point minYSoFar = new Point(237, 14);
		
		JobaQuarterConvexHull currentQuarterConvexHull = new JobaQuarterConvexHull(minxtominyOutlinePoints, minXSoFar, minYSoFar);
		ArrayList<Point> currentQuarterConvexPoints = currentQuarterConvexHull.getConvexPoints();
		for (Point p : currentQuarterConvexPoints)
		{
			System.out.println(p);
		}
	}
	
}
 

Jay1980

Bekanntes Mitglied
Servus,

habe meine Klasse JobaQuarterConvexHull noch etwas aufpoliert, jetzt kompilierts sie und man kann schön lesen, wann der Fehler kommt, beim vierten Durchlauf packt mein ListIterator das Element an die zweite Stelle anstatt ganz nach hinten, warum ist das so, wie kann ich es verhindern?

Danke vorab.

Polierte kompilierbare Klasse (Main-Klasse von oben einfach übernehmen):
Java:
package test003;

import java.awt.Point;
import java.util.ArrayList;
import java.util.ListIterator;

import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

public class JobaQuarterConvexHull 
{
	Point startPoint;
	Point endPoint;
	Point currentPoint;
	Point currentConvexPoint;
		
	ArrayList<Point> outlinePoints;
	ArrayList<Point> convexPoints;
	ListIterator<Point> litout;
	ListIterator<Point> litcon;
	
	JobaQuarterConvexHull( ArrayList<Point> outlineP, Point start, Point end )
	{
		outlinePoints = new ArrayList<Point>();
		outlinePoints.add( new Point(start) );
		outlinePoints.addAll( outlineP );
		outlinePoints.add( end );
		litout = outlinePoints.listIterator();
		
		convexPoints = new ArrayList<Point>();
		startPoint = new Point( (int)start.getX(), (int)start.getY() );
		endPoint = new Point( (int)end.getX(), (int)end.getY() );
		litcon = convexPoints.listIterator();
		
		computeConvexPoints();
	}
	
	
	private void computeConvexPoints()
	{	
		String dbg = new String();
		dbg += "Bin in der Methode computeConvexPoints()....\n";
		
		// ++++ Start Stegreifberechnungen für convexPoints, die zum Ausbruch aus der Methode führen
		if ( outlinePoints.size() == 0 )
		{
			dbg += " Bin im Stegreifzweig für outlinePoints, hier outlinePoints.size() == 0 \n";
			litcon.add(startPoint);
			litcon.add(endPoint);
			return;
		}
		
		if ( outlinePoints.size() == 1 )
		{
			dbg += " Bin im Stegreifzweig für outlinePoints, hier outlinePoints.size() == 1 \n";
			litcon.add(startPoint);
			currentPoint = litout.next();
			boolean erg = isLeftToLine(startPoint, endPoint, currentPoint);
			if ( erg == true )
			{
				litcon.add(currentPoint);
			}
			litcon.add(endPoint);
			return;
		}
		// ---- Ende Stegreifberechnungen
		
		
		// ++++ Start Gehe-Vorwärts-Algorithmus
		int loopCounter = 0;
		while ( litout.hasNext() == true && loopCounter < 100  )
		{
			loopCounter++;
			dbg += "Trete in die Schleife ein, litout hasNext(), loopCounter bei " + loopCounter + " ...\n";
			
			dbg += "	+-----------------------------------------+\n";
			dbg += "	| Collection: outlinePoints .... \n";
			dbg += " 	+-----------------------------------------+\n";
			for (Point p : outlinePoints )
			{
				dbg += " 	| P ( " + p + ");\n";
			}
			dbg += " 	+-----------------------------------------+\n";
			
			dbg += "	+-----------------------------------------+\n";
			dbg += "	| Collection: convexPoints .... \n";
			dbg += " 	+-----------------------------------------+\n";
			for (Point p : convexPoints )
			{
				dbg += " 	| P ( " + p + ");\n";
			}
			dbg += " 	+-----------------------------------------+\n";
			
			// nimm den nächsten Punkt der outlinePoints als aktuellen Punkt 
			currentPoint = new Point(litout.next()); // Punkt als Kopie damit er Teil der Outline bleibt
			
			dbg += "Nehme als currentPoint litout.next(), hier P ( " + currentPoint + " ); \n";
			
			// erstmal aufnehmen und currentConvexPoint setzen mit einer Kopie
			currentConvexPoint = new Point(currentPoint);
			litcon.add(currentConvexPoint);
			
			dbg += "Bilde currentConvexPoint als Kopie von currentPoint, hier " + currentPoint + ".\n";
			dbg += "Nehme currentConvexPoint mit litcon.add in die convexPoints-Collection auf, hier " + currentConvexPoint + ".\n";
			
			dbg += "( +++ Check aktuelle convexPoints-Liste: ";
			for (Point p : convexPoints )
			{
				dbg += "| P ( " + p + "); ";
			}
			dbg += " +++)\n";
			
			// +++++++ Start Walk-Back-Mechanismus
			
			// +++++++ Stegreifberechnungen für convexPoints, die zum Abbruch der Aussen-Schleife und damit der Berechnung aller Punkte führen, sollte sich identisch mit return-Aufruf verhalten
			
			// +++++++ Stegreifberechnungen für convexPoints, die zum Abbruch der Aussen-Schleifen-Iteration führen und damit der Berechnung für den currentPoint aus outlinePoints
			if ( convexPoints.size() == 0 )
			{
				dbg += " Bin im Stegreifzweig für convexPoints, convexPoints.size() == 0 \n";
				// nimm erstmal den Extrempunkt rein
				litcon.add(startPoint);
				dbg += " --> litcon.add(startPoint), hier " + startPoint + " und nextRun\n";
				continue; // nimm nächsten Punkt
			}
			
			if ( convexPoints.size() == 1 )
			{
				dbg += " Bin im Stegreifzweig für convexPoints, convexPoints.size() == 1 \n";
				// da liegt dann nur der Startpunkt drin, da hole mal den nächsten Punkt, bei 2 greift dann ein 
				// anderer Zweig
				dbg += " --> keine Aktion nur nextRun\n";
				continue;
			}
			
			if ( convexPoints.size() == 2 )
			{
				dbg += " Bin im Stegreifzweig für convexPoints, convexPoints.size() == 2 \n";
				dbg += " --> RLT auf currentConvexPoint zu startPoint-endPoint ...\n";
				// prüfe den currentConvexPoint gegen Start und Ende und entscheide ob er drin bleiben darf
				// es müssen noch weitere Punkte kommen, da sonst bereits der Stegreifzweig outlinePoints == 1 griefe :-)
				Point a = startPoint; // ist auch schon drin
				Point b = endPoint;
				Point c = currentConvexPoint;
				
				boolean erg = isLeftToLine(a, b, c);
				if ( erg == true )
				{
					dbg += " ----> erg, c liegt links, litcon.add() auf currentConvexPoint, hier " + currentConvexPoint + " und nextRun.\n";
					litcon.add(currentConvexPoint);
					continue; // nächsten Punkt holen der dann ja gleich ein neuer currentConvexPoint wird
				}
				else 
				{
					dbg += " ----> erg false, c liegt rechts, keine Aktion nur nextRun.\n";
					// Punkt nicht aufnehmen und neuen holen 
					continue;
				}
			}
			
			// +++++++ Walkback-Algorithmus, nur wenn Stegreifberchnungen nicht greifen 
			// Neuaufnahme fordert Walkback, convexPoints.size() ist mindestens 3, 
			int loopTwoCounter = 0;
			while ( litcon.hasPrevious() == true )
			{
				loopTwoCounter++;
				dbg += "\n*** Eintritt in die while-innen-Schleife zum Walkback, loopTwoCounter bei " + loopTwoCounter + " ...\n";
				
				// Stegreifberechnungen um die Aussage für den currentConvexPoint zu treffen
				if ( convexPoints.size() == 2 )
				{
					// hier liegen der Startpunkt und der erste Punkt drin, da kann man dann aus dieser
					// Schleife ausbrechen, dann wird diese Sache vom Stegreifzweig der eine Hierachie 
					// weiter oben liegenden Schleife behandelt
					break;
				}
				
				// Standardalgorithmus Walkback
				// nimm den letzten und vorletzten Punkt von litcon als Kind und Enkel
				dbg += "Check currentConvexPoint ist bei " + currentConvexPoint + "\n";
				Point currentConvexPointChild;
				Point currentConvexPointGrandChild;
				
				currentConvexPointChild = litcon.previous(); 
				dbg += "Nimm litcon.previous() hier " + currentConvexPointChild + " als currentConvexPointChild.\n";
				
				// TODO hier hagelt es einen NullPointer
				if ( litcon.hasPrevious() == true )
				{
					currentConvexPointGrandChild = litcon.previous();
					dbg += "Nimm litcon.previous() hier " + currentConvexPointGrandChild + " als currentConvexPointGrandChild.\n";
				}
				else 
				{
					currentConvexPointGrandChild = new Point(startPoint);
					dbg += "Nimm startPoint-Kopie als litcon.previous() hier " + currentConvexPointGrandChild + " als currentConvexPointGrandChild.\n";
				}
					
				
				// Pruefe 
				Point a = currentConvexPoint;
				Point b = currentConvexPointChild;
				Point c = currentConvexPointGrandChild;
				dbg += " Gehe in den RLT fürs Walkback hier mit c (Grandchild) " + c + "; a (currentConvexPoint) " + a + "; b (Child) " + b + ";\n";
				boolean erg = isRightToLine(a, b, c);
				if ( erg == true )
				{
					
					// das letzte gelieferte des litcon ist das GrandChild, also vorher noch einmal nach vorne um bei previous zu landen
					Point pointToDelete = litcon.next();
					litcon.remove();
					dbg += "--> erg WalkbackRLT c ist rechts von ab, litcon.remove auf pointToDelete hier" + pointToDelete + " und nextRun.\n";
					dbg += "(+++ Check convexPoints-Col: ";
					for ( Point p : convexPoints)
					{
						dbg += "| " + p + "; "; 
					}
					dbg += "\n";
					continue;
				}
				else
				{
					// Punkt liegt innerhalb, dann muss nichts gelöscht werden
					// aus dem Walkback kann man weg, man kann sogar aus
					dbg += "--> erg WalkbackRLT c ist links von ab, keine Aktion, Schleifenabbruch mit break.\n";
					break;
				}
				
			} // Ende while innen
			dbg += "while-Innen-Schleife ist komplett durch.\n";
		}
		// while aussen durch
		// adde letzten Punkt zu den convexPoints
		
		dbg += "while-Schleifen sind komplett durch.\n";
		litcon.add(endPoint);
		
		dbg += "litcon.add() auf den endPoint anwenden, hier " + endPoint + "\n";
		dbg += "......... gesamte Methode ist durchgelaufen .... \n";
		
		JTextArea jta = new JTextArea(dbg, 30, 80);
		JScrollPane jsp = new JScrollPane(jta);
		JOptionPane.showMessageDialog(null, jsp);
	}
	
	
	public ArrayList<Point> getConvexPoints()
	{
		return convexPoints;
	}
	
	private boolean isRightToLine(Point a, Point b, Point c )
	{
		// Strecke a nach b, Punkt c ist der zu testende Punkt
		double d = ( ( c.getX() - a.getX() ) * ( c.getY() + a.getY() ) + ( b.getX() - c.getX() ) * ( b.getY() + c.getY() ) + ( a.getX() - b.getX() ) * ( a.getY() + b.getY() ) );
		
		// Testfall a = 200,200; b = 200, 100; c = 400, 200; also Marschrichtung wie im Quadrant 1, passt
		if ( d > 0 ) 
		{
			//JOptionPane.showMessageDialog(null, "d ist groesser 0, Punkt liegt rechts der Geraden.");
			return true;
		}
		else if ( d < 0 )
		{
			//JOptionPane.showMessageDialog(null, "d ist kleiner 0, Punkt liegt links der Geraden.");
			return false;
		}
		else if ( d == 0 )
		{
			//JOptionPane.showMessageDialog(null, "d ist 0, Punkt liegt auf der Geraden.");
			return false;
		}
		else {}
		
		return false;
	}
	
	private boolean isLeftToLine( Point a, Point b, Point c )
	{
		// Strecke a nach b, Punkt c ist der zu testende Punkt
		double d = ( ( c.getX() - a.getX() ) * ( c.getY() + a.getY() ) + ( b.getX() - c.getX() ) * ( b.getY() + c.getY() ) + ( a.getX() - b.getX() ) * ( a.getY() + b.getY() ) );
		
		// Testfall a = 200,200; b = 200, 100; c = 400, 200; also Marschrichtung wie im Quadrant 1, passt
		if ( d < 0 ) 
		{
			//JOptionPane.showMessageDialog(null, "d ist kleiner 0, Punkt liegt links der Geraden.");
			return true;
		}
		else if ( d > 0 )
		{
			//JOptionPane.showMessageDialog(null, "d ist groesser 0, Punkt liegt rechts der Geraden.");
			return false;
		}
		else if ( d == 0 )
		{
			//JOptionPane.showMessageDialog(null, "d ist 0, Punkt liegt auf der Geraden.");
			return false;
		}
		else {}
		
		return false;
	}
}
 

Jay1980

Bekanntes Mitglied
Okay ich kreise um mein Problem, vielleicht schaff ich es ja noch heute Nacht da mal richtig draufzuhauen :). Das mit den ListIteratoren ist geklärt, ich muss eben aufpassen dass lit.add() an der aktuellen Stelle des Iterators einfügt und nicht am Anfang. Naja, das laesst den Vorteil, dass man beim Iterator nicht mitzählen muss etwas dahinschwinden. Wir werden sehen.
 

Jay1980

Bekanntes Mitglied
Okay, dann führ ich meinen Monolog mal weiter.

Ich habe das Problem nun mehr oder weniger gelöst.

Dabei treibe ich den Iterator immer nach vorne, wenn ich sicher stellen will, dass er am Ende der Collection stehen soll, das klingt nicht sauber, aber so klappt es nun mittlerweile.

Java:
while( litcon.hasNext() )
{
    litcon.next();
}
litcon.add(neuerPunktGanzHinten);
 
Status
Nicht offen für weitere Antworten.
Ähnliche Java Themen
  Titel Forum Antworten Datum
F KI / Machine Learning Parameter verschachtelte for Schleifen Allgemeine Java-Themen 2
F KI / Machine Learning Parameter verschachtelte for Schleifen Allgemeine Java-Themen 1
T Verschachtelte For-Schleife gibt falschen Wert zurück, Abbruchbedingung evtl. falsch? Allgemeine Java-Themen 9
A verschachtelte for-Schleife in einen Stream umwandeln? Allgemeine Java-Themen 4
O Datentypen Erstellung eines Containers, der verschachtelte Map-Strukturen beherbergen kann Allgemeine Java-Themen 0
Z Datentypen Verschachtelte Generics Allgemeine Java-Themen 1
D Verschachtelte HashMap initializieren Allgemeine Java-Themen 1
G Verschachtelte Generics Allgemeine Java-Themen 2
R n verschachtelte Schleifen? Allgemeine Java-Themen 14
Loyd Noch ne Regex-Frage: Verschachtelte Ausdrücke Allgemeine Java-Themen 4
T Verschachtelte Schleifen abbrechen Allgemeine Java-Themen 3
G Verschachtelte Treemaps, nach Value sortieren Allgemeine Java-Themen 11
S Verschachtelte Schleifen Allgemeine Java-Themen 9
O Verschachtelte Iteration: Innere Iteration abbrechen Allgemeine Java-Themen 3
A Parallele Threads oder verschachtelte? Allgemeine Java-Themen 7
S verschachtelte for-Schleife Allgemeine Java-Themen 2
M Verschachtelte Schleifen (unbekannte Tiefe) Allgemeine Java-Themen 3
R Verschachtelte Arrays Allgemeine Java-Themen 2
E Probleme beim Zugriff auf verschachtelte Vektoren Allgemeine Java-Themen 16
F verschachtelte Methoden auflösen Allgemeine Java-Themen 2
O Text aus einer Textdatei rausholen, der zwischen zwei Schlüsselworten steht Allgemeine Java-Themen 4
D Zwei Listen vergleichen Allgemeine Java-Themen 7
Tobero Wie berechnet man ob zwei Linien sich schneiden? Allgemeine Java-Themen 2
kodela Zwei gleichzeitig gedrückte Steuertasten Allgemeine Java-Themen 10
X Bedingung zwei mal überprüfen Allgemeine Java-Themen 4
Zrebna Random Number - Generische Formel zwischen zwei INKLUSIVEN Werten Allgemeine Java-Themen 16
D Input/Output Zwischen zwei ID-Räumen unterscheiden und Objekt löschen Allgemeine Java-Themen 16
D OOP Gemeinsamen ID-Raum für zwei Klassen implementieren Allgemeine Java-Themen 7
S Wenn eine Klasse zwei Interfaces mit derselben Methodensignatur implementiert: welche wird aufgerufen? Allgemeine Java-Themen 15
S Kann man Variablen oder Felder definieren deren Typ zwei Interfaces ist..? Allgemeine Java-Themen 9
K Aus String zwei Jahreszahlen auslesen Allgemeine Java-Themen 18
M Wie kann man eine void Methode mit Variablen von zwei verschiedenen Objekten ausführen? Allgemeine Java-Themen 15
VfL_Freak Double mit zwei festen NK-Stellen ausgeben Allgemeine Java-Themen 9
Neoline Methoden Zwei Arrays abwechselnd zusammenführen Allgemeine Java-Themen 15
J Zwei Wavdateien gleichzeitig mit SourceDataLine abspielen Allgemeine Java-Themen 0
D Best Practice Die niedrigste Differenz zwischen zwei Listen ermitteln. Allgemeine Java-Themen 10
J Fahrroute zwischen zwei Punkten finden Allgemeine Java-Themen 1
J Kollision von zwei Kreisen Allgemeine Java-Themen 15
J Transfer von Integer zwischen zwei Clients - RMI Allgemeine Java-Themen 4
S Variablen split-Funkton mit zwei Variabeln verwenden? Allgemeine Java-Themen 4
T Alle Kombinationen aus zwei Arrays Allgemeine Java-Themen 8
G Liste zwischen zwei Kalenderdaten erstellen Allgemeine Java-Themen 3
AssELAss Zwei Arrays / ArrayLists inhaltlich vergleichen Allgemeine Java-Themen 2
H RegularExpression zwischen zwei Strings Allgemeine Java-Themen 2
P Zwei Applikationen mit einem Job Allgemeine Java-Themen 0
A Lineare Interpolation mit zwei Arrays Allgemeine Java-Themen 4
E Berechnung des Schnittpunktes von zwei Geraden Allgemeine Java-Themen 1
S Zwei String vergleichen, Fehler markieren Allgemeine Java-Themen 3
G Matrix reduzieren zwei Methoden Allgemeine Java-Themen 2
Dechasa Vergleichen von zwei Arrays Allgemeine Java-Themen 4
P Zwei ArrayLists: Ohne die eine überhaupt anzurühren, wird sie verändert Allgemeine Java-Themen 2
S Anwendung zum ausrechnen der Differenz von zwei Tagen Allgemeine Java-Themen 9
F Zwei LinkedHashMaps iterieren und vergleichen Allgemeine Java-Themen 2
M Zwei unterschiedliche JAR Dateien mit ANT erstellen Allgemeine Java-Themen 8
B Fehler beim Auslesen von Einstellungen. Zwei ähnliche Blöcke, nur eins geht. Allgemeine Java-Themen 5
L Zwei Files miteinander vergleichen und Grafisch darstellen Allgemeine Java-Themen 1
T Zwei Wortendungen vergleichen ohne .equals Allgemeine Java-Themen 10
F Webstart zwei Java Versionen / aktivieren bzw deaktivieren Allgemeine Java-Themen 2
S Zwei Comparable (compareTo) vergleichen Allgemeine Java-Themen 6
E zwei Gleitkommazahlen durcheinander dividieren Allgemeine Java-Themen 2
X Generic muss zwei Klassen/Interfaces erfüllen Allgemeine Java-Themen 5
turmaline OOP zwei gleiche Methoden mit kleinen Unterschieden Allgemeine Java-Themen 15
C Threads Zwei Threads greifen auf LinkedList zu. Allgemeine Java-Themen 12
T Wie heißt ein Binärbaum, dessen Knoten immer zwei Kinder haben müssen? Allgemeine Java-Themen 2
C ActionListener zwei Buttons zuweisen Allgemeine Java-Themen 11
M Eclipse drei slashs durch zwei ersetzen? Allgemeine Java-Themen 3
1 zwei Strings vergleichen Allgemeine Java-Themen 16
C Buchstaben, die in zwei Wörtern vorkommen Allgemeine Java-Themen 13
J Gleiche Packagestruktur in zwei *.jar Dateien Allgemeine Java-Themen 4
G Zwei bytes vergleichen Allgemeine Java-Themen 2
B zwei-dimensionale Collections bzw. Array mit Indizes Allgemeine Java-Themen 3
C Zwei Arrays vereinen Allgemeine Java-Themen 3
K Objekt-Austausch zwischen zwei Programmen über System-Clipboard Allgemeine Java-Themen 5
H Zwei verschiedene Dateien mittels einem Binärstream übertragen? Allgemeine Java-Themen 13
N hashCode() für zwei ints Allgemeine Java-Themen 5
turmaline Gleichheit von zwei Maps Map <String, Map <String, String>> Allgemeine Java-Themen 30
N Wie Listenabgleich auf zwei CPU Cores auslagern? Allgemeine Java-Themen 6
D Zufall wahr bzw. falsch mit zwei Faktoren Allgemeine Java-Themen 10
H Datenaustausch zwischen zwei Java-Programmen Allgemeine Java-Themen 5
H Ausgabe von zwei Textfeldern Allgemeine Java-Themen 3
H Zwei unabhängige Threads miteinander kommunizieren lassen Allgemeine Java-Themen 3
G zwei mal synchronized Allgemeine Java-Themen 5
Z zwei Daten vergleichen Allgemeine Java-Themen 4
C ArrayList anhand von zwei Attributen sortieren Allgemeine Java-Themen 4
S Alle Elemente von zwei Listen vergleichen Allgemeine Java-Themen 10
T IText: Zwei A4 PDF´s auf ein A3 PDF´s Allgemeine Java-Themen 2
A Differenz zwischen zwei Uhrzeiten Allgemeine Java-Themen 7
H Shortcut ruft zwei Menu-punkte auf Allgemeine Java-Themen 5
J Zwei konstruktoren? Allgemeine Java-Themen 8
A zwei listen vergleichen und unterschiede anzeigen Allgemeine Java-Themen 3
J Zwei sortierte Listen zusammenfassen Allgemeine Java-Themen 8
G Linked List zwischen zwei Threds übergeben Allgemeine Java-Themen 11
J zwei HashMaps vereinen Allgemeine Java-Themen 3
C Viele Informationen aus zwei Collections vergleichen Allgemeine Java-Themen 2
G Jfreechart zwei charts Allgemeine Java-Themen 2
S Zwei Anwendungen unter Tomcat Allgemeine Java-Themen 4
T Anzahl Tage zwischen zwei Daten - Stunde fehlt? Allgemeine Java-Themen 2
V Zwei ArrayList(s) vergleichen Allgemeine Java-Themen 6
T Überprüfen ob zwei Farben ähnlich sind Allgemeine Java-Themen 14
M zwei main-Methoden Allgemeine Java-Themen 7

Ähnliche Java Themen

Neue Themen


Oben