जावा में कार्यात्मक प्रोग्रामिंग: उन्नत तकनीकें और Stream API

जावा में कार्यात्मक प्रोग्रामिंग: उन्नत स्तर

कार्यात्मक प्रोग्रामिंग (FP) एक प्रतिमान है जिसमें गणनाओं को गणितीय फलनों की गणना के रूप में देखा जाता है, जो स्थिति में परिवर्तन और परिवर्तनीय डेटा से बचते हैं। Java, एक ऑब्जेक्ट-ओरिएंटेड भाषा होने के बावजूद, Java 8 के आगमन के साथ FP के लिए शक्तिशाली उपकरण प्राप्त हुए: लैम्ब्डा एक्सप्रेशन, Stream API और कार्यात्मक इंटरफ़ेस। उन्नत स्तर पर, ये क्षमताएँ अधिक संक्षिप्त, सुरक्षित और अभिव्यंजक कोड लिखने की अनुमति देती हैं, विशेष रूप से कलेक्शन, एसिंक्रोनस ऑपरेशन और त्रुटि प्रबंधन के साथ काम करते समय।

इस लेख में, हम जावा में कार्यात्मक प्रोग्रामिंग की उन्नत तकनीकों पर विचार करेंगे: फ़ंक्शन संयोजन, मोनाड (Optional और CompletableFuture), समानांतर प्रसंस्करण के साथ Stream API और करीइंग।

1. फ़ंक्शन संयोजन और कार्यात्मक इंटरफ़ेस

जावा में, कार्यात्मक इंटरफ़ेस वे इंटरफ़ेस हैं जिनमें एक एकल अमूर्त विधि (SAM) होती है। सबसे अधिक उपयोग किए जाने वाले हैं: Function<T, R>, Predicate<T>, Consumer<T> और Supplier<T>। उन्नत उपयोग में andThen() और compose() विधियों के माध्यम से फ़ंक्शन संयोजन शामिल है।

उदाहरण: रूपांतरण श्रृंखला

import java.util.function.Function;

public class FunctionComposition {    public static void main(String[] args) {        // फ़ंक्शन: स्ट्रिंग -> उसकी लंबाई        Function<String, Integer> lengthFunction = String::length;        // फ़ंक्शन: संख्या -> उसका वर्ग        Function<Integer, Integer> squareFunction = x -> x * x;

        // संयोजन: स्ट्रिंग -> लंबाई -> लंबाई का वर्ग        Function<String, Integer> composedFunction = lengthFunction.andThen(squareFunction);

        String text = "Hello, Java!";        int result = composedFunction.apply(text); // 12 * 12 = 144        System.out.println("परिणाम: " + result); // 144    }}

andThen() विधि पहले फ़ंक्शन को लागू करती है, फिर दूसरे को। compose() इसके विपरीत करता है: पहले पारित फ़ंक्शन को लागू करता है, फिर पहले को। यह लचीली और पुन: प्रयोज्य रूपांतरण श्रृंखलाएँ बनाने की अनुमति देता है।

व्यावहारिक उदाहरण: सूची का फ़िल्टरिंग और रूपांतरण

import java.util.List;import java.util.function.Function;import java.util.function.Predicate;import java.util.stream.Collectors;

public class PredicateAndFunction {    public static void main(String[] args) {        List<String> names = List.of("Alice", "Bob", "Charlie", "David", "Eve");

        Predicate<String> startsWithA = s -> s.startsWith("A");        Function<String, String> toUpperCase = String::toUpperCase;

        List<String> result = names.stream()                .filter(startsWithA)                .map(toUpperCase)                .collect(Collectors.toList());

        System.out.println(result); // [ALICE]    }}

2. जावा में मोनाड: Optional और CompletableFuture

मोनाड एक पैटर्न है जो एक मान को एनकैप्सुलेट करता है और स्पष्ट अनरैपिंग के बिना इसे रूपांतरित करने के लिए संचालन प्रदान करता है। जावा में, मोनाड को Optional (null प्रबंधन के लिए) और CompletableFuture (एसिंक्रोनस संचालन के लिए) के माध्यम से कार्यान्वित किया जाता है।

Optional एक मोनाड के रूप में

map(), flatMap() और filter() विधियाँ मान की संभावित अनुपस्थिति के साथ श्रृंखलाबद्ध रूप से काम करने की अनुमति देती हैं।

import java.util.Optional;

public class OptionalMonad {    public static void main(String[] args) {        // गैर-रिक्त मान के साथ Optional बनाएं        Optional<String> optional = Optional.of("Hello");

        // रूपांतरण श्रृंखला        String result = optional                .filter(s -> s.length() > 3)   // फ़िल्टर                .m