AtomicInteger & lambda expressions in single-threaded app

I need to modify a local variable inside a lambda expression in a JButton's ActionListener and since I'm not able to modify it directly, I came across the AtomicInteger type.

I implemented it and it works just fine but I'm not sure if this is a good practice or if it is the correct way to solve this situation.

My code is the following:

newAnchorageButton.addActionListener(e -> {
    AtomicInteger anchored = new AtomicInteger();
        
    anchored.set(0);
    
    cbSets.forEach(cbSet ->
        cbSet.forEach(cb -> {
            if (cb.isSelected())
                anchored.incrementAndGet();
        })
    );
        
    // more code where I use the 'anchored' variable...
}

I'm not sure if this is the right way to solve this since I've read that AtomicInteger is used mostly for concurrency-related applications and this program is single-threaded, but at the same time I can't find another way to solve this.

I could simply use two nested for-loops to go over those arrays but I'm trying to reduce the method's cognitive complexity as much as I can according to the sonarlint vscode extension, and leaving those for-loops theoretically increases the method complexity and therefore its readability and maintainability.

Replacing the for-loops with lambda expressions reduces the cognitive complexity but maybe I shouldn't pay that much attention to it.

While it is safe enough in single-threaded code, it would be better to count them in a functional way, like this:

long anchored = cbSets.stream()     // get a stream of the sets
    .flatMap(List::stream)          // flatten to list of cb's
    .filter(JCheckBox::isSelected)  // only selected ones
    .count();                       // count them

Instead of mutating an accumulator, we limit the flattened stream to only the ones we're interested in and ask for the count.

More generally, though, it is always possible to sum things up or generally aggregate the values without a mutable variable. Consider:

record Country(int population) { }

countries.stream()
    .mapToInt(Country::population)
    .reduce(0, Math::addExact)

Note: we never mutate any values; instead, we combine each successive value with the preceding one, producing a new value. One could use sum() but I prefer reduce(0, Math::addExact) to avoid the possibility of overflow.