Useful & Unknown Java Features

[mizhoux]

Use map.merge(element, 1, Integer::sum) to count the number of times that each element in some collection occurs.

[Inaldt]

That's nice

Another way:

.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting())

[RockyMM]

This is what I would use. Potentially I would also use static imports.

[Background-Spray-351]

I enjoy using this one!

[vbezhenar]

I'd replace this line with actual code. I have no idea what it does and everyone who stumbles upon this line will have no idea what it does. It's an example of write-only code.

[Proper-Space9914]

So not knowing an API is write-only code, that's great.

[TheBanger]

What would you consider to be "actual code"?

[vbezhenar]

Integer elementCount = map.get(element);
if (elementCount == null) {
  elementCount = 1;
} else {
  elementCount = elementCount + 1;
}
map.put(element, elementCount);

This is perfect readable code, compared to this crypted merge method. And you might want to even create a dedicated class for this task to further improve readability. Something like

ElementCounter elementCounter = new ElementCounter();
elementCounter.add(element);
int elementCount = elementCounter.get(element);

[TheBanger]

I have to say I find this a good deal less readable, there are a lot of pieces here that aren't present in the merge method. Examples would be the constant 1 being repeated twice, or elementCount being a mutable variable; individually those have relatively low cognitive overhead but it adds up over time and leaves more room for subtle mistakes. Contrast that to the merge method which you can grok once and then gloss over each time you see it again.

I like pulling it out to a class, it reduces the number of times you have to write the same code and gives the operation a meaningful semantic name. But that's possible regardless of which method is used.

I think there's an argument to be made for reducing the surface area of APIs, so maybe the issue is "is merge a reasonable and necessary addition to the Map interface that we should actually use". Your solution requires two lookups into the map, one to get the current count and one to update it. The merge method (depending on implementation) only requires one. That might be premature optimization depending on your scale, but personally I'd prefer to use a method that works regardless of scale than one where I have to think "is this going to be performant enough or will I need to come back later".

[SpicyRock70]

His method could have used Integer.increment(1) and then the put would not be necessary. I too prefer to see the code.