Java sammeln mit lambda-expression-Beispiel

War ich versucht zu konvertieren, das 

 String r = "";
 for ( Persona p : list ) {
    r += p.lastName;
 }

Zu stream().filter.collect() form, aber ich möchte wissen, wie man die collect mit ein lambda-Ausdruck (nicht-Methode Referenzen). Ich konnte Sie nicht finden, ein gutes Beispiel.

Dies ist, was ich haben

class B {
    public static void main( String ... args ) {
        List<Person> p = Arrays.asList(
                new Person("John", "Wilson"),
                new Person("Scott", "Anderson"),
                new Person("Bruce", "Kent"));

        String r;
        String s = p.stream()
            .filter( p -> p.lastName.equals("kent"))
            .collect((r, p) -> r += p.lastName);///?????
    }
}
class Person {
    String name;
    String lastName;
    public Person( String name, String lastName ) {
        this.name = name;
        this.lastName = lastName;
    }
}

Allen Beispielen, die ich finde sind mit der Methode Verweise, während ich denke es sollte eine einfache Möglichkeit zum schreiben eines lambda-Ausdrucks statt.

  • Haben Sie sah Collectors.joining() oder ist die Frage nach der Umsetzung es selbst?
  • stackoverflow.com/questions/31456898/...
  • Die Frage ist, wie die Verwendung eines lambda-Ausdrucks, so etwas wie: .collect( (acc, p ) -> acc += p.lastName);
  • Das ist nicht wirklich, wie es funktioniert. Müssen Sie zunächst die Zuordnung jeder person zu deren Nachname mit map(person -> person.lastName) und dann können Sie sammeln, werden diese Zeichenfolgen mit .collect(joining()).
  • Die Lektion, die Sie lernen sollen, ist, dass Sie 99% der Zeit sollten mit einem pre-build Sammler, und alle den rest der Zeit sollten Sie mit Collector.of oder mit collect(Supplier, BiConsumer, BiConsumer).
  • Gut, die Frage ist, genau zu erfahren, dass die 1%. Ich weiß, wie man es mit der Methode Verweise, aber ich habe Mühe mit lambdas Ausdrücken. Die Tatsache, dass ich mehr Kommentare als Antworten gibt an, dass dies schwer für alle anderen auch.

