Vavr संग्रह एपीआई गाइड

VAVR (जिसे पहले Javaslang के रूप में जाना जाता है) जावा 8+ के लिए एक गैर-लाभकारी कार्यात्मक पुस्तकालय है। यह आपको जावा में कार्यात्मक स्काला जैसे कोड लिखने की अनुमति देता है और कोड की मात्रा को कम करने और इसकी गुणवत्ता में सुधार करने का कार्य करता है। पुस्तकालय स्थल ।

कट के तहत वावर कलेक्शंस एपीआई पर जानकारी व्यवस्थित करने वाले एक लेख का अनुवाद है।

@Middle_java द्वारा अनुवादित

अंतिम संशोधित मूल लेख: 15 अगस्त, 2019

1. अवलोकन

Vavr लाइब्रेरी, जिसे पहले Javaslang के रूप में जाना जाता था, जावा के लिए एक कार्यात्मक लाइब्रेरी है। इस लेख में, हम इसके शक्तिशाली संग्रह एपीआई की खोज करते हैं।

इस पुस्तकालय के बारे में अधिक जानकारी के लिए यह लेख देखें।

2. लगातार संग्रह

एक निरंतर संग्रह, जब संशोधित किया जाता है, तो वर्तमान संस्करण को बदले बिना संग्रह का एक नया संस्करण बनाता है।

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

यह जावा यूटिलिटी क्लास Collections से unmodifiableCollection() से मौलिक रूप से अलग है, जो बस बेस कलेक्शन के लिए एक आवरण प्रदान करता है।

इस तरह के संग्रह को संशोधित करने का प्रयास एक नया संस्करण बनाने के बजाय UnsupportedOperationException । इसके अलावा, आधार संग्रह इसके प्रत्यक्ष लिंक के माध्यम से अभी भी परिवर्तनशील है।

3. ट्रैवर्सेबल

Traversable सभी ववर संग्रह का आधार प्रकार है। यह इंटरफ़ेस सभी डेटा संरचनाओं के लिए सामान्य तरीकों को परिभाषित करता है।

यह कुछ उपयोगी डिफ़ॉल्ट तरीके प्रदान करता है, जैसे size() , get() , filter() , isEmpty() और अन्य जो सब-इंटरफेस द्वारा विरासत में मिले हैं।

हम आगे संग्रह पुस्तकालय का अन्वेषण करते हैं।

4. सीक

चलिए सीक्वेंस से शुरुआत करते हैं।

Seq इंटरफ़ेस एक अनुक्रमिक डेटा संरचना है। यह List , Stream , Queue , Array , Vector और CharSeq लिए मूल इंटरफ़ेस है। इन सभी डेटा संरचनाओं के अपने विशिष्ट गुण हैं, जिनकी हम नीचे चर्चा करेंगे।

4.1। सूची

List एक ऊर्जावान रूप से गणना की जाती है (उत्सुकता से मूल्यांकन किया जाता है, ऑपरेशन किया जाता है जैसे ही इसके ऑपरेंड के मान ज्ञात हो जाते हैं) तत्वों का एक क्रम जो LinearSeq इंटरफ़ेस का विस्तार करता है।

लगातार List निर्माण प्रमुख और पूंछ का उपयोग करके किया जाता है:

• सिर पहला तत्व है
• पूंछ - शेष तत्वों से युक्त एक सूची (यह सूची भी सिर और पूंछ से बनाई गई है)

List API में स्थिर फ़ैक्टरी विधियाँ हैं जिनका उपयोग आप List बनाने के लिए कर सकते हैं। आप एक या अधिक ऑब्जेक्ट्स से List आवृत्ति बनाने के लिए of() विधि के स्थैतिक of() उपयोग कर सकते हैं।

आप एक खाली List बनाने के लिए स्थैतिक empty() विधि का उपयोग कर सकते हैं और प्रकार की List बनाने के लिए सभी विधि ofAll() विधि:

 List < String > list = List.of( "Java", "PHP", "Jquery", "JavaScript", "JShell", "JAVA"); 

आइए सूची हेरफेर के कुछ उदाहरणों को देखें।

हम पहले N तत्वों को हटाने के लिए drop() विधि और इसके वेरिएंट का उपयोग कर सकते हैं:

 List list1 = list.drop(2); assertFalse(list1.contains("Java") && list1.contains("PHP")); List list2 = list.dropRight(2); assertFalse(list2.contains("JAVA") && list2.contains("JShell")); List list3 = list.dropUntil(s - > s.contains("Shell")); assertEquals(list3.size(), 2); List list4 = list.dropWhile(s - > s.length() > 0); assertTrue(list4.isEmpty()); 

drop(int n) सूची से n आइटम हटाता है, पहले आइटम से शुरू होता है, जबकि dropRight() ऐसा ही करता है, सूची में अंतिम आइटम से शुरू होता है।

dropUntil() सूची से आइटम हटाता है जब तक कि विधेय true , जबकि dropWhile() आइटम हटाता है जब तक कि विधेय true ।

dropRightWhile() और dropRightUntil() विधियाँ भी हैं जो दाईं ओर से शुरू होने वाली वस्तुओं को dropRightUntil() ।

अगला, सूची से आइटम पुनर्प्राप्त करने के take(int n) उपयोग किया जाता है। यह सूची से n आइटम लेता है और फिर बंद हो जाता है। इसमें takeRight(int n) , जो सूची के अंत से तत्व लेता है:

 List list5 = list.take(1); assertEquals(list5.single(), "Java"); List list6 = list.takeRight(1); assertEquals(list5.single(), "Java"); List list7 = list.takeUntil(s - > s.length() > 6); assertEquals(list3.size(), 3); 

अंत में, takeUntil() सूची से तत्व लेता है जब तक कि विधेय true हो जाता। takeWhile() का एक प्रकार है जो एक विधेय तर्क भी लेता है।

इसके अलावा, एपीआई में अन्य उपयोगी विधियां हैं, उदाहरण के लिए, यहां तक ​​कि distinct() , जो हटाए गए डुप्लिकेट के साथ तत्वों की एक सूची देता है, और distinctBy() , जो समानता को निर्धारित करने के लिए Comparator को स्वीकार करता है।

यह बहुत दिलचस्प है कि intersperse() भी है, जो सूची के प्रत्येक तत्व के बीच एक तत्व सम्मिलित करता है। String साथ संचालन के लिए यह बहुत सुविधाजनक हो सकता है:

 List list8 = list .distinctBy((s1, s2) - > s1.startsWith(s2.charAt(0) + "") ? 0 : 1); assertEquals(list3.size(), 2); String words = List.of("Boys", "Girls") .intersperse("and") .reduce((s1, s2) - > s1.concat(" " + s2)) .trim(); assertEquals(words, "Boys and Girls"); 

सूची को श्रेणियों में विभाजित करना चाहते हैं? और इसके लिए एक एपीआई है:

 Iterator < List < String >> iterator = list.grouped(2); assertEquals(iterator.head().size(), 2); Map < Boolean, List < String >> map = list.groupBy(e - > e.startsWith("J")); assertEquals(map.size(), 2); assertEquals(map.get(false).get().size(), 1); assertEquals(map.get(true).get().size(), 5); 

group(int n) विधि अलग-अलग तत्वों के समूह में List को विभाजित करती है। groupdBy() पद्धति में एक Function होता है जिसमें सूची को विभाजित करने के लिए तर्क होता है और दो तत्वों के साथ एक Map देता है: true और false ।

true कुंजी को Function में निर्दिष्ट स्थिति को संतुष्ट करने वाले तत्वों की List पर मैप किया गया है। उन तत्वों की List false प्रमुख नक्शे जो इस स्थिति को संतुष्ट नहीं करते हैं।

जैसा कि अपेक्षित था, List बदलते समय, मूल List वास्तव में नहीं बदलती है। इसके बजाय, List नया संस्करण हमेशा लौटाया जाता है।

हम स्टैक के शब्दार्थ का उपयोग करके List के साथ बातचीत भी कर सकते हैं - "अंतिम, पहले बाहर" सिद्धांत (LIFO) के अनुसार तत्वों को निकालने वाले। इस अर्थ में, एपीआई विधियाँ जैसे कि peek() , pop() और push() स्टैक में हेरफेर के लिए मौजूद हैं:

 List < Integer > intList = List.empty(); List < Integer > intList1 = intList.pushAll(List.rangeClosed(5, 10)); assertEquals(intList1.peek(), Integer.valueOf(10)); List intList2 = intList1.pop(); assertEquals(intList2.size(), (intList1.size() - 1)); 

स्टैक पर पूर्णांक की एक श्रृंखला सम्मिलित करने के लिए pushAll() फ़ंक्शन का उपयोग किया जाता है, और स्टैक के मुख्य तत्व को पुनः प्राप्त करने के लिए peek() फ़ंक्शन का उपयोग किया जाता है। एक peekOption() विधि भी है जो Option ऑब्जेक्ट में परिणाम को लपेट सकती है।

List इंटरफ़ेस में अन्य रोचक और वास्तव में उपयोगी विधियां हैं जो जावा डॉक्स में पूरी तरह से प्रलेखित हैं।

4.2। कतार

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

अंदर Queue में दो लिंक की गई सूची होती है: सामने की List और पीछे की List । सामने की List में कतार से हटाए गए आइटम हैं, और पीछे की List में पंक्तिबद्ध आइटम शामिल हैं।

यह आपको कतारबद्धता को हटाने और कतार से हटाने की जटिलता ओ (1) की अनुमति देता है । जब List सामने की List में समाप्त हो जाती है जब इसे कतार से हटा दिया जाता है, तो पीछे की List उलट जाती है और नई सामने List बन जाती है।

आइए एक कतार बनाएँ:

 Queue < Integer > queue = Queue.of(1, 2); Queue < Integer > secondQueue = queue.enqueueAll(List.of(4, 5)); assertEquals(3, queue.size()); assertEquals(5, secondQueue.size()); Tuple2 < Integer, Queue < Integer >> result = secondQueue.dequeue(); assertEquals(Integer.valueOf(1), result._1); Queue < Integer > tailQueue = result._2; assertFalse(tailQueue.contains(secondQueue.get(0))); 

dequeue() फ़ंक्शन Queue से हेड एलिमेंट को हटा देता है और Tuple2<T, Q> लौटाता है। टपल का पहला तत्व कतार से हटाए जाने वाला मुख्य तत्व है, टुपल का दूसरा तत्व शेष Queue तत्व है।

हम Queue में तत्वों के सभी संभावित N संयोजनों को प्राप्त करने के लिए combination(n) का उपयोग कर सकते हैं:

 Queue < Queue < Integer >> queue1 = queue.combinations(2); assertEquals(queue1.get(2).toCharSeq(), CharSeq.of("23")); 

एक बार फिर, Queue से आइटम जोड़ने / हटाने के दौरान मूल Queue नहीं बदलती है।

4.3। धारा

Stream एक lazily लिंक्ड सूची का कार्यान्वयन है जो java.util.stream से काफी अलग है। Java.util.stream के विपरीत, Stream Vavr डेटा संग्रहीत करता है और आलसी बाद के तत्वों की गणना करता है।
मान लें कि हमारे पास Stream पूर्णांक हैं:

 Stream < Integer > s = Stream.of(2, 1, 3, 4); 

कंसोल में s.toString() के परिणाम को प्रिंट करते समय, केवल स्ट्रीम (2,?) प्रदर्शित की जाएगी। इसका मतलब यह है कि केवल Stream हेड तत्व की गणना की गई थी, जबकि पूंछ तत्व नहीं थे।

s.get(3) कॉल s.get(3) और फिर s.tail() रिटर्न स्ट्रीम (1, 3, 4 ,?) का परिणाम प्रदर्शित करना। इसके विपरीत, यदि आप s.get(3) कॉल नहीं करते हैं - जो Stream को अंतिम तत्व की गणना करेगा - केवल स्ट्रीम (1 ,?) s.tail() ) का परिणाम होगा। इसका मतलब है कि केवल पहले पूंछ तत्व की गणना की गई थी।

यह व्यवहार प्रदर्शन में सुधार कर सकता है और Stream को उन दृश्यों का प्रतिनिधित्व करने के लिए उपयोग करने की अनुमति देता है जो (सैद्धांतिक रूप से) असीम रूप से लंबे होते हैं।
वावर में Stream अपरिवर्तनीय है और Empty या Cons हो सकता है। Cons में सिर तत्व और Stream की आलसी गणना की पूंछ शामिल है। List विपरीत, Stream मुख्य तत्व को मेमोरी में संग्रहीत करता है। टेल तत्वों की गणना आवश्यकतानुसार की जाती है।

आइए 10 धनात्मक पूर्णांक की एक Stream बनाएं और सम संख्याओं के योग की गणना करें:

 Stream < Integer > intStream = Stream.iterate(0, i - > i + 1) .take(10); assertEquals(10, intStream.size()); long evenSum = intStream.filter(i - > i % 2 == 0) .sum() .longValue(); assertEquals(20, evenSum); 

Java 8 से Stream एपीआई के विपरीत, Vavr में Stream तत्वों के अनुक्रम को संग्रहीत करने के लिए एक डेटा संरचना है।

इसलिए, इसमें अपने तत्वों में हेरफेर करने के लिए तरीके get() जैसे get() , append() , insert() और अन्य शामिल हैं। drop() , distinct() और पहले चर्चा की गई कुछ अन्य विधियां भी उपलब्ध हैं।

अंत में, आइए Stream में tabulate() प्रदर्शित करें। यह विधि लंबाई n युक्त तत्वों Stream एक Stream जो फ़ंक्शन को लागू करने का परिणाम हैं:

 Stream < Integer > s1 = Stream.tabulate(5, (i) - > i + 1); assertEquals(s1.get(2).intValue(), 3); 

हम Tuple2<Integer, Integer> से एक Stream बनाने के लिए zip() का भी उपयोग कर सकते हैं, जिसमें Stream को संयोजित करके बनाए गए तत्व शामिल हैं:

 Stream < Integer > s = Stream.of(2, 1, 3, 4); Stream < Tuple2 < Integer, Integer >> s2 = s.zip(List.of(7, 8, 9)); Tuple2 < Integer, Integer > t1 = s2.get(0); assertEquals(t1._1().intValue(), 2); assertEquals(t1._2().intValue(), 7); 

4.4। सरणी

Array एक अपरिवर्तनीय अनुक्रमित अनुक्रम है जो कुशल यादृच्छिक अभिगम प्रदान करता है। यह वस्तुओं की एक जावा सरणी पर आधारित है। संक्षेप में, यह टाइप T की वस्तुओं की एक सरणी के लिए एक Traversable रैपर है T

आप of() विधि के स्थिर of() उपयोग करके Array का एक उदाहरण बना सकते हैं। इसके अलावा, आप स्टेटिक मेथड्स range() और rangeBy() का उपयोग करके कई प्रकार के तत्व बना सकते हैं। rangeBy() विधि में एक तीसरा पैरामीटर है, जो आपको कदम निर्धारित करने की अनुमति देता है।

range() और rangeBy() विधियों से तत्वों का निर्माण होगा, जो प्रारंभिक मूल्य से अंतिम मूल्य शून्य से शुरू होता है। अगर हमें अंतिम मूल्य को शामिल करने की आवश्यकता है, तो हम rangeClosed() या rangeClosedBy() उपयोग कर सकते हैं:

 Array < Integer > rArray = Array.range(1, 5); assertFalse(rArray.contains(5)); Array < Integer > rArray2 = Array.rangeClosed(1, 5); assertTrue(rArray2.contains(5)); Array < Integer > rArray3 = Array.rangeClosedBy(1, 6, 2); assertEquals(list3.size(), 3); 

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

 Array < Integer > intArray = Array.of(1, 2, 3); Array < Integer > newArray = intArray.removeAt(1); assertEquals(3, intArray.size()); assertEquals(2, newArray.size()); assertEquals(3, newArray.get(1).intValue()); Array < Integer > array2 = intArray.replace(1, 5); assertEquals(s1.get(0).intValue(), 5); 

4.5। वेक्टर

Vector Array और List बीच एक क्रॉस है, तत्वों का एक और अनुक्रमित अनुक्रम प्रदान करता है, जो निरंतर समय में यादृच्छिक अभिगम और संशोधन दोनों की अनुमति देता है:

 Vector < Integer > intVector = Vector.range(1, 5); Vector < Integer > newVector = intVector.replace(2, 6); assertEquals(4, intVector.size()); assertEquals(4, newVector.size()); assertEquals(2, intVector.get(1).intValue()); assertEquals(6, newVector.get(1).intValue()); 

4.6। CharSeq

CharSeq आदिम पात्रों के अनुक्रम का प्रतिनिधित्व करने के लिए एक संग्रह वस्तु है। संक्षेप में, संग्रह के संचालन के अतिरिक्त String लिए यह एक आवरण है।

CharSeq बनाने के लिए आपको निम्नलिखित कार्य करने होंगे।

 CharSeq chars = CharSeq.of("vavr"); CharSeq newChars = chars.replace('v', 'V'); assertEquals(4, chars.size()); assertEquals(4, newChars.size()); assertEquals('v', chars.charAt(0)); assertEquals('V', newChars.charAt(0)); assertEquals("Vavr", newChars.mkString()); 

5. सेट करें

यह खंड संग्रह पुस्तकालय में Set के विभिन्न कार्यान्वयन पर चर्चा करता है। Set डेटा संरचना की एक अनूठी विशेषता यह है कि यह डुप्लिकेट मानों की अनुमति नहीं देता है।

Set विभिन्न कार्यान्वयन हैं। मुख्य एक HashSet । TreeSet डुप्लिकेट तत्वों की अनुमति नहीं देता है और इसे सॉर्ट किया जा सकता है। LinkedHashSet तत्वों के सम्मिलन क्रम को सुरक्षित रखता है।

आइए एक के बाद एक इन कार्यान्वयनों पर करीब से नज़र डालें।

5.1। HashSet

नए उदाहरण बनाने के लिए HashSet में स्थिर फ़ैक्टरी विधियाँ हैं। जिनमें से कुछ का हमने पहले इस लेख में अध्ययन किया था, उदाहरण of() , ofAll() और range() विधियों पर भिन्नताएं।

diff() विधि का उपयोग करके दो सेट के बीच अंतर प्राप्त किया जा सकता है। इसके अलावा, union() और intersect() तरीके संघ और दो सेट के प्रतिच्छेदन लौटाते हैं:

 HashSet < Integer > set0 = HashSet.rangeClosed(1, 5); HashSet < Integer > set0 = HashSet.rangeClosed(1, 5); assertEquals(set0.union(set1), HashSet.rangeClosed(1, 6)); assertEquals(set0.diff(set1), HashSet.rangeClosed(1, 2)); assertEquals(set0.intersect(set1), HashSet.rangeClosed(3, 5)); 

हम बुनियादी संचालन भी कर सकते हैं, जैसे कि तत्वों को जोड़ना और हटाना:

 HashSet < String > set = HashSet.of("Red", "Green", "Blue"); HashSet < String > newSet = set.add("Yellow"); assertEquals(3, set.size()); assertEquals(4, newSet.size()); assertTrue(newSet.contains("Yellow")); 

HashSet कार्यान्वयन हैश सरणी मैपेड ट्राइ (एचएएमटी) पर आधारित है, जो नियमित हैशटेबल की तुलना में बेहतर प्रदर्शन का दावा करता है और इसकी संरचना इसे लगातार संग्रह का समर्थन करने के लिए उपयुक्त बनाती है।

5.2। TreeSet

अपरिवर्तनीय SortedSet इंटरफ़ेस का कार्यान्वयन है। यह सॉर्ट किए गए तत्वों के एक सेट को संग्रहीत करता है और बाइनरी सर्च ट्री का उपयोग करके कार्यान्वित किया जाता है। इसके सभी ऑपरेशन ओ (लॉग एन) समय के दौरान किए जाते हैं।

डिफ़ॉल्ट रूप से, TreeSet तत्वों को उनके प्राकृतिक क्रम में क्रमबद्ध किया जाता है।
आइए एक प्राकृतिक सॉर्ट क्रम का उपयोग करके एक SortedSet बनाएं:

 SortedSet < String > set = TreeSet.of("Red", "Green", "Blue"); assertEquals("Blue", set.head()); SortedSet < Integer > intSet = TreeSet.of(1, 2, 3); assertEquals(2, intSet.average().get().intValue()); 

कस्टम तरीके से आइटम की व्यवस्था करने के लिए, TreeSet बनाते समय एक Comparator इंस्टेंस पास करें। आप तत्वों के एक सेट से एक स्ट्रिंग भी बना सकते हैं:

 SortedSet < String > reversedSet = TreeSet.of(Comparator.reverseOrder(), "Green", "Red", "Blue"); assertEquals("Red", reversedSet.head()); String str = reversedSet.mkString(" and "); assertEquals("Red and Green and Blue", str); 

5.3। BitSet

Vavr संग्रह में एक अपरिवर्तनीय BitSet कार्यान्वयन भी है। BitSet इंटरफ़ेस BitSet इंटरफ़ेस का विस्तार करता है। BitSet स्थिर तरीकों का उपयोग करके BitSet बनाया जा सकता है।
Set डेटा संरचना के अन्य कार्यान्वयन के साथ, BitSet आपको एक सेट में डुप्लिकेट रिकॉर्ड जोड़ने की अनुमति नहीं देता है।

यह Traversable इंटरफ़ेस से हेरफेर करने के तरीकों को विरासत में मिला है। ध्यान दें कि यह मानक जावा लाइब्रेरी से java.util.BitSet से अलग है। BitSet डेटा में String मान नहीं हो सकते।

of() फ़ैक्टरी विधि of() उपयोग करके BitSet का एक उदाहरण बनाने पर विचार करें:

 BitSet < Integer > bitSet = BitSet.of(1, 2, 3, 4, 5, 6, 7, 8); BitSet < Integer > bitSet1 = bitSet.takeUntil(i - > i > 4); assertEquals(list3.size(), 4); 

पहले चार BitSet तत्वों का चयन करने के लिए BitSet हमने takeUntil() कमांड का उपयोग किया। ऑपरेशन ने एक नया उदाहरण लौटाया। ध्यान दें कि takeUntil() विधि Traversable इंटरफ़ेस में परिभाषित की गई है, जो BitSet लिए मूल इंटरफ़ेस है।

Traversable इंटरफ़ेस में ऊपर वर्णित अन्य तरीके और संचालन भी BitSet लागू होते हैं।

6. नक्शा

Map एक कुंजी-मूल्य डेटा संरचना है। Vavr में Map अपरिवर्तनीय है और इसमें HashMap , TreeMap और LinkedHashMap ।

आमतौर पर, मानचित्र अनुबंध डुप्लिकेट कुंजियों की अनुमति नहीं देते हैं, जबकि डुप्लिकेट मान अलग-अलग कुंजियों के लिए मैप किए जा सकते हैं।

6.1। HashMap

HashMap अपरिवर्तनीय Map इंटरफ़ेस का कार्यान्वयन है। यह कुंजी के हैश का उपयोग करके कुंजी-मूल्य जोड़े को संग्रहीत करता है।

Vavr में Map पारंपरिक Entry प्रकार के बजाय कुंजी-मूल्य जोड़े का प्रतिनिधित्व करने के लिए Tuple2 का उपयोग करता है:

 Map < Integer, List < Integer >> map = List.rangeClosed(0, 10) .groupBy(i - > i % 2); assertEquals(2, map.size()); assertEquals(6, map.get(0).get().size()); assertEquals(5, map.get(1).get().size()); 

हैशसेट की तरह , हैशपे का कार्यान्वयन हैश एरे मैप्ड ट्राइ (एचएएमटी) पर आधारित है, जो लगभग सभी ऑपरेशनों के लिए निरंतर समय की ओर जाता है।
फ़िल्टर तत्वों को filterKeys() विधि का उपयोग करके या filterKeys() विधि का उपयोग करके मान द्वारा फ़िल्टर किया जा सकता है। दोनों तरीकों को तर्क के रूप में Predicate :

 Map < String, String > map1 = HashMap.of("key1", "val1", "key2", "val2", "key3", "val3"); Map < String, String > fMap = map1.filterKeys(k - > k.contains("1") || k.contains("2")); assertFalse(fMap.containsKey("key3")); Map < String, String > map1 = map1.filterValues(v - > v.contains("3")); assertEquals(list3.size(), 1); assertTrue(fMap2.containsValue("val3")); 

आप map() पद्धति का उपयोग करके मानचित्र तत्वों को भी रूपांतरित कर सकते हैं। उदाहरण के लिए, हम map1 को Map<String, Integer> बदलें :

 Map < String, Integer > map2 = map1.map( (k, v) - > Tuple.of(k, Integer.valueOf(v.charAt(v.length() - 1) + ""))); assertEquals(map2.get("key1").get().intValue(), 1); 

6.2। ट्री-मैप

अपरिवर्तनीय TreeMap SortedMap इंटरफ़ेस का एक कार्यान्वयन है। TreeSet साथ, TreeMap तत्वों के छंटाई को अनुकूलित करने के लिए TreeSet एक कस्टम उदाहरण उपयोग किया जाता है।
SortedMap के निर्माण को प्रदर्शित करते हैं:

 SortedMap < Integer, String > map = TreeMap.of(3, "Three", 2, "Two", 4, "Four", 1, "One"); assertEquals(1, map.keySet().toJavaArray()[0]); assertEquals("Four", map.get(4).get()); 

डिफ़ॉल्ट रूप से, TreeMap प्रविष्टियाँ प्राकृतिक कुंजी क्रम में क्रमबद्ध होती हैं। हालाँकि, आप छँटाई के लिए उपयोग किए जाने वाले Comparator को निर्दिष्ट कर सकते हैं:

 TreeMap < Integer, String > treeMap2 = TreeMap.of(Comparator.reverseOrder(), 3, "three", 6, "six", 1, "one"); assertEquals(treeMap2.keySet().mkString(), "631"); 

TreeSet के मामले में, ट्री के उपयोग से TreeMap कार्यान्वयन भी बनाया गया है, इसलिए, इसके संचालन में समय ओ (लॉग एन) है । map.get(key) विधि रिटर्न Option , जिसमें निर्दिष्ट मानचित्र कुंजी का मान होता है।

7. जावा संगतता

Vavr Collection API जावा संग्रह फ्रेमवर्क के साथ पूरी तरह से संगत है। आइए देखें कि यह व्यवहार में कैसे किया जाता है।

7.1। जावा से Vavr में परिवर्तित करें

Vavr में प्रत्येक संग्रह कार्यान्वयन में AAll ofAll() विधि का एक स्थिर कारखाना है जो java.util.Iterable स्वीकार करता है। यह आपको जावा संग्रह से ववर संग्रह बनाने की अनुमति देता है। इसी तरह, एक और ofAll() फैक्टरी विधि सीधे जावा Stream स्वीकार करती है।

जावा List को अपरिवर्तनीय List बदलने के लिए:

 java.util.List < Integer > javaList = java.util.Arrays.asList(1, 2, 3, 4); List < Integer > vavrList = List.ofAll(javaList); java.util.stream.Stream < Integer > javaStream = javaList.stream(); Set < Integer > vavrSet = HashSet.ofAll(javaStream); 

एक अन्य उपयोगी फ़ंक्शन collector() , जिसका उपयोग Vavr संग्रह प्राप्त करने के लिए Stream.collect() के साथ संयोजन में किया जा सकता है:

 List < Integer > vavrList = IntStream.range(1, 10) .boxed() .filter(i - > i % 2 == 0) .collect(List.collector()); assertEquals(4, vavrList.size()); assertEquals(2, vavrList.head().intValue()); 

7.2। Vavr से जावा में परिवर्तित करें

Value इंटरफ़ेस में Vavr प्रकार से जावा प्रकार में परिवर्तित करने के लिए कई तरीके हैं। इन विधियों में toJavaXXX() प्रारूप है।

कुछ उदाहरणों पर विचार करें:

 Integer[] array = List.of(1, 2, 3) .toJavaArray(Integer.class); assertEquals(3, array.length); java.util.Map < String, Integer > map = List.of("1", "2", "3") .toJavaMap(i - > Tuple.of(i, Integer.valueOf(i))); assertEquals(2, map.get("2").intValue()); 

हम Vavr संग्रह से आइटम एकत्र करने के लिए Java 8 Collectors का भी उपयोग कर सकते हैं:

 java.util.Set < Integer > javaSet = List.of(1, 2, 3) .collect(Collectors.toSet()); assertEquals(3, javaSet.size()); assertEquals(1, javaSet.toArray()[0]); 

7.3। जावा कलेक्शंस व्यूज

इसके अलावा, पुस्तकालय तथाकथित संग्रह विचार प्रदान करता है जो जावा संग्रह में परिवर्तित होने पर सबसे अच्छा काम करता है। जावा संग्रह बनाने के लिए सभी तत्वों के पिछले अनुभाग में परिवर्तन विधियाँ

दूसरी ओर, वेव आधार संग्रह में मानक जावा इंटरफेस और प्रतिनिधि पद्धति कॉल को लागू करें।

इस लेखन के समय, केवल List दृश्य समर्थित है। प्रत्येक अनुक्रमिक संग्रह के दो तरीके हैं: एक अपरिवर्तनीय प्रतिनिधित्व बनाने के लिए, दूसरा परिवर्तनशील के लिए।

अपरिवर्तनीय दृश्य पर बदलने के लिए कॉलिंग विधियाँ UnsupportedOperationException ।

आइए एक उदाहरण देखें:

 @Test(expected = UnsupportedOperationException.class) public void givenVavrList_whenViewConverted_thenException() { java.util.List < Integer > javaList = List.of(1, 2, 3) .asJava(); assertEquals(3, javaList.get(2).intValue()); javaList.add(4); } 

एक अपरिवर्तनीय दृश्य बनाने के लिए:

 java.util.List < Integer > javaList = List.of(1, 2, 3) .asJavaMutable(); javaList.add(4); assertEquals(4, javaList.get(3).intValue()); 

8. निष्कर्ष

इस ट्यूटोरियल में, हमने ववर कलेक्शंस एपीआई द्वारा प्रदान की गई विभिन्न कार्यात्मक डेटा संरचनाओं के बारे में सीखा। वहाँ भी उपयोगी और उत्पादक एपीआई तरीके हैं जो जावा डॉक्टर और वावर कलेक्शंस यूजर गाइड में पाए जा सकते हैं।

अंत में, यह नोट करना महत्वपूर्ण है कि लाइब्रेरी Try , Option , Iterable Either और Future को भी परिभाषित करती है, जो Value इंटरफ़ेस का विस्तार करते हैं और परिणामस्वरूप, जावा Iterable इंटरफ़ेस को लागू करते हैं। इसका मतलब है कि कुछ स्थितियों में वे संग्रह की तरह व्यवहार कर सकते हैं।

इस लेख में सभी उदाहरणों के लिए पूर्ण स्रोत कोड जीथब पर पाया जा सकता है।

अतिरिक्त सामग्री:
habr.com/ru/post/421839
www.baeldung.com/vavr

@Middle_java द्वारा अनुवादित