मूल्य जोड़े का एक जावा संग्रह? (Tuples?)

Question

मुझे पसंद है कि जावा के पास एक नक्शा कैसे है जहां आप उदाहरण के लिए, नक्शे में प्रत्येक प्रविष्टि के प्रकारों को परिभाषित कर सकते हैं <String, Integer>।

मैं जो देख रहा हूं वह एक प्रकार का संग्रह है जहां संग्रह में प्रत्येक तत्व मूल्यों की एक जोड़ी है। जोड़ी में प्रत्येक मूल्य का अपना प्रकार हो सकता है (जैसे स्ट्रिंग और पूर्णांक उदाहरण ऊपर), जिसे घोषणा के समय परिभाषित किया गया है।

संग्रह अपने दिए गए आदेश को बनाए रखेगा और मूल्यों में से एक को एक अद्वितीय कुंजी (एक नक्शे के रूप में) के रूप में नहीं मानेगा।

अनिवार्य रूप से मैं टाइप के ARRAY <String,Integer>या किसी अन्य 2 प्रकार को परिभाषित करने में सक्षम होना चाहता हूं ।

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

मुझे यह भी एहसास है कि मैं एक 2 डी सरणी का उपयोग कर सकता हूं, लेकिन विभिन्न प्रकारों के कारण जिन्हें मुझे उपयोग करने की आवश्यकता है, मुझे उन्हें OBJECT के सरणियों को बनाना होगा, और फिर मुझे हर समय डालना होगा।

मुझे केवल संग्रह में जोड़े संग्रहीत करने की आवश्यकता है, इसलिए मुझे केवल प्रति प्रविष्टि दो मान चाहिए। क्या क्लास रूट पर जाए बिना ऐसा कुछ होता है? धन्यवाद!

Comments

मुझे आश्चर्य है कि अमरूद भी इसके लिए एक वर्ग हो सकता है।

— सिकोरस्की

अमरूद बहुत विरोधी है Pair, और Google पर लोगों ने इतना बेहतर विकल्प - ऑटो / मूल्य बनाने के लिए इतनी दूर चले गए हैं । यह आपको उचित समान / हैशकोड शब्दार्थ के साथ आसानी से अच्छी तरह से टाइप किए गए मूल्य प्रकार की कक्षाएं बनाने देता है । आपको Pairफिर से एक प्रकार की आवश्यकता नहीं होगी !

— dimo414

Answer 1

पेयर क्लास उन "गिम्मे" जेनरिक उदाहरणों में से एक है जो अपने दम पर लिखना आसान है। उदाहरण के लिए, मेरे सिर के ऊपर से:

public class Pair<L,R> {

  private final L left;
  private final R right;

  public Pair(L left, R right) {
    assert left != null;
    assert right != null;

    this.left = left;
    this.right = right;
  }

  public L getLeft() { return left; }
  public R getRight() { return right; }

  @Override
  public int hashCode() { return left.hashCode() ^ right.hashCode(); }

  @Override
  public boolean equals(Object o) {
    if (!(o instanceof Pair)) return false;
    Pair pairo = (Pair) o;
    return this.left.equals(pairo.getLeft()) &&
           this.right.equals(pairo.getRight());
  }

}

और हां, यह नेट पर कई स्थानों पर मौजूद है, जिसमें संपूर्णता और विशेषता की अलग-अलग डिग्री है। (ऊपर दिया गया मेरा उदाहरण अपरिवर्तनीय है।)

Comments

मुझे यह पसंद है, लेकिन आप बाएं और दाएं क्षेत्रों को सार्वजनिक करने के बारे में क्या सोचते हैं? यह बहुत स्पष्ट है कि जोड़ी वर्ग कभी भी किसी भी तर्क से जुड़ा नहीं है और सभी ग्राहकों को 'बाएं' और 'दाएं' तक पहुंच की आवश्यकता होगी, इसलिए इसे आसान क्यों नहीं बनाया जाए?

— डाकू प्रोग्रामर

बेनाम: उम ... नहीं यह नहीं होगा। फ़ील्ड को अंतिम के रूप में चिह्नित किया जाता है, इसलिए उन्हें पुन: असाइन नहीं किया जा सकता है। और यह थ्रेडसेफ़ नहीं है क्योंकि 'लेफ्ट' और 'राइट' परस्पर मिल सकता है। जब तक getLeft () / getRight () इस मामले में रक्षात्मक प्रतियाँ (बेकार) वापस नहीं आती, मैं नहीं देखता कि बड़ी बात क्या है।

— डाकू प्रोग्रामर

ध्यान दें कि हैशकोड () जैसा है वैसा ही मान देता है यदि बाएं और दाएं स्वैप किए जाते हैं। शायद:long l = left.hashCode() * 2654435761L; return (int)l + (int)(l >>> 32) + right.hashCode();

— कर्मकेज

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

— cquezel

आपका क्या मतलब है "अपने दम पर लिखना आसान है"? वह भयानक सॉफ्टवेयर इंजीनियरिंग है। क्या MyPair और SomeoneElsesPair के बीच कनवर्ट करने के लिए N ^ 2 एडेप्टर क्लासेस भी आसान हैं जिन्हें किसी के लिए लिखना काफी आसान है?

— djechlin

Answer 2

AbstractMap.SimpleEntry

आसान आप इस के लिए देख रहे हैं:

java.util.List<java.util.Map.Entry<String,Integer>> pairList= new java.util.ArrayList<>();

आप इसे कैसे भर सकते हैं?

java.util.Map.Entry<String,Integer> pair1=new java.util.AbstractMap.SimpleEntry<>("Not Unique key1",1);
java.util.Map.Entry<String,Integer> pair2=new java.util.AbstractMap.SimpleEntry<>("Not Unique key2",2);
pairList.add(pair1);
pairList.add(pair2);

यह सरल करता है:

Entry<String,Integer> pair1=new SimpleEntry<>("Not Unique key1",1);
Entry<String,Integer> pair2=new SimpleEntry<>("Not Unique key2",2);
pairList.add(pair1);
pairList.add(pair2);

और, एक createEntryविधि की मदद से , आगे क्रिया को कम कर सकते हैं:

pairList.add(createEntry("Not Unique key1", 1));
pairList.add(createEntry("Not Unique key2", 2));

चूंकि ArrayListअंतिम नहीं है, इसलिए इसे एक ofविधि (और पूर्वोक्त createEntryविधि) को उजागर करने के लिए उप-वर्गित किया जा सकता है , जिसके परिणामस्वरूप वाक्य-रचना की प्रवृत्ति:

TupleList<java.util.Map.Entry<String,Integer>> pair = new TupleList<>();
pair.of("Not Unique key1", 1);
pair.of("Not Unique key2", 2);

Comments

FYI करें: सुझाव दिया SimpleEntryहै कि एक भाई वर्ग छोड़ने की setValueविधि अपरिवर्तनीय है। इस प्रकार नाम SimpleImmutableEntry।

— बेसिल बोर्ख

यह आत्म-कार्यान्वयन से बेहतर है। यह तथ्य कि इसे लागू करना आसान है, हर बार इसे लागू करने का बहाना नहीं है।

— पावोगम

मैं इसे "मानक" नहीं मानूंगा। Entryएक कुंजी-मूल्य जोड़ी माना जाता है, और यह उसके लिए ठीक है। लेकिन यह एक सच्ची गुदगुदी के रूप में कमजोरी है। उदाहरण के लिए , तत्वों के कोड को केवल xors hashcodeमें कार्यान्वित SimpleEntryकरना, इसलिए <a,b>समान मान के साथ हैश करना <b,a>। टपल कार्यान्वयन अक्सर लेक्सोग्राफिक रूप से सॉर्ट SimpleEntry करता है , लेकिन लागू नहीं होता है Comparable। इसलिए वहाँ से सावधान रहें ...

— जेन

Answer 3

जावा 9+

जावा 9 में, आप बस लिख सकते हैं: Map.entry(key, value) एक अपरिवर्तनीय जोड़ी बनाने के लिए।

नोट: यह विधि कुंजी या मान को शून्य होने की अनुमति नहीं देती है। यदि आप उदाहरण के लिए शून्य मानों को अनुमति देना चाहते हैं, तो आप इसे बदलना चाहेंगे Map.entry(key, Optional.ofNullable(value)):।

---

जावा 8+

जावा 8 में, आप javafx.util.Pairएक अपरिवर्तनीय, क्रमबद्ध जोड़ी बनाने के लिए अधिक सामान्य-उद्देश्य का उपयोग कर सकते हैं । इस वर्ग करता अशक्त कुंजी और शून्य मान अनुमति देते हैं। (जावा 9 में, यह वर्ग javafx.baseमॉड्यूल में शामिल है )। संपादित करें: जावा 11 के रूप में, JavaFX को JDK से हटा दिया गया है, इसलिए आपको अतिरिक्त maven विरूपण साक्ष्य org.openjfx: javafx-base की आवश्यकता होगी।

---

जावा 6+

जावा 6 और ऊपर में, आप AbstractMap.SimpleImmutableEntryएक अपरिवर्तनीय जोड़ी के लिए अधिक क्रिया का उपयोग कर सकते हैं , या AbstractMap.SimpleEntryएक जोड़ी के लिए जिसका मूल्य बदला जा सकता है। ये कक्षाएं शून्य कुंजियों और अशक्त मूल्यों की भी अनुमति देती हैं, और क्रमबद्ध हैं।

---

एंड्रॉयड

यदि आप एंड्रॉइड के लिए लिख रहे हैं, तो बस Pair.create(key, value)एक अपरिवर्तनीय जोड़ी बनाने के लिए उपयोग करें।

---

अपाचे कॉमन्स

Apache Commons LangPair.of(key, value)एक अपरिवर्तनीय, तुलनीय, क्रमबद्ध जोड़ी बनाने के लिए सहायक प्रदान करता है ।

---

ग्रहण संग्रह

यदि आप उन युग्मों का उपयोग कर रहे हैं जिनमें आदिम, ग्रहण संग्रह हैं कुछ बहुत ही कुशल आदिम जोड़ी वर्ग प्रदान करता है जो सभी अकुशल ऑटो-बॉक्सिंग और ऑटो-अनबॉक्सिंग से बचेंगे।

उदाहरण के लिए, आप a बनाने के लिए , या a बनाने के PrimitiveTuples.pair(int, int)लिए उपयोग कर सकते हैं ।IntIntPairPrimitiveTuples.pair(float, long)FloatLongPair

---

प्रोजेक्ट लोम्बोक

प्रोजेक्ट लोम्बोक का उपयोग करके , आप केवल लिखकर एक अपरिवर्तनीय जोड़ी वर्ग बना सकते हैं:

@Value
public class Pair<K, V> {
    K key;
    V value;
}

लंबोक निर्माता, टिककर खेल, में भर जाएगा equals(), hashCode()और toString()उत्पन्न बाईटकोड में स्वचालित रूप से आप के लिए तरीके। आप एक स्थिर कारखाने विधि के बजाय एक निर्माता, जैसे चाहते हैं, एक Pair.of(k, v)के लिए, बस एनोटेशन को बदलने के लिए: @Value(staticConstructor = "of")।

---

अन्यथा

यदि उपरोक्त समाधानों में से कोई भी आपकी नाव को फ्लोट नहीं करता है, तो आप बस निम्नलिखित कोड को कॉपी और पेस्ट कर सकते हैं (जो स्वीकृत उत्तर में सूचीबद्ध वर्ग के विपरीत, NullPointerException के खिलाफ गार्ड):

import java.util.Objects;

public class Pair<K, V> {

    public final K key;
    public final V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public boolean equals(Object o) {
        return o instanceof Pair && Objects.equals(key, ((Pair<?,?>)o).key) && Objects.equals(value, ((Pair<?,?>)o).value);
    }

    public int hashCode() {
        return 31 * Objects.hashCode(key) + Objects.hashCode(value);
    }

    public String toString() {
        return key + "=" + value;
    }
}

Comments

हालांकि, JavaFX केवल डेस्कटॉप है, जो गैर-डेस्कटॉप वातावरण (जैसे सर्वर) के लिए अनावश्यक निर्भरता को जोड़ता है।

— foo

एक्लिप्स कलेक्शंस में Pairऑब्जेक्ट्स के लिए एक इंटरफ़ेस भी होता है , जिसे कॉल करके इंस्टेंट किया जा सकता है Tuples.pair(object1, object2)। eclipse.org/collections/javadoc/9.2.0/org/eclipse/collections/…

— डोनाल्ड रब

यह वास्तव में जावा-एस्क का उत्तर लगता है। सभी उपलब्ध कार्यान्वयन। बहुत अच्छी तरह से, बहुत धन्यवाद!

— माइक

हाय @ मैं एक सूची का उपयोग कर रहा हूं List<Pair<Integer, String> listOfTuple। मैं कैसे उपयोग listOfTuple.add()करूं? अगर मैं करूँगा - listOfTuple.add(Pair<someInteger, someString>);यह काम नहीं करेगा। अग्रिम में धन्यवाद।

— Me_developer

एंड्रॉइड संस्करण यूनिट टेस्ट में उपलब्ध नहीं है, जो इसे वास्तव में उपयोगी नहीं बनाता है ...

— OznOg

Answer 4

Map.Entry

ये बिल्ट-इन कक्षाएं भी एक विकल्प हैं। दोनों Map.Entryइंटरफ़ेस को लागू करते हैं ।

• AbstractMap.SimpleEntry
• AbstractMap.SimpleImmutableEntry

Comments

वे सिर्फ एक विकल्प नहीं हैं, वे सही उत्तर हैं। मुझे लगता है कि कुछ लोग सिर्फ पहिये पर लगाम लगाना पसंद करते हैं।

— कर्टनडॉग

Answer 5

अपाचे कॉमन लैंग 3 में पेयर क्लास और कुछ अन्य लाइब्रेरियाँ हैं जिनका इस धागे में उल्लेख किया गया है है कि जावा में C ++ Pair <L, R> के बराबर क्या है?

उदाहरण आपके मूल प्रश्न से आवश्यकता का मिलान करता है:

List<Pair<String, Integer>> myPairs = new ArrayList<Pair<String, Integer>>();
myPairs.add(Pair.of("val1", 11));
myPairs.add(Pair.of("val2", 17));

//...

for(Pair<String, Integer> pair : myPairs) {
  //following two lines are equivalent... whichever is easier for you...
  System.out.println(pair.getLeft() + ": " + pair.getRight());
  System.out.println(pair.getKey() + ": " + pair.getValue());
}

Comments

यदि Apache Commons उपलब्ध है तो यह सबसे सरल विकल्प है।

— किप

Answer 6

Android के लिए किसी को भी विकसित करने के लिए, आप android.util.Pair का उपयोग कर सकते हैं । :)

Answer 7

"अपाचे कॉमन्स लैंग 3" Pairवर्ग और रिश्तेदार उपवर्गों के बारे में क्या?

    import org.apache.commons.lang3.tuple.ImmutablePair;
    import org.apache.commons.lang3.tuple.Pair;
    ...
    @SuppressWarnings("unchecked")
    Pair<String, Integer>[] arr = new ImmutablePair[]{
            ImmutablePair.of("A", 1),
            ImmutablePair.of("B", 2)};

    // both access the 'left' part
    String key = arr[0].getKey();
    String left = arr[0].getLeft();

    // both access the 'right' part
    Integer value = arr[0].getValue();
    Integer right = arr[0].getRight();

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

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.4</version>
        </dependency>

Answer 8

आप एक सामान्य जोड़ी <A, B> वर्ग लिख सकते हैं और इसे एक सरणी या सूची में उपयोग कर सकते हैं। हां, आपको एक वर्ग लिखना होगा, लेकिन आप सभी प्रकारों के लिए एक ही कक्षा का पुन: उपयोग कर सकते हैं, इसलिए आपको इसे केवल एक बार करना होगा।

Comments

मुझे इसका एक उदाहरण देखना अच्छा लगेगा!

— DivideByHero

दान, उस के बारे में बुरी बात यह है कि यह स्वीकार करना संभव नहीं है उदाहरण के लिए केवल जोड़ी <String, Integer> s क्योंकि erasure, no? लेकिन ऐसा ही है जावा ...

— जोहान्स वेस

दिलचस्प है, जोहान्स। java.sun.com/docs/books/tutorial/java/generics/erasure.html

— JMD

मुझे नहीं लगता कि यह सादे सरणियों के लिए काम करेगा, लेकिन यह निश्चित रूप से अन्य संग्रह के लिए काम करेगा।

— डाकू प्रोग्रामर

@ ओटलॉ प्रोग्रामर: अच्छा बिंदु, आप इसे सरणियों के साथ उपयोग कर सकते हैं, लेकिन यह बदसूरत है क्योंकि आपको जेनेरिक सरणियों को बनाने के लिए एक हैक का उपयोग करना होगा।

— डैन डायर

Answer 9

अन्य उत्तरों पर विस्तार करते हुए एक सामान्य अपरिवर्तनीय जोड़ी में एक स्थिर विधि होनी चाहिए जो आपके कोड को निर्माणकर्ता को कॉल करने से रोकने के लिए हो:

class Pair<L,R> {
      final L left;
      final R right;

      public Pair(L left, R right) {
        this.left = left;
        this.right = right;
      }

      static <L,R> Pair<L,R> of(L left, R right){
          return new Pair<L,R>(left, right);
      }
}

यदि आप "या" जोड़ीऑफ "की स्थिर विधि का नाम देते हैं, तो कोड धाराप्रवाह हो जाता है क्योंकि आप या तो लिख सकते हैं:

    list.add(Pair.of(x,y)); // my preference
    list.add(pairOf(x,y)); // use with import static x.y.Pair.pairOf

इसकी असली शर्म यह है कि कोर जावा लाइब्रेरियाँ ऐसी चीजों पर इतनी विरल हैं कि आपको इस तरह के मूल सामान को करने के लिए कॉमन्स-लैंग या अन्य 3 पार्टियों का उपयोग करना होगा। अभी तक एक और कारण scala में अपग्रेड ...

Answer 10

मैं पूछने जा रहा था कि क्या आप सिर्फ एक का उपयोग नहीं करना चाहेंगे List<Pair<T, U>>? लेकिन फिर, निश्चित रूप से, JDK के पास Pair <> वर्ग नहीं है। लेकिन एक त्वरित Google ने विकिपीडिया , और forum.sun.com दोनों पर एक पाया । चियर्स

Answer 11

जैसा कि आपने बताया है कि पसंदीदा समाधान एक सूची सूची है (यानी सूची)।

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

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

इस बात को ध्यान में रखें कि संग्रह एक एकल प्रकार के तत्वों को समाहित करने के लिए डिज़ाइन किया गया है। मानचित्र जैसे संबंधित उपयोगिता इंटरफेस वास्तव में संग्रह नहीं हैं (यानी मानचित्र संग्रह इंटरफ़ेस को लागू नहीं करता है)। एक जोड़ी संग्रह इंटरफ़ेस को लागू नहीं करेगी लेकिन स्पष्ट रूप से बड़े डेटा संरचनाओं के निर्माण में एक उपयोगी वर्ग है।

Comments

मैं इस समाधान को जेनेरिक पेयर <K, V> के साथ "जीतने" से बेहतर मानता हूं। यह सब कुछ अनुरोध करता है और बॉक्स से बाहर आता है। मैं इसे अपने कार्यान्वयन के लिए उपयोग करता हूं।

— सॉयर

Answer 12

यह JavaHelp4u के कोड पर आधारित है।

कम क्रिया और दिखाता है कि एक पंक्ति में कैसे करें और चीजों पर कैसे लूप करें।

//======>  Imports
import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;

//======>  Single Entry
SimpleEntry<String, String> myEntry = new SimpleEntry<String, String>("ID", "Text");
System.out.println("key: " + myEntry.getKey() + "    value:" + myEntry.getValue());
System.out.println();

//======>  List of Entries
List<Entry<String,String>> pairList = new ArrayList<>();

//-- Specify manually
Entry<String,String> firstButton = new SimpleEntry<String, String>("Red ", "Way out");
pairList.add(firstButton);

//-- one liner:
pairList.add(new SimpleEntry<String,String>("Gray", "Alternate route"));  //Ananomous add.

//-- Iterate over Entry array:
for (Entry<String, String> entr : pairList) {
    System.out.println("Button: " + entr.getKey() + "    Label: " + entr.getValue());
}

Answer 13

Apache Crunch में एक Pairवर्ग भी है : http://crunch.apache.org/apidocs/0.5.0/org/apache/crunch/Pair.html

Answer 14

जैसे एक कक्षा बनाएँ

class tuples 
{ 
int x;
int y;
} 

फिर टुपल्स के इस ऑब्जेक्ट की सूची बनाएं

List<tuples> list = new ArrayList<tuples>();

तो आप उसी तरह अन्य नए डेटा स्ट्रक्चर्स को भी लागू कर सकते हैं।

Answer 15

मेरा मतलब है, भले ही Pairजावा में कोई वर्ग नहीं है, वहाँ कुछ बहुत अच्छा सिमेरिलर है:Map.Entry

Map.Entry प्रलेखन

यह (क्या थोड़ा सा सरलीकरण है) HashMap, या वास्तव में कोई भी Mapस्टोर।

आप इसमें Mapअपने मूल्यों को संग्रहीत करने का एक उदाहरण बना सकते हैं और प्रवेश सेट प्राप्त कर सकते हैं। आप एक के साथ समाप्त होगा Set<Map.Entry<K,V>>जो प्रभावी रूप से आप चाहते हैं।

इसलिए:

public static void main(String []args)
{    
    HashMap<String, Integer> values = new HashMap<String,Integer>();
    values.put("A", 235);//your custom data, the types may be different
    //more data insertions....
    Set<Map.Entry<String,Integer>> list = values.entrySet();//your list 
    //do as you may with it
}

Comments

इस विकल्प में अद्वितीय कुंजियों की समस्या है। मान लीजिए कि आपके पास व्यक्तियों के गुण हैं (जैसे {(person1, "blue-eyed"), (person1, "red-haired", (person2, "shortsighted"), (person2, "quick-thinker")}} नहीं, एक नक्शा में जोड़े के रूप में उन्हें स्टोर करने के लिए के बाद से प्रत्येक व्यक्ति के नक्शे के लिए महत्वपूर्ण है में सक्षम हो सकता है और केवल प्रति व्यक्ति एक विशेषता की अनुमति होगी।

— manuelvigarcia

Answer 16

स्प्रिंग का Pair<S,T>डेटा यूटिल्स पैकेज में एक प्रकार हैorg.springframework.data.util

Pair<String,Integer> pair = Pair.of("Test", 123);
System.out.println(pair.getFirst());
System.out.println(pair.getSecond());

Answer 17

Com.sun.tools.javac.util.Pair के बारे में क्या?

Comments

यह प्रकार टूल.जर में है - जेवैक कंपाइलर के "सन" कार्यान्वयन का हिस्सा है। यह केवल JDK के हिस्से के रूप में वितरित किया जाता है, अन्य विक्रेताओं के कार्यान्वयन में मौजूद नहीं हो सकता है और सार्वजनिक API का हिस्सा होने की संभावना नहीं है।

— मैकडॉवेल

Answer 18

कुंजी / मूल्य जोड़े के बारे में बात करते समय मेरे दिमाग में पहला गुण गुण वर्ग है जहां आप आइटम को एक स्ट्रीम / फ़ाइल में सहेज सकते हैं और लोड कर सकते हैं।

Answer 19

प्रोजेक्ट रिएक्टर में (io.projectreactor: रिएक्टर-कोर) एन-ट्यूपल्स के लिए उन्नत समर्थन है:

Tuple2<String, Integer> t = Tuples.of("string", 1)

वहाँ आप t.getT1(), t.getT2(), ...विशेष रूप से स्ट्रीम या फ्लक्स के साथ प्राप्त कर सकते हैं आप टपल तत्वों को भी मैप कर सकते हैं:

Stream<Tuple2<String, Integer>> s;
s.map(t -> t.mapT2(i -> i + 2));