Why Do Java 8 Constructor References Cause High Heap Memory Usage?

What are the performance implications of using Java 8 constructor references like ArrayList::new? How do they compare to traditional constructor usage?

public class TestMain {
  public static void main(String[] args) {
    boolean newMethod = false;
    Map<Integer,List<Integer>> map = new HashMap<>();
    int index = 0;

    while(true){
      if (newMethod) {
        map.computeIfAbsent(index, ArrayList::new).add(index);
      } else {
        map.computeIfAbsent(index, i -> new ArrayList<>()).add(index);
      }
      if (index++ % 100 == 0) {
        System.out.println("Reached index " + index);
      }
    }
  }
}

Utilizing Java 8 constructor references like `ArrayList::new` can lead to inefficient memory usage and performance issues. This is particularly evident when repeatedly creating objects in high-frequency scenarios.

map.computeIfAbsent(index, i -> new ArrayList<>()).add(index); // Traditional constructor

Causes

• Constructor references create lambda expressions that retain an additional reference to their enclosing scope.
• Each method call may lead to the creation of various temporary objects, especially during hashmap operations.
• In scenarios where the collection grows rapidly, constructor references can inadvertently create more objects than needed.

Solutions

• Prefer using traditional constructor calls (e.g., `i -> new ArrayList<>()`) when high throughput is required.
• Monitor and manage the growth of the collections effectively to ensure limits and thresholds are not breached.
• Utilize 'initial capacity' features in collections to mitigate frequent resizing.

Mistake: Not considering the extra overhead of lambda expressions created by constructor references.

Solution: Use traditional method references or constructor calls when high performance is crucial.

Mistake: Failing to initialize collections with an appropriate size, leading to repeated reallocations.

Solution: Specify the initial capacity of collection objects where applicable to avoid overhead.