Maximal Strom mit benutzerdefinierten Komparator

Unten ist mein code, der speziell für die Verwendung benutzerdefinierter Comparator mit max in Java 8 Stream.

import java.math.BigDecimal;
import java.util.*;

public class BigDecimalMax  {

    public static BigDecimal getBigDecimalMax(List<forTest> list) {

        return list.stream()
            .filter(t -> t.id % 2 == 0)
            .max(forTestComparator::compare)  //<-- syntax error ----------
            .orElse(null);
    }

    public static class forTestComparator implements Comparator<forTest> {

        @Override
        public int compare(forTest val1, forTest val2) {
            return val1.value.compareTo(val2.value);
        }
    }

    public static void main(String[] args) {

        List<forTest> lst = new ArrayList<>();
        Random rn = new Random();
        BigDecimalMax bdm = new BigDecimalMax();

        for (int i=1; i<22; ++i) {
            lst.add(bdm.new forTest(i, BigDecimal.valueOf(rn.nextLong())));
        }

        System.out.println(getBigDecimalMax(lst));

    }

    class forTest {
        public int id;
        public BigDecimal value;

        forTest(int id, BigDecimal value) {
            this.id = id;
            this.value = value;
        }

        @Override
        public String toString() {
            return "forTest{" +
                    "id=" + id +
                    ", value=" + value +
                    '}';
        }
    }
}

Ich bin immer ein syntax-Fehler, die auf eine Methode verweisen, die ich nicht verstehe.

Error:(15, 18) java: incompatible types: invalid method reference
    cannot find symbol
      symbol:   method compare(BigDecimalMax.forTest, BigDecimalMax.forTest)
      location: class BigDecimalMax.forTestComparator

während IntelliJ IDEA beschwert, dass Non-static method cannot be referenced from a static context.

Was genau mache ich hier falsch?

ZUSÄTZLICHE ERKLÄRUNG (04/24/14):

Verstehe ich jetzt den Grund für den Syntaxfehler. Danke.
Wurde speziell Comparator eigentlich hier nötig?

Seit BigDecimal implementiert Comparable aber nicht nicht scheinen zu implementieren Comparator ( es hat CompareTo() aber keine Compare()) ich dachte, die benutzerdefinierte Comparator notwendig war. Deshalb konnte ich nicht einfach Comparator.comparing(ft -> ft.value). Ist es ein Fehler in meiner Logik?

Eine benutzerdefinierte Komparator ist nicht hier erforderlich. Erstens ist dies eine unübersichtliche API-da sind die Namen alle so ähnlich sind. Anfahren, Sie sind richtig, dass BigDecimal implementiert Vergleichbar, aber Stream.max() will einen Komparator. Die one-arg überlastung der Komparator.Vergleich() tut dies. Auch die ForTest-Klasse (original version) gar nicht implementieren. Sie müssen also die Lieferung eines lambda - ft -> ft.value zu extrahieren BigDecimal (das ist Vergleichbar) aus der ForTest, und dann passieren diese lambda-arg-Komparator.Vergleich() zum erstellen eines Komparators angesichts der Vergleichbaren Instanzen.
Ich Las eigentlich comparing Beschreibung mehrmals, aber nur nach der Lektüre Ihre Antwort (auch mehrmals), habe ich realisiert, was es bedeutete. Also comparaing dient als Brücke zwischen Comparator und Comparable, richtig?
Ja, das ist ein guter Weg, es zu beschreiben. Leider sind die Dokumentation und die Generika in der Signatur sind Recht kompliziert, so dass es sehr schwer ist, zu lernen, die Nutzung nur durch das Lesen der Dokumentation. Dann sehen Sie ein Beispiel und gehen Sie "aha!" Ich hoffe.

InformationsquelleAutor PM 77-1 | 2014-04-24

12

Sotirios Delimanolis' Antwort zeigt, wie die Probleme zu beheben, aber ich habe ein paar Dinge hinzufügen.

Wenn Sie bereits eine Klasse, die implementiert Comparator, Sie brauchen nicht zu verwenden, eine Methode, Verweis auf seine compare () - Methode. Sie können nur übergeben Sie eine Instanz direkt, da max() übernimmt eine Referenz auf ein Komparator:
```
    .max(new forTestComparator())
```
oder
```
    forTestComparator instance = new forTestComparator();
    ...
    .max(instance)
```
Jedoch die combinator-Funktionen auf Komparator in der Regel machen es unnötig, eine Klasse, die implementiert Comparator. Zum Beispiel, Sie können loszuwerden, die forTestComparator Klasse vollständig und genau dies tun:
```
    .max(Comparator.comparing(ft -> ft.value))
```
oder wenn forTest waren die offensichtlichen getValue () - Methode, könnte man umschreiben, dass der stream max () - Aufruf wie folgt:
```
    .max(Comparator.comparing(forTest::getValue))
```
Darüber hinaus, wenn Sie wollte forTest Umsetzung der Comparable - Schnittstelle, Sie könnten dies tun:
```
public class forTest implements Comparable<forTest> {
    @Override
    public int compareTo(forTest other) {
        return this.value.compareTo(other.value);
    }
    ...
}
```
und die Art der Verwendung von max() Vergleichbar ist:
```
    .max(Comparator.naturalOrder())
```
Zwei Stil-Hinweise:
1. Ich dringend davon abgeraten, mit orElse(null) auf Instanzen von Optional. Dies ist zulässig, wenn es seinen Hauptzweck, um die Nachrüstung Nutzung der neuen Java-8-APIs in code, der erwartet von null, um anzuzeigen, die Abwesenheit eines Werts. Vermeiden orElse(null) wenn Sie möglicherweise können, da dies zwingt den Anrufer auf null prüfen. Stattdessen ersetzen Sie einen tatsächlichen Wert ersetzen eines fehlenden Wertes, oder zur Rückgabe der Optional sich der Anrufer, so der Anrufer kann gelten, was die Politik es will.
2. Empfehle ich das festhalten an der etablierten Java-Namenskonventionen groß geschrieben, groß-und Kleinbuchstaben-Klassennamen. Die Namen der Klassen forTest und forTestComparator diesen code irgendwie schwierig, mit zu arbeiten, da Sie nicht Aussehen wie Klassennamen.
Danke. Sprach ich mit einem Ihrer Vorschläge, indem meine Argumentation zu dem original-Beitrag. Könnten Sie bitte schauen?

InformationsquelleAutor Stuart Marks
6

forTestComparator#compare ist eine Instanz-Methode. Sie benötigen eine Instanz Methode Referenz, im Gegensatz zu einem static Methode Referenz, die Sie haben.

Etwas wie
```
new forTestComparator()::compare
```
oder der lange Weg (Ihre Klasse nicht Instanz Staat, so dass Sie nicht wirklich über die Referenz)
```
forTestComparator instance = new forTestComparator(); //fix for Java conventions
return list.stream()
        .filter(t -> t.id % 2 == 0)
        .max(instance::compare)  //<-- syntax error ----------
        .orElse(null);
```
Finden Sie in der Java-tutorial auf Methode verweisen hier.

Verweis auf eine Instanz-Methode von einem bestimmten Objekt -> ContainingObject::instanceMethodName

Seite beachten, dies
```
return list.stream()
            .filter(t -> t.id % 2 == 0)
            .max(new forTestComparator()::compare)  
            .orElse(null);
```
löst in einem forTest Wert. Sie müssen ändern Sie den Rückgabetyp der Methode.

+1 für die Festsetzung der Probleme, und siehe meine Antwort für zusätzliche Punkte.
Ein besonderer Dank für die Anmerkung. Ich habe nicht realisiert seine Bedeutung auf den ersten.

InformationsquelleAutor Sotirios Delimanolis

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.