Collectors toList metodu

Giriş
Şu satırı dahil edebiliriz.

import static java.util.stream.Collectors.toList;

toList metodu
Liste'nin ne tip olacağıyla (örneğin immutable olması gibi) ilgili bir bilgi yok. Açıklaması şöyle

There are no guarantees on the type, mutability, serializability, or thread-safety of the List returned

toList() ve asList() gibi isimlendirmelerin arasındaki farkı mantıken belirten bir açıklama şöyle.

A toXYZ() function is expected to do a conversion, and to return a new independent object (though immutability allows for optimization, java.lang.String.toString() just returns the object).

An asXYZ() function on the other hand is expected to return a (potentially different) view of the source, doing minimal work.

Yeni bir liste oluşturur. Döndürülen nesne List tipindendir. Şöyle yaparız.

List<Integer> list = new ArrayList<Integer>();
list.add(3);
list.add(5);
list.add(4);
list.add(2);
list.add(5);
list = list.stream().filter(i -> i >= 3).collect(Collectors.toList());

Diğer
Immutable list için Java 8'de şöyle yaparız. Java 10 ile Collectors.toUnmodifiableList() kullanılır.

List<Integer> result = Arrays.asList(1, 2, 3, 4)
            .stream()
            .collect(Collectors.collectingAndThen(
                    Collectors.toList(),
                    x -> Collections.unmodifiableList(x)));

Çok Fazla Kod - Verbose

Aslında bir çok insan Java'nın çok fazla kod yazmak zorunda  bırakmasından şikayetçi. Şu anda şöyle yapıyoruz.

Stream.of(-2,1,2,-5)
  .filter(n -> n > 0)
  .map(n -> n * n)
  .collect(Collectors.toList());

Şöyle yapabilseydik çok daha kolay olurdu. Bu tür kod yazabilmek harici kütüphaneler ile mümkün.

Stream.of(-2,1,2,-5)
  .filter(n -> n > 0)
  .map(n -> n * n)
  .toList();

Metodun İçi Nasıldır
Metodun içi şöyledir.

public static <T>
Collector<T, ?, List<T>> toList() {
  return new CollectorImpl<>((
    Supplier<List<T>>) ArrayList::new, //Supplier
    LList::add,                        //Accumulator
    (left, right) -> { left.addAll(right); return left; },//Combiner
    CH_ID);
}

Accumulator
Accumulator tek bir thread için kullanılır. Şöyle yaparız.

List<Integer> desc = Stream.iterate(n, k -> k - 1).limit(n + 1)
    .collect(Collectors.toList());

Combiner
Combiner paralel stream'ler için kullanılır. Accumulator'leri birleştirir. Şöyle yaparız.

List<Integer> desc = ...;

desc.parallelStream()
    .map(k -> {
        ...
    })
    .collect(Collectors.toList());