Stream Dönüşüm Metodları

Giriş
Dönüşüm metodları intermediate metodlar olarak ta bilinirler. Her intermediate metod yeni bir Stream döndürür.

flatMap metodu
Java 8 Stream flatMap metodu yazısına taşıdım.

flatMapToDouble metodu
Örnek ver

flatMapToInt metodu
Stream Collection,Array gibi nesnelerden oluşuyorsa bu nesneleri açarak her elemanını dolaşabilmemizi sağlar. Elimde şöyle bir iki boyutlu dizi olsun.

int[][] matrix = ...;

Her alanı toplamak için şöyle yaparız.

long sum = Arrays.stream(matrix).flatMapToInt(arr -> Arrays.stream(arr)).sum();

flatMapToLong metodu
Örnek ver

map metodu
İmzası şöyle

Stream<R> map(Function<? super T,? extends R> mapper)

Metodun içi şöyle. Yeni bir StatelessOp nesnesi döndürdüğü görülebilir.

public final <R> Stream<R> map(Function<? super P_OUT, ? extends R> mapper) {
  Objects.requireNonNull(mapper);
  return new StatelessOp<P_OUT, R>(this, StreamShape.REFERENCE,
                                 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
    @Override
    Sink<P_OUT> opWrapSink(int flags, Sink<R> sink) {
      return new Sink.ChainedReference<P_OUT, R>(sink) {
        @Override
        public void accept(P_OUT u) {
          downstream.accept(mapper.apply(u));
        }
      };
    }
  };
}

Örnek
map genellikle map->filter->collect üçlüsü ile beraber kullanılır.
Eskiden şöyle kodlardık

List<String> inputStrings = new ArrayList<>(); // say, a list of inputStrings

ArrayList<SomeClass> outputResultStrings = new ArrayList();
for(String anInputString : inputStrings) {
    SomeClass someResult = doSomthing(anInputString);
    if (someResult != null) {
        outputResultStrings.add(someResult);
    }
}

Şimdi şöyle kodluyoruz.

List<SomeClass> outputResultStrings = 
    inputStrings.stream()
                .map(SomeClass::doSomething)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());

map içinde exception yakalanabilir.

intList = strList.stream()// same with "parallelStream()"
            .map(x -> {
                try {
                    return Integer.parseInt(x);
                } catch (NumberFormatException nfe) {
                    System.err.println(nfe.getMessage());
                }
                return null;
            })
            .filter(x -> x!= null)
            .collect(Collectors.toList());

map ve method reference
Map akıllı olduğu için gerekirse girdiyi çağırdığı dönüşüm metoduna geçebilir. Aşağıdaki örnekte new Foo () yerine new Foo (foo) metodu tetiklenir.

List<Foo> copy(List<Foo> foos) {
  return foos.stream().map(Foo::new).collect(Collectors.toList());
}

mapToDouble
Bu metod bir DoubleStream döndürür.
Double'ı double'a dönüştürmek için şöyle yaparız.

List<Double> values = ...;
double[] ar = values.stream().mapToDouble(Double::doubleValue).toArray();

Integer'ı double'a dönüştürmek için şöyle yaparız.

int n = ...
return IntStream.range(0, n)
  .mapToDouble(i -> 8.0/(4*i+1)/(4*i+3))
  .sum();

String'i double'a dönüştürmek için şöyle yaparız.

List<String> data = ...
double sum = data.stream()
  .mapToDouble(Double::parseDouble)
  .sum()

mapToInt metodu
Bu metod bir IntStream döndürür.

mapToLong metodu
Bu metod bir LongStream döndürür. Örnek ver.