web-dev-qa-db-ja.com

オブジェクト値によるグループ化、最大オブジェクト属性によるグループキーのカウントと設定

Java 8 Streams APIを使用して、最初にオブジェクトRouteのリストをその値でグループ化し、次に各グループのオブジェクト数をカウントします。それはマッピングRoute->を返します。これがコードです。

Map<Route, Long> routesCounted = routes.stream()
                .collect(Collectors.groupingBy(gr -> gr, Collectors.counting()));

そしてRouteクラス：

public class Route implements Comparable<Route> {
    private long lastUpdated;
    private Cell startCell;
    private Cell endCell;
    private int dropOffSize;

    public Route(Cell startCell, Cell endCell, long lastUpdated) {
        this.startCell = startCell;
        this.endCell = endCell;
        this.lastUpdated = lastUpdated;
    }

    public long getLastUpdated() {
        return this.lastUpdated;
    }

    public void setLastUpdated(long lastUpdated) {
        this.lastUpdated = lastUpdated;
    }

    public Cell getStartCell() {
        return startCell;
    }

    public void setStartCell(Cell startCell) {
        this.startCell = startCell;
    }

    public Cell getEndCell() {
        return endCell;
    }

    public void setEndCell(Cell endCell) {
        this.endCell = endCell;
    }

    public int getDropOffSize() {
        return this.dropOffSize;
    }

    public void setDropOffSize(int dropOffSize) {
        this.dropOffSize = dropOffSize;
    }

    @Override
    /**
     * Compute hash code by using Apache Commons Lang HashCodeBuilder.
     */
    public int hashCode() {
        return new HashCodeBuilder(43, 59)
                .append(this.startCell)
                .append(this.endCell)
                .toHashCode();
    }

    @Override
    /**
     * Compute equals by using Apache Commons Lang EqualsBuilder.
     */
    public boolean equals(Object obj) {
        if (!(obj instanceof Route))
            return false;
        if (obj == this)
            return true;

        Route route = (Route) obj;
        return new EqualsBuilder()
                .append(this.startCell, route.startCell)
                .append(this.endCell, route.endCell)
                .isEquals();
    }

    @Override
    public int compareTo(Route route) {
        if (this.dropOffSize < route.dropOffSize)
            return -1;
        else if (this.dropOffSize > route.dropOffSize)
            return 1;
        else {
                // if contains drop off timestamps, order by last timestamp in drop off
                // the highest timestamp has preceding
            if (this.lastUpdated < route.lastUpdated)
                return -1;
            else if (this.lastUpdated > route.lastUpdated)
                return 1;
            else
                return 0;
        }
    }
}

さらに達成したいのは、各グループのキーが、lastUpdatedの値が最も大きいキーになることです。私はすでに このソリューション を見ていましたが、値によるカウントとグループ化およびルートの最大lastUpdated値を組み合わせる方法がわかりません。これが私が達成したいことのサンプルデータです：

例：

List<Route> routes = new ArrayList<>();
routes.add(new Route(new Cell(1, 2), new Cell(2, 1), 1200L));
routes.add(new Route(new Cell(3, 2), new Cell(2, 5), 1800L));
routes.add(new Route(new Cell(1, 2), new Cell(2, 1), 1700L));

次のように変換する必要があります：

Map<Route, Long> routesCounted = new HashMap<>();
routesCounted.put(new Route(new Cell(1, 2), new Cell(2, 1), 1700L), 2);
routesCounted.put(new Route(new Cell(3, 2), new Cell(2, 5), 1800L), 1);

2つのルートをカウントしたマッピングのキーは、lastUpdatedの値が最も大きいものであることに注意してください。

javajava-8groupingjava-stream
18
Jernej Jerin

これが1つのアプローチです。最初にグループ化してリストにしてから、リストを実際に必要な値に処理します。

import static Java.util.Comparator.comparingLong;
import static Java.util.stream.Collectors.groupingBy;
import static Java.util.stream.Collectors.toMap;


Map<Route,Integer> routeCounts = routes.stream()
        .collect(groupingBy(x -> x))
        .values().stream()
        .collect(toMap(
            lst -> lst.stream().max(comparingLong(Route::getLastUpdated)).get(),
            List::size
        ));
8
Misha

2つのコレクターを1つに結合する抽象的な「ライブラリー」メソッドを定義できます。

_static <T, A1, A2, R1, R2, R> Collector<T, ?, R> pairing(Collector<T, A1, R1> c1, 
        Collector<T, A2, R2> c2, BiFunction<R1, R2, R> finisher) {
    EnumSet<Characteristics> c = EnumSet.noneOf(Characteristics.class);
    c.addAll(c1.characteristics());
    c.retainAll(c2.characteristics());
    c.remove(Characteristics.IDENTITY_FINISH);
    return Collector.of(() -> new Object[] {c1.supplier().get(), c2.supplier().get()},
            (acc, v) -> {
                c1.accumulator().accept((A1)acc[0], v);
                c2.accumulator().accept((A2)acc[1], v);
            },
            (acc1, acc2) -> {
                acc1[0] = c1.combiner().apply((A1)acc1[0], (A1)acc2[0]);
                acc1[1] = c2.combiner().apply((A2)acc1[1], (A2)acc2[1]);
                return acc1;
            },
            acc -> {
                R1 r1 = c1.finisher().apply((A1)acc[0]);
                R2 r2 = c2.finisher().apply((A2)acc[1]);
                return finisher.apply(r1, r2);
            }, c.toArray(new Characteristics[c.size()]));
}
_

その後、実際の操作は次のようになります。

_Map<Route, Long> result = routes.stream()
        .collect(Collectors.groupingBy(Function.identity(),
            pairing(Collectors.maxBy(Comparator.comparingLong(Route::getLastUpdated)), 
                    Collectors.counting(), 
                    (route, count) -> new AbstractMap.SimpleEntry<>(route.get(), count))
            ))
        .values().stream().collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()));
_

更新：そのようなコレクターは、私の StreamEx ライブラリー： MoreCollectors.pairing() で使用できます。また、同様のコレクターが jOOL ライブラリーに実装されているため、pairingの代わりに_Tuple.collectors_を使用できます。

7
Tagir Valeev

原則として、これは1回のパスで実行できるはずです。通常のしわは、これにはアドホックなタプルまたはペア、この場合はRouteとカウントが必要であることです。 Javaにはこれらがないため、長さ2のオブジェクト配列（ Tagir Valeevの回答 に示すように）、またはAbstractMap.SimpleImmutableEntry、または仮説を使用しますPair<A,B>クラス。

もう1つの方法は、Routeとカウントを保持する小さな値クラスを記述することです。もちろん、これを行うには多少の苦痛がありますが、この場合、結合ロジックを配置する場所を提供するので、私はそれが報われると思います。これにより、ストリーム操作が簡素化されます。

次に、Routeとカウントを含む値クラスを示します。

class RouteCount {
    final Route route;
    final long count;

    private RouteCount(Route r, long c) {
        this.route = r;
        count = c;
    }

    public static RouteCount fromRoute(Route r) {
        return new RouteCount(r, 1L);
    }

    public static RouteCount combine(RouteCount rc1, RouteCount rc2) {
        Route recent;
        if (rc1.route.getLastUpdated() > rc2.route.getLastUpdated()) {
            recent = rc1.route;
        } else {
            recent = rc2.route;
        }
        return new RouteCount(recent, rc1.count + rc2.count);
    }
}

かなり単純ですが、combineメソッドに注目してください。最近更新されたRouteCountを選択し、カウントの合計を使用して、2つのRoute値を組み合わせます。これでこの値クラスができたので、必要な結果を得るためにワンパスストリームを書き込むことができます。

    Map<Route, RouteCount> counted = routes.stream()
        .collect(groupingBy(route -> route,
                    collectingAndThen(
                        mapping(RouteCount::fromRoute, reducing(RouteCount::combine)),
                        Optional::get)));

他の回答と同様に、これはルートを開始セルと終了セルに基づいて等価クラスにグループ化します。キーとして使用される実際のRouteインスタンスは重要ではありません。それはそのクラスの代表にすぎません。値は、最後に更新されたRouteCountインスタンスと、対応するRouteインスタンスの数を含む単一のRouteになります。

これが機能する方法は、同じ開始セルと終了セルを持つ各RouteインスタンスがgroupingByのダウンストリームコレクターに供給されることです。このmappingコレクターは、RouteインスタンスをRouteCountインスタンスにマップし、次に、それをreducingコレクターに渡します。コレクターは、上記の結合ロジックを使用してインスタンスを削減します。 collectingAndThenのand-then部分は、reducingコレクターが生成するOptional<RouteCount>から値を抽出します。

（通常、裸のgetは危険ですが、少なくとも1つの値が使用可能でない限り、このコレクターに到達することはありません。したがって、この場合はgetが安全です。）

2
Stuart Marks

イコールとハッシュコードが開始セルと終了セルのみに依存するように変更されました。

@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Cell cell = (Cell) o;

        if (a != cell.a) return false;
        if (b != cell.b) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = a;
        result = 31 * result + b;
        return result;
    }

私の解決策は次のようになります：

Map<Route, Long> routesCounted = routes.stream()
            .sorted((r1,r2)-> (int)(r2.lastUpdated - r1.lastUpdated))
            .collect(Collectors.groupingBy(gr -> gr, Collectors.counting()));

もちろん、intへのキャストは、より適切なものに置き換える必要があります。

2
Mati