Warum Komparator.der Vergleich funktioniert nicht mit String::toLowerCase Methode Referenz?

Ich versuche ein array Sortieren von Zeichenfolgen, indem umgekehrter Reihenfolge (ignoring case), ohne es zu ändern, und nur drucken. Also ich bin mit Java8-stream. Aber ich kann nicht es tun, zu verwalten.

Hier ist mein Versuch :

package experimentations.chapter02;

import java.util.Arrays;
import java.util.Comparator;
import java.util.stream.Collectors;

public class StringStream {

    public static void main(String[] args) {
        sortStrings();
    }

    public static void sortStrings(){
        String[] stringsArray = "The quick brown fox has a dirty ladder".split("\\s+");
        System.out.println(
                Arrays.stream(stringsArray)
                .sorted(Comparator.comparing(String::toLowerCase).reversed())
                .collect(Collectors.toList())
        );
    }

}

Hier das problem, dass String::toLowerCase wird nicht akzeptiert in der statischen Methode Comparator.comparing.

Mittlerweile habe ich es geschafft zu Sortieren das array, aber ändern:

public static void sortStrings(){
        String[] stringsArray = "The quick brown fox has a dirty ladder".split("\\s+");
        System.out.println(
                Arrays.stream(stringsArray)
                .map(String::toLowerCase)
                .sorted(Comparator.reverseOrder())
                .collect(Collectors.toList())
        );
}

Also, was ist die einfachste Lösung?

Ich fand die Lösung : .sortiert((String e) -> e -.toLowerCase) . Inzwischen habe ich gebeten, eine Löschung der post, wie es scheint so offensichtlich für mich wissen, ich könnte es gefunden haben, ohne dass die Frage gestellt ...
Der erste code-snippet kompiliert einwandfrei. Sind Sie auf einem alten build von Java 8? Oder vielleicht kompilieren in eclipse? Das problem, das Sie erwähnen, wurde behoben in build 129. Siehe auch stackoverflow.com/q/21751830/829571

InformationsquelleAutor loloof64 | 2014-04-08

24

Das problem ist, dass Java können keine Rückschlüsse auf die generischen Typen, die für einige komplexe Ausdrücke. Die erste Anweisung arbeitet, während die zweite Anweisung führt zu einem compile-Zeit-Fehler:
```
Comparator<String> comparator = Comparator.comparing(String::toLowerCase);
Comparator<String> comparator = Comparator.comparing(String::toLowerCase).reversed();
```
Es gibt mehrere Möglichkeiten, das problem zu lösen. Hier sind drei von Ihnen:

Speichern der Mittelstufe Komparator in eine variable:
```
Comparator<String> comparator = Comparator.comparing(String::toLowerCase);
System.out.println(
            Arrays.stream(stringsArray)
            .sorted(comparator.reversed())
            .collect(Collectors.toList()));
```
Verwenden String.CASE_INSENSITIVE_ORDER:
```
System.out.println(
            Arrays.stream(stringsArray)
            .sorted(String.CASE_INSENSITIVE_ORDER.reversed())
            .collect(Collectors.toList()));
```
Hinzufügen explizite Typ-Parameter:
```
System.out.println(
            Arrays.stream(stringsArray)
            .sorted(Comparator.<String,String>comparing(String::toLowerCase).reversed())
            .collect(Collectors.toList()));
```
Das erste code-snippet gepostet von der OP kompiliert einwandfrei.
Über das code-snippet redest du? Das erste code-snippet gepostet von der OP nicht kompilieren hier.
Arrays.stream(stringsArray).sorted(Comparator.comparing(String::toLowerCase).reversed()).collect(Collectors.toList()) kompiliert mit javac/netbeans auf b132.
Nun, es wird nicht kompilieren mit dem Java-Compiler, das ist ein Teil der neuesten Version von Oracle JDK8.
Ich bin nicht sicher, warum es ist eine Zusammenstellung Fehler überhaupt. Die Regeln bezüglich der Methode Verweise sind ziemlich Komplex. Daher habe ich eine neue Frage: stackoverflow.com/questions/22945870/...

InformationsquelleAutor nosid
5

Fand ich die Lösung :
```
 .sorted((String e) -> e.toLowerCase) 
```
Ich denke, das problem mit der syntax
```
 .sorted(String::toLowerCase)
```
ist, dass der compiler erwartet ein Objekt übergeben, um die Instanz-Methode toLowerCase von String. So brauche ich, um meine eigene lambda-Methode, ohne dabei den Typ des lambda-Parameters (String), sonst wird der compiler immer noch nicht lösen können.

IntelliJ sagt mir, dass das, was Sie versucht zunächst eine zyklische Ableitung, was verboten ist. Nun, ich versuche zu verstehen, was ist eine zyklische Inferenz 🙂
Als telled mich assylias, es scheint, dass einige IDE hat noch keine echte Unterstützung für Java8-features. Auch habe ich versucht einen ähnlichen code in Netbeans, ohne jedes problem.

InformationsquelleAutor loloof64

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.