Java 8 Streams, member wijzigen met map()

[steveman]

Een tijdje terug kwam ik een bug tegen in m'n code, dit heb ik kunnen reduceren tot het volgende waar het probleem optreedt. Ik heb er al een tijd mee lopen stoeien, maar het waarom ontgaat me.

Het doel is om een threshold toe te passen op een rijtje getallen, getallen die niet voldoen worden NaN, dat werkt. En dan wordt er nog een flag bijgehouden om te zien of er overschrijdingen waren. Het wijzigen van die flag geeft problemen.

Java:

public class Why {
    public static void main(String[] args)  {
        System.out.println(System.getProperty("java.version"));
        // Works as expected
        Stream<Double> data = Stream.of(Double.valueOf(1.0), Double.valueOf(2.0), Double.valueOf(3.0),
                Double.valueOf(4.0), Double.valueOf(5.0));

        Flag flag = new Flag();

        System.out.println("Result: " + data.map(i -> valueOverThree(i, flag)).collect(Collectors.toList()));
        System.out.println("Flag: " + flag.getFlag() + "\n");

        
        
        // Flag remains false... Why?
        final Stream<Double> data2 = Stream.of(Double.valueOf(1.1), Double.valueOf(2.1), Double.valueOf(2.9),
                Double.valueOf(4.1), Double.valueOf(5.1));

        Flag flag2 = new Flag();
        
        Stream<Double> result = data2.map(a -> valueOverThree(a, flag2));
        Object[] outputWrapper = valueOverThreeWithFlag(result);
        
        System.out.println("Result: " + ((Stream<Double>) (outputWrapper[0])).collect(Collectors.toList()));
        System.out.println("Flag: " +outputWrapper[1]);
    }

    public static Object[] valueOverThreeWithFlag(final Stream<Double> data) {
        Flag flag = new Flag();
        flag.setFlag(false);
        return new Object[] { data.map(a -> valueOverThree(a, flag)), Boolean.valueOf(flag.getFlag()) };
    }

    static Double valueOverThree(final Double input, Flag flag) {
        if (input.doubleValue() > 3.0) {
            flag.setFlag(true);
            System.out.println("Setting the flag to true: " + input);
            return Double.NaN;
        }

        return input;
    }
}

//De genoemde Flag 
public class Flag {
    private boolean flag;

    /**
     * @return the flag
     */
    public boolean getFlag() {
        return flag;
    }

    /**
     * @param flag the flag to set
     */
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

De output van het programma verwart mij:

Setting the flag to true: 4.0
Setting the flag to true: 5.0
Result: [1.0, 2.0, 3.0, NaN, NaN]
Flag: true //mooi!

Setting the flag to true: 4.1
Setting the flag to true: 5.1
Result: [1.1, 2.1, 2.9, NaN, NaN]
Flag: false //heh?

Ik snap niet wat er nou anders is aan die tweede case, waarbij het flag object gemaakt wordt in de methode.

Met Java 10.0.2 overigens (Ik zat nog op 8, maar dat werkte hetzelfde).
Met StreamEx (https://github.com/amaembo/streamex) ook hetzelfde resultaat.
Inlinen van de objecten die het array in gaan op line 31 hielp (gelukkig) ook niet.

Tips?

[ValHallASW]

Ja, https://plugins.jetbrains...9696-java-stream-debugger, of je code iets anders uitschrijven:

Java:

Flag flag1 = new Flag();
Flag flag2 = new Flag();
        
List<Double> result1 = data2.map(a -> valueOverThree(a, flag1)).collect(Collectors.toList())
List<Double> result2 = result1.map(a -> valueOverThree(a, flag2)).collect(Collectors.toList());

Je zult dan zien dat er in result1 geen waarden groter dan 3 meer staan -- die heb je immers door NaN vervangen. flag2 wordt dan ook niet op true gezet.

[Feanathiel]

De collect(Collectors.toList()) forceert evaluatie van de expressie ervoor. data.map(a -> valueOverThree(a, flag)) doet opzich zelf niks (lazy, zet maar een breakpoint), dus als je direct daarna Boolean.valueOf(flag.getFlag()) opvraagt, dan is valueOverThree nog nooit uitgevoerd en de flag dus false. Uiteindelijk wordt de flag wel op true gezet, maar dan heb je 'm al bevraagd, en heb je er niks meer aan.

[Voor 18% gewijzigd door Feanathiel op 24-09-2018 22:29]

[steveman]

Ah, juist! Nou zo blijkt maar, m'n J8-boeken die vanmiddag aankomen zijn geen overbodige luxe

[Hydra]

Afgezien van het antwoord: dat soort state modifications op je input en dan gewoon hetzelfde object doorsturen wil je vermijden. Deze nieuwe Java 8 spullen zijn gestoeld op het functioneel programmeren denken waarbij je objecten in princiepe immutable zijn; je 'map' levert dus normaliter een nieuw object op. Dat maakt de code een stuk simpeler om over te redeneren, helemaal als je concurrency moet ondersteunen.