JavaStream API va lambda9 boʻlim · 26 savol

Java Stream API va lambda: pipeline qanday ishlaydi

Bu sahifa Java Stream API va lambda mavzusini chuqur tushuntiradi: lambda aslida nima, stream pipeline qanday ishlaydi, nega u lazy va qachon oddiy sikl yaxshiroq. Murakkab joylar qadamma-qadam animatsiya bilan koʻrsatilgan.

Boʻlimlar asoslardan chuqurroq mavzularga qarab ketadi: lambda va functional interfaceʼdan parallel stream va performanceʼgacha. Bilgan joyingizni oʻtkazib yuborishingiz yoki istalgan boʻlimdan boshlashingiz mumkin. Kod Java 21 da yozilgan, boshqa LTS versiyalardagi farqlar alohida aytilgan.

Har boʻlim oxirida tushunganingizni tekshiradigan savollar bor. Avval javobni oʻzingiz oʻylab koʻring, keyin oching.

1Lambda, functional interface va method reference

Lambda — nomsiz funksiya: parametrlar, strelka va tana. x -> x * 2 — bitta parametr, tanasi bitta ifoda. (a, b) -> a + b — ikki parametr, () -> 42 — parametrsiz. Tana bir necha qatordan iborat boʻlsa, u figurali qavsga olinadi va natija return bilan qaytariladi. Parametr turlari odatda yozilmaydi: kompilyator ularni kontekstdan chiqaradi.

Javaʼda funksiya uchun alohida tur yoʻq: lambda functional interfaceʼni — bitta abstract metodi bor interfeysni — implement qiladi. Lambda tanasi shu metodning tanasi boʻladi, qaysi interfeys ekanini esa kontekst belgilaydi: oʻzgaruvchi turi, metod parametri yoki qaytish turi. Bu target type deyiladi.

@FunctionalInterface annotatsiyasi majburiy emas: u kompilyatorga «bu interfeysda aynan bitta abstract metod boʻlsin» deydi va kimdir ikkinchisini qoʻshsa, kod kompilyatsiya boʻlmaydi. default va static metodlar hisobga olinmaydi, Objectdan kelgan equals kabi public metodlar ham — shuning uchun Comparator ham functional interface. Koʻp ishlatiladiganlari java.util.function paketida tayyor:

InterfeysMetodNima qiladiMisol
Function<T, R>R apply(T t)T dan R yasaydiString::length
Predicate<T>boolean test(T t)shartni tekshiradis -> s.isEmpty()
Consumer<T>void accept(T t)qiymatni oladi, hech narsa qaytarmaydiSystem.out::println
Supplier<T>T get()argumentsiz qiymat beradiArrayList::new
UnaryOperator<T>, BinaryOperator<T>T apply(T t), T apply(T a, T b)bir xil turdagi qiymatlar ustida amalString::trim, Integer::sum

Ikki parametrli variantlar ham bor (BiFunction, BiPredicate, BiConsumer), primitivlar uchun esa boxingʼsiz variantlar: IntPredicate, ToIntFunction<T>, IntFunction<R>, IntBinaryOperator va boshqalar. Interfeyslarning default metodlari lambdaʼlarni birlashtiradi: f.andThen(g), p.and(q), p.negate(), Java 11 dan Predicate.not(String::isBlank).

Method reference — bitta metodni chaqiradigan lambdaʼning qisqa yozuvi: s -> s.length() oʻrniga String::length. Uning toʻrt turi bor:

TurYozuvLambda koʻrinishida
static metodInteger::parseInts -> Integer.parseInt(s)
bound: tayyor obyektning metodiSystem.out::println, prefix::concatx -> System.out.println(x), s -> prefix.concat(s)
unbound: birinchi parametrning metodiString::length, String::compareTos -> s.length(), (a, b) -> a.compareTo(b)
konstruktorArrayList::new, int[]::new() -> new ArrayList<>(), n -> new int[n]

Lambda tashqaridagi oʻzgaruvchilarni ishlata oladi — bu capture deyiladi. Lekin lokal oʻzgaruvchi faqat final yoki effectively final boʻlsa capture qilinadi: eʼlon qilingandan keyin unga qayta qiymat berilmagan boʻlishi kerak. final soʻzini yozish shart emas — Java 8 dan beri kompilyator buni oʻzi koʻradi.

Lambda oʻzgaruvchining oʻzini emas, qiymatining nusxasini oladi. Instance field ishlatilsa, nusxa emas, this capture qilinadi: lambda fieldʼni har safar obyektdan oʻqiydi. Lambda ichidagi this ham shu obyekt — anonymous klassdagidek yangi obyekt emas.

Tushunganingizni tekshiring

Functional interface nima? Lambda qaysi interfeysni implement qilishini qayerdan biladi?Javob
Qisqa javob

Functional interface — bitta abstract metodi bor interfeys. Lambda shu metodning implementationʼi boʻladi, qaysi interfeys ekanini esa kontekst belgilaydi: oʻzgaruvchi turi, metod parametri yoki qaytish turi.

Bir xil lambda turli interfeyslarga mos kelishi mumkin: s -> s.isEmpty() Predicate<String> ham, Function<String, Boolean> ham boʻla oladi. Kompilyator lambdaʼni kontekst kutgan turga — target typeʼga — moslaydi. Shuning uchun var f = x -> x * 2; kompilyatsiya boʻlmaydi: kontekstda tur yoʻq.

@FunctionalInterface majburiy emas, lekin foydali: interfeysga ikkinchi abstract metod qoʻshilsa, kompilyator darhol xato beradi. default metodlar qoʻshish mumkin — ular lambdaʼlarni birlashtirishga xizmat qiladi, xuddi Predicate.and kabi.

Lambda anonymous klassga oʻxshaydi, lekin bir xil emas. Lambda ichida this uni oʻrab turgan klassning obyekti, anonymous klassda esa anonymous klassning oʻzi. Lambda yangi scope ochmaydi: tashqaridagi lokal oʻzgaruvchi nomini lambda ichida qayta eʼlon qilib boʻlmaydi. Kompilyatsiyada ham farq bor: anonymous klass uchun alohida .class fayl yaratiladi, lambda esa invokedynamic orqali runtimeʼda bogʻlanadi.

@FunctionalInterface
interface Validator<T> {
    boolean validate(T value);

    default Validator<T> and(Validator<T> other) {
        return v -> validate(v) && other.validate(v);
    }
}

Validator<String> notEmpty = s -> !s.isEmpty();
Validator<String> shortStr = s -> s.length() < 10;
boolean ok = notEmpty.and(shortStr).validate("salom");
Method referenceʼning qanday turlari bor? String::length va str::length farqi nima?Javob
Qisqa javob

Toʻrt turi bor: static metod (Integer::parseInt), tayyor obyektning metodi (str::length), birinchi parametrning metodi (String::length) va konstruktor (ArrayList::new). str::length aynan shu strga bogʻlangan va parametr olmaydi, String::length esa satrni parametr sifatida oladi.

String::length — Function<String, Integer>: qaysi satrning uzunligi kerakligi chaqiruvda beriladi, s -> s.length(). str::length esa Supplier<Integer>: obyekt oldindan tanlangan, () -> str.length(). Birinchisi unbound, ikkinchisi bound method reference deyiladi.

Bound method referenceʼda obyekt reference yaratilgan paytda hisoblanadi. System.out::println System.outni oʻsha zahoti oladi, x -> System.out.println(x) esa uni har chaqiruvda qayta oʻqiydi. Obyekt null boʻlsa, method referenceʼda NullPointerException yaratilishning oʻzida chiqadi, lambdaʼda esa faqat chaqirilganda.

Konstruktor reference ham kontekstga qarab tanlanadi: ArrayList::new Supplier<List<T>> sifatida argumentsiz konstruktorni, IntFunction<List<T>> sifatida esa ArrayList(int initialCapacity)ni chaqiradi. String[]::new esa toArray(String[]::new) uchun kerakli oʻlchamdagi massiv yaratadi.

Function<String, Integer> len = String::length;
Supplier<Integer> fixed = "salom"::length;
BiPredicate<String, String> eq = String::equals;

String s = null;
Supplier<Integer> lazy = () -> s.length(); // xato yoʻq
Supplier<Integer> eager = s::length; // NPE shu yerda
Lambda nimani capture qiladi? Nega lokal oʻzgaruvchi effectively final boʻlishi kerak?Javob
Qisqa javob

Lambda ishlatgan lokal oʻzgaruvchining qiymatini nusxa qilib oladi, field ishlatsa — thisni. Lokal oʻzgaruvchi oʻzgarmas boʻlishi kerak, aks holda nusxa va asl qiymat bir-biridan ajralib qolardi.

Effectively final — final deb yozilmagan, lekin eʼlon qilingandan keyin qayta qiymat berilmagan oʻzgaruvchi. Qayta qiymat lambdaʼdan oldin yoki keyin berilishining farqi yoʻq: metodning istalgan joyida berilsa, kompilyator xato beradi.

