क्या Java SE 8 में जोड़े या ट्यूपल हैं?

Question

मैं जावा एसई 8 में आलसी कार्यात्मक संचालन के साथ खेल रहा हूं, और मैं mapएक इंडेक्स iको एक जोड़ी / टपल के लिए चाहता हूं (i, value[i]), फिर filterदूसरे value[i]तत्व के आधार पर , और अंत में सिर्फ सूचकांकों का उत्पादन करता हूं ।

क्या मुझे अभी भी यह भुगतना होगा: जावा में C ++ जोड़ी <L, R> के बराबर क्या है? मेमने और धाराओं के नए युग में?

अद्यतन: मैंने एक सरल उदाहरण प्रस्तुत किया है, जिसमें नीचे दिए गए उत्तरों में से एक में @dkatzel द्वारा पेश किया गया एक साफ समाधान है। हालाँकि, यह सामान्य नहीं करता है। इसलिए, मुझे एक और सामान्य उदाहरण जोड़ने दें:

package com.example.test;

import java.util.ArrayList;
import java.util.stream.IntStream;

public class Main {

  public static void main(String[] args) {
    boolean [][] directed_acyclic_graph = new boolean[][]{
        {false,  true, false,  true, false,  true},
        {false, false, false,  true, false,  true},
        {false, false, false,  true, false,  true},
        {false, false, false, false, false,  true},
        {false, false, false, false, false,  true},
        {false, false, false, false, false, false}
    };

    System.out.println(
        IntStream.range(0, directed_acyclic_graph.length)
        .parallel()
        .mapToLong(i -> IntStream.range(0, directed_acyclic_graph[i].length)
            .filter(j -> directed_acyclic_graph[j][i])
            .count()
        )
        .filter(n -> n == 0)
        .collect(() -> new ArrayList<Long>(), (c, e) -> c.add(e), (c1, c2) -> c1.addAll(c2))
    );
  }

}

यह गलत आउटपुट देता है[0, 0, 0] जो सभी तीन कॉलमों के लिए मायने रखता हैfalse । मुझे इन तीन स्तंभों के सूचक हैं। सही आउटपुट होना चाहिए [0, 2, 4]। मुझे यह परिणाम कैसे मिल सकता है?

Comments

वहां पहले से ही है AbstractMap.SimpleImmutableEntry<K,V>वैसे भी, साल के लिए ... लेकिन मानचित्रण के बजाय iकरने के लिए (i, value[i])बस से छानने के लिए value[i]और मानचित्रण वापस करने के लिए i: क्यों नहीं बस फिल्टर द्वारा value[i]मानचित्रण के बिना, पहली जगह में?

— होल्गर

@ होलगर मुझे यह जानने की आवश्यकता है कि किसी सरणी के किन सूचकांकों में मान एक मापदंड से मेल खाते हैं। मैं इसे iधारा में संरक्षित किए बिना नहीं कर सकता । मुझे भी value[i]मापदंड की जरूरत है। यही कारण है कि मुझे जरूरत है(i, value[i])

— necromancer

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

— स्टुअर्ट मार्क्स

@necromancer मैंने आपके द्वारा पूछे जा रहे प्रश्न को स्पष्ट करने के लिए पिछले पैराग्राफ को थोड़ा संपादित किया। क्या यह सही है? इसके अलावा, क्या यह एक निर्देशित (एसाइक्लिक) ग्राफ के बारे में सवाल नहीं है? (ऐसा नहीं है कि यह बहुत मायने रखता है।) अंत में, वांछित आउटपुट होना चाहिए [0, 2, 4]?

— स्टुअर्ट मार्क्स

मेरा मानना ​​है कि इसे ठीक करने का सही समाधान भविष्य के जावा रिलीज़ सपोर्ट टुपल्स को रिटर्न टाइप (ऑब्जेक्ट के विशेष मामले के रूप में) में रखना है और लैम्ब्डा एक्सप्रेशन को अपने मापदंडों के लिए इस तरह के टपल का सीधे उपयोग करने में सक्षम होना है।

— Thorbjørn Ravn Andersen

Answer 1

अद्यतन: यह उत्तर मूल प्रश्न के उत्तर में है, क्या जावा एसई 8 में जोड़े या ट्यूपल हैं? (और स्पष्ट रूप से, यदि नहीं, तो क्यों नहीं?) ओपी ने प्रश्न को और अधिक पूर्ण उदाहरण के साथ अपडेट किया है, लेकिन ऐसा लगता है कि इसे किसी भी तरह की पेयर संरचना का उपयोग किए बिना हल किया जा सकता है। [ओपी से नोट: यहाँ अन्य सही उत्तर है ।]

---

संक्षिप्त जवाब नहीं है। आपको या तो अपना स्वयं का रोल करना होगा या इसे लागू करने वाले कई पुस्तकालयों में से एक में लाना होगा।

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

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

ध्यान दें कि JavaFX में javafx.util.Pair क्लास है। जावाएफएक्स के एपीआई जावा एसई एपीआई से अलग से विकसित हुए हैं।

जैसा कि एक जुड़े हुए प्रश्न से देख सकते हैं कि जावा में C ++ जोड़ी के बराबर क्या है? वहाँ काफी बड़ा डिज़ाइन स्पेस है जो कि स्पष्ट रूप से इतना आसान एपीआई है। क्या वस्तुओं को अपरिवर्तनीय होना चाहिए? क्या उन्हें धारावाहिक होना चाहिए? क्या उन्हें तुलनीय होना चाहिए? क्लास फाइनल होनी चाहिए या नहीं? क्या दो तत्वों का आदेश दिया जाना चाहिए? क्या यह एक इंटरफ़ेस या एक वर्ग होना चाहिए? जोड़े पर क्यों रोक? क्यों नहीं ट्रिपल, क्वाड्स या एन-ट्यूपल्स?

और निश्चित रूप से तत्वों के लिए अनिवार्य नामकरण है:

• (ए, बी)
• (प्रथम क्षण)
• (बाएँ दांए)
• (कार, सीडीआर)
• (फू, बार)
• आदि।

एक बड़ा मुद्दा जिसका उल्लेख शायद ही किया गया है, वह है प्राइमेन्स से पेयर का संबंध। यदि आपके पास एक (int x, int y)डीटम है जो 2 डी अंतरिक्ष में एक बिंदु का प्रतिनिधित्व करता है, तो इसका प्रतिनिधित्व करते हुए दो 32-बिट शब्दों के बजाय तीन वस्तुओं काPair<Integer, Integer> उपभोग करता है । इसके अलावा, इन वस्तुओं को ढेर पर रहना चाहिए और जीसी ओवरहेड को उकसाना होगा।

यह स्पष्ट प्रतीत होगा कि, धाराओं की तरह, वहाँ के लिए आवश्यक होगा कि जोड़े के लिए आदिम विशेषज्ञता हो। क्या हम देखना चाहते हैं:

Pair
ObjIntPair
ObjLongPair
ObjDoublePair
IntObjPair
IntIntPair
IntLongPair
IntDoublePair
LongObjPair
LongIntPair
LongLongPair
LongDoublePair
DoubleObjPair
DoubleIntPair
DoubleLongPair
DoubleDoublePair

यहां तक ​​कि एक IntIntPairको अभी भी ढेर पर एक वस्तु की आवश्यकता होगी।

ये निश्चित रूप से, java.util.functionजावा एसई 8. में पैकेज में कार्यात्मक इंटरफेस के प्रसार की याद दिलाते हैं । यदि आप एक फूला हुआ एपीआई नहीं चाहते हैं, तो आप किन लोगों को छोड़ देंगे? आप यह भी तर्क दे सकते हैं कि यह पर्याप्त नहीं है, और कहा कि विशेषज्ञता के लिए Booleanभी कहा जाना चाहिए।

मेरी भावना यह है कि यदि जावा ने बहुत पहले एक जोड़ी क्लास जोड़ी थी, तो यह सरल, या यहां तक ​​कि सरलीकृत होता था, और यह उन उपयोग के कई मामलों को संतुष्ट नहीं करता था जिन्हें हम अभी कल्पना कर रहे हैं। विचार करें कि अगर PD को JDK 1.0 समय सीमा में जोड़ा गया होता, तो शायद यह परिवर्तनशील होता! (Java.util.Date को देखें।) क्या लोग इससे खुश होंगे? मेरा अनुमान है कि यदि जावा में एक पेयर क्लास था, तो यह थोड़े-थोड़े समय के लिए उपयोगी होगा और हर कोई अभी भी अपनी जरूरतों को पूरा करने के लिए अपना खुद का रोल कर रहा होगा, बाहरी पुस्तकालयों में विभिन्न पेयर और टपल कार्यान्वयन होंगे। और लोग अभी भी जावा के जोड़ी वर्ग को ठीक करने के बारे में बहस / चर्चा कर रहे हैं। दूसरे शब्दों में, आज हम जिस स्थान पर हैं, उसी तरह के हैं।

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

Comments

आदिम के साथ @necromancer Factory विधियाँ मदद के लिए नहीं Pair<T,U>। चूंकि जेनरिक संदर्भ प्रकार का होना चाहिए। स्टोर किए जाने पर कोई भी आदिम बॉक्सिंग की जाएगी। प्राथमिकताओं को संग्रहीत करने के लिए आपको वास्तव में एक अलग वर्ग की आवश्यकता होती है।

— स्टुअर्ट मार्क्स

@necromancer और हां मुकर्रर किए गए बॉक्सिंग में आदिम निर्माता सार्वजनिक नहीं होने valueOfचाहिए थे , और बॉक्सिंग इंस्टेंस पाने का एकमात्र तरीका होना चाहिए था। लेकिन वे जावा 1.0 के बाद से वहाँ रहे हैं और शायद इस बिंदु पर बदलने की कोशिश करने के लायक नहीं हैं।

— स्टुअर्ट मार्क्स

जाहिर है, पृष्ठभूमि में पारदर्शी तरीके से आवश्यक विशेषज्ञता वर्ग (अनुकूलित भंडारण के साथ) बनाने वाली फैक्टरी विधि के साथ केवल एक सार्वजनिक Pairया Tupleवर्ग होना चाहिए । अंत में, लंबोदर बिल्कुल ऐसा करते हैं: वे मनमाने प्रकार के चर के एक मनमाने संख्या पर कब्जा कर सकते हैं। और अब एक भाषा समर्थन को एक invokedynamicनिर्देश द्वारा ट्रिगर होने वाले रनटाइम पर उचित ट्यूपल क्लास बनाने की अनुमति देता है ...

— होलगर

@ होलगर ऐसा कुछ काम कर सकता है यदि कोई मौजूदा जेवीएम पर मूल्य प्रकारों को वापस ले रहा है, लेकिन मूल्य प्रकार का प्रस्ताव (अब "प्रोजेक्ट वल्लाह" ) अधिक कट्टरपंथी है। विशेष रूप से, इसके मूल्य प्रकार आवश्यक रूप से ढेर-आवंटित नहीं होंगे। इसके अलावा, आज वस्तुओं के विपरीत, और आज की तरह आदिम, मूल्यों की कोई पहचान नहीं होगी।

— स्टुअर्ट मार्क्स

@ स्टुअर्ट मार्क्स: जैसा कि मैंने बताया था कि इस तरह के एक मूल्य प्रकार के लिए "बॉक्सिंग" प्रकार हो सकता है हस्तक्षेप नहीं करेगा। invokedynamicलैम्बडा निर्माण के समान एक आधारित कारखाने के साथ जैसे बाद में रेट्रोफिटिंग में कोई समस्या नहीं होगी। वैसे, लंबोदर की कोई पहचान नहीं है। जैसा कि स्पष्ट रूप से कहा गया है, आज आप जो पहचान महसूस कर सकते हैं वह वर्तमान कार्यान्वयन की एक कलाकृति है।

— होल्गर

Answer 2

आप इन अंतर्निहित कक्षाओं पर एक नज़र डाल सकते हैं:

• AbstractMap.SimpleEntry
• AbstractMap.SimpleImmutableEntry

Comments

यह सही उत्तर है, जहां तक ​​जोड़े के लिए अंतर्निहित कार्यक्षमता है। ध्यान दें कि SimpleImmutableEntryकेवल इस बात की गारंटी है कि संग्रहीत संदर्भ Entryपरिवर्तित नहीं होते हैं, यह नहीं कि लिंक की गई फ़ील्ड keyऔर valueऑब्जेक्ट्स (या वे ऑब्जेक्ट जो वे लिंक करते हैं) परिवर्तित नहीं होते हैं।

— ल्यूक हचिसन

Answer 3

अफसोस की बात है कि, जावा 8 ने जोड़े या टुपल्स का परिचय नहीं दिया। आप हमेशा org.apache.commons.lang3.tup का उपयोग कर सकते हैं । बेशक (जो मैं व्यक्तिगत रूप से जावा 8 के संयोजन में उपयोग करता हूं) या आप अपने स्वयं के रैपर बना सकते हैं। या मैप्स का उपयोग करें। या उस तरह का सामान, जैसा कि उस प्रश्न के स्वीकृत उत्तर में बताया गया है जिससे आप जुड़े हैं।

---

अद्यतन: JDK 14 पूर्वावलोकन सुविधा के रूप में रिकॉर्ड पेश कर रहा है । ये ट्यूपल्स नहीं हैं, लेकिन इनका उपयोग एक ही समस्या से बचाने के लिए किया जा सकता है। ऊपर से आपके विशिष्ट उदाहरण में, जो कुछ इस तरह दिख सकता है:

public class Jdk14Example {
    record CountForIndex(int index, long count) {}

    public static void main(String[] args) {
        boolean [][] directed_acyclic_graph = new boolean[][]{
                {false,  true, false,  true, false,  true},
                {false, false, false,  true, false,  true},
                {false, false, false,  true, false,  true},
                {false, false, false, false, false,  true},
                {false, false, false, false, false,  true},
                {false, false, false, false, false, false}
        };

        System.out.println(
                IntStream.range(0, directed_acyclic_graph.length)
                        .parallel()
                        .mapToObj(i -> {
                            long count = IntStream.range(0, directed_acyclic_graph[i].length)
                                            .filter(j -> directed_acyclic_graph[j][i])
                                            .count();
                            return new CountForIndex(i, count);
                        }
                        )
                        .filter(n -> n.count == 0)
                        .collect(() -> new ArrayList<CountForIndex>(), (c, e) -> c.add(e), (c1, c2) -> c1.addAll(c2))
        );
    }
}

जब JDK 14 के साथ संकलित किया गया और चलाया गया (लेखन के समय, यह एक प्रारंभिक पहुंच है) --enable-previewझंडे का उपयोग करते हुए , आपको निम्नलिखित बातें प्राप्त होती हैं:

[CountForIndex[index=0, count=0], CountForIndex[index=2, count=0], CountForIndex[index=4, count=0]]

Comments

वास्तव में @StuartMarks द्वारा दिए गए जवाबों में से एक ने मुझे टुपल्स के बिना इसे हल करने की अनुमति दी, लेकिन चूंकि यह सामान्य नहीं लगता है कि शायद मुझे अंततः इसकी आवश्यकता होगी।

— नेक्रोमन्ट

@necromancer हाँ, यह एक बहुत अच्छा जवाब है। अपाचे पुस्तकालय अभी भी कई बार काम में आ सकता है लेकिन यह सब जावस भाषा के डिजाइन के लिए आता है। मूल रूप से, ट्यूपल्स को अन्य भाषाओं में काम करने के लिए आदिम (या समान) होना चाहिए।

— ब्लालासाद्रि

यदि आपने इसे नोटिस नहीं किया है, तो इस उत्तर में इस बेहद जानकारीपूर्ण लिंक को शामिल किया गया: cr.openjdk.java.net/~jrose/values/values-0.html टुपल्स सहित इस तरह की आदिमताओं की आवश्यकता और संभावनाओं के बारे में।

— नेक्रोमन्ट

Answer 4

ऐसा प्रतीत होता है कि पूर्ण उदाहरण किसी भी प्रकार की पेयर संरचना के उपयोग के बिना हल किया जा सकता है। कॉलम इंडेक्स को फिल्टर करने के लिए कुंजी है, falseउस कॉलम में प्रविष्टियों की संख्या के लिए कॉलम इंडेक्स को मैप करने के बजाय, पूरे कॉलम की जांच करें।

यह करने वाला कोड यहाँ है:

    System.out.println(
        IntStream.range(0, acyclic_graph.length)
            .filter(i -> IntStream.range(0, acyclic_graph.length)
                                  .noneMatch(j -> acyclic_graph[j][i]))
            .boxed()
            .collect(toList()));

इसका परिणाम यह [0, 2, 4]है कि मुझे लगता है कि ओपी द्वारा अनुरोध किया गया सही परिणाम है।

उस boxed()ऑपरेशन को भी नोट करें जो intमानों को Integerऑब्जेक्ट्स में बॉक्स करता है । यह toList()कलेक्टर कार्यों को लिखने के बजाय पहले से मौजूद कलेक्टर का उपयोग करने के लिए सक्षम बनाता है जो स्वयं मुक्केबाजी करते हैं।

Comments

अपनी आस्तीन ऊपर +1 करें :) यह अभी भी सामान्य नहीं है, है ना? यह सवाल का अधिक महत्वपूर्ण पहलू था क्योंकि मैं अन्य स्थितियों का सामना करने की उम्मीद करता हूं, जहां इस तरह की योजना काम नहीं करेगी (उदाहरण के लिए 3 मानों से अधिक नहीं वाले कॉलम true)। तदनुसार, मैं आपके अन्य उत्तर को सही मानूंगा, लेकिन यह भी इंगित करता हूं! बहुत बहुत धन्यवाद :)

— necromancer

यह सही है लेकिन उसी उपयोगकर्ता द्वारा अन्य उत्तर को स्वीकार करना। (ऊपर और अन्य टिप्पणियों को देखें।)

— नेक्रोमन्ट

@necromancer राइट, यह तकनीक उन मामलों में पूरी तरह से सामान्य नहीं है जहां आप इंडेक्स चाहते हैं, लेकिन डेटा एलीमेंट को इंडेक्स का उपयोग करके पुनर्प्राप्त या गणना नहीं किया जा सकता है। (कम से कम आसानी से नहीं।) उदाहरण के लिए, एक समस्या पर विचार करें जहां आप नेटवर्क कनेक्शन से पाठ की पंक्तियों को पढ़ रहे हैं, और आप उस Nth लाइन की लाइन संख्या को खोजना चाहते हैं जो कुछ पैटर्न से मेल खाती है। सबसे आसान तरीका है कि लाइनों की संख्या के लिए प्रत्येक पंक्ति को एक जोड़ी या कुछ समग्र डेटा संरचना में मैप करें। हालांकि एक नया डेटा संरचना के बिना ऐसा करने के लिए शायद एक hacky, साइड-इफेक्टिव तरीका है।

— स्टुअर्ट मार्क्स

@StuartMarks, एक जोड़ी <T, U> है। एक ट्रिपल <टी, यू, वी>। आदि आपका उदाहरण एक सूची है, जोड़ी नहीं।

— पचेरियर

Answer 5

Vavr (जिसे पहले Javaslang कहा जाता है) ( http://www.vavr.io ) टुपल्स ( 8 के आकार का टिल) प्रदान करता है। यहाँ javadoc है: https://static.javadoc.io/io.vavr/vavr/0.9.0/io/vavr/Tuple.html ।

यह एक सरल उदाहरण है:

Tuple2<Integer, String> entry = Tuple.of(1, "A");

Integer key = entry._1;
String value = entry._2;

क्यों JDK खुद एक साधारण किस्म की तुफान के साथ नहीं आया था अब मेरे लिए एक रहस्य है। रैपर क्लासेस लिखना हर दिन का व्यवसाय लगता है।

Comments

Vavr के कुछ वर्जन हुड के नीचे स्नीकी थ्रो का इस्तेमाल करते हैं। उन का उपयोग न करने के लिए सावधान रहें।

— थोरबजोरन रावन एंडरसन

Answer 6

जावा 9 के बाद से, आप Map.Entryपहले से आसान के उदाहरण बना सकते हैं :

Entry<Integer, String> pair = Map.entry(1, "a");

Map.entryएक unmodifiable Entryऔर निषिद्ध नल लौटाता है।

Answer 7

चूंकि आप केवल अनुक्रमणिका के बारे में परवाह करते हैं, इसलिए आपको टुपल्स के लिए मैप करने की आवश्यकता नहीं है। सिर्फ एक फ़िल्टर क्यों न लिखें, जो आपके एरे में तत्वों को देखता है?

     int[] value =  ...


IntStream.range(0, value.length)
            .filter(i -> value[i] > 30)  //or whatever filter you want
            .forEach(i -> System.out.println(i));

Comments

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

— नेक्रोमन्ट

Answer 8

हाँ।

Map.Entryएक के रूप में इस्तेमाल किया जा सकता है Pair।

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

तब तक, केवल कम उपयोग है।

EDIT 2018-02-12: एक प्रोजेक्ट पर काम करते हुए मैंने एक सहायक वर्ग लिखा, जो आपको बाद में एक स्ट्रीम में पहले से पहचानकर्ता होने के विशेष मामले को संभालने में मदद करता है, लेकिन बीच में धारा का हिस्सा इसके बारे में नहीं जानता है। जब तक मैं अपने आप ही इसे जारी करने के आसपास यह पर उपलब्ध है IdValue.java पर एक इकाई परीक्षण के साथ IdValueTest.java

Answer 9

ग्रहण संग्रह में Pairआदिम / वस्तु जोड़े के सभी संयोजन हैं (सभी आठ आदिम के लिए)।

Tuplesकारखाने के उदाहरण बना सकते हैं Pair, और PrimitiveTuplesकारखाने आदिम / वस्तु जोड़े के सभी संयोजनों बनाने के लिए इस्तेमाल किया जा सकता है।

जावा 8 जारी होने से पहले हमने इन्हें जोड़ा। वे हमारे आदिम मानचित्रों के लिए कुंजी / मूल्य Iterators को लागू करने के लिए उपयोगी थे, जिसे हम सभी आदिम / वस्तु संयोजनों में भी समर्थन करते हैं।

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

IntList list = IntLists.mutable.withAll(intStream);

नोट: मैं ग्रहण संग्रहों के लिए एक कमिटेटर हूं।