java-8 - Streams, die Karte und count distinct

Mein Erster Versuch mit java-8-streams...

Ich ein Objekt, das Gebot, das entspricht einem Gebot von einem Benutzer für ein Objekt in einer Auktion. ich habe eine Liste von geboten, und ich möchte, um eine Karte, die zählt, wie viele (verschiedene) - Auktionen der user ein Gebot gemacht.

dies ist mein nehmen auf Sie:

bids.stream()
         .collect(
             Collectors.groupingBy(
                  bid ->  Bid::getBidderUserId, 
                  mapping(Bid::getAuctionId, Collectors.toSet())
             )
         ).entrySet().stream().collect(Collectors.toMap(
             e-> e.getKey(),e -> e.getValue().size())
        );

Funktioniert es, aber ich fühle mich, als würde ich Cheaten, weil ich stream der Eintrag legt die Karte, anstatt das zu tun, eine manipulation, die auf den ersten stream... muss ein richtiger Weg, dies zu tun, aber ich konnte nicht es herausfinden...

Dank

  • Können Sie Ihre Erklärung der Gebote für ein Objekt?
InformationsquelleAutor Zemer | 2015-05-17
  1. 22

    Können Sie durchführen groupingBy zweimal:

    Map<Integer, Map<Integer, Long>> map = bids.stream().collect(
        groupingBy(Bid::getBidderUserId,
                groupingBy(Bid::getAuctionId, counting())));

    Diese Art und Weise haben Sie, wie viele Angebote jeder Benutzer hat in jeder Auktion. Also die Größe der internen Karte ist die Anzahl der Auktionen der Benutzer teilgenommen hat. Wenn Sie nicht brauchen, die zusätzliche Informationen, können Sie dies tun:

    Map<Integer, Integer> map = bids.stream().collect(
        groupingBy(
                Bid::getBidderUserId,
                collectingAndThen(
                        groupingBy(Bid::getAuctionId, counting()),
                        Map::size)));

    Dies ist genau das, was Sie brauchen: Zuordnung von Nutzern zu Anzahl der Auktionen user teilgenommen.

    Update: es gibt auch ähnliche Lösung, die näher an deinem Beispiel:

    Map<Integer, Integer> map = bids.stream().collect(
        groupingBy(
                Bid::getBidderUserId,
                collectingAndThen(
                        mapping(Bid::getAuctionId, toSet()),
                        Set::size)));
    • Ja ich löschte meinen Kommentar, da ich es realisiert werden sollte, was Sie gerade Hinzugefügt haben. Ich war Entsendung, bevor denken.
    • Ausgezeichnet! das ist genau das, was ich suchte, die collectingAndThen Methode, die ich konnte nicht herausfinden, wie zu bedienen. Vielen Dank 🙂
    InformationsquelleAutor Tagir Valeev
  2. 0

    Tagir Valeev s Antwort ist die richtige (+1). Hier ist eine weitere, die genau das gleiche tut Sie mit Ihren eigenen downstream-Kollektor für die groupBy:

        Map<Integer, Long> map = bids.stream().collect(
               Collectors.groupingBy(Bid::getBidderUserId, 
                                     new Collector<Bid, Set<Integer>, Long>() {

        @Override
        public Supplier<Set<Integer>> supplier() {
            return HashSet::new;
        }

        @Override
        public BiConsumer<Set<Integer>, Bid> accumulator() {
            return (s, b) -> s.add(b.getAuctionId());
        }

        @Override
        public BinaryOperator<Set<Integer>> combiner() {
            return (s1, s2) -> {
                s1.addAll(s2);
                return s1;
            };
        }

        @Override
        public Function<Set<Integer>, Long> finisher() {
            return (s) -> Long.valueOf(s.size());
        }

        @Override
        public Set<java.util.stream.Collector.Characteristics> characteristics() {
            return Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.UNORDERED, Collector.Characteristics.IDENTITY_FINISH));
        }
    }));
    InformationsquelleAutor Ruben
Schreibe einen Kommentar