Vavr के साथ कार्यात्मक जावा प्रोग्रामिंग

कई ने हास्केल और क्लोजर जैसी कार्यात्मक भाषाओं के बारे में सुना है। लेकिन उदाहरण के लिए, स्काला जैसी भाषाएं हैं। यह OOP और एक कार्यात्मक दृष्टिकोण दोनों को जोड़ती है। अच्छे पुराने जावा के बारे में क्या? क्या उस पर कार्यात्मक शैली में कार्यक्रम लिखना संभव है और यह कितना नुकसान पहुंचा सकता है? हाँ, जावा 8 है और धाराओं के साथ लैम्ब्डा है। यह भाषा के लिए एक बड़ा कदम है, लेकिन यह अभी भी पर्याप्त नहीं है। क्या इस स्थिति में कुछ के साथ आना संभव है? यह हाँ निकलता है।



आरंभ करने के लिए, आइए यह निर्धारित करने का प्रयास करें कि एक कार्यात्मक शैली में कोड लिखना क्या है। सबसे पहले, हमें उनके साथ चर और जोड़तोड़ के साथ नहीं, बल्कि कुछ गणनाओं की श्रृंखलाओं के साथ काम करना चाहिए। संक्षेप में, कार्यों का एक क्रम। इसके अलावा, हमारे पास विशेष डेटा संरचनाएं होनी चाहिए। उदाहरण के लिए, मानक जावा संग्रह उपयुक्त नहीं हैं। यह जल्द ही स्पष्ट हो जाएगा कि क्यों।

आइए कार्यात्मक संरचनाओं पर अधिक विस्तार से विचार करें। ऐसी किसी भी संरचना को कम से कम दो स्थितियों से संतुष्ट होना चाहिए:

• अपरिवर्तनीय - संरचना अपरिवर्तनीय होनी चाहिए। इसका मतलब यह है कि हम निर्माण के स्तर पर वस्तु की स्थिति को ठीक करते हैं और इसे अपने अस्तित्व के अंत तक ऐसे ही छोड़ देते हैं। एक शर्त के उल्लंघन का एक स्पष्ट उदाहरण: मानक ArrayList।
• लगातार - संरचना को यथासंभव लंबे समय तक मेमोरी में संग्रहीत किया जाना चाहिए। यदि हमने कुछ ऑब्जेक्ट बनाया है, तो उसी राज्य के साथ एक नया बनाने के बजाय, हमें तैयार एक का उपयोग करना चाहिए। औपचारिक रूप से, इस तरह की संरचनाएं अपने सभी पिछले राज्यों को संशोधित करती हैं। इन शर्तों का संदर्भ पूरी तरह से चालू होना चाहिए।

जाहिर है, हमें किसी तरह के तीसरे पक्ष के समाधान की आवश्यकता है। और इस तरह का एक समाधान है: वावर पुस्तकालय। आज यह एक कार्यात्मक शैली में काम करने के लिए सबसे लोकप्रिय जावा पुस्तकालय है। अगला, मैं पुस्तकालय की मुख्य विशेषताओं का वर्णन करूंगा। कई, लेकिन किसी भी तरह से सभी, उदाहरण और विवरण आधिकारिक दस्तावेज से लिए गए थे।

वावर लाइब्रेरी की मुख्य डेटा संरचनाएँ

गाड़ी

सबसे बुनियादी और सरल कार्यात्मक डेटा संरचनाओं में से एक ट्यूपल हैं। टपल एक निश्चित लंबाई का एक क्रमबद्ध सेट है। सूचियों के विपरीत, एक टपल में किसी भी प्रकार का डेटा हो सकता है।

Tuple tuple = Tuple.of(1, "blablabla", .0, 42L); // (1, blablabla, 0.0, 42) 

वांछित वस्तु प्राप्त करना क्षेत्र में आइटम नंबर के साथ कॉल करने से आता है।

 ((Tuple4) tuple)._1 // 1 

कृपया ध्यान दें: 1 पर tuple अनुक्रमण शुरू होता है! इसके अलावा, वांछित तत्व प्राप्त करने के लिए, हमें अपनी वस्तु को उचित प्रकार के तरीकों के साथ वांछित प्रकार में बदलना चाहिए। ऊपर दिए गए उदाहरण में, हमने 4 तत्वों के एक टपल का उपयोग किया, जिसका अर्थ है कि रूपांतरण टाइप टूले 4 का होना चाहिए। वास्तव में, कोई भी हमें सही प्रकार से शुरू करने से नहीं रोक रहा है।

 Tuple4 tuple = Tuple.of(1, "blablabla", .0, 42L); // (1, blablabla, 0.0, 42) System.out.println(tuple._1); // 1 

