Java Academy · पाठ

thenApply और thenCompose से Chaining

thenApply से results transform करें और nested futures से बचने के लिए thenCompose से async steps को flatMap करें।

पाठ 2, कुल 4 में से13 चरण

thenApply और thenCompose से Chaining, CoddyKit पर Java Academy का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Java Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Java Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

thenApply: परिणाम बदलना

thenApply(Function) पूरे हुए फ़्यूचर के परिणाम पर तुल्यकालिक फ़ंक्शन लागू करता है और बदले हुए प्रकार का नया फ़्यूचर लौटाता है। यह नया अतुल्यकालिक कार्य शुरू नहीं करता।

CompletableFuture<String> nameFuture = CompletableFuture
    .supplyAsync(() -> 42L)            // CF<Long>
    .thenApply(id -> "User#" + id);    // CF<String>
System.out.println(nameFuture.join()); // "User#42"

thenApplyAsync: थ्रेड पर परिवर्तन करना

thenApplyAsync परिवर्तन फ़ंक्शन को ForkJoinPool (या दिए गए निष्पादक) पर चलाता है, जिससे परिणाम पूरा करने वाला थ्रेड तुरंत मुक्त हो जाता है।

CompletableFuture<String> result = fetchUserAsync()
    .thenApplyAsync(user -> serialize(user)); // runs on pool thread

thenAccept: लौटाए बिना उपयोग करना

thenAccept(Consumer) परिणाम को संसाधित करता है, लेकिन CompletableFuture<Void> लौटाता है। जब आपको कोई मान आगे भेजने की आवश्यकता न हो, तब प्रक्रिया-श्रृंखला के अंतिम चरण के रूप में इसका उपयोग करें।

fetchUserAsync()
    .thenApply(User::getName)
    .thenAccept(name -> System.out.println("Hello, " + name));

thenRun: पूरा होने के बाद चलाना

thenRun(Runnable) फ़्यूचर पूरा होने के बाद कोई कार्य चलाता है और परिणाम को अनदेखा करता है। संसाधन बंद करने या अन्य प्रभाव उत्पन्न करने के लिए यह उपयोगी है।

downloadFileAsync(url)
    .thenRun(() -> System.out.println("Download complete"));

कई thenApply कॉल की शृंखला बनाना

कई thenApply कॉल मिलकर एक प्रक्रिया-श्रृंखला बनाती हैं। प्रत्येक चरण को पिछले चरण का आउटपुट मिलता है।

CompletableFuture<Double> result = CompletableFuture
    .supplyAsync(() -> "  42.5  ")
    .thenApply(String::trim)
    .thenApply(Double::parseDouble)
    .thenApply(d -> d * 1.21); // apply 21% VAT
System.out.println(result.join()); // 51.425

thenCompose: नेस्टेड फ़्यूचर को समतल करना

thenCompose(Function<T, CompletionStage<U>>) फ़्यूचर के लिए flatMap जैसा है। यह नेस्टेड फ़्यूचर को समतल करके CompletableFuture<CompletableFuture<T>> से बचाता है।

// Wrong with thenApply — returns CF<CF<Order>>:
CompletableFuture<CompletableFuture<Order>> nested =
    fetchUser(id).thenApply(u -> fetchLatestOrder(u.getId()));
// Correct with thenCompose — returns CF<Order>:
CompletableFuture<Order> flat =
    fetchUser(id).thenCompose(u -> fetchLatestOrder(u.getId()));

क्रमिक अतुल्यकालिक कॉल के लिए thenCompose

जब प्रत्येक अतुल्यकालिक चरण पिछले चरण के परिणाम पर निर्भर हो, तब thenCompose का उपयोग करें — इससे चरण क्रमिक और परिणाम-निर्भर बनते हैं।

fetchUser(userId)
    .thenCompose(user -> fetchOrders(user.getId()))
    .thenCompose(orders -> computeTotal(orders))
    .thenAccept(total -> System.out.println("Total: " + total));

thenApply और thenCompose की तुलना

thenApply: T -> U का मानचित्रण करता है (तुल्यकालिक परिवर्तन)। thenCompose: T -> CompletableFuture<U> का मानचित्रण करके उसे समतल करता है। अगला चरण भी अतुल्यकालिक होने पर compose का उपयोग करें।

handle से मध्यवर्ती त्रुटियाँ संभालना

handle(BiFunction<T, Throwable, U>) फ़्यूचर सामान्य रूप से या अपवाद के साथ पूरा होने पर, दोनों स्थितियों में कॉल किया जाता है। इससे प्रक्रिया-श्रृंखला के बीच में त्रुटियों से उबरना या उन्हें बदलना संभव होता है।

fetchUser(id)
    .thenApply(User::getProfile)
    .handle((profile, ex) -> {
        if (ex != null) return Profile.empty(); // recover
        return profile;
    })
    .thenAccept(System.out::println);

whenComplete: किसी भी परिणाम के बाद प्रभाव

whenComplete(BiConsumer) पूरा होने के बाद (सामान्य या अपवादपूर्ण) लॉगिंग या सफ़ाई के लिए कॉल किया जाता है। handle के विपरीत, यह परिणाम नहीं बदलता।

fetchAsync()
    .whenComplete((result, ex) -> {
        if (ex != null) log.error("Failed", ex);
        else            log.info("Result: " + result);
    });

गैर-अवरोधकारी प्रक्रिया-श्रृंखला का उदाहरण

पूरी तरह गैर-अवरोधकारी प्रक्रिया-श्रृंखला बनाएँ: उपयोगकर्ता प्राप्त करें, उसके ऑर्डर प्राप्त करें और सारांश की गणना करें — सभी चरण अतुल्यकालिक रूप से चलते हैं और प्रत्येक पिछले चरण पर निर्भर करता है।

CompletableFuture<String> summary =
    fetchUser(userId)
        .thenCompose(u -> fetchOrders(u.getId()))
        .thenApply(orders -> orders.size() + " orders")
        .exceptionally(ex -> "Error: " + ex.getMessage());
System.out.println(summary.join());

त्वरित जाँच

thenApply के बजाय thenCompose का उपयोग कब करना चाहिए?

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावृत्ति

thenApply प्रक्रिया-श्रृंखला में तुल्यकालिक मानों को बदलता है। thenCompose अतुल्यकालिक चरणों की शृंखला बनाता है (फ़्यूचर के लिए flatMap)। handle / whenComplete त्रुटि-प्रबंधन और अतिरिक्त प्रभाव जोड़ते हैं। पठनीयता के लिए प्रक्रिया-श्रृंखलाएँ बाएँ से दाएँ बनाएँ।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Java सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 104
पाठ: 374

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “thenApply और thenCompose से Chaining” पाठ निःशुल्क है?

हाँ—“thenApply और thenCompose से Chaining” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Java Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Java Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“thenApply और thenCompose से Chaining” में मैं क्या सीखूँगा?

thenApply से results transform करें और nested futures से बचने के लिए thenCompose से async steps को flatMap करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Java Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Java Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Java Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“thenApply और thenCompose से Chaining” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Java Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Java Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Java Academy पर वापस जाएँ