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

यह लेख इस बारे में है:

• जावा भाषा में प्रोग्रामिंग की कार्यात्मक शैली के आवेदन पर।
• जावा उदाहरणों में कार्यात्मक प्रोग्रामिंग से डेटा के संग्रह के साथ काम करने के लिए कुछ बुनियादी पैटर्न के बारे में।
• Google संग्रह लाइब्रेरी के बारे में थोड़ा सा।

यदि आप जावा, सी #, सी ++, पीएचपी, या किसी अन्य ओओ भाषा में प्रोग्राम करते हैं, तो कार्यात्मक प्रोग्रामिंग से परिचित होना चाहते हैं, लेकिन हास्केल / स्काला / लिस्प / पायथन सीखने की क्षमता / इच्छा नहीं है, यह लेख विशेष रूप से आपके लिए है।

जो लोग कार्यात्मक प्रोग्रामिंग से परिचित हैं, लेकिन जावा में इसका उपयोग कभी नहीं किया है, मुझे लगता है कि यह दिलचस्प भी होगा।

हम जावा भाषा में "फ़ंक्शन" के निर्माण का परिचय देते हैं

कार्यात्मक प्रोग्रामिंग क्या है? संक्षेप में, कार्यात्मक प्रोग्रामिंग प्रोग्रामिंग है जिसमें फ़ंक्शन ऑब्जेक्ट हैं, और उन्हें चर को सौंपा जा सकता है, अन्य कार्यों के लिए तर्क के रूप में पारित किया गया, फ़ंक्शन से परिणाम के रूप में लौटा, आदि। इस अवसर का पता चलता है कि लाभ होगा थोड़ी देर बाद समझें। अभी के लिए, हमें यह पता लगाने की आवश्यकता है कि जावा में "फ़ंक्शन" का उपयोग कैसे करें।

जैसा कि आप जानते हैं, जावा में कोई फ़ंक्शन नहीं हैं, केवल कक्षाएं, विधियां और क्लास ऑब्जेक्ट हैं। लेकिन जावा में अनाम कक्षाएं हैं, अर्थात, बिना नाम वाली कक्षाएं जिन्हें किसी भी विधि के कोड में सीधे घोषित किया जा सकता है। यह वही है जो हम उपयोग करेंगे। सबसे पहले, इस इंटरफ़ेस की घोषणा करें:

public final interface Function<F, T> { T apply(F from); } 

अब कुछ विधि के कोड में, हम इस इंटरफ़ेस के एक अनाम कार्यान्वयन की घोषणा कर सकते हैं:

 public static void main() { //  "",    intToString. Function<Integer, String> intToString = new Function<Integer, String>() { @Override public String apply(Integer from) { return from.toString(); } }; intToString.apply(9000); //   .   "9000". } 

हम ऐसे कार्यान्वयन को एक "अनाम फ़ंक्शन" कहेंगे। कार्यात्मक प्रोग्रामिंग के दृष्टिकोण से, आप इसे कार्यात्मक भाषाओं से एक फ़ंक्शन के साथ भी कर सकते हैं: चर को असाइन करें, इसे अन्य फ़ंक्शन (और वर्ग विधियों) के तर्क के रूप में पास करें, और फ़ंक्शन (और वर्ग विधियों) से परिणाम प्राप्त करें।

अब हम कार्यात्मक प्रोग्रामिंग के कुछ बुनियादी पैटर्न पेश करने पर आगे बढ़ सकते हैं।

कार्यात्मक शैली संग्रह

मान लीजिए कि हमारे पास पूर्णांकों का एक संग्रह है। हम उन्हें एक स्ट्रिंग के रूप में प्रदर्शित करना चाहते हैं, और स्ट्रिंग में प्रत्येक संख्या एक अल्पविराम द्वारा अलग हो जाएगी। एक गैर-कार्यात्मक समाधान कुछ इस तरह दिखाई देगा:

 public String joinNumbers(Collection<? extends Integer> numbers) { StringBuilder result = new StringBuilder(); boolean first = true; for (Integer number : numbers) { if (first) first = false; else result.append(", "); result.append(number); } return result; } 

एक कार्यात्मक समाधान को लागू करने के लिए, हमें पहले कई कार्यों और विधियों को तैयार करना होगा। हम उन्हें वर्ग के स्थिर क्षेत्रों के रूप में घोषित करेंगे:

 public static final Function<Integer, String> INT_TO_STRING = ... //    //      from,      transformer //         . public static <F, T> List<T> map(Collection<F> from, Function<? super F,? extends T> transformer) { ArrayList<T> result = new ArrayList<T>(); for (F element : from) result.add(transformer.apply(element)); return result; } //          public static <T> String join(Collection<T> from, String separator) { StringBuilder result = new StringBuilder(); boolean first = true; for (T element : from) { if (first) first = false; else result.append(separator); result.append(element); } return result.toString(); } 

अब हमारी joinNumbers विधि इस तरह दिखाई देगी:

 public String joinNumbers(Collection<? extends Integer> numbers) { return join(map(numbers, INT_TO_STRING), ", "); } 

विधि बिल्कुल एक सरल रेखा में कार्यान्वित की जाती है।

मैं कई महत्वपूर्ण बिंदुओं को नोट करना चाहूंगा:

1. map और join तरीके काफी सामान्यीकृत हैं, अर्थात, उनका उपयोग न केवल इस समस्या को हल करने के लिए किया जा सकता है। इसका मतलब यह है कि उन्हें एक उपयोगिता वर्ग में अलग किया जा सकता है, और फिर परियोजना के विभिन्न हिस्सों में इस वर्ग का उपयोग किया जा सकता है।
2. map विधि में Collection वर्ग के बजाय, हम Iterable पास कर सकते हैं और एक नए Iterable वापस कर सकते हैं, स्थानांतरित संग्रह से डेटा पुनर्प्राप्त कर सकते हैं क्योंकि हम लौटे हुए संग्रह में डेटा को क्रॉल करते हैं, अर्थात, तत्वों को प्राप्त करते हुए, आलसी, चरणों में, और सभी को एक बार में नहीं। इस तरह के कार्यान्वयन की अनुमति होगी, उदाहरण के लिए, डेटा परिवर्तन की श्रृंखलाएं बनाना, रूपांतरण के प्रत्येक चरण को एक अलग सरल फ़ंक्शन के रूप में उजागर करना, जबकि एल्गोरिथ्म की दक्षता ओ (एन) के आदेश पर रहेगी:
   map(map(numbers, MULTIPLY_X_2), INT_TO_STRING); // .
3. वर्ग बनाते समय, आप इसके कुछ तरीकों के लिए स्थैतिक क्षेत्र बना सकते हैं, जो आवरण कार्य होते हैं जो लागू कॉल को संबंधित वर्ग विधि के लिए कॉल को सौंपते हैं। यह कार्यात्मक शैली में वस्तुओं के "तरीकों" के उपयोग की अनुमति देगा, उदाहरण के लिए, ऊपर प्रस्तुत निर्माणों में।

Google संग्रह का उपयोग करके संग्रह के साथ काम करें

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

• interface Function<F, T> । एक इंटरफ़ेस जैसा कि मैंने ऊपर दिया था।
• Iterables.filter । एक संग्रह और एक विधेय फ़ंक्शन (एक फ़ंक्शन जो बूलियन मान लौटाता है) लेता है। जवाब में, यह मूल के सभी तत्वों से युक्त एक संग्रह लौटाता है, जिसमें निर्दिष्ट फ़ंक्शन सही लौटा है। यह सुविधाजनक है, उदाहरण के लिए, यदि हम संग्रह से सभी संख्याओं को फ़िल्टर करना चाहते हैं: Iterables.filter(numbers, IS_ODD);
• Iterables.transform । ऊपर दिए गए उदाहरण में मानचित्र कार्य के समान है।
• Functions.compose । इसमें दो कार्य होते हैं। यह एक नया फ़ंक्शन लौटाता है - उनकी संरचना, अर्थात्, एक फ़ंक्शन जो एक तत्व प्राप्त करता है, इसे दूसरे फ़ंक्शन को पास करता है, परिणाम पहले फ़ंक्शन को पास करता है, और पहले फ़ंक्शन से प्राप्त परिणाम उपयोगकर्ता को देता है। एक रचना का उपयोग किया जा सकता है, उदाहरण के लिए, निम्न प्रकार: Iterables.transform(numbers, Functions.compose(INT_TO_STRING, MULTIPLY_X_2));

बेशक, कार्यात्मक प्रोग्रामिंग के लिए Google संग्रह में कई अन्य उपयोगी चीजें हैं और साथ ही अनिवार्य शैली में संग्रह के साथ काम करने के लिए।

संदर्भ

• कार्यात्मक प्रोग्रामिंग पर विकिपीडिया लेख ।
• Google Guava , जिसका एक प्रोजेक्ट Google संग्रह एक हिस्सा है।
• जोशुआ बलोच के साथ Google संग्रह वीडियो प्रस्तुति ।
• अपाचे कॉमन्स कलेक्शंस । यह Google संग्रह के समान समस्याओं को हल करता है, लेकिन जावा 4 के तहत लिखा गया था, जो कि पैरामीट्रिक प्रकार के बिना है।

मैं आपको और क्या बताना चाहूंगा

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

1. उत्परिवर्तन और प्रतिरक्षा सर्किट।
2. पैटर्न-मेल खाने वाले।
3. इकाई।
4. एक कार्यात्मक दृष्टिकोण का उपयोग कर समानांतर।
5. पार्सर कॉम्बिनेटर।

मुझे आपकी टिप्पणियाँ और सुझाव सुनकर खुशी होगी।