Sababi: lokal oʻzgaruvchi stack frameʼda turadi va metod tugashi bilan yoʻqoladi, lambda esa undan keyin ham yashashi mumkin — fieldʼga saqlanadi, executorʼga beriladi, boshqa threadʼda ishlaydi. Shuning uchun Java qiymatning nusxasini oladi. Oʻzgaruvchini oʻzgartirishga ruxsat berilganda, lambda eskirgan nusxani koʻrardi yoki ikki thread bitta oʻzgaruvchi ustida data raceʼga tushardi.

Cheklovni aylanib oʻtish oson: int[] count = {0} yoki AtomicInteger — reference oʻzgarmaydi, ichidagi qiymat oʻzgaradi. Kompilyatsiya boʻladi, lekin muammo yoʻqolmaydi. Massiv elementi thread-safe emas: kimdir .parallel() qoʻshgan kuni natija jimgina notoʻgʻri chiqadi. AtomicInteger thread-safe, lekin natija stream qanday bajarilishiga bogʻliq boʻlib qoladi: masalan, Java 9 dan beri count() baʼzan pipelineʼni umuman ishga tushirmaydi. Toʻgʻri yoʻl — natijani streamʼning oʻzidan olish: count(), sum(), collect(...).

int count = 0;
names.forEach(n -> count++);
// xato: local variables referenced from a lambda
// expression must be final or effectively final

// kompilyatsiya boʻladi, lekin yomon
AtomicInteger c = new AtomicInteger();
names.stream()
        .filter(n -> n.startsWith("A"))
        .forEach(n -> c.incrementAndGet());

// toʻgʻri
long c2 = names.stream()
        .filter(n -> n.startsWith("A"))
        .count();

2Stream qanday ishlaydi: lazy evaluation va short-circuit

Stream — maʼlumot saqlaydigan kolleksiya emas, elementlar ustidagi hisob-kitob tavsifi. U manbadan (kolleksiya, massiv, fayl, generator) boshlanadi, bir nechta intermediate operatsiyadan oʻtadi va bitta terminal operatsiya bilan tugaydi. Bu zanjir pipeline deyiladi. Sikl bilan solishtiring: sikl imperativ — qanday qilishni qadamma-qadam yozasiz, stream deklarativ — nima kerakligini yozasiz, aylanib chiqishni kutubxona qiladi.

record User(String name, String email, String city,
            int age, boolean active) {}

// sikl
List<String> adults = new ArrayList<>();
for (User u : users) {
    if (u.age() >= 18) adults.add(u.name());
}

// stream
List<String> adults2 = users.stream()
        .filter(u -> u.age() >= 18)
        .map(User::name)
        .toList();

Keyingi misollarda shu User ishlatiladi. Operatsiyalar ikki turga boʻlinadi:

OperatsiyaNima qaytaradiMisollar
intermediateyangi Stream — hali hech narsa bajarilmaydifilter, map, flatMap, distinct, sorted, limit, skip, peek
terminalnatija yoki side effect — pipeline shu yerda ishga tushadicollect, toList, forEach, reduce, count, min, findFirst, anyMatch

Intermediate operatsiya chaqirilganda hech bir element qayta ishlanmaydi: u faqat pipelineʼga yangi bosqich qoʻshadi. Bu lazy evaluation. Ish terminal operatsiya chaqirilganda boshlanadi va elementlar pipelineʼdan bittalab oʻtadi: birinchi element hamma bosqichlardan oʻtadi, keyin ikkinchisi. «Avval hamma elementlar filterdan, keyin hammasi mapdan» degan tasavvur notoʻgʻri.

1/6list.stream().filter(...).map(...) — pipeline tayyor, lekin terminal operatsiya yoʻq. Hech bir element oʻqilmagan: intermediate operatsiyalar faqat bosqich qoʻshdi.

Shu tufayli short-circuit mumkin: findFirst, findAny, anyMatch, allMatch, noneMatch va limit natija aniq boʻlishi bilan pipelineʼni toʻxtatadi. Qolgan elementlar umuman oʻqilmaydi — manba cheksiz boʻlsa ham: Stream.iterate(1, x -> x * 2).limit(10) oʻnta elementdan keyin toʻxtaydi.

Hamma intermediate operatsiya ham elementni darhol keyingi bosqichga uzata olmaydi. filter, map, peek — stateless: har bir elementni boshqalardan mustaqil qayta ishlaydi. distinct, sorted, limit, skip, takeWhile va dropWhile esa stateful: ular oldingi elementlar haqida nimadir eslab qoladi — qaysilari koʻrilganini, nechtasi oʻtganini yoki shart buzilganini. sorted esa hamma elementni koʻrmaguncha birinchisini ham bera olmaydi. U pipeline oʻrtasidagi toʻsiqqa aylanadi:

1/8Pipeline: filter(x > 1) → sorted() → map(x * 10) → findFirst(). Manbada 5, 2, 8, 1.

Bundan amaliy xulosa: operatsiyalar tartibi natijaga ham, narxga ham taʼsir qiladi. filter imkon qadar oldinroq turgani maʼqul — keyingi bosqichlarga kamroq element yetadi. Cheksiz streamʼda esa sorted hech qachon natija bermaydi.

Yana bir qoida: stream bir martalik. Terminal operatsiyadan keyin, hatto bitta intermediate operatsiya chaqirilgandan keyin ham, oʻsha stream obyektini qayta ishlatib boʻlmaydi — IllegalStateException chiqadi. Kolleksiyadan esa istalgancha yangi stream olish mumkin.

Tushunganingizni tekshiring

Intermediate va terminal operatsiya farqi nima? Bu kod qanday tartibda chop etadi?Javob
Qisqa javob

Intermediate operatsiya yangi Stream qaytaradi va hech narsani bajarmaydi — faqat pipelineʼga bosqich qoʻshadi. Terminal operatsiya pipelineʼni ishga tushiradi, elementlar esa undan bittalab oʻtadi: filter ali, filter olma, map olma, filter nok — «avval hamma filter, keyin hamma map» emas.

Terminal operatsiya boʻlmasa, filter yoki map ichidagi kod bir marta ham ishlamaydi: quyidagi zanjir .toList()siz hech narsa chop etmaydi. Terminal operatsiya manbadan elementni oladi va uni zanjir boʻylab itaradi; filter oʻtkazmasa, element shu yerda tushib qoladi va keyingi bosqichlar uni koʻrmaydi.

Shuning uchun stateless operatsiyalar orasida oraliq kolleksiya yaratilmaydi: Files.lines bilan katta faylni filtrlab sanash butun faylni xotiraga yuklamaydi. Stream manbani ham terminal operatsiya boshlangandagina oʻqiydi: ArrayListdan stream olingandan keyin, lekin terminal operatsiyadan oldin listga qoʻshilgan element natijaga kiradi.

Terminal operatsiyalar ikki xil: natija qaytaradiganlar (collect, toList, reduce, count, findFirst) va faqat side effect qiladiganlar (forEach, forEachOrdered). Terminal operatsiyadan keyin stream ishlatib boʻlingan hisoblanadi.

Stream.of("ali", "olma", "nok")
        .filter(w -> {
            System.out.println("filter " + w);
            return w.length() > 3;
        })
        .map(w -> {
            System.out.println("map " + w);
            return w.toUpperCase();
        })
        .toList();
// filter ali
// filter olma
// map olma
// filter nok
Short-circuit operatsiya nima? Cheksiz stream qanday qilib tugaydi?Javob
Qisqa javob

Short-circuit operatsiya natija aniq boʻlishi bilan pipelineʼni toʻxtatadi: findFirst birinchi mos elementda, anyMatch birinchi trueda, allMatch birinchi falseda, limit(n) n ta elementdan keyin. Cheksiz stream faqat shunday operatsiya bilan tugaydi.

Cheksiz streamʼni Stream.iterate(seed, next) yoki Stream.generate(supplier) yaratadi. Ular elementni faqat soʻralganda hisoblaydi, shuning uchun Stream.iterate(1, x -> x * 2) oʻzi xotirani toʻldirmaydi. Lekin pipelineʼda limit, findFirst, anyMatch yoki takeWhile kabi operatsiya boʻlmasa, terminal operatsiya tugamaydi.

Java 9 dan iteratening shartli varianti bor: Stream.iterate(1, x -> x <= 1000, x -> x * 2) — for siklining aynan oʻzi. U shart false boʻlganda toʻxtaydi, shuning uchun limit kerak emas.

limitning oʻrni muhim: iterate(...).filter(p).limit(10) filtrdan oʻtgan 10 ta elementni topguncha ishlaydi — ular 10 tadan kam boʻlsa, abadiy qidiradi. iterate(...).limit(10).filter(p) esa faqat birinchi 10 tasini tekshiradi.

// birinchi 5 ta toq kvadrat
List<Integer> squares = Stream.iterate(1, i -> i + 1)
        .map(i -> i * i)
        .filter(x -> x % 2 == 1)
        .limit(5)
        .toList(); // [1, 9, 25, 49, 81]

// birinchi mos elementda toʻxtaydi
boolean anyMinor = users.stream()
        .anyMatch(u -> u.age() < 18);
Operatsiyalar tartibi nega muhim? sorted cheksiz streamʼda nima qiladi?Javob
Qisqa javob

Stateful operatsiyalar — sorted, distinct — elementlarni yigʻadi yoki eslab qoladi, shuning uchun ulardan oldin qancha element oʻtsa, shuncha xotira va vaqt ketadi. Cheksiz streamʼda sorted tugamaydi: u hamma elementni kutadi, ular esa tugamaydi.

