Which is the best way to set/drop boolean flag inside lambda function

Question

Say I have a currency rates loader returning isLoaded=true result only when all the rates are loaded successfully:

//List<String> listFrom = Stream.of("EUR", "RUB").collect(toList());
//List<String> listTo = Stream.of("EUR", "CNY").collect(toList());

boolean isLoaded = true;

final FixerDataProvider httpProvider = new FixerDataProvider(maxAttempts);
final List<CurrencyRatePair> data =
    listFrom.stream()
        .flatMap(from -> {
            final List<CurrencyRatePair> result = httpProvider.findRatesBetweenCurrencies(from, listTo);
            if (Objects.isNull(result) || result.size() == 0) {
                isLoaded = false; //!!!Not working as ineffectively final!!!
            }
            return result.stream();
        }).collect(Collectors.toList());

if (!isLoaded) {
    return false;
}

// do smth with loaded data 

return true;

Assignment isLoaded = false; inside lambda function is not allowed when isLoaded variable is not final or effectively final.

Which is the most elegant solution to set/drop boolean flag inside lambda expressions?

What do you think about AtomicBoolean and set(false) method as a possible approach?

Answer 1

You may be better off with an old-style loop, as others have suggested. It does feel like a bit of a programming faux pas to write lambdas with side-effects, but you're likely to find an equal number of developers who think it's fine too.

As for getting this particular lambda-with-side effects working, making isLoaded into an AtomicBoolean is probably your best bet. You could achieve the same effect by making isLoaded a boolean[] of size 1, but that seems less elegant than going with AtomicBoolean to me.

But seriously, try using an old-school loop instead too and see which one you like better.

---

If you use parallel stream, you must use AtomicBoolean. Because boolean[1] may not be safe in parallel scenario.