Lampda funktion ?

[kantaki]

Hallo,

ich bin ein umsteiger von c++ auf java und habe eine frage.

in c++ kann man einen vector mit einer eigenen funktion sortieren. zb

				 partial_sort(tenwps.begin(),tenwps.end(),tenwps.end(),
                     [&](const data& p1,const data& p2)
                     {
                       return p1.dist_p2(startPoint)<p2.dist_p2(startPoint);
                     });

wobei in tenwps 10 wegpunkte gepspeichert sind und die funktion dist_p2 mir die distanz von p1 zu 2 errechnet. nun kann ich die waypoints so sortieren das der nächstliegende wegpunkt auf tenwps[0] liegt und der am weitest entfernte wegpunkt auf tenwp[9] liegt.

wie wäre das equivalent zu diesem code in java ?

welchen container sollte ich nehmen? arraylist?

vielleicht könntet ihr mir auch einen beispiel code geben.

ich hoffe ihr könnt mir helfen danke =).

 

[Marco13]

Ein direktes analogon zu "partial_sort" gibt es nicht. Das eigentliche Sortieren mit einer eigenen Vergleichsfunktion würde am einfachsten mit einer (Array)List und einem eigenen Comparator gehen (siehe auch http://www.java-forum.org/allgemeines/39510-arrays-listen-sortieren.html ).

WENN es aber viele Elemente sind, und man nur "wenige" größte Elemente braucht, wäre das natürlich Zeitverschwendung, und man sollte sich ggf. eine eigene partialSort-Methode basteln.

EDIT: Aber... es scheint als würdest du auch ALLE sortieren, und bräuchtest demnach eigentlich gar nicht partial_sort, sondern sort ?! ???:L

 

[SlaterB]

Galileo Computing :: Java ist auch eine Insel – 9 Besondere Klassen der Java SE

das allgemeine Konzept ist schlicht das Interface

 

[kantaki]

danke schonmal für die links.
ich bin leider noch anfänger, aber mal schauen ob ich mir nen sortier algo. selber schreiben kann.

 

[andiv]

				 partial_sort(tenwps.begin(),tenwps.end(),tenwps.end(),
                     [&](const data& p1,const data& p2)
                     {
                       return p1.dist_p2(startPoint)<p2.dist_p2(startPoint);
                     });

				 List<Data> tenwps = new ArrayList<Data>();
				 // Liste füllen...
				 Collections.sort(tenwps, new Comparator<Data>() {
				     @Override
				     public int compare(final Data p1, final Data p2) {
				         return p1.dist_p2(startPoint) - p2.dist_p2(startPoint);
				     }
				 };

 

[kantaki]

kannst du mit den code mal in ein beispiel schreiben ? ich sitze jetzt seit mehreren stunden dran und bekomme ihn nicht kompiliert.

 

[SlaterB]

sind das nicht 7 korrekte Beispiel-Codezeilen?
die Data-Objekte mit der Distanz-Berechnung solltest du nun wirklich selber bauen,
das hat doch mit der Sortierungsfrage nicht mehr direkt zu tun, das ist Vorarbeit 😉

dann ist wegen 'partial' noch die Frage, evtl. nur ein paar Elemente der Ausgangslise in eine neue zu kopieren, diese zu sortieren und wieder zurück,
ist das deine Frage? eigentlich auch leicht,

also es gibt verschiedene Teilbereiche, wonach richtet sich deine Frage, was hast du alles schon fertig?
nur 'macht ihr mal' ist nicht der richtige Ansatz 😉

poste doch was bei dir nicht kompiliert + Fehler dazu

 

[kantaki]

Also mit der Vorarbeit bin ich fertig und es funktioniert auch "noch" alles wie es soll, obwohl ich auch noch nicht weiß ob ich einen stack over flow irgentwann bekomme.

undzwar

 List<Data> tenwps = new ArrayList<Data>();
                 // Liste füllen...
                 Collections.sort(tenwps, new Comparator<Data>() {
                     @Override
                     public int compare(final Data p1, final Data p2) {
                         return p1.dist_p2(startPoint) - p2.dist_p2(startPoint);
                     }
                 };

anstatt

List<Data> tenwps = new ArrayList<Data>();

benutze ich meine test.wpArray ( Test.class)
nebenbei ist es keine list sondern eine ArrayList, aus irgenteinem Grund durfte ich das gestern nicht machen.

public int

das ersetze ich durch public double

return p1.dist_p2(startPoint) - p2.dist_p2(startPoint);

da ist ein kleiner fehler drin, müsste eigentlich return p1.dist_p2(startPoint) < p2.dist_p2(startPoint);

aber er nimmt den code nicht an er sagt zum beispiel das der returnwert int sein muss, wenn ich es auf int stelle soll er boolean sein und so weiter. ( ich nutze eclipse)

irgentwas habe ich extrem falsch gemacht. ich starte gerade mal meinen laptop damit ich mehr über die fehler sagen kann
EDIT: so habe ihn implementiert

Collections.sort(test.wpArray, new Comparator<Data>() {
             @Override
             public double compare(final Data p1, final Data p2) {
                 return p1.dist_p2(startPoint) < p2.dist_p2(startPoint);
             }
         });

er unterstreicht mir double soll zu int werden und das return will einen booleanwert weil er ja vergleicht. hmm

// TEXT DATEI
//x y z
1,2,3
4,5,6
7,8,9

class Data {

	public double X;
	public double Y;
	public double Z;

	public double dist_p2(Data p2) {
		double xd = Math.abs(X - p2.X);
		double yd = Math.abs(Y - p2.Y);
		double zd = Math.abs(Z - p2.Z);
		return xd * xd + yd * yd + zd * zd;
	}

}

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Scanner;

class Read {

	public ArrayList<Data> wpArray = new ArrayList<Data>();

	public void input() throws FileNotFoundException {
		File inputFile = new File("C:\\Users\\kanta\\Desktop\\hallo.txt");
		Scanner scanner = new Scanner(inputFile);
		Data o;

		while (scanner.hasNextLine()) {
			o = new Data();
			String row = scanner.nextLine();

			String[] splitter = row.split(",");

			o.X = Double.parseDouble(splitter[0]);
			o.Y = Double.parseDouble(splitter[1]);
			o.Z = Double.parseDouble(splitter[2]);
			wpArray.add(o);
		}
	}
}

import java.io.FileNotFoundException;
import java.util.Collections;
import java.util.Comparator;

class Test {

	/**
	 * @param args
	 * @throws FileNotFoundException
	 */
	public static void main(String[] args) throws FileNotFoundException {
		Read test = new Read();
		test.input();
		Data startPoint = new Data();
		startPoint.X = 5;
		startPoint.Y = 5;
		startPoint.Z = 5;
		// HIER SOLL SORTIERT WERDEN

	}
}

 

[SlaterB]

na das sind doch viel mehr Informationen zu denen man auch viel mehr sagen kann,

das Interface von Comparator ist fest vorgegeben, man muss sich schon für einen konkreten Typ entscheiden,
weder kann man in Java int, double oder boolean zurückgeben, welche alles als boolean interpretiert werden (0 oder nicht 0)
noch gibt es mehrere Comparator zur Wahl, nur einen mit int,
Collections.sort() funktioniert nur exakt so, daran ist nichts zu rütteln,

nur mit boolean hättest du eh zu wenig Möglichkeiten, du musst ja normalerweise drei Zustände beschreiben, kleiner, gleich oder größer
(ich will eigentlich gar nicht so viel aus dem Lehrbuch wiederholen 😉 )

also int steht fest, der noch fehlende Gedanke ist, deine interne Berechnung umzustellen,
du kannst ja gerne erstmal double oder boolean ausrechnen, dass dann aber umwandeln,
z.B.

boolean kleiner = ..;
if (kleiner) return -1;
return 1;

schon hast du ints als Rückgabe, ob -1 und 1 oder andersrum durch Testen prüfen, vergesse ich immer

 

[kantaki]

okay danke ich werde es heute nachmittag mal testen !

Edit
habe es gerade einfach trotzdemal geschrieben und es scheint zu funktionieren ! =)

Collections.sort(test.wpArray, new Comparator<Data>() {
			@Override
			public int compare(final Data p1, final Data p2) {
				return (p1.dist_p2(startPoint) < p2.dist_p2(startPoint)) ? -1
						: 1;
			}
		});

okay bekomme bei bestimmten werten einen error

Exception in thread "main" java.lang.IllegalArgumentException: Comparison method violates its general contract!
	at java.util.TimSort.mergeLo(Unknown Source)
	at java.util.TimSort.mergeAt(Unknown Source)
	at java.util.TimSort.mergeCollapse(Unknown Source)
	at java.util.TimSort.sort(Unknown Source)
	at java.util.TimSort.sort(Unknown Source)
	at java.util.Arrays.sort(Unknown Source)
	at java.util.Collections.sort(Unknown Source)
	at Test.main(Test.java:20)

 

[Marco13]

Bei Comparator (Java Platform SE 6) stehen die Bedinungen für die compare-Methode dabei. Z.B. muss es consistent with equals sein: Bei dir werden NIE irgendzwei Elemente als "gleich" angesehen (auch wenn sie es sind!)

 

[kantaki]

Bei Comparator (Java Platform SE 6) stehen die Bedinungen für die compare-Methode dabei. Z.B. muss es consistent with equals sein: Bei dir werden NIE irgendzwei Elemente als "gleich" angesehen (auch wenn sie es sind!)

stimmt, daran habe ich heute morgen noch garnicht gedacht.

super vielen dank euch allen <3