शीर्ष 3 vavr संग्रह

सूची

Vavr के साथ एक सूची बनाना बहुत सरल है। बिना ववर के भी आसान।

 List.of(1, 2, 3) 

हम ऐसी सूची के साथ क्या कर सकते हैं? ठीक है, सबसे पहले, हम इसे एक मानक जावा सूची में बदल सकते हैं।

 final boolean containThree = List.of(1, 2, 3) .asJava() .stream() .anyMatch(x -> x == 3); 

लेकिन वास्तव में, यह बहुत आवश्यक नहीं है, क्योंकि हम कर सकते हैं, उदाहरण के लिए, इस तरह:

 final boolean containThree = List.of(1, 2, 3) .find(x -> x == 1) .isDefined(); 

सामान्य तौर पर, मानक vavr लाइब्रेरी सूची में कई उपयोगी विधियाँ हैं। उदाहरण के लिए, एक बल्कि शक्तिशाली दृढ़ संकल्प फ़ंक्शन है जो आपको कुछ नियम और एक तटस्थ तत्व द्वारा मूल्यों की सूची को संयोजित करने की अनुमति देता है।

 //   final int zero = 0; //   final BiFunction<Integer, Integer, Integer> combine = (x, y) -> x + y; //   final int sum = List.of(1, 2, 3) .fold(zero, combine); //   

यहां एक महत्वपूर्ण बिंदु पर ध्यान दिया जाना चाहिए। हमारे पास कार्यात्मक डेटा संरचनाएं हैं, जिसका अर्थ है कि हम उनके राज्य को बदल नहीं सकते हैं। हमारी सूची को कैसे लागू किया गया है? अरे सिर्फ हमें शोभा नहीं देता।

डिफ़ॉल्ट सूची के रूप में सूचीबद्ध सूची

चलिए अपरिवर्तनीय वस्तुओं के साथ एक सरल लिंक की गई सूची बनाते हैं। यह कुछ इस तरह दिखेगा:




सूची के प्रत्येक तत्व की दो मुख्य विधियाँ हैं: मुख्य तत्व (हेड) और अन्य सभी (टेल) प्राप्त करना।


अब, यदि हम सूची में पहला तत्व बदलना चाहते हैं (1 से 0 तक), तो हमें तैयार भागों के पुन: उपयोग के साथ एक नई सूची बनाने की आवश्यकता है।



और वह सब है! चूंकि वर्कशीट में हमारी वस्तुएं अपरिवर्तनीय हैं, इसलिए हमें एक थ्रेड-सुरक्षित और पुन: प्रयोज्य संग्रह मिलता है। हमारी सूची के तत्वों को आवेदन में कहीं भी लगाया जा सकता है और यह पूरी तरह से सुरक्षित है!

बारी

एक और अत्यंत उपयोगी डेटा संरचना कतार है। कार्यात्मक शैली में प्रभावी और विश्वसनीय कार्यक्रमों के निर्माण के लिए एक कतार कैसे बनाएं? उदाहरण के लिए, हम पहले से ज्ञात डेटा संरचनाओं को ले सकते हैं: दो सूचियां और एक ट्यूपल।




जब पहला समाप्त होता है, तो हम दूसरे का विस्तार करते हैं और इसे पढ़ने के लिए उपयोग करते हैं।





यह याद रखना महत्वपूर्ण है कि कतार को अन्य सभी संरचनाओं की तरह अपरिवर्तित होना चाहिए। लेकिन एक कतार का उपयोग क्या है जो नहीं बदलता है? वास्तव में, एक चाल है। कतार के स्वीकृत मूल्य के रूप में, हमें दो तत्वों का एक हिस्सा मिलता है। पहला: वांछित कतार तत्व, दूसरा: इस तत्व के बिना कतार का क्या हुआ।

 System.out.println(queue); // Queue(1, 2, 3, 4, 5) Tuple2<Integer, Queue<Integer>> tuple2 = queue.dequeue(); System.out.println(tuple2._1); // 1 System.out.println(tuple2._2); // Queue(2, 3, 4, 5) 

धारा

अगली महत्वपूर्ण डेटा संरचना धारा है। एक धारा एक निश्चित, अक्सर सार, मूल्यों के सेट पर कुछ कार्यों के निष्पादन की एक धारा है।

कोई कह सकता है कि जावा 8 में पहले से ही पूर्ण धाराएँ हैं और हमें बिल्कुल भी नए की आवश्यकता नहीं है। क्या ऐसा है?

आरंभ करने के लिए, आइए सुनिश्चित करें कि जावा स्ट्रीम एक कार्यात्मक डेटा संरचना नहीं है। परिवर्तनशीलता के लिए संरचना की जाँच करें। ऐसा करने के लिए, एक ऐसी छोटी सी धारा बनाएं:

 IntStream standardStream = IntStream.range(1, 10); 

हम स्ट्रीम में सभी तत्वों के माध्यम से सॉर्ट करेंगे:

 standardStream.forEach(System.out::print); 

जवाब में, हमें कंसोल को आउटपुट मिलता है: 123456789 । चलो ब्रूट बल ऑपरेशन दोहराते हैं:

 standardStream.forEach(System.out::print); 

ओह, निम्नलिखित त्रुटि हुई:

 java.lang.IllegalStateException: stream has already been operated upon or closed 

तथ्य यह है कि मानक धाराएं एक इट्रेटर पर बस किसी प्रकार का अमूर्त है। यद्यपि यह धाराएँ बाहर की ओर बहुत स्वतंत्र और शक्तिशाली लगती हैं, फिर भी पुनरावृत्तियों के गायब नहीं हुए हैं।

उदाहरण के लिए, एक धारा की परिभाषा तत्वों की संख्या को सीमित करने के बारे में कुछ नहीं कहती है। दुर्भाग्य से, यह पुनरावृत्त में मौजूद है, जिसका अर्थ है कि यह मानक धाराओं में है।

सौभाग्य से, vavr पुस्तकालय इन समस्याओं को हल करता है। यह सुनिश्चित करें:

 Stream stream = Stream.range(1, 10); stream.forEach(System.out::print); stream.forEach(System.out::print); 

जवाब में, हमें 123456789123456789 मिलता है। जिसका अर्थ है कि पहले ऑपरेशन ने हमारी धारा को "खराब" नहीं किया।

आइए एक अंतहीन स्ट्रीम बनाने की कोशिश करें:

स्ट्रीम infiniteStream = Stream.from (1);
System.out.println (infiniteStream); // स्ट्रीम (1 ,?)

कृपया ध्यान दें: किसी वस्तु को प्रिंट करते समय, हमें एक अनंत संरचना नहीं मिलती है, लेकिन पहला तत्व और एक प्रश्न चिह्न होता है। तथ्य यह है कि धारा में प्रत्येक बाद का तत्व मक्खी पर उत्पन्न होता है। इस दृष्टिकोण को आलसी आरंभीकरण कहा जाता है। यह वह है जो आपको ऐसी संरचनाओं के साथ सुरक्षित रूप से काम करने की अनुमति देता है।

यदि आपने अनंत डेटा संरचनाओं के साथ काम नहीं किया है, तो सबसे अधिक संभावना है कि आप सोच रहे हैं: यह बिल्कुल क्यों आवश्यक है? लेकिन वे बेहद सुविधाजनक हो सकते हैं। हम एक स्ट्रीम लिखते हैं जो एक विषम संख्या में रिटर्न देता है, उन्हें एक स्ट्रिंग में परिवर्तित करता है और एक स्थान जोड़ता है:

 Stream oddNumbers = Stream .from(1, 2) //  1   2 .map(x -> x + " "); //  //   oddNumbers.take(5) .forEach(System.out::print); // 1 3 5 7 9 oddNumbers.take(10) .forEach(System.out::print); // 1 3 5 7 9 11 13 15 17 19 

इतना सरल।

संग्रह की सामान्य संरचना

बुनियादी संरचनाओं पर चर्चा करने के बाद, यह वावर कार्यात्मक संग्रह की सामान्य वास्तुकला को देखने का समय है:



संरचना के प्रत्येक तत्व को चलने योग्य के रूप में इस्तेमाल किया जा सकता है:

 StringBuilder builder = new StringBuilder(); for (String word : List.of("one", "two", "tree")) { if (builder.length() > 0) { builder.append(", "); } builder.append(word); } System.out.println(builder.toString()); // one, two, tree 

लेकिन आपको दो बार सोचना चाहिए और उपयोग करने से पहले डॉक देखना चाहिए। पुस्तकालय आपको परिचित चीजों को आसान बनाने की अनुमति देता है।

 System.out.println(List.of("one", "two", "tree").mkString(", ")); // one, two, tree 

कार्यों के साथ काम करें

पुस्तकालय में कई कार्य हैं (8 टुकड़े) और उनके साथ काम करने के लिए उपयोगी तरीके। वे कई दिलचस्प तरीकों के साथ साधारण कार्यात्मक इंटरफेस हैं। कार्यों का नाम स्वीकार किए गए तर्कों की संख्या (0 से 8 तक) पर निर्भर करता है। उदाहरण के लिए, फ़ंक्शन 0 कोई तर्क नहीं लेता है, फ़ंक्शन 1 एक तर्क लेता है, फ़ंक्शन 2 दो लेता है, आदि।

 Function2<String, String, String> combineName = (lastName, firstName) -> firstName + " " + lastName; System.out.println(combineName.apply("Griffin", "Peter")); // Peter Griffin 

