Getting a list from a stream – Arrays, collections and data structures

110. Getting a list from a stream

Collecting a Stream into a List is a popular task that occurs all over the place in applications that manipulates streams and collections.In JDK 8, collecting a stream into a List can be done via the toList() collector as follows:

List<File> roots = Stream.of(File.listRoots())
  .collect(Collectors.toList());

Starting with JDK 10, we can rely on toUnmodifiableList() collector (for maps use, toUnmodifiableMap() and for sets toUnmodifiableSet()):

List<File> roots = Stream.of(File.listRoots())
  .collect(Collectors.toUnmodifiableList());

Obviously, the returned list is an unmodifiable/immutable list.JDK 16 has introduced the following toList() default method in the Stream interface:

default List<T> toList() {
  return (List<T>) Collections.unmodifiableList(
    new ArrayList<>(Arrays.asList(this.toArray())));
}

Using this method to collect a Stream into an unmodifiable/immutable list is straightforward:

List<File> roots = Stream.of(File.listRoots()).toList();

In the bundled code you can also find an example of combining flatMap() and toList().

111. Handling map capacity

Let’s assume that we need a List capable to hold 260 items. We can do it as follows:

List<String> list = new ArrayList<>(260);

The array underlying the ArrayList is created directly to accommodate 260 items. In other words, we can insert 260 items without worry that the list has to be resized/enlarged several times in order to hold these 260 items.Following this logic, we can reproduce it for a map as well:

Map<Integer, String> map = new HashMap<>(260);

So, now we can assume that we have a map capable to accommodate 260 mappings. Actually, no, this assumption is not true! A HashMap works on the hashing principle and is initialized with an initial capacity (16 if no explicit initial capacity is provided) representing the number of internal buckets and a default load factor of 0.75. What does that mean? It means that when a HashMap reaches 75% of its current capacity it is doubled in size and a rehashing takes place. This guarantees that the mappings are evenly distributed in the internal buckets. But, for significantly large maps, this is an expensive operation. Even Javadoc stands that: creating a HashMap with a sufficiently large capacity will allow the mappings to be stored more efficiently than letting it perform automatic rehashing as needed to grow the table.In our case, it means that map can hold 260 x 0.75 = 195 mappings. In other words, when we insert the mapping number 195, the map will be automatically resized to 260 * 2 = 520 mappings.To create a HashMap for 260 mappings, we have to calculate the initial capacity as the number of mappings/load factor: 260 / 0.75 = 347 mappings.

// accommodate 260 mappings without resizing
Map<Integer, String> map = new HashMap<>(347);

Or, if we want to express it as a formula, we can do it as follows:

Map<Integer, String> map = new HashMap<>(
  (int) Math.ceil(260 / (double) 0.75));

Starting with JDK 19, this formula has been hidden behind the static <K,V> HashMap<K,V> newHashMap(int numMappings) method. This time, the numMappings represents the number of mappings so we can write this:

// accommodate 260 mappings without resizing
Map<Integer, String> map = HashMap.newHashMap(260);

Analog methods exist for HashSet, LinkedHashSet, LinkedHashMap and WeakHashMap.