Lambda Ausdrücke in einem Comparator

Guten Tag,
vorne weg ich werde mich morgen wieder mit den Lambdas beschäftigen sprich erst mal wieder die Theorie lernen denn ich verzweifel seit einiger Zeit an einer super Leichten Aufgabe am Lambda Ausdruck :-/

Also was ich versuche ist ein Tuple Object nach der Summe z. B. zu vergleichen. Die Tuple werden mit int, long, double oder float Werten gespeichert also Primitiv.

Hier mal das was ich gemacht habe das geht auch :)
Comparator als Anonyme-Klasse realisiert:

Java:
    public  void sortSum(TwoTuple[] a) {
        Arrays.sort(a, new Comparator<TwoTuple>() {
            @Override
            public int compare(TwoTuple o1, TwoTuple o2) {
                return new Double(o1.first+o1.second).compareTo(new Double(o2.first+o2.second));
            }
        });
Nun wollte ich die Lambda Ausdrücke Üben und stelle fest nichts klappt :(
Damit es funktioniert habe ich es so gemacht:

Code:
public void sortSum(TwoTuple[] a) {
Comparator<TwoTuple> c = (TwoTuple o1, TwoTuple o2) -> new Double(o1.first+o1.second).compareTo(new Double(o2.first+o2.second));
Arrays.sort(a,c);
Ich hab es nicht hin bekommen den Lambda-Ausdruck direkt bei Arrays.sort(a, ?) rein zu schreiben!
Wie muss der Aussehen?

Dann noch eine Frage wieso muss die Zeile so aussehen ohne return?
Comparator<TwoTuple> c = (TwoTuple o1, TwoTuple o2) -> new Double(o1.first+o1.second).compareTo(new Double(o2.first+o2.second));
mit return bekomme ich Fehler:
Comparator<TwoTuple> c = (TwoTuple o1, TwoTuple o2) -> return new Double(o1.first+o1.second).compareTo(new Double(o2.first+o2.second));

Danke schon mal für die Hilfe :)

LG
 
Anhand des Kontexts. Letztlich wird aus dem Lambdaausdruck eine Instanz einer generierten Klasse, die die generische Schnittstelle `java.util.Comparator` implementiert. Wenn du dir die sort() Methode in `java.util.Arrays` genau anschaust, sieht die so aus:
Java:
public static <T> void sort(T[] a, Comparator<? super T> c) { ... }
Das heißt, der Compiler sieht anhand des Typs `T` (was beim Aufruf ja `TwoTuple` ist), dass der Comparator ebenfalls höchstens `T`s vergleichen kann. Durch den Lower Bound mit "super" wird dann einfach das `T` also `TwoTuple` angenommen.
 
o_O oh man so einfach! Also sieht er anhand des Types T hier in dem Falle ja sortSum(TwoTuple[] a) => T[] a => T = TwoTuple welcher Typ o1 und o2 z. B. wären :)
Danke für die schnelle Hilfe und die nette Erklärung hätte ich gewusst das es so schnell geht hätte ich mir die letzte Stunde sparen können :D
Doch alleine kam ich einfach so nicht drauf naja ein Ansatz war ja immerhin schon mal da :p

Morgen kommt sicherlich mehr :p

LG
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben