जावा और उनके संग्रह में वस्तुओं के टप्ल्स

अक्सर अभ्यास में "जोड़ी" ( Pair<First, Second> ) के रूप में इस तरह के निर्माणों का उपयोग करने की आवश्यकता होती है, कम बार "ट्रिनर" ऑब्जेक्ट्स ( Triplet<First, Second, Third> ) और संबंधित वस्तुओं की लंबी श्रृंखला। इस संबंध में, मैं हमेशा सोच रहा था कि JDK में ( java.lang.* या java.util.* ) अभी भी कोई मानक Pair<First, Second> या लंबा निर्माण क्यों नहीं है। मुझे लगता है कि कई जावा प्रोग्रामर का अपना "जोड़ी" कार्यान्वयन है। मैं कोई अपवाद नहीं हूं।

और एक बार फिर बड़ी संख्या में अलग-अलग tuples के साथ काम करने की आवश्यकता पर ठोकर खाई, मैंने इस समस्या से व्यवस्थित रूप से निपटने का फैसला किया। वह परियोजना के लिए एक नाम के साथ आया, लक्ष्य निर्धारित किया और कुछ समय लेने वाले प्रयोगों के बाद, कोड (git: //github.com/telesik/rumba.git) पोस्ट किया।

मैं क्या हासिल करना चाहता था:

• एक सुविधाजनक निर्माण की आवश्यकता है (चलो इसे एक टपल कहते हैं ) कई वस्तुओं के संघ के लिए जिनके प्रकार परिणामी टपल में स्थिति से निर्धारित किए जाएंगे;
• एक टपल लंबाई और प्रकार में असीमित होना चाहिए;
• तत्व प्रकार अपेक्षाकृत नियंत्रित होना चाहिए (कम से कम जेनरिक तक सीमित);
• टपल की संरचना का विवरण सरल होना चाहिए;

टपल की रोशनी की घटना

और यहाँ Cortege इंटरफ़ेस Cortege :

 public interface Cortege<V, T extends Cortege> { T setValue(V value); T nextElement(); <Vi> Vi getValue(int index) throws ClassCastException; // be careful with types. Type is not bounded int getDeep(); <Vi> void setValue(int index, Vi value); // be careful with types. Type is not bounded Cortege<V, T> setValues(Object... values); // be careful with types. Type is not bounded!!! V getValue(); static abstract class End<V, T extends Cortege<V, T>> implements Cortege<V, T> { } } 

नीचे दिया गया आंकड़ा स्पष्ट रूप से मनमानी लंबाई और तत्व प्रकारों के ट्यूपल्स का वर्णन करने के लिए तंत्र को दर्शाता है

अंजीर। 1. मनमानी लंबाई और तत्वों के प्रकार के tuples का वर्णन करने के लिए तंत्र

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

उपयोग के उदाहरण

मैं तुरंत उपयोग के उदाहरण के लिए पास करूंगा:

 //   : Cortege<Long, Cortege<String, Cortege.End>> cortegeLS = CortegeChain.create(2); 

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

नोट: लेकिन फिर भी, अगर कोई अपने समाधान की पेशकश कर सकता है, तो यह पैरामीटर के साथ एक समस्या है - मैं बहुत आभारी रहूंगा।

तो एक उदाहरण है

 //    // 1-  (    ,   ) cortegeLS.setValue(4L); cortegeLS.nextElement().setValue("str"); // 2-  (  ,   ) cortegeLS.setValue(4L).setValue("str"); // 3-  ( ,   ) cortegeLS.setValues(4L, "str"); 

अब पढ़ रहे हैं

 // 1-  (    ,   ) Long valueA = cortegeLS.getValue(); // 2-  (    ,   ) String valueB = cortegeLS.nextElement().getValue(); // 3-  (    ,   ) Long valueC = cortegeLS.getValue(1); String valueD = cortegeLS.getValue(2); 

टपल के साथ और क्या किया जा सकता है:
1. "सही" पर टुपल प्राप्त करें।

 Cortege<String, Cortege.End> rightCortegeS = cortegeLS.nextElement(); //   Cortege.End rightCortegeEnd = cortegeLS.nextElement().nextElement(); 

2. "गहराई" (टपल में तत्वों की संख्या) प्राप्त करें

 int deep = cortegeLS.getDeep(); 

शायद बस इतना ही। लेकिन सभी नहीं! :)

टपल कलेक्शन

मैंने एक कारण के लिए एक ट्यूपल बनाया। अब, इस तरह के निर्माण के बाद, यह एक अनुकूल संग्रह परिवार ( java.util.Collection ) के लिए "टाई" करना अच्छा होगा। जल्दी से नहीं कहा। लेकिन संग्रह के एक तत्व के रूप में एक टुपल का केले का उपयोग दिलचस्प नहीं है। मैं न केवल संग्रह के तत्वों को ढूंढना, हटाना, संशोधित करना चाहता हूं, जो कि java.util.Set और java.util.List इंटरफेस के पारंपरिक कार्यान्वयन देते हैं, लेकिन संग्रह में संग्रहीत ट्यूपल्स के अलग-अलग तत्वों को खोजने, संपूर्ण स्तंभों को संशोधित करने आदि के लिए फ़िल्टर भी करते हैं। जो संबंधपरक तालिकाओं के लिए स्वाभाविक है।

इसलिए फिर से लक्ष्य निर्धारित करें:

• संग्रह लंबे समय से स्थापित java.util.Collection के साथ संगत होना चाहिए। चयन परिवार के इंटरफेस (जैसे java.util.Set और java.util.List )
• कार्यान्वयन को सरल वस्तुओं की दुनिया में अपने एनालॉग्स की कार्यक्षमता का विस्तार करना चाहिए (उदाहरण के लिए, जैसे java.util.HashSet<T> );
• संग्रह को सार मानदंड द्वारा खोजना आसान होना चाहिए;
• एक सबसेट को लागू करना आवश्यक है;
• मैं एक संग्रह पर एक दृश्य (रिलेशनल डेटाबेस में दृश्य का एनालॉग) बनाने की संभावना को महसूस करना बहुत पसंद करूंगा।
  
  • दृश्य स्रोत डेटा को "स्वयं" नहीं करता है, लेकिन केवल कसौटी के अनुसार मूल संग्रह को फ़िल्टर करता है
  • फ़िल्टरिंग डिस्पोजेबल नहीं होनी चाहिए, लेकिन गतिशील। यानी प्रासंगिक होना चाहिए और मूल तालिका की स्थिति को प्रतिबिंबित करना चाहिए। संग्रह से सभी सम्मिलन, संशोधन और विलोपन को इसके प्रतिनिधित्व के रूप में परिलक्षित विधेयकों के अनुसार प्रस्तुत किया जाना चाहिए।

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

और यहाँ क्या हुआ:

 public interface CortegeCollection<T extends Cortege> extends Collection<T>, Iterable<T> { <T> boolean contains(int num, T obj); CortegeCollection<T> extract(int num, Object key); CortegeCollection<T> extract(Corteges.Predicate<T> predicate); // <C> CortegeCollection<T> view(int num, Corteges.Predicate<C> predicate); T findAny(int num, Object key); T findAny(Corteges.Predicate<T> predicate); <Vi> List<Vi> getColumnCopy(int num); <Vi> void fill(int num, Vi value); } public interface CortegeSet<T extends Cortege> extends CortegeCollection<T>, Set<T> { } public interface CortegeList<T extends Cortege> extends CortegeCollection<T>, List<T> { } 

अंजीर। 2. टपल संग्रह की टोपोलॉजी

टपल संग्रह का उपयोग करने के उदाहरण

अब यह संभवतः सार्थक है, जैसा कि Cortege विवरण के मामले में Cortege तुरंत उपयोग के दृश्य उदाहरणों पर जाएं:

 public class ExampleCollections { public static void main(String[] args) { //   CortegeHashSet CortegeSet<Cortege<Long, Cortege<String, Cortege.End>>> cortegeHashSetLS = Corteges.newCortegeHashSet(2); for (long i = 0; i < 5; i++) { Cortege<Long, Cortege<String, Cortege.End>> cortegeLS = CortegeChain.create(2); cortegeLS.setValue(i).setValue("" + i); cortegeHashSetLS.add(cortegeLS); } for (Cortege cortege : cortegeHashSetLS) { System.out.println(cortege); } cortegeHashSetLS.add(CortegeChain.<Long, Cortege<String, Cortege.End>>create(2)); Cortege<Long, Cortege<String, Cortege.End>> cortegeIS = CortegeChain.create(2); System.out.println(cortegeHashSetLS.contains(cortegeIS)); cortegeIS.setValue(null).setValue("3"); System.out.println(cortegeIS); System.out.println(cortegeHashSetLS.contains(cortegeIS)); System.out.println(cortegeHashSetLS.contains(1, 3L)); Cortege<Long, Cortege<Long, Cortege<String, Cortege.End>>> cortegeLLS1 = CortegeChain.create(3); Cortege<Long, Cortege<Long, Cortege<String, Cortege.End>>> cortegeLLS2 = CortegeChain.create(3); Cortege<Long, Cortege<Long, Cortege<String, Cortege.End>>> cortegeLLS3 = CortegeChain.create(3); CortegeChain<String, CortegeChain<Long, CortegeChain<String, Cortege.End>>> cortegeSLS = CortegeChain.create(3); cortegeLLS1.setValue(1L); cortegeLLS1.nextElement().setValue(11L); cortegeLLS1.nextElement().nextElement().setValue("AAA"); cortegeLLS2.setValue(2L); cortegeLLS2.nextElement().nextElement().setValue("BBB"); cortegeLLS3.setValue(3L); cortegeLLS3.nextElement().setValue(33L); cortegeLLS3.nextElement().nextElement().setValue("AAA"); CortegeHashSet<Cortege<Long, Cortege<Long, Cortege<String, Cortege.End>>>> cortegeSetLLS = Corteges.newCortegeHashSet(cortegeLLS1.getDeep()); System.out.println(cortegeSetLLS.contains(cortegeLLS1)); cortegeSetLLS.add(cortegeLLS1); cortegeSetLLS.add(cortegeLLS2); cortegeSetLLS.add(cortegeLLS3); System.out.println(cortegeSetLLS.contains(cortegeLLS1)); for (Cortege<Long, Cortege<Long, Cortege<String, Cortege.End>>> cortege : cortegeSetLLS) { System.out.println(cortege); } System.out.println(cortegeSetLLS.contains(3, "AAA")); cortegeSetLLS.fill(1, 5L); cortegeSetLLS.fill(2, 8L); cortegeSetLLS.fill(3, "XXX"); for (Cortege<Long, Cortege<Long, Cortege<String, Cortege.End>>> cortege : cortegeSetLLS) { System.out.println(cortege); } // Collection<Cortege> corteges = cortegeSetLLS.extract(2, "111"); } } 

संक्षेप में कहना

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

• मनमानी लंबाई का एक टपल बनाना काफी सरल है और केवल उन तत्वों के प्रकारों को सूचीबद्ध करने के लिए नीचे आता है जो ट्यूल के भविष्य के उदाहरण को बनाते हैं।
• जब एक नलिका के तत्वों को क्रमिक रूप से एक्सेस किया जाता है, तो तत्व का प्रकार नियंत्रित होता है
• टपल की घोषणा और भंडारण की चयनित संरचना के कारण, "दाईं ओर" ( nextElement() विधि) एक उप-टपल प्राप्त करना संभव है।

Cortege संरचना के अलावा, पुस्तकालय में दो प्रकार के संग्रह हैं जो जाने-माने java.util.Set और java.util.List ) com.rumba.cortege.CortegeSet और com.rumba.cortege.CortegeList ) को com.rumba.cortege.CortegeList ।

• तत्व के लिए एक सरल मानदंड द्वारा एक संग्रह में ट्यूपल या टुपल्स का एक उपसमूह ढूंढना संभव है, तत्व के लिए संदर्भ ऑब्जेक्ट (अर्क (इंट संख्या, ऑब्जेक्ट कुंजी) और findAny (int num, ऑब्जेक्ट कुंजी) विधियों के बराबर होना
• किसी संग्रह में टुप्ले या टुपल्स का एक भाग पूर्व निर्धारित करके निकालना संभव है (एक्सट्रैक्ट (Corteges.Predicate <T> विधेय) और खोज करें (Corteges.Predicate <T> विधेय तरीके)
• संग्रह के टुपल्स के तत्वों से गठित निर्दिष्ट संख्या के साथ किसी भी कॉलम को प्राप्त करना संभव है
• तत्वों के पूरे कॉलम में भरना संभव है

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

• इकाई <A> (1 तत्व)
• जोड़ी <A, B> (2 तत्व)
• ट्रिपल <ए, बी, सी> (3 तत्व)
• चौकड़ी <ए, बी, सी, डी> (4 तत्व)
• पंचक <ए, बी, सी, डी, ई> (5 तत्व)
• सेक्सट <ए, बी, सी, डी, ई, एफ> (6 तत्व)
• सेप्टेट <ए, बी, सी, डी, ई, एफ, जी> (7 तत्व)
• ओकटेट <ए, बी, सी, डी, ई, एफ, जी, एच> (8 तत्व)
• एननैड <ए, बी, सी, डी, ई, एफ, जी, एच, आई> (9 तत्व)
• दशक <, B, C, D, E, F, G, H, I, J> (10 तत्व)

निष्कर्ष

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

उपयोगी लिंक

javatuples
लागू करने का काफी दिलचस्प प्रयास