👀 돌 다리도 두들겨 보고 건너자 (Stream.collect(Collectors.toList()) 와 Stream.toList())

Stream.collect(Collectors.toList()) 와 Stream.toList() 는 다르다!

---

어느날 production 의 레거시 로직에서 발생한 UnsupportedOperationException…

무엇이 문제였을까요?

---

java 로 백엔드 개발을 하다 보면,

가장 흔한 패턴 중 하나가

특정 데이터를 원하는 형태로 변환하거나 추출하는 것입니다.

이때는 Stream API 를 사용하면 편리하고, 일반적으로 좋은 가독성을 유지할 수 있습니다.

아래 코드를 살펴봅시다.

        List<String> imageUrls = articleImageRepository.findByArticle(article)
                .stream()
                .map(ArticleImage::getImageUrl)
                .collect(Collectors.toList());

위 코드 스니펫에서는 articleImage 엔티티 리스트를 쿼리해온 뒤에, ImageUrl 만 List 으로 추출하고 있습니다.

여기서 주목해야 할 부분은 collect(Collectors.toList() 입니다.

해당 부분에 커서를 가져다 대면 intelliJ 에서는 아래와 같은 메세지를 띄워줍니다.

`collect(toList())` can be replaced with 'toList()'

- Replace 'collect(toList())' with 'toList()'?

이 제안을 무심코 수락하다가는, 예상치 못한 잠재적인 버그를 서비스에 심을 수 있습니다.

 🔥 Stream.collect(Collectors.toList()) 와 Stream.toList() 는 명백하게 다르다! 

---

어떻게 다를까?

주요한 차이점은 아래와 같습니다.

- Stream.collect(Collectors.toList()) 는 가변 리스트를 반환한다.

- Stream.toList() 는 불변 리스트를 반환한다.

jdk 16 부터 도입된 메서드 인 Stream.toList() 는 불변 리스트를 반환하며, 외부에서 수정 시도 시 UnsupportedOperationException 이 터집니다.

List<String> mutableList = Stream.of("a", "b").collect(Collectors.toList());
mutableList.add("c"); // ✅ 가능

List<String> immutableList = Stream.of("a", "b").toList();
immutableList.add("c"); // 🔥 UnsupportedOperationException 발생

필요한 구현체가 불변 리스트인지, 가변리스트인지 요구사항을 정확하게 파악하고 사용하는 것이 중요합니다.

IntelliJ, SonarQube 등에서 collect(Collectors.toList()) 를 Stream.toList() 으로 변경하는 것을 권할 수 있지만,

두 메서드의 기능적인 차이점을 명확히 인지하지 못한 채 받아들이면

상황에 따라 꽤나 심각한 버그가 발생할 수도 있겠죠.

돌다리도 두들겨 보고 건너야 할 것 같습니다.

---

내부 구현 코드를 따라가서 두 눈으로 검증하기

시간적으로 허용된다면 반드시 내부 구현 코드를 확인해서, 스스로 납득하는 것이 가장 기억에 오래 남는 것 같습니다.

jdk 17 기준으로 살펴보겠습니다.

먼저 Stream.collect(Collectors.toList()) 부터 따라가봅시다.

    /**
     * Accumulates the elements of this stream into a {@code List}. The elements in
     * the list will be in this stream's encounter order, if one exists. The returned List
     * is unmodifiable; calls to any mutator method will always cause
     * {@code UnsupportedOperationException} to be thrown. There are no
     * guarantees on the implementation type or serializability of the returned List.
     *
     * <p>The returned instance may be <a href="{@docRoot}/java.base/java/lang/doc-files/ValueBased.html">value-based</a>.
     * Callers should make no assumptions about the identity of the returned instances.
     * Identity-sensitive operations on these instances (reference equality ({@code ==}),
     * identity hash code, and synchronization) are unreliable and should be avoided.
     *
     * <p>This is a <a href="package-summary.html#StreamOps">terminal operation</a>.
     *
     * @apiNote If more control over the returned object is required, use
     * {@link Collectors#toCollection(Supplier)}.
     *
     * @implSpec The implementation in this interface returns a List produced as if by the following:
     * <pre>{@code
     * Collections.unmodifiableList(new ArrayList<>(Arrays.asList(this.toArray())))
     * }</pre>
     *
     * @implNote Most instances of Stream will override this method and provide an implementation
     * that is highly optimized compared to the implementation in this interface.
     *
     * @return a List containing the stream elements
     *
     * @since 16
     */
    @SuppressWarnings("unchecked")
    default List<T> toList() {
        return (List<T>) Collections.unmodifiableList(new ArrayList<>(Arrays.asList(this.toArray())));
    }


    /**
     * Returns an <a href="Collection.html#unmodview">unmodifiable view</a> of the
     * specified list. Query operations on the returned list "read through" to the
     * specified list, and attempts to modify the returned list, whether
     * direct or via its iterator, result in an
     * {@code UnsupportedOperationException}.<p>
     *
     * The returned list will be serializable if the specified list
     * is serializable. Similarly, the returned list will implement
     * {@link RandomAccess} if the specified list does.
     *
     * @implNote This method may return its argument if the argument is already unmodifiable.
     * @param  <T> the class of the objects in the list
     * @param  list the list for which an unmodifiable view is to be returned.
     * @return an unmodifiable view of the specified list.
     */
    @SuppressWarnings("unchecked")
    public static <T> List<T> unmodifiableList(List<? extends T> list) {
      if (list.getClass() == UnmodifiableList.class || list.getClass() == UnmodifiableRandomAccessList.class) {
        return (List<T>) list;
      }

      return (list instanceof RandomAccess ?
        new UnmodifiableRandomAccessList<>(list) :
        new UnmodifiableList<>(list));
    }

이번에는 collect(Collectors.toList()) 를 봅시다.

    /**
     * Returns a {@code Collector} that accumulates the input elements into a
     * new {@code List}. There are no guarantees on the type, mutability,
     * serializability, or thread-safety of the {@code List} returned; if more
     * control over the returned {@code List} is required, use {@link #toCollection(Supplier)}.
     *
     * @param <T> the type of the input elements
     * @return a {@code Collector} which collects all the input elements into a
     * {@code List}, in encounter order
     */
    public static <T>
    Collector<T, ?, List<T>> toList() {
        return new CollectorImpl<>(ArrayList::new, List::add,
                                   (left, right) -> { left.addAll(right); return left; },
                                   CH_ID);
    }

무엇이 다른가요?

toList() 에서 반환하는 구현체는 Collectors.UnmodifiableRandomAccessList, Collectors.UnmodifiableList 으로 불변 리스트이지만

collect(Collectors.toList()) 에서 반환하는 구현체는 ArrayList 으로 가변 리스트입니다.

---

불변 리스트의 원소를 수정하려고 하면 UnsupportedOperationException 이 발생하고,

해당 예외는 runtime 에, 해당 line 이 수행될 때에만 발생하므로 찾기 어렵죠.

UnsupportedOperationException 이 triggering 되는 코드는 UnmodifiableList 내부 코드를 확인해서 확신을 얻을 수 있습니다.

public static <T> List<T> unmodifiableList(List<? extends T> list) {
         // ... 생략 ...
    }

    /**
     * @serial include
     */
    static class UnmodifiableList<E> extends UnmodifiableCollection<E>
                                  implements List<E> {
        // ... 생략 ...
        public E set(int index, E element) {
            throw new UnsupportedOperationException();
        }
        public void add(int index, E element) {
            throw new UnsupportedOperationException();
        }
        public E remove(int index) {
            throw new UnsupportedOperationException();
        }
        public boolean addAll(int index, Collection<? extends E> c) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            throw new UnsupportedOperationException();
        }
        @Override
        public void sort(Comparator<? super E> c) {
            throw new UnsupportedOperationException();
        }

        // ... 생략 ...

        public ListIterator<E> listIterator(final int index) {
            return new ListIterator<E>() {
                
                // ... 생략 ...

                public void remove() {
                    throw new UnsupportedOperationException();
                }
                public void set(E e) {
                    throw new UnsupportedOperationException();
                }
                public void add(E e) {
                    throw new UnsupportedOperationException();
                }
            };
          // ... 생략 ...
        }

---

P.S.

항상 의심해...

---

References

• https://stackoverflow.com/questions/65969919/differences-of-java-16s-stream-tolist-and-stream-collectcollectors-tolist