InformationsquelleAutor OscarRyz | 2016-04-06
  1. 4

    Vorausgesetzt, Sie wollen nicht zu verwenden ready-made-Sammler wie Collectors.joining() könnten Sie in der Tat erstellen Sie Ihre eigenen Sammler.

    Aber, wie in der javadoc-zeigt an, sammeln() erwartet, dass entweder 3 funktionale interface Instanzen als argument oder ein Sammler. So kann man nicht einfach einen einzigen lambda-Ausdruck, um zu sammeln().

    Vorausgesetzt, Sie verwenden möchten die erste version, unter 3 lambda-Ausdrücke, werden Sie bemerken, durch das Lesen der javadoc, dass das Ergebnis muss ein mutable object und String sind nicht veränderlich. Also sollten Sie stattdessen einen StringBuilder. Zum Beispiel:

    StringBuilder s = 
    p.stream()
     .filter( p -> p.lastName.equals("kent"))
     .map(p -> p.lastName)
     .collect(StringBuilder::new,
              StringBuilder::append,
              StringBuilder::append);

    Nutzt diese Methode Referenzen, aber alle Methoden-Referenzen kann geschrieben werden als lambda-Ausdrücke. Die oben ist äquivalent zu

    StringBuilder s = 
    p.stream()
     .filter( p -> p.lastName.equals("kent"))
     .map(p -> p.lastName)
     .collect(() -> new StringBuilder(),
              (stringBuilder, string) -> stringBuilder.append(string),
              (stringBuilder1, stringBuilder2) -> stringBuilder1.append(stringBuilder2));
    • Ja, das ist genau das, was ich suchte. Also der erste Ausdruck, der sagt, wie man erstellen Sie Objekte, die von den beiden anderen Ausdrücke, die zweite, wie Sie ansammeln, und die Dritte, wie zum kombinieren der angesammelten Ergebnis mit der nächsten kumulierte Ergebnis? An diesem Punkt würde nicht mehr Sinn machen, zu verwenden reduce statt?
    • Dies ist diskutiert, in der Länge, in der doc: docs.oracle.com/javase/8/docs/api/java/util/stream/.... Verwendung von reduce() würde erzwingen Sie die Erstellung einer viele String kopiert, so dass der Abbau viel langsamer als ein veränderliches Reduktion.
    • Beachten Sie, dass Collectors.joining() entspricht Collector.of(StringBuilder::new, StringBuilder::append, StringBuilder::append, StringBuilder::toString), die sich nur mit dem finisher-Funktion, die wiederum die StringBuilder in eine String.
    InformationsquelleAutor JB Nizet
  2. 2

    Können Sie auch die .reduce() Funktion, es ist einfacher zu Lesen als das sammeln.

        String s = p.stream()
        .filter( p -> p.lastName.equals("kent"))
        .reduce("", (acc, p) -> acc + p.lastName(), String::concat);

    Version mit StringBuilder:

        StringBuilder s = p.stream()
        .filter( p -> p.lastName.equals("kent"))
        .reduce(new StringBuilder(), (acc, p) -> acc.append(p.lastName()), StringBuilder::append);
    • Aber es ist viel, viel, viel langsamer. Wie sieht die Antwort auf die Frage, BTW?
    • Dieser Code wird nicht kompiliert. reduce erfordert eine BinaryOperator<T>, aber es gibt keine + Betreiber geltenden Persona.
    • richtig, aber "vorzeitige Optimierung ist die Wurzel allen übels" ich würde es vorziehen, die Lesbarkeit zu verbessern. Aber es kann gezwickt werden, um die StringBuilder/Buffer
    • Vorzeitige Optimierung ist, wenn man die Optimierung ohne zu wissen, ob Sie eine perf problem, und ohne zu wissen, ob der optimierte code ist effizienter als die nicht-optimierten ein. Das ist hier nicht der Fall. Anhängen an strings ist bekannt, sehr langsam zu sein, und das sammeln ist bekannt, dass viel schneller. Wenn Sie möchten, Lesbarkeit, verwenden Sie Collectors.joining(). Aber die Frage war etwa, wie Sie schreiben Ihre eigenen sammeln mithilfe von lambda-Ausdrücken.
    • mit einer Karte, die operation zum extrahieren des letzten Namen, die Sie erhalten würden, um das fehlen eines BinaryOperator. Zum Beispiel String s = Personen.stream() .Karte( p -> p.lastName ) .die Verringerung der((r, ln) -> r + ln) .orElse("");
    • Verwenden Sie nicht reduce mit einem Stringbuilder wie Sie es tun. Diese ist gebrochen. Sie müssen verstehen, den Unterschied zwischen Reduction und Veränderlich Reduktion.

    InformationsquelleAutor Jiri Kremser
  3. 1

    Vielleicht waren Sie Vorstellungsvermögen eine reduce Betrieb eher als ein sammeln, die Ihnen erlauben würde, die Verwendung eines lambda-Ausdrucks, wie Sie sich das vorgestellt haben. Zum Beispiel,

    String s = persons.stream()
        .map( (s1, str) -> s1.concat(str) )
        .reduce("", String::concat);

    Dies ist eine übung, natürlich. Die String-Verkettung ist ineffizient, so wäre es am besten zu verwenden collect(Collectors.joining()) verwendet StringBuffer wie sein Akku.

    • Was ist der Punkt, der mit StringBuil..Buffer wenn Sie es schaffen, auf jeder iteration?
    • Guter Punkt @nyxz, und ich danke Ihnen.
    InformationsquelleAutor Hank D
  4. 0

    Könnten Sie weglassen, das mapping mit dieser Lösung:

    Collector<Person, StringBuilder, String> collector = Collector.of(  
    StringBuilder::new,
    (buf, person) -> buf.append( person.lastName ),
    (buf1, buf2) -> {
      buf1.append( buf2 );
      return( buf1 );
    },
    buf -> buf.toString() 
  );

list.stream()
  .filter( p -> p.lastName.equals( "Kent" ) )
  .collect( collector );
    InformationsquelleAutor Kaplan
Schreibe einen Kommentar