Strumienie przetwarzanie

Pytanie bo nie potrafię znaleźć jednoznacznej odpowiedzi. Mając stream:

Arrays.stream(g).filter(i-> i%2==0).filter(i-> i%3==0).filter(i-> i%4==0).map(i -> wynik[i] = i).collect(Collectors.toList());

Będzie przetwarzany w taki sposób? "pętla" z filtrem 1 potem znowu "pętla" z filtrem 2 itd...
Czy stream to jakoś zlepi i wykona te operacje w jednej "pętli" ?

Każdy filtr osobno.

To jest jakby jedna pętla:

       List<String> x = new ArrayList<>();
        x.add("a");
        x.add("b");
        x.stream().filter(a -> {
            System.out.println("not null: " + a);
            return a != null;
        }).filter(a -> {
            System.out.println("length: " + a.length() + " " + a);
            return a.length() > 0;
        }).toArray();
    }

wynik:

not null: a
length: 1 a
not null: b
length: 1 b

W tym przypadku filter() jest operacją intemediate co jakby dodaje instrukcje do pętli. toArray() jest terminalny co oznacza że to już koniec pętli. Dodatkowo bez zdarzenia terminalnego pętla się nie uruchomi

Dodałbym jeszcze, że te 3 filtry mógłbyś zamienić w jeden: filter(i-> i%12==0)

kixe52 napisał(a):

Dodałbym jeszcze, że te 3 filtry mógłbyś zamienić w jeden: filter(i-> i%12==0)

te 3 filtry to tylko żeby zobrazować o co mi chodzi ;)

Pytam czy dzieje sie to jako jedna petla bo zrobiłem test z normalnym for i stream wyszedł duuuuzooo wolniejszy. Natomiast pararell stream tylko trochę wolniejszy od for.

darksead napisał(a):

Pytam czy dzieje sie to jako jedna petla bo zrobiłem test z normalnym for i stream wyszedł duuuuzooo wolniejszy. Natomiast pararell stream tylko trochę wolniejszy od for.

To normalne - streamy są pewnym overheadem, pewnym narzutem. Dzięki nim mamy czytelniejsze api, bardziej funkcyjne, jednak pod spodem i tak siedzą zwykłe pętle, tylko dodatkowo jeszcze obudowane, więc zawsze stream będzie wolniejszy od zwykłego fora. No może poza sytuacją, kiedy mamy baaardzo dużo danych, a przetwarzanie da się jakoś zrównoleglić, to wtedy parallel stream **może **będzie szybszy.

Z parallel streamami może tez być problem jak używasz ich w różnych miejscach i wątkach - one używają domyślnego ForkJoinPool które jest wspólne dla wszystkich strumieni równoległych, no chyba że jakies haki