sorted hamma elementni bufferʼga yigʻadi, manba tugaganda saralaydi va shundan keyingina keyingi bosqichlarga uzatadi. Undan keyin turgan limit(5) uni toʻxtata olmaydi: birinchi beshtani bilish uchun ham hamma elementni koʻrish kerak. Cheksiz streamʼda sorted elementlarni xotira tugaguncha yigʻadi va odatda OutOfMemoryError bilan tugaydi.

distinct ham koʻrganlarini eslab qoladi, lekin ketma-ket streamʼda yangi elementni darhol uzatadi; ordered parallel streamʼda esa u ham sorted kabi hamma elementni kutadi. Shuning uchun iterate(...).distinct().limit(10) 10 ta unikal element topilsa tugaydi, unikal qiymatlar 10 tadan kam boʻlsa esa osilib qoladi.

Umumiy qoida: filter iloji boricha oldinda turadi — keyingi bosqichlarga, ayniqsa qimmat map va sortedga kamroq element yetadi. Qimmat hisob-kitob (map(this::loadFromDb)) short-circuit operatsiyadan oldin tursa, u faqat kerakli elementlar uchun chaqiriladi — bu lazy evaluationʼning katta foydasi.

// tugamaydi: sorted hamma elementni kutadi
Stream.iterate(1, i -> i + 1)
        .sorted()
        .limit(5)
        .toList();

// ishlaydi: avval 5 ta, keyin saralash
Stream.iterate(1, i -> i + 1)
        .limit(5)
        .sorted()
        .toList();
Nega bitta streamʼni ikki marta ishlatib boʻlmaydi?Javob
Qisqa javob

Stream — kolleksiya emas, bir martalik hisob-kitob: u manbani bir marta oʻqiydi va elementlarni saqlab qolmaydi. Ikkinchi marta ishlatilsa — IllegalStateException: stream has already been operated upon or closed.

Har bir intermediate operatsiya oldingi stream obyektini «ishlatilgan» deb belgilaydi va yangisini qaytaradi. Shuning uchun xato ikkinchi terminal operatsiyadagina emas, bitta streamʼdan ikkita zanjir boshlaganda ham chiqadi: s.filter(...)dan keyin s.map(...).

Sababi — manbani qayta oʻqib boʻlmasligi mumkin: fayl qatorlari, tarmoqdan kelgan maʼlumot, Iterator, generator. Elementlarni eslab qolish esa lazy va xotirani tejaydigan model gʻoyasiga zid. Maʼlumot qayta kerak boʻlsa, u kolleksiyaga yigʻiladi yoki stream manbadan qaytadan yaratiladi.

Shuning uchun metod Stream emas, kolleksiya qaytargani koʻpincha xavfsizroq: chaqiruvchi uni necha marta aylansa ham boʻladi. Stream qaytarish natija juda katta yoki lazy boʻlishi kerak boʻlganda oʻrinli.

Stream<String> active = users.stream()
        .filter(User::active)
        .map(User::name);
long n = active.count();
List<String> names = active.toList();
// IllegalStateException

Supplier<Stream<String>> activeNames = () -> users
        .stream()
        .filter(User::active)
        .map(User::name);
long n2 = activeNames.get().count();
List<String> names2 = activeNames.get().toList();

3Tartiblash: sorted va Comparator

sorted() argumentsiz natural order boʻyicha saralaydi: elementlar Comparable boʻlishi kerak, aks holda terminal operatsiyada ClassCastException chiqishi mumkin. Boshqa tartib uchun sorted(comparator)ga Comparator beriladi. Uni qoʻlda yozish shart emas — Comparatorning static va default metodlari kerakli tartibni yigʻib beradi:

MetodNima qiladi
comparing(User::name)kalitni ajratib oladi va uni natural order boʻyicha solishtiradi
comparingInt(User::age)xuddi shunday, lekin kalit int — boxing yoʻq
comparing(User::name, cmp)kalitni berilgan comparator bilan solishtiradi
thenComparing(...)oldingi kalit teng boʻlsa, keyingisiga qaraydi
reversed()shu paytgacha yigʻilgan butun comparator tartibini teskari qiladi
nullsFirst(cmp), nullsLast(cmp)nullni boshiga yoki oxiriga qoʻyadi, qolganlarini cmp bilan solishtiradi
naturalOrder(), reverseOrder()natural order va uning teskarisi
import static java.util.Comparator.*;

// shahar boʻyicha, ichida yosh kamayishi, keyin ism
List<User> sorted = users.stream()
        .sorted(comparing(User::city)
            .thenComparing(User::age, reverseOrder())
            .thenComparing(User::name))
        .toList();

Ordered streamʼda saralash stable: teng elementlar bir-biriga nisbatan oldingi tartibini saqlaydi. sorted asl kolleksiyani oʻzgartirmaydi — list.sort(...)dan farqli ravishda, u elementlarni yangi tartibda keyingi bosqichga beradi.

Tushunganingizni tekshiring

Foydalanuvchilarni yosh boʻyicha kamayish, yoshi teng boʻlsa ism boʻyicha oʻsish tartibida qanday saralaysiz?Javob
Qisqa javob

comparingInt(User::age).reversed().thenComparing(User::name) yoki comparing(User::age, reverseOrder()).thenComparing(User::name). reversed() qayerda turishi muhim: u oʻzidan oldingi butun zanjirni teskari qiladi.

comparingInt(User::age).thenComparing(User::name).reversed() — xato: bu ism boʻyicha tartibni ham teskari qiladi. reversed() faqat oxirgi kalitga emas, shu paytgacha yigʻilgan comparatorʼga qoʻllanadi. Bitta kalitni teskari qilish uchun unga comparator beriladi: thenComparing(User::name, reverseOrder()).

Yana bir tuzoq — type inference. comparing(u -> u.name()).reversed() kompilyatsiya boʻlmaydi: .reversed() chaqirilgani uchun kompilyator lambda parametrining turini kontekstdan ola olmaydi va uni Object deb hisoblaydi. Yechim — method reference (comparing(User::name)), parametr turini yozish ((User u) -> u.name()) yoki Comparator.<User, String>comparing(...).

comparingInt, comparingLong, comparingDouble primitiv kalit bilan boxingʼsiz ishlaydi. compareni qoʻlda yozganda esa a.age() - b.age() emas, Integer.compare(a.age(), b.age()) ishlatiladi: ayirish katta sonlarda overflow beradi.

// yosh: kamayish, ism: oʻsish
Comparator<User> byAge = comparingInt(User::age)
        .reversed()
        .thenComparing(User::name);

// xato: ism ham teskari boʻlib qoladi
Comparator<User> wrong = comparingInt(User::age)
        .thenComparing(User::name)
        .reversed();
Saralanadigan maydonda null boʻlsa nima boʻladi? Uni qanday hal qilasiz?Javob
Qisqa javob

comparing(User::city) null shaharga yetganda NullPointerException tashlaydi: null ustida compareToni chaqirib boʻlmaydi. Yechim — comparing(User::city, nullsLast(naturalOrder())): nulllar oxirida, qolganlari odatdagi tartibda.

nullsFirst va nullsLast boshqa comparatorʼni oʻraydi: ikkala qiymat ham null boʻlsa — teng, bittasi null boʻlsa — u boshiga yoki oxiriga, ikkalasi ham bor boʻlsa — ichki comparator hal qiladi.

Ehtiyot boʻling: nullsLast(comparing(User::city)) boshqa narsa. U User obyektining oʻzi null boʻlishini hisobga oladi, shahar null boʻlsa esa baribir NPE chiqadi. nullsLast null boʻlishi mumkin boʻlgan qiymat darajasida qoʻyiladi.

Baʼzan nullni saralashdan oldin filter(u -> u.city() != null) bilan olib tashlash toʻgʻriroq. Bu biznes qarori: null shahar «nomaʼlum» degani boʻlsa, uni roʻyxat oxirida koʻrsatish odatda mantiqan toʻgʻri.

List<User> byCity = users.stream()
        .sorted(comparing(User::city,
                nullsLast(naturalOrder())))
        .toList();

4map, flatMap va Collectors

map har bir elementni bitta yangi elementga aylantiradi: Stream<User> → map(User::email) → Stream<String>. flatMap esa har bir elementdan butun stream yasaydi va ularni bitta streamʼga tekislaydi: bitta element nol, bitta yoki koʻp elementga aylanishi mumkin.

record Order(String id, List<String> items) {}

// map: har bir buyurtma → bitta list
List<List<String>> nested = orders.stream()
        .map(Order::items)
        .toList();

// flatMap: hamma buyurtmalarning mahsulotlari
List<String> all = orders.stream()
        .flatMap(o -> o.items().stream())
        .toList();

Natijani yigʻish uchun collect va Collectors bor. Collector — natija konteynerini yaratish, unga element qoʻshish, ikki konteynerni birlashtirish va oxirida natijani tayyorlash qoidalari toʻplami. Eng koʻp ishlatiladiganlari:

CollectorNatija
toList(), toSet(), toCollection(TreeSet::new)kolleksiya
joining(", ")satrlarni bitta Stringga ulaydi
toMap(k, v)Map: har bir elementdan kalit va qiymat
groupingBy(f)Map<K, List<T>>: bir xil kalitli elementlar bitta guruhda
partitioningBy(p)Map<Boolean, List<T>>: shart boʻyicha ikki guruh
counting(), summingInt, averagingDouble, mapping, filteringdownstream: guruh ichida nima yigʻiladi

groupingBy har bir element uchun kalitni hisoblaydi va elementni mapʼdagi oʻz guruhiga qoʻshadi. Kalit birinchi marta uchrasa, guruh uchun yangi konteyner yaratiladi — xuddi computeIfAbsent kabi. Guruh ichida nima yigʻilishini ikkinchi argument — downstream collector — belgilaydi:

1/7collect(groupingBy(String::length)): har bir soʻz uchun kalit — uning uzunligi. Natija — Map<Integer, List<String>>, hozircha boʻsh.
import static java.util.stream.Collectors.*;

Map<String, List<String>> namesByCity = users.stream()
        .collect(groupingBy(User::city,
                mapping(User::name, toList())));

Tushunganingizni tekshiring

map va flatMap farqi nima? Qachon flatMap kerak boʻladi?Javob
Qisqa javob

map bitta elementni bitta elementga aylantiradi. flatMap bitta elementdan stream yasaydi va hamma streamʼlarni bitta streamʼga ulaydi. Ichma-ich tuzilmani tekislash kerak boʻlsa — List<List<T>>dan List<T> — flatMap ishlatiladi.

Belgisi: mapga berilgan funksiya Stream qaytarsa, natija Stream<Stream<T>> boʻlib qoladi — bu odatda flatMap kerakligini bildiradi. flatMap(List::stream) yoki flatMap(o -> o.items().stream()) ichki listlarni bitta streamʼga aylantiradi.

flatMap bilan elementni olib tashlash yoki bir nechtaga koʻpaytirish ham mumkin: funksiya boʻsh stream qaytarsa, element yoʻqoladi. Masalan, Optionallar streamʼidan qiymatlarni olish: flatMap(Optional::stream) (Java 9+). Java 16 dan buning uchun mapMulti ham bor — u har bir element uchun yangi stream yaratmaydi.

Xuddi shu gʻoya boshqa APIʼlarda ham bor: Optional.flatMap funksiya Optional qaytarganda ichma-ich Optional<Optional<T>>ning oldini oladi, CompletableFuture.thenCompose esa asinxron natija uchun shu ishni qiladi.

List<List<Integer>> matrix = List.of(
        List.of(1, 2), List.of(3), List.of());

List<Integer> flat = matrix.stream()
        .flatMap(List::stream)
        .toList(); // [1, 2, 3]
groupingBy qanday ishlaydi? Guruhdagi elementlar sonini yoki oʻrtacha qiymatni qanday olasiz?Javob
Qisqa javob

groupingBy(f) har bir element uchun f bilan kalit hisoblaydi va elementni shu kalitli guruhga qoʻshadi: natija Map<K, List<T>>. Guruh ichida list emas, boshqa narsa kerak boʻlsa, ikkinchi argument — downstream collector — beriladi: counting(), averagingInt(...), mapping(User::name, toList()).

groupingBy mapʼga computeIfAbsent qiladi: kalit yangi boʻlsa, downstream collector yangi konteyner yaratadi, keyin element shu konteynerga qoʻshiladi. Oxirida har bir guruhga downstreamʼning finisherʼi qoʻllanadi — masalan, averagingInt yigʻindi va sondan Double yasaydi.

Default holatda natija — HashMap, guruhlar ichida — list, lekin javadoc ularning turini kafolatlamaydi. Tartib kerak boʻlsa, map factory beriladi: groupingBy(User::city, TreeMap::new, counting()). Kalit null boʻlsa — NullPointerException: element cannot be mapped to a null key.

partitioningBy(p) — shart boʻyicha guruhlashning maxsus holati: natijada ikkala kalit — true ham, false ham — boʻladi, guruh boʻsh boʻlsa ham. groupingBy esa faqat uchragan kalitlarni qoʻyadi.

Map<String, Long> countByCity = users.stream()
        .collect(groupingBy(User::city, counting()));

Map<String, Double> avgAge = users.stream()
        .collect(groupingBy(User::city,
                averagingInt(User::age)));

Map<Boolean, List<User>> adults = users.stream()
        .collect(partitioningBy(u -> u.age() >= 18));
Collectors.toMapda ikki element bir xil kalit bersa nima boʻladi?Javob
Qisqa javob

IllegalStateException: Duplicate key ... — ikki argumentli toMap takror kalitga ruxsat bermaydi. Takror boʻlishi mumkin boʻlsa, uchinchi argument — merge funksiyasi — beriladi: toMap(User::email, u -> u, (a, b) -> a).

Xato faqat maʼlumotda takror kalit paydo boʻlganda chiqadi, shuning uchun testlarda koʻrinmay, productionʼda birdan chiqishi mumkin. Java 9 dan beri xabarda kalit ham, ikkala qiymat ham koʻrsatiladi: Duplicate key a (attempted merging values 1 and 2) (Java 8 da xabarda kalit emas, qiymat chiqardi).

Merge funksiyasi nima qilishi biznes qaroriga bogʻliq: birinchisini qoldirish (a, b) -> a, oxirgisini olish (a, b) -> b, qiymatlarni qoʻshish Integer::sum. Hamma qiymatlar kerak boʻlsa, bu allaqachon groupingBy.

Yana bir tuzoq: toMap qiymat null boʻlganda ham NullPointerException tashlaydi, garchi HashMapning oʻzi null qiymatga ruxsat bersa ham. Toʻrtinchi argument map turini beradi: toMap(k, v, merge, LinkedHashMap::new) — elementlar tartibi saqlanadi.

Map<String, User> byEmail = users.stream()
        .collect(toMap(User::email, u -> u));
// takror email boʻlsa: IllegalStateException

Map<String, User> firstWins = users.stream()
        .collect(toMap(User::email, u -> u,
                (first, second) -> first));

5reduce va oʻz Collectoringiz

reduce hamma elementlarni bitta qiymatga yigʻadi: reduce(identity, accumulator). Identity — boshlangʻich qiymat va ayni paytda neytral element: qoʻshish uchun 0, koʻpaytirish uchun 1, satr ulash uchun "". Accumulator joriy natija va keyingi elementdan yangi natija yasaydi.

int sum = Stream.of(1, 2, 3, 4)
        .reduce(0, Integer::sum);    // 10

Optional<Integer> max = Stream.of(1, 2, 3, 4)
        .reduce(Integer::max);       // Optional[4]

Identityʼsiz variant Optional qaytaradi: stream boʻsh boʻlsa, natija yoʻq. Uch argumentli variant — reduce(identity, accumulator, combiner) — natija turi element turidan farq qilganda kerak. Combiner parallel streamʼda ikki boʻlakning natijasini birlashtiradi.

Parallel streamʼda manba boʻlaklarga boʻlinadi va har bir boʻlak identityʼdan boshlab alohida yigʻiladi. Shuning uchun identity haqiqatan neytral, accumulator esa associative boʻlishi kerak: (a + b) + c == a + (b + c). Aks holda ketma-ket va parallel natija farq qiladi.

reduce immutable qiymatlar uchun moʻljallangan: son, BigDecimal, kichik record. Natija mutable konteyner — list, map, StringBuilder — boʻlsa, collect ishlatiladi: u har bir boʻlak uchun bitta konteyner yaratadi va elementlarni unga qoʻshadi. reduce bilan buni qilish har qadamda yangi list yaratishni yoki umumiy listni oʻzgartirishni talab qiladi.

Collector — toʻrtta funksiya: supplier yangi konteyner yaratadi, accumulator unga element qoʻshadi, combiner ikki konteynerni birlashtiradi, finisher konteynerdan yakuniy natijani yasaydi. Tayyor collectorʼlar yetmasa, Collector.of bilan oʻzingiz yozasiz.

Tushunganingizni tekshiring

reduceda identity nima? reduce(10, Integer::sum) parallel streamʼda nima beradi?Javob
Qisqa javob

Identity — boshlangʻich qiymat, u accumulator uchun neytral boʻlishi kerak: 0 + x == x. 10 neytral emas: ketma-ket streamʼda u bir marta qoʻshiladi, parallel streamʼda esa har bir boʻlakda — natija kattaroq chiqadi va boʻlaklar soniga bogʻliq boʻladi.

Stream.of(1, 2, 3, 4).reduce(10, Integer::sum) ketma-ket streamʼda 20 beradi. .parallel() qoʻshilsa, har bir boʻlak 10dan boshlanadi: toʻrt boʻlakda natija 50. Javadoc talabi: har qanday t uchun accumulator.apply(identity, t) tga teng boʻlishi kerak. Boshlangʻich qiymat kerak boʻlsa, u reducedan keyin qoʻshiladi.

Accumulator associative va stateless boʻlishi kerak. Ayirish associative emas: reduce(0, (a, b) -> a - b) parallel streamʼda boshqa natija beradi.