वावर लाइब्रेरी के कार्यों में, हम बहुत सारी शांत चीजें कर सकते हैं। कार्यक्षमता के मामले में, वे मानक फ़ंक्शन, BiFunction, आदि से बहुत आगे जाते हैं। उदाहरण के लिए, करी। भागों में क्रियाओं का निर्माण कार्य है। आइए एक उदाहरण देखें:

 //    Function2<String, String, String> combineName = (lastName, firstName) -> firstName + " " + lastName; //           Function1<String, String> makeGriffinName = combineName .curried() .apply("Griffin"); //      System.out.println(makeGriffinName.apply("Peter")); // Peter Griffin System.out.println(makeGriffinName.apply("Lois")); // Lois Griffin 

जैसा कि आप देख सकते हैं, काफी रसीला। करी विधि बेहद सरल है, लेकिन बहुत उपयोगी हो सकती है।


फंक्शन सेट में कई और उपयोगी तरीके हैं। उदाहरण के लिए, आप किसी फ़ंक्शन का रिटर्न परिणाम कैश कर सकते हैं:

 Function0<Double> hashCache = Function0.of(Math::random).memoized(); double randomValue1 = hashCache.apply(); double randomValue2 = hashCache.apply(); System.out.println(randomValue1 == randomValue2); // true 

अपवादों के खिलाफ लड़ो

जैसा कि हमने पहले कहा था, प्रोग्रामिंग प्रक्रिया सुरक्षित होनी चाहिए। ऐसा करने के लिए, विभिन्न बाहरी प्रभावों से बचने के लिए आवश्यक है। अपवाद उनके स्पष्ट जनरेटर हैं।

आप एक कार्यात्मक शैली में अपवादों को सुरक्षित रूप से संभालने के लिए ट्राई क्लास का उपयोग कर सकते हैं। वास्तव में, यह एक विशिष्ट सन्यासी है । उपयोग के लिए सिद्धांत में तल्लीन करना आवश्यक नहीं है। बस एक साधारण उदाहरण देखें:

 Try.of(() -> 4 / 0) .onFailure(System.out::println) .onSuccess(System.out::println); 

जैसा कि आप उदाहरण से देख सकते हैं, सब कुछ काफी सरल है। हम घटना को संभावित त्रुटि पर लटकाते हैं और इसे संगणना की सीमा से आगे नहीं ले जाते हैं।

पैटर्न मिलान

अक्सर एक स्थिति उत्पन्न होती है जिसमें हमें परिणाम के आधार पर एक चर के मूल्य की जांच करने और कार्यक्रम के व्यवहार को मॉडल करने की आवश्यकता होती है। बस ऐसी स्थितियों में, एक अद्भुत टेम्पलेट खोज इंजन बचाव के लिए आता है। आपको अब और का एक गुच्छा नहीं लिखना है, बस सभी तर्क को एक स्थान पर कॉन्फ़िगर करें।

 import static io.vavr.API.*; import static io.vavr.Predicates.*; public class PatternMatchingDemo { public static void main(String[] args) { String s = Match(1993).of( Case($(42), () -> "one"), Case($(anyOf(isIn(1990, 1991, 1992), is(1993))), "two"), Case($(), "?") ); System.out.println(s); // two } } 

कृपया ध्यान दें कि मामला कैपिटल में है मामला एक कीवर्ड है और पहले से ही लिया गया है।

निष्कर्ष

मेरी राय में, पुस्तकालय बहुत अच्छा है, लेकिन यह बहुत सावधानी से उपयोग करने के लायक है। वह घटना-संचालित विकास में बहुत अच्छा कर सकती है। हालांकि, थ्रेड पूल पर आधारित मानक अनिवार्य प्रोग्रामिंग में इसका अत्यधिक और विचारहीन उपयोग बहुत अधिक सिरदर्द ला सकता है। इसके अलावा, अक्सर हमारी परियोजनाओं में हम स्प्रिंग और हाइबरनेट का उपयोग करते हैं, जो इस तरह के आवेदन के लिए हमेशा तैयार नहीं होते हैं। अपनी परियोजना में एक पुस्तकालय आयात करने से पहले, आपको इसकी स्पष्ट समझ की आवश्यकता है कि इसका उपयोग कैसे और क्यों किया जाएगा। मैं अपने अगले लेखों में किस बारे में बात करूंगा।