Java 8 Lambda - Kreuzung von Zwei Listen

Ich bin auf der Suche intersection zwei Listen auf der Grundlage einer Bedingung und mache ein paar Schritte. Konnte nicht einen Weg finden, es zu tun (in der Lernphase) 🙂

Double totalAmount = 0.00d;
Double discount = 0.00d;


List<OrderLineEntry> orderLineEntryList = orderEntry.getOrderReleases().stream().flatMap(orderReleaseEntry ->
    orderReleaseEntry.getOrderLines().stream()).filter(orderLineEntry -> orderLineEntry.getStatus().equals("PP") 
        || orderLineEntry.getStatus().equals("PD")).collect(Collectors.toList());

for (OrderLineEntry orderLineEntry : orderLineEntryList) {
    for (SplitLineEntry splitLineEntry : splitReleaseEntry.getLineEntries()) {
        if (splitLineEntry.getOrderLineId().equals(orderLineEntry.getId()) && splitLineEntry.getStatusCode() !=
            "PX") {
            totalAmount += orderLineEntry.getFinalAmount();
            couponDiscount += orderLineEntry.getCouponDiscount() == null ? 0.00d : orderLineEntry.getCouponDiscount();
        }
    }
}

Als Sie sehen, die Logik ist einfach

Bekommen Alle Elemente, um basierend auf einige filter list und überschneiden sich mit anderen list und einige Sachen.

InformationsquelleAutor der Frage Reddy | 2015-07-28

  1. 85

    Die einfachste Methode ist diese:

    List<T> intersect = list1.stream()
                         .filter(list2::contains)
                         .collect(Collectors.toList());

    InformationsquelleAutor der Antwort Silas Reinagel

  2. 10

    Ich muss vergleichen Sie Sie auf übernehmen list1.id == liste2.fk_id

    Zunächst erstellen Sie einen Satz von der fk_id;

    Set<Integer> orderLineEntrSet = orderEntry.getOrderReleases().stream()
    .flatMap(orderReleaseEntry ->
orderReleaseEntry.getOrderLines().stream())
    .filter(orderLineEntry -> { 
            String s = orderLineEntry.getStatus(); 
            return "PP".equals(s) || "PD".equals(s); 
    })
    .map(e -> e.getId())
    .collect(Collectors.toSet());

double[] totalAmount = { 0.0 };
double[] couponDiscount = { 0.0 };
orderLineEntryList.stream()
    .flatMap(sre -> sre.getLineEntries().stream())
    .filter(ole -> orderLineEntrySet.contains(ole.getOrderLineId())
    .filter(ole -> !"PX".equals(ole.getStatusCode()))
    .forEach(ole -> {
            totalAmount[0] += ole.getFinalAmount();
            if (ole.getCouponDiscount() != null)
                couponDiscount[0] += ole.getCouponDiscount();
        });

    Können Sie verhindern, indem eine Referenz auf ein array-Objekt mit Funktion reduzieren. z.B. sehen, wie Sammler.averagingDouble umgesetzt wird. Aber ich finde das komplizierter.

    Hinweis: dies ist O(N) durch einen Satz von ids anstatt mit einer Liste der übereinstimmenden ids, die wäre O(N^2)

    InformationsquelleAutor der Antwort Peter Lawrey

  3. -5

    Liste intersect = "list1".stream().filter(set1::enthält).collect(Collectors.toList());

    Wird diese Arbeit, wo T ist String, Integer, Float etc, wo equals, hashcode, ist Recht unkompliziert. Aber wenn der T ist ein benutzerdefiniertes Objekt, das wir implementieren müssen, HashCode & gleich

    InformationsquelleAutor der Antwort psekar

Schreibe einen Kommentar