reduce notoʻgʻri tanlov boʻladigan holatlar: satr ulash — reduce("", String::concat) har qadamda yangi satr yaratadi va O(n²) ishlaydi, Collectors.joining esa qismlarni yigʻib, natija satrini bir marta yasaydi; kolleksiya yigʻish — collect yoki toList(); sonlar yigʻindisi — mapToInt(...).sum(), boxingʼsiz. Koʻp holatda tayyor terminal operatsiya bor: count, sum, max, min.

int seq = Stream.of(1, 2, 3, 4)
        .reduce(10, Integer::sum);   // 20
int par = Stream.of(1, 2, 3, 4).parallel()
        .reduce(10, Integer::sum);   // masalan, 50

// toʻgʻri: identity neytral, qoʻshimcha qiymat keyin
int ok = 10 + Stream.of(1, 2, 3, 4).parallel()
        .reduce(0, Integer::sum);    // 20
Collector.of bilan oʻz collectorʼingizni qanday yozasiz? Bu qachon kerak?Javob
Qisqa javob

Toʻrt funksiya beriladi: supplier — boʻsh konteyner, accumulator — elementni qoʻshish, combiner — ikki konteynerni birlashtirish, finisher — konteynerdan natija. Bu tayyor collectorʼlar va ularning kombinatsiyasi yetmaganda va shu yigʻish bir necha joyda takrorlanganda kerak.

Ketma-ket streamʼda supplier odatda bir marta chaqiriladi va hamma elementlar bitta konteynerga tushadi. Parallel streamʼda har bir boʻlak oʻz konteynerini oladi, keyin combiner ularni juft-juft birlashtiradi. Combiner ketma-ket streamʼda ishlatilmasa ham, toʻgʻri yozilishi kerak: shu collector bilan kimdir parallelStream() chaqirishi mumkin.

Characteristics optimizatsiya uchun ishora beradi: IDENTITY_FINISH — finisher kerak emas, konteynerning oʻzi natija; UNORDERED — elementlar tartibi natijaga taʼsir qilmaydi; CONCURRENT — bitta konteynerga bir nechta thread bir vaqtda yoza oladi; stream bu yoʻlni faqat stream unordered boʻlsa yoki collectorʼda UNORDERED ham boʻlsa tanlaydi. Notoʻgʻri characteristic — masalan, oddiy ArrayList uchun CONCURRENT va UNORDERED — jimgina buzilgan natija beradi.

Oʻz collectorʼingizni yozishdan oldin tayyorlarini birlashtirib koʻring: collectingAndThen(toList(), List::copyOf), groupingBy + mapping, teeing. Koʻp holatda shu yetadi.

// eng katta n ta element, bir oʻtishda
static <T> Collector<T, ?, List<T>> topN(
        int n, Comparator<? super T> cmp) {
    return Collector.of(
            () -> new PriorityQueue<T>(cmp),
            (q, x) -> {
                q.offer(x);
                if (q.size() > n) q.poll();
            },
            (a, b) -> {
                for (T x : b) {
                    a.offer(x);
                    if (a.size() > n) a.poll();
                }
                return a;
            },
            q -> {
                List<T> r = new ArrayList<>(q);
                r.sort(cmp.reversed());
                return r;
            });
}

List<User> oldest = users.stream()
        .collect(topN(3, comparingInt(User::age)));

6Optionaldan toʻgʻri foydalanish

Optional<T> — qiymat boʻlishi ham, boʻlmasligi ham mumkinligini turning oʻzida koʻrsatadigan konteyner. findFirst, max, min va identityʼsiz reduce uni qaytaradi: boʻsh streamʼda natija yoʻq. Javadoc uning asosiy maqsadini aniq aytadi: «natija yoʻq» holatini bildirish kerak boʻlgan metodning qaytish turi.

KerakMetod
qiymatni aylantirishmap(f); f Optional qaytarsa — flatMap(f)
shart boʻyicha tashlab yuborishfilter(p)
default qiymatorElse(x); hisoblash qimmat boʻlsa — orElseGet(() -> ...)
qiymat yoʻq boʻlsa — exceptionorElseThrow() (Java 10), orElseThrow(NotFoundException::new)
qiymat bor boʻlsa — amalifPresent(c), ifPresentOrElse(c, r) (Java 9)
boʻsh boʻlsa — boshqa Optionalor(() -> ...) (Java 9)
streamʼga aylantirishstream() (Java 9)

Asosiy gʻoya — Optionalni if bilan ochib emas, zanjir bilan ishlatish. mapga berilgan funksiya null qaytarsa, natija boʻsh Optional boʻladi, shuning uchun ichma-ich null tekshiruvlari bitta zanjirga aylanadi:

record Address(String city) {}
record Customer(String name, Address address) {}

// ichma-ich null tekshiruvi
String city = "nomaʼlum";
if (customer != null && customer.address() != null
        && customer.address().city() != null) {
    city = customer.address().city();
}

// Optional zanjiri
String city2 = Optional.ofNullable(customer)
        .map(Customer::address)
        .map(Address::city)
        .orElse("nomaʼlum");

Tushunganingizni tekshiring

orElse va orElseGet farqi nima?Javob
Qisqa javob

orElse(x)ning argumenti Optionalda qiymat bor-yoʻqligidan qatʼi nazar hisoblanadi — bu oddiy metod chaqiruvi, argument undan oldin hisoblanadi. orElseGet(supplier) esa supplierʼni faqat Optional boʻsh boʻlganda chaqiradi.

findUser(id).orElse(createGuest()) — createGuest() foydalanuvchi topilsa ham chaqiriladi. U bazaga yozsa yoki tarmoqqa murojaat qilsa, bu jimgina side effect va bekor ketgan vaqt. orElseGet(this::createGuest) buni faqat kerak boʻlganda qiladi.

orElse tayyor konstanta yoki arzon qiymat uchun: orElse(""), orElse(0), orElse(List.of()). Hisoblash kerak boʻlsa — orElseGet. Qiymat boʻlishi shart boʻlsa — orElseThrow(() -> new NotFoundException(id)).

// topilsa ham createGuest() chaqiriladi
User a = repo.findById(id)
        .orElse(createGuest());

// faqat Optional boʻsh boʻlsa chaqiriladi
User b = repo.findById(id)
        .orElseGet(this::createGuest);
Optional qachon notoʻgʻri ishlatiladi? isPresent() + get() nega yomon?Javob
Qisqa javob

if (opt.isPresent()) opt.get() — oddiy null tekshiruvining uzunroq koʻrinishi, get() esa boʻsh Optionalda NoSuchElementException tashlaydi. Optionalni field, metod parametri yoki kolleksiya elementi sifatida ishlatish ham odatda notoʻgʻri: u qaytish turi uchun moʻljallangan.

get() nomi xavfni yashiradi: aslida u «qiymat boʻlmasa — exception» degani. Shuning uchun Java 10 da xuddi shu ishni qiladigan, lekin nomi buni aytib turadigan orElseThrow() qoʻshilgan. isPresent() + get() oʻrniga map, orElse, ifPresent yoki orElseThrow yoziladi.

Field sifatida Optional noqulay: u Serializable emas, har bir obyektga yana bitta obyekt qoʻshadi va oʻzi ham null boʻlib qolishi mumkin — shunda ikki xil «yoʻq» paydo boʻladi. Field oddiy null boʻla oladi, getter esa Optional.ofNullable(field) qaytaradi. Parametr sifatida ham noqulay: chaqiruvchi Optional.empty(), Optional.of(x) yoki hatto null berishi mumkin — overload yoki null boʻlishi mumkinligini aytadigan annotatsiya aniqroq.

Kolleksiya uchun Optional<List<T>> emas, boʻsh list qaytariladi. Primitivlar uchun OptionalInt, OptionalLong, OptionalDouble bor — IntStream.max() shuni qaytaradi. Optional turidagi oʻzgaruvchining oʻzi null boʻlmasligi kerak: Optional qaytaradigan metoddan null qaytarish — eng yomon variant.

// yomon
Optional<User> opt = repo.findById(id);
if (opt.isPresent()) {
    return opt.get().email();
}
return "-";

// yaxshi
return repo.findById(id)
        .map(User::email)
        .orElse("-");

7Side effect, checked exception va resurslar

Stream operatsiyalariga beriladigan lambdaʼlar ideal holda faqat elementga qarab natija qaytaradi va tashqi holatni oʻzgartirmaydi. Javadoc buni ikki talab bilan ifodalaydi: non-interfering — pipeline ishlayotganda manbani oʻzgartirmaslik, stateless — natija tashqi, oʻzgarib turadigan holatga bogʻliq boʻlmasligi. Side effect — tashqi listga qoʻshish, fieldʼni oʻzgartirish — natijani stream qanday bajarilishiga bogʻlab qoʻyadi: qaysi elementlar uchun, qaysi tartibda, qaysi threadʼda.

Side effect uchun moʻljallangan joy — forEach va forEachOrdered. peek esa javadoc boʻyicha asosan debug uchun: u har bir element uchun chaqirilishi kafolatlanmagan — count() va short-circuit operatsiyalar uni oʻtkazib yuborishi mumkin.

Ikkinchi muammo — checked exception. Function, Predicate, Consumerning metodlari throws eʼlon qilmaydi, shuning uchun map(Files::readString) kompilyatsiya boʻlmaydi: incompatible thrown types IOException in functional expression. Exception lambda ichida ushlanadi va unchecked exceptionʼga oʻraladi:

List<String> texts = paths.stream()
        .map(p -> {
            try {
                return Files.readString(p);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        })
        .toList();

Uchinchisi — resurslar. Koʻp streamʼlar xotiradagi kolleksiya yoki massiv ustida ishlaydi va ularni yopish shart emas. Lekin Files.lines, Files.list, Files.walk ochiq fayl yoki katalogni ushlab turadi. Stream AutoCloseable, shuning uchun bunday streamʼlar try-with-resources ichida ishlatiladi:

try (Stream<String> lines = Files.lines(log)) {
    long errors = lines
            .filter(l -> l.contains("ERROR"))
            .count();
}

Tushunganingizni tekshiring

Lambda ichida tashqi listga qoʻshish yoki hisoblagichni oshirish nega xavfli? peekga tayansa boʻladimi?Javob
Qisqa javob

Natija stream qanday bajarilishiga bogʻliq boʻlib qoladi: parallel streamʼda oddiy ArrayListga yozish elementlarni yoʻqotadi yoki exception beradi, count() va short-circuit operatsiyalar esa lambdaʼni baʼzi elementlar uchun umuman chaqirmasligi mumkin. peek — debug uchun, unga biznes logika qoʻyilmaydi.

IntStream.range(0, 100_000).parallel().forEach(list::add) oddiy ArrayListga yozsa, natijada 100 000 dan kam element boʻlishi yoki ArrayIndexOutOfBoundsException chiqishi mumkin. Xuddi shu kod ketma-ket streamʼda ishlaydi, shuning uchun xato .parallel() qoʻshilgan kuni chiqadi.

peek haqida javadoc ochiq aytadi: stream elementlarni optimizatsiya qilib oʻtkazib yuborsa, peek ular uchun chaqirilmaydi. list.stream().peek(...).count() Java 9 dan beri peekni umuman chaqirmaydi: listning oʻlchami maʼlum, peek esa elementlar sonini oʻzgartirmaydi. Shuning uchun peek ichida hisoblagich oshirish yoki bazaga yozish ishonchsiz.

forEach side effect uchun moʻljallangan, lekin parallel streamʼda u tartibni kafolatlamaydi va lambdaʼni bir nechta threadʼda chaqiradi. Tartib kerak boʻlsa — forEachOrdered. Natijani yigʻish uchun esa forEach va tashqi list emas, collect yoki toList().

// yomon: tashqi holat
List<String> emails = new ArrayList<>();
users.stream()
        .filter(User::active)
        .forEach(u -> emails.add(u.email()));

// yaxshi: natija streamʼdan
List<String> emails2 = users.stream()
        .filter(User::active)
        .map(User::email)
        .toList();
Lambda ichida checked exception tashlaydigan metodni qanday chaqirasiz?Javob
Qisqa javob

Standart functional interfeyslar throws eʼlon qilmaydi, shuning uchun exception lambda ichida ushlanadi va unchecked exceptionʼga oʻraladi — masalan, IOException → UncheckedIOException. Takrorlanadigan joylar uchun bu oʻrash alohida metodga yoki yordamchi funksiyaga chiqariladi.

Eng oddiy variant — lambda tanasini alohida metodga chiqarish: map(this::readOrThrow). Metod ichida try/catch va kerakli exception turi turadi, pipeline esa oʻqiladigan boʻlib qoladi.

Koʻp joyda kerak boʻlsa, throws eʼlon qilgan oʻz functional interfeysingiz va oʻrovchi funksiya yoziladi: map(unchecked(Files::readString)). Vavr yoki jOOλ kabi kutubxonalarda bunday yordamchilar tayyor.

Ehtiyot boʻlish kerak boʻlgan usul — «sneaky throw»: generic hiyla bilan checked exceptionʼni eʼlon qilmasdan tashlash. Exception metod imzosida koʻrinmaydi, chaqiruvchi esa uni catch (IOException e) bilan ushlay olmaydi — kompilyator bu blokni «try ichida bunday exception tashlanmaydi» deb rad etadi, faqat catch (Exception e) qoladi.

@FunctionalInterface
interface IoFunction<T, R> {
    R apply(T t) throws IOException;
}

static <T, R> Function<T, R> unchecked(
        IoFunction<T, R> f) {
    return t -> {
        try {
            return f.apply(t);
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    };
}

List<String> texts = paths.stream()
        .map(unchecked(Files::readString))
        .toList();
Files.lines yoki repositoryʼdan kelgan streamʼni nega yopish kerak? Lazy evaluation bu yerda qanday xatolarga olib keladi?Javob
Qisqa javob

Bunday stream orqasida ochiq resurs turadi: fayl descriptor, database connection yoki cursor. Terminal operatsiya streamʼni yopmaydi, shuning uchun u try-with-resources ichida ishlatiladi. Lazy evaluation sabab xatolar ham kech chiqadi: oʻqish xatosi stream yaratilganda emas, terminal operatsiyada paydo boʻladi.

Files.lines javadocʼi buni toʻgʻridan-toʻgʻri aytadi: stream try-with-resources yoki shunga oʻxshash konstruksiya ichida ishlatilishi kerak. Yopilmagan streamʼlar koʻpaysa, jarayon ochiq fayllar limitiga yetadi va Too many open files chiqadi. Spring Data repositoryʼsi Stream<User> qaytarsa, orqasida ochiq connection va cursor turadi: Spring Data JPA bunday metodni tranzaksiya ichida chaqirishni talab qiladi, streamʼni esa ishlatib boʻlgach oʻzingiz yopasiz — try-with-resources bilan.

Lazy evaluation xatolarni kechiktiradi. Files.lines faylni darhol ochadi — fayl yoʻq boʻlsa, NoSuchFileException shu qatorda chiqadi. Lekin qatorlar terminal operatsiyada oʻqiladi: faylda UTF-8 ga mos kelmaydigan baytlar boʻlsa, MalformedInputException UncheckedIOExceptionga oʻralib keyinroq chiqadi va catch (IOException e) uni ushlamaydi. map ichidagi xato ham stream yaratilgan qatorda emas, terminal operatsiya chaqirilgan joyda paydo boʻladi.

Eng koʻp uchraydigan xato — resursga bogʻliq streamʼni metoddan qaytarish. try (var s = Files.lines(p)) { return s.filter(...); } streamʼni qaytishdan oldin yopadi va chaqiruvchi terminal operatsiyada IllegalStateException oladi. Xavfsiz yoʻl — streamʼni ochgan joyning oʻzida terminal operatsiyagacha yetkazish va kolleksiya yoki qiymat qaytarish. Stream qaytarish kerak boʻlsa, uni yopish chaqiruvchining vazifasi boʻladi va bu javadocʼda yoziladi.

@Transactional(readOnly = true)
public long countActive() {
    try (Stream<User> users = repo.streamAllBy()) {
        return users.filter(User::active).count();
    }
}

// xato: stream qaytishdan oldin yopiladi
Stream<String> lines(Path p) throws IOException {
    try (Stream<String> s = Files.lines(p)) {
        return s.filter(l -> !l.isBlank());
    }
}

8Yangi imkoniyatlar: Java 9 dan 24 gacha

Stream API Java 8 da paydo boʻlgan va keyingi versiyalarda kengaygan. Java 21 LTSʼda 16-versiyagacha qoʻshilganlarning hammasi bor, Gatherers esa yoʻq: ular Java 25 LTSʼda.

VersiyaNima qoʻshilgan
9takeWhile, dropWhile, shartli Stream.iterate, Stream.ofNullable, Collectors.filtering va flatMapping, Optional.stream(), or, ifPresentOrElse
10Collectors.toUnmodifiableList, toUnmodifiableSet, toUnmodifiableMap, Optional.orElseThrow()
11Predicate.not, Optional.isEmpty(), lambda parametrlarida var
12Collectors.teeing
16Stream.toList(), mapMulti
22–23Gatherers — preview
24Gatherers final (JEP 485): Stream.gather va Gatherers

toList() va Collectors.toList() bir xil emas. stream.toList() (Java 16) oʻzgartirib boʻlmaydigan list qaytaradi va null elementlarga ruxsat beradi. collect(Collectors.toList()) hozir ArrayList qaytaradi va uni oʻzgartirish mumkin, lekin javadoc turini ham, oʻzgartirsa boʻlishini ham kafolatlamaydi. Collectors.toUnmodifiableList() (Java 10) oʻzgartirib boʻlmaydigan list beradi va nullni qabul qilmaydi.

takeWhile(p) shart true boʻlib turganda elementlarni oladi va birinchi falseda toʻxtaydi, dropWhile(p) esa shu elementlarni tashlab, qolganini beradi. mapMulti (Java 16) — flatMapning boshqa koʻrinishi: har bir element uchun stream yaratish oʻrniga, natijalar Consumerga beriladi. teeing (Java 12) ikki collectorʼni bir oʻtishda ishlatib, natijalarini birlashtiradi.

// mapMulti: har bir buyurtmadan uning mahsulotlari
List<String> items = orders.stream()
        .<String>mapMulti((o, sink) -> {
            for (var it : o.items()) sink.accept(it);
        })
        .toList();

// teeing: bir oʻtishda faollar ulushi, %
long percent = users.stream()
        .collect(teeing(
                filtering(User::active, counting()),
                counting(),
                (active, all) -> all == 0
                        ? 0 : active * 100 / all));

Gatherers (Java 24, JEP 485) — oʻz intermediate operatsiyangizni yozish imkoniyati. Collector terminal yigʻishni moslashtirgani kabi, Gatherer pipeline oʻrtasidagi bosqichni moslashtiradi: holat saqlashi, elementlarni guruhlab yoki koʻpaytirib chiqarishi va erta toʻxtashi mumkin. Tayyorlari Gatherers klassida: windowFixed, windowSliding, fold, scan, mapConcurrent.

// Java 24+
List<List<Integer>> pages = Stream.of(1, 2, 3, 4, 5)
        .gather(Gatherers.windowFixed(2))
        .toList(); // [[1, 2], [3, 4], [5]]

List<Integer> running = Stream.of(1, 2, 3, 4)
        .gather(Gatherers.scan(() -> 0, Integer::sum))
        .toList(); // [1, 3, 6, 10]

Tushunganingizni tekshiring

stream.toList() va collect(Collectors.toList()) farqi nima?Javob
Qisqa javob

toList() (Java 16) oʻzgartirib boʻlmaydigan list qaytaradi: add yoki set — UnsupportedOperationException. Collectors.toList() hozir oddiy ArrayList qaytaradi, lekin javadoc buni kafolatlamaydi. Ikkalasi ham null elementga ruxsat beradi, Collectors.toUnmodifiableList() esa yoʻq.

Eski koddagi collect(Collectors.toList())ni toList()ga almashtirish xavfsiz koʻrinadi, lekin natija listini keyin oʻzgartiradigan kod boʻlsa, u runtimeʼda UnsupportedOperationException bilan buziladi. Kompilyator buni ushlamaydi: ikkalasining turi ham List<T>.

Uchta variantning farqi: toList() — unmodifiable, null mumkin; Collectors.toList() — amalda mutable ArrayList, null mumkin; Collectors.toUnmodifiableList() — unmodifiable, null boʻlsa NullPointerException. Aniq mutable list kerak boʻlsa, niyatni ochiq koʻrsatadigan variant — collect(Collectors.toCollection(ArrayList::new)).

Yangi kodda odatda toList() tanlanadi: qisqa va natija tasodifan oʻzgartirilmaydi.

List<String> a = Stream.of("x").toList();
a.add("y"); // UnsupportedOperationException

List<String> b = Stream.of("x")
        .collect(Collectors.toList());
b.add("y"); // hozir ishlaydi, lekin kafolat yoʻq

List<String> c = Stream.of("x", null).toList(); // OK
takeWhile va filter farqi nima?Javob
Qisqa javob

filter hamma elementni tekshiradi va mos kelganlarini oʻtkazadi. takeWhile shart birinchi marta false boʻlganda toʻxtaydi: undan keyingi elementlar tekshirilmaydi ham. Shuning uchun takeWhile cheksiz streamʼni tugata oladi, filter esa yoʻq.

Stream.of(1, 2, 5, 1).takeWhile(x -> x < 3) — [1, 2]: 5 da toʻxtaydi va oxirgi 1 ga yetmaydi. filter(x -> x < 3) esa [1, 2, 1] beradi. dropWhile(x -> x < 3) — teskarisi: [5, 1], birinchi falsedan keyin hamma element oʻtadi.

Bu operatsiyalar tartibga tayanadi, shuning uchun saralangan yoki vaqt boʻyicha kelayotgan maʼlumot uchun moʻljallangan: «sanasi bugungacha boʻlgan yozuvlar», «birinchi boʻsh qatorgacha boʻlgan sarlavhalar». Unordered streamʼda — masalan, HashSetdan olinganda — natijani oldindan aytib boʻlmaydi.

Java 8 da bu operatsiyalar yoʻq edi: streamʼni shart bilan toʻxtatish uchun oʻz Spliteratorʼingiz yoki kutubxona kerak edi. Java 9 dagi shartli Stream.iterate(seed, hasNext, next) ham shu muammoning bir qismini hal qiladi.

List<Integer> sorted = List.of(1, 3, 5, 8, 9, 12);
List<Integer> small = sorted.stream()
        .takeWhile(x -> x < 6)
        .toList(); // [1, 3, 5]

Stream.iterate(1, x -> x <= 1000, x -> x * 2)
        .forEach(System.out::println); // 1 2 4 … 512
Gatherers nima va ular qanday muammoni hal qiladi?Javob
Qisqa javob

Gatherer — oʻzingiz yozadigan intermediate operatsiya, stream.gather(...) bilan ulanadi (Java 24+, JEP 485). U holat saqlashi, elementlarni guruhlab yoki koʻpaytirib chiqarishi va erta toʻxtashi mumkin — map va filter bilan yozib boʻlmaydigan narsalar. Tayyorlari Gatherers klassida.

Gathererʼlardan oldin oʻz intermediate operatsiyangizni qoʻshishning qulay yoʻli yoʻq edi: «elementlarni uchtadan guruhla», «yigʻindini har qadamda chiqar», «kalit boʻyicha distinct» kabi vazifalar uchun stream yigʻib olinardi va qaytadan yaratilardi yoki holat lambdaʼdan tashqarida saqlanardi. Endi bular pipeline ichidagi oddiy bosqich.

Gatherer Collectorʼga oʻxshab toʻrt qismdan iborat: initializer — holatni yaratadi, integrator — har bir elementni qayta ishlaydi, combiner — parallel boʻlaklarni birlashtiradi, finisher — oxirida qolganini chiqaradi. Integratordan boshqalari ixtiyoriy. Integrator false qaytarsa, pipeline toʻxtaydi: short-circuit shunday yoziladi. Gatherers.mapConcurrent(n, f) funksiyani virtual threadʼlarda, bir vaqtda koʻpi bilan n ta chaqiruv bilan bajaradi va tartibni saqlaydi.

Java 21 LTSʼda Gatherers yoʻq: ular Java 22 va 23 da preview boʻlgan, Java 24 da final boʻldi va Java 25 LTSʼga kirdi.

// Java 24+: kalit boʻyicha distinct
static <T, K> Gatherer<T, ?, T> distinctBy(
        Function<? super T, ? extends K> key) {
    return Gatherer.ofSequential(HashSet<K>::new,
        (seen, x, down) -> {
            // takror kalit: tashlab, davom etamiz
            if (!seen.add(key.apply(x))) return true;
            return down.push(x);
        });
}

List<User> onePerCity = users.stream()
        .gather(distinctBy(User::city))
        .toList();

9Performance, parallel stream va code review

Stream bepul emas: pipeline obyektlari, lambdaʼlar, har bir element uchun bir nechta chaqiruv. Koʻp holatda JIT buning katta qismini optimizatsiya qiladi va farq sezilmaydi. Sezilarli farq odatda ikki joyda chiqadi: boxing va juda kichik, juda tez-tez chaqiriladigan hisob-kitoblar.

Stream<Integer>dagi har bir son — Integer obyekti. reduce(0, Integer::sum) har qadamda unboxing qiladi va natijani yana boxing qiladi. Primitiv streamʼlar — IntStream, LongStream, DoubleStream — sonlarni obyektga oʻramasdan ishlaydi va sum, average, max, summaryStatistics kabi metodlarga ega. Ularga mapToInt, mapToLong, mapToDouble bilan oʻtiladi, orqaga — boxed() yoki mapToObj bilan.

// boxing: har qadamda Integer
int a = numbers.stream()
        .reduce(0, Integer::sum);

// boxingʼsiz
int b = numbers.stream()
        .mapToInt(Integer::intValue)
        .sum();

long evens = IntStream.rangeClosed(1, 1_000_000)
        .filter(i -> i % 2 == 0)
        .count();

parallel() yoki parallelStream() streamʼni odatda ForkJoinPool.commonPool()da bajaradi: manba Spliterator orqali boʻlaklarga boʻlinadi, boʻlaklar workerʼlarda hisoblanadi va natijalar birlashtiriladi. Pool qanday ishlashi — work stealing va nega unga bloklovchi vazifa berib boʻlmasligi — Concurrency qoʻllanmasida batafsil.

OmilParallel uchun yaxshiParallel uchun yomon
hajm va ishkoʻp element, har biriga sezilarli CPU ishikam element yoki arzon operatsiya
manbaArrayList, massiv, IntStream.range — teng boʻlinadiLinkedList, Stream.iterate, Iterator — yomon boʻlinadi
operatsiyalarstateless: map, filter, sumtartibga bogʻliq: limit, findFirst, distinct, forEachOrdered
lambdamustaqil, side effectʼsizIO, bloklanish, umumiy holat yoki lock

Parallel stream tezlashtirishi kafolatlanmagan: ish taqsimlash va natijalarni birlashtirishning ham narxi bor, commonPool esa butun JVM uchun bitta. Qaror faqat oʻlchash bilan qabul qilinadi — JMH yoki real yuklama ostidagi profiler.

Oʻqilish ham performance kabi muhim. Code reviewʼda koʻp uchraydigan muammolar: haddan uzun zanjirlar, bir necha qatorli va ichma-ich lambdaʼlar, peek yoki map ichidagi logika, Optionalni stream ichida get() bilan ochish. Davo odatda oddiy: lambdaʼni nomi bor metodga chiqarish, oraliq natijaga nom berish, zanjirni ikkiga boʻlish yoki sikl yozish.

Tushunganingizni tekshiring

Stream<Integer> va IntStream farqi nima? Boxing qachon sezilarli boʻladi?Javob
Qisqa javob

Stream<Integer> har bir sonni Integer obyekti sifatida tashiydi, IntStream esa int bilan ishlaydi. Katta hajmda boxing qoʻshimcha obyektlar, GC yuki va sekinroq kod degani. Sonlar ustida hisob-kitobda mapToInt bilan IntStreamga oʻtiladi.

Boxing koʻpincha yashirin: Stream<Integer>dagi map(x -> x * 2) har bir natijani yana Integerga oʻraydi — default holatda -128…127 oraligʻidan tashqarida bu yangi obyekt; reduce(0, Integer::sum) har qadamda ochib, qayta oʻraydi. JIT escape analysis baʼzan bu obyektlarni yoʻqotadi, lekin bunga tayanib boʻlmaydi.

IntStreamning oʻz metodlari bor: sum(), average() (OptionalDouble), max() (OptionalInt), summaryStatistics() — bir oʻtishda soni, yigʻindisi, minimumi, maksimumi va oʻrtachasi. IntStream.range(0, n) boxingʼsiz index siklining oʻrnini bosadi.

Ehtiyot boʻlish kerak boʻlgan joy: Stream.of(intArray) int[]ni bitta element qilib, Stream<int[]> yaratadi. Massivdan IntStream olish uchun Arrays.stream(intArray) yoki IntStream.of(...) ishlatiladi.

List<Integer> prices = List.of(1200, 800, 4500);

int total = prices.stream()
        .mapToInt(Integer::intValue)
        .sum();

IntSummaryStatistics st = prices.stream()
        .mapToInt(Integer::intValue)
        .summaryStatistics();
// st.getMin(), st.getMax(), st.getAverage()
Parallel stream qachon foydali, qachon zararli?Javob
Qisqa javob

Foydali: elementlar koʻp, har biriga sezilarli CPU ishi bor, manba yaxshi boʻlinadi (ArrayList, massiv, IntStream.range) va lambdaʼlar bir-biridan mustaqil. Zararli: kichik hajm, IO yoki bloklovchi chaqiruvlar, yomon boʻlinadigan manba (LinkedList, Stream.iterate) va tartibga bogʻliq operatsiyalar.

Parallel stream ForkJoinPool.commonPool()da ishlaydi (terminal operatsiya boshqa ForkJoinPool ichidan chaqirilsa — oʻsha poolda), chaqiruvchi thread ham ishga qoʻshiladi. commonPool default holatda yadrolar sonidan bitta kam workerʼga ega va butun JVM uchun bitta: uni CompletableFuturening executorʼsiz async metodlari ham ishlatadi. Parallel stream ichidagi HTTP yoki JDBC chaqiruvlari poolʼni band qilsa, boshqa joylardagi parallel streamʼlar va async vazifalar ham kutib qoladi.

Foyda element soniga va bitta elementga ketadigan ishga bogʻliq. Ish arzon boʻlsa (x * 2), parallel foyda berishi uchun juda koʻp element kerak, shunda ham tezlashish yadrolar sonidan ancha kam boʻlishi mumkin: ishni taqsimlash, natijalarni birlashtirish va xotiraga murojaat oʻz narxini oladi.

Web ilovada parallel stream odatda yaxshi gʻoya emas: soʻrovlar allaqachon koʻp threadʼda ishlaydi va yadrolar band. Parallel stream — batch ishlov, ogʻir hisob-kitob va benchmark bilan tasdiqlangan qaynoq joylar uchun.

// yaxshi nomzod: koʻp element, CPU ish, range
double sum = IntStream.range(0, 10_000_000)
        .parallel()
        .mapToDouble(i -> Math.sqrt(i) * Math.sin(i))
        .sum();

// yomon: har bir element — tarmoq chaqiruvi
List<Price> prices = ids.parallelStream()
        .map(priceClient::fetch)
        .toList();
Parallel streamʼda tartib va thread-safety bilan qanday muammolar chiqadi?Javob
Qisqa javob

forEach elementlarni istalgan tartibda va har xil threadʼlarda chaqiradi; tartib kerak boʻlsa — forEachOrdered. findFirst, limit va distinct encounter orderʼni saqlaydi, lekin parallel streamʼda buning uchun qimmatroq ishlaydi. Lambdaʼdan umumiy mutable holatga — ArrayList, HashMap, oddiy hisoblagichga — yozish race condition beradi.

Ordered manbada (List, massiv) parallel stream ham encounter orderʼni hurmat qiladi: toList() va collect(toList()) natijasi ketma-ket streamʼdagi tartibda boʻladi. Tartibni forEach va findAny kabi operatsiyalar kafolatlamaydi. findFirst esa birinchi elementni aniqlash uchun oldingi boʻlaklarni kutishi kerak — tartib muhim boʻlmasa, findAny yoki unordered() tezroq.

Collector har bir boʻlak uchun alohida konteyner yaratadi va ularni combiner bilan birlashtiradi, shuning uchun collect(toList()) parallel streamʼda ham xavfsiz. forEach(list::add) esa bitta umumiy ArrayListga bir nechta threadʼdan yozadi: elementlar yoʻqoladi yoki ArrayIndexOutOfBoundsException chiqadi. synchronized qoʻshish buni tuzatadi, lekin parallellikning foydasini yoʻqotadi.

Natija ketma-ket va parallel streamʼda farq qilsa, bu bug belgisi: identity notoʻgʻri, accumulator associative emas yoki lambda tashqi holatga bogʻliq. Toʻgʻri yozilgan pipeline ikkala rejimda bir xil natija beradi — forEach tartibi, findAny va double yigʻindisi bundan mustasno: floating-point qoʻshish associative emas, parallel sum() oxirgi xonalarda farq qilishi mumkin.

// tartib kafolatlanmaydi: masalan, 6 2 8 0 …
IntStream.range(0, 10).parallel()
        .forEach(i -> System.out.print(i + " "));

// encounter order: 0123456789
IntStream.range(0, 10).parallel()
        .forEachOrdered(System.out::print);

// xavfsiz: har bir boʻlakka alohida list
List<Integer> squares = IntStream.range(0, 1000)
        .parallel()
        .map(i -> i * i)
        .boxed()
        .toList();
Code reviewʼda stream kodining qaysi belgilari uni qayta yozishga sabab boʻladi? Qachon sikl oʻqishga qulayroq?Javob
Qisqa javob

Haddan uzun zanjir, bir necha qatorli yoki ichma-ich lambdaʼlar, peek yoki map ichidagi side effect, forEach bilan tashqi listni toʻldirish va sikl oddiyroq boʻlgan joyda streamʼni majburan qoʻllash. Odatdagi davo: lambdaʼni nomi bor metodga chiqarish, oraliq natijaga nom berish yoki sikl yozish.

Uzun zanjirda har bir bosqich oʻzi oddiy boʻlsa ham, butunligicha nima qilinayotganini tushunish qiyin. Zanjir mantiqiy qismlarga boʻlinadi va har biriga nom beriladi: activeUsers, ordersByCity. Bir necha qatorli lambda private metodga chiqariladi: map(this::toDto) nima boʻlayotganini aytadi, 15 qatorli lambda esa yashiradi.

Ichma-ich stream — lambda ichidagi boshqa stream — koʻpincha flatMap, groupingBy yoki oldindan tayyorlangan Map bilan soddalashadi. Ayniqsa a.stream().filter(x -> b.stream().anyMatch(...)) — bu O(n × m), bni oldindan Setga yigʻish esa uni taxminan O(n + m) qiladi.

Sikl yaxshiroq boʻlgan joylar: bir oʻtishda bir nechta natija yigʻish, break/continue bilan murakkab boshqaruv, checked exception, index bilan ishlash, oldingi elementga qarash. Bunday joyda streamʼni AtomicInteger, massiv-hisoblagich va peek bilan majburlashdan oddiy for aniqroq. Debug uchun peek(x -> log.debug(...)) bosqichlar orasiga vaqtincha qoʻyiladi va keyin olib tashlanadi.

// oʻqish qiyin
List<OrderDto> dtos = orders.stream()
        .filter(o -> o.status() == Status.PAID
                && o.total() > 0
                && !o.items().isEmpty())
        .map(o -> new OrderDto(o.id(),
                o.items().stream()
                        .map(Item::name)
                        .collect(joining(", "))))
        .toList();

// nomi bor bosqichlar
List<OrderDto> dtos2 = orders.stream()
        .filter(this::isBillable)
        .map(this::toDto)
        .toList();

Tushunganingizni suhbatda sinab koʻring

Mavzuli mock intervyuda «Stream API va lambda»ni tanlang. AI shu kabi savollarni beradi, javobingizga qarab chuqurroq savol soʻraydi va har javobingizga fikr bildiradi.

Mock intervyuni boshlash