Foreach Schleifen in Streams umändern

[Monokuma]

Hallo! Ich hab ein Problem bei meinem Versuch eine Foreach Schleife in einen Stream umzuwandeln.

for (PickOrder pickOrder : pickOrders) {
            for (PickOrderLine pickOrderLine : pickOrder.getPickOrderLines()) {
                if (pickOrderLine.getQuantity() > quantityOnHand.get(pickOrderLine.getProductCode())) {
                    return productCollection.findByCode(pickOrderLine.getProductCode());
                }
            }
       }

Das ist die foreach Schleife und ich hab schon einen Versuch getätigt, aber der funktioniert nicht.

pickOrders.stream()
                .flatMap(pickOrder -> pickOrder.getPickOrderLines().stream())
                .filter(pickOrderLine -> pickOrderLine.getQuantity() > quantityOnHand.get(pickOrderLine.getProductCode()))
                .collect(Collectors.toList()).stream().findFirst();

Ich würde mich sehr über Hilfe freuen. Ich hab noch andere foreach Schleifen, bei denen ich auch die Hilfe brauche, aber eins nach dem anderen.

 

[httpdigest]

Was genau geht denn daran nicht? Sieht richtig aus. Nur, dass du halt aus dem gesamten Ausdruck ein Optional bekommst. Aber da kannst du ja mit .orElse(<wasDuZurückGibstWennKeinWertGefundenWird>) auch einfach das zurückgeben, was deine Methode nach der Schleife zurückgegeben hätte.
Und, du brauchst auch eigentlich kein collect:

return pickOrders
      .stream()
      .flatMap(po -> po.getPickOrderLines().stream())
      .filter(pol -> pol.getQuantity() > quantityOnHand.get(pol.getProductCode()))
      .findFirst()
      .orElse(null);

 

[Monokuma]

Moment. Ich glaube ich hab was vergessen zu erwähnen. Also meine ganze Methode soll dann ein Product Objekt zurückgeben

private Product getNextProduct() {
        return pickOrders
                .stream()
                .flatMap(n -> n.getPickOrderLines().stream())
                .filter(p -> p.getQuantity() > quantityOnHand.get(p.getProductCode()))
                .findFirst()
                .orElse(null);

        return null;
    }

Der Stream returned ein PickOrderLine Objekt so weit

 

[httpdigest]

Ach natürlich, sorry. Den fehlenden findByCode() Aufruf in deiner Stream-Lösung hatte ich überlesen. So geht's:

return pickOrders
      .stream()
      .flatMap(po -> po.getPickOrderLines().stream())
      .filter(pol -> pol.getQuantity() > quantityOnHand.get(pol.getProductCode()))
      .map(pol -> productCollection.findByCode(pol.getProductCode()))
      .findFirst()
      .orElse(null);

EDIT: Oder so (mit Optional.map()):

return pickOrders
      .stream()
      .flatMap(po -> po.getPickOrderLines().stream())
      .filter(pol -> pol.getQuantity() > quantityOnHand.get(pol.getProductCode()))
      .findFirst()
      .map(pol -> productCollection.findByCode(pol.getProductCode()))
      .orElse(null);

 

[Monokuma]

Perfekt danke sehr! Ich werde mich wiederum hier melden, falls ich Hilfe bei den anderen foreach Schleifen brauche

 

[Monokuma]

Map<String, Integer> removedProducts = new LinkedHashMap<>(); 
for (PickOrder pickedOrder : pickedOrders) {
                for (PickOrderLine pickedOrderLines : pickedOrder.getPickOrderLines()) {
                    if (!removedProducts.containsKey(pickedOrderLines.getProductCode())) {
                        removedProducts.put(pickedOrderLines.getProductCode(), pickedOrderLines.getQuantity());
                    } else {
                        removedProducts.replace(pickedOrderLines.getProductCode(),
                                removedProducts.get(pickedOrderLines.getProductCode()) +
                                        pickedOrderLines.getQuantity());
                    }
                }
}

Ich habe jetzt diese foreach Schleife, die ich in einen Stream umwandeln will. Ich habe noch keine richtige Lösung dafür. Kann ich ein paar Tipps haben?

 

[LimDul]

Aus dem Bauch heraus würde ich die eher so lassen - alternativ eine Variante wie folgt:

pickedorder.stream().flatMap(p->p.getPickOrderLines().stream().foreach(l->verarbeite(l, removedProducts));

Sprich den if/else Teil in eine eigene Methode auszulagern und dann aufzurufen. Direkt in einem Stream geht mit Sicherheit auch, aber wird haarig und schwer lesbar. Streams sind toll wenn jedes Element gleich behandelt wird - und das ist hier nicht mehr der Fall.

 

[httpdigest]

Das ist sehr einfach mit einem toMap Collector umzusetzen. Die Essenz dessen, was du tust, ist ja eine Map zu bauen, bei der der Schlüssel der ProductCode ist und der Value die Quantity und bei mehreren gleichen Keys soll die Quantity summiert werden:

Map<String, Integer> removedProducts =
     pickedOrders
    .stream()
    .flatMap(po -> po.getPickOrderLines().stream())
    .collect(Collectors.toMap(
        pol -> pol.getProductCode(),
        pol -> pol.getQuantity(),
        (q1, q2) -> q1 + q2));

 

[Monokuma]

Das ist sehr einfach mit einem toMap Collector umzusetzen. Die Essenz dessen, was du tust, ist ja eine Map zu bauen, bei der der Schlüssel der ProductCode ist und der Value die Quantity und bei mehreren gleichen Keys soll die Quantity summiert werden:

Map<String, Integer> removedProducts =
     pickedOrders
    .stream()
    .flatMap(po -> po.getPickOrderLines().stream())
    .collect(Collectors.toMap(
        pol -> pol.getProductCode(),
        pol -> pol.getQuantity(),
        (q1, q2) -> q1 + q2));

Also ist das quasi schon die Lösung oder wie soll ich das verstehen?

 

[httpdigest]

Also ist das quasi schon die Lösung oder wie soll ich das verstehen?

Ja. Hast du es denn mal ausprobiert? Wieso stellen Leute immer wieder Fragen, deren Antwort sie mit nur 2 Sekunde Aufwand selbst herausfinden könnten...

 

[Monokuma]

Ja. Hast du es denn mal ausprobiert? Wieso stellen Leute immer wieder Fragen, deren Antwort sie mit nur 2 Sekunde Aufwand selbst herausfinden könnten...

Ich hab die erste Antwort von dir genommen gehabt. Tut mir leid

 

[httpdigest]

Ich hab die erste Antwort von dir genommen gehabt. Tut mir leid

Schon okay. Nicht böse/persönlich gemeint.
Aber dennoch verstehe ich die Aussage nicht: Du hast meine Antwort mit dem Code gequotet und dann gefragt, ob das schon die Lösung sei.
Ja ist sie.
Und als ich dich gefragt hatte, ob du es denn überhaupt schon ausprobiert hast, hast du gesagt, dass du die erste (welche erste?) Antwort (also nicht das, was du von mir gequotet hast?) genommen hast? Verwirrung.

 

[Monokuma]

Deine Antwort war vorhin eine andere. Da hat es bei mir ein Int zurückgegeben und es war komplett rot. Deswegen habe ich gefragt, weil es bei mir nicht ging.

 

[httpdigest]

Deine Antwort war vorhin eine andere. Da hat es bei mir ein Int zurückgegeben und es war komplett rot. Deswegen habe ich gefragt, weil es bei mir nicht ging.

Ah, verstehe. Ja, ich nutze die 5 Minuten Zeitspanne gerne noch etwas aus, bis zu der man den Post ohne einen "wurde editiert" Hinweis bearbeiten kann. Vorher war der Code noch einfach ein "return" Statement, der die Map direkt zurückgegeben hat, weil ich das so gerade in einer IDE ausprobiert hatte. Dann hatte ich gemerkt, dass du es ja einfach einer lokalen Variablen zuweist und das noch geändert.

 

[Monokuma]

Welche IDE benutzt du denn, wenn ich fragen darf?

 

[Monokuma]

for (PickOrder pickOrder : pickOrders) {
                for (String productCode : removedProducts.keySet()) {
                    if (pickOrder.containsProduct(productCode)) {
                        pickOrder.calcReplenishmentsNeeded(quantityOnHand);
                        if (error) {
                            System.out.println("Recalculating: " + pickOrder);
                        }
                        break;
                    }
                }
}

Wie bearbeite ich die foreach Umwandlung, wenn ein break drinnen ist? Oder kann ich es einfach ignorieren?

 

[httpdigest]

Das ist ein Beispiel für einen für Streams ungeeigneten Anwendungsfall. Du willst ja einfach nur etwas mit einem Element "tun" und nicht Streamelemente in etwas "anderes" konvertieren. Das würde ich so lassen. Streams sollen ja nach Möglichkeit eine funktionale Form haben, ohne Seiteneffekte. Etwas anderes wäre es, wenn calcReplenishmentsNeeded() z.B. auf einem immutable PickOrder arbeiten würde und als Ergebnis ein neues/transformierets PickOrder erzeugen würde.

 

[Monokuma]

Ich muss diese for each Schleife aber loswerden

 

[Monokuma]

for (Map.Entry<String, Integer> entry : removedProducts.entrySet()) {
                if (error) {
                    System.out.println("Remove " + entry.getValue() + " pieces of " + entry.getKey());
                }
                quantityOnHand.replace(entry.getKey(), quantityOnHand.get(entry.getKey()) - entry.getValue());
}

Dann hätte ich nur noch das und das wars dann mit foreach Umwandlung

 

[LimDul]

Ich muss diese for each Schleife aber loswerden

Warum?

 

[Monokuma]

Warum?

Anweisung vom Lehrer. Keine Schleifen

 

[httpdigest]

Könnte vielleicht das Wort "Rekursion" oder "rekursiv" im Unterricht gefallen sein? Also, statt Schleifen in Streams zu "verstecken", solltest du das vielleicht rekursiv lösen?

 

[Monokuma]

Das Wort ist gefallen, aber das ist schon länger her. Aber wenn es eine rekursive Lösung gibt, dann würde ich es sehr gerne versuchen

 

[kneitzel]

Ja, dann überleg es Dir doch einmal. Kannst Du ja erst einmal etwas generisch nachdenken: Wie könnte z.B. eine While-Schleife in einer Rekursion abgebildet werden?