জাভাতে সি ++ পেয়ার <এল, আর> এর সমতুল্য কত?

Question

Pair<L,R>জাভাতে নেই থাকার কোনও কারণ আছে কি ? এই সি ++ নির্মাণের সমতুল্য কি হবে? আমি বরং আমার নিজের পুনরায় সংশোধন এড়াতে চাই।

দেখে মনে হচ্ছে 1.6 অনুরূপ কিছু সরবরাহ করছে ( AbstractMap.SimpleEntry<K,V>), তবে এটি বেশ বিভ্রান্ত দেখাচ্ছে।

Comments

কেন AbstractMap.SimpleEntryনিষ্প্রভিত হয়?

— কার্টেনডগ

নামিগের কারণে, নির্বিচারে একটি কী এবং একটি মানের নামকরণ।

— এনারসিসিও

আরও দেখুন stackoverflow.com/questions/6271731/...

— Raedwald

@sffc জাভাএফএক্স JDK7 এর কোনও ডিফল্ট ক্লাসপথগুলিতে নেই, এটি ব্যবহার করে জেএফএক্স রানটাইম লাইব্রেরিগুলি ম্যানুয়ালি যুক্ত করা দরকার।

— কর্ড রেহেন

@ আন্তর্সিও: সুতরাং, আপনি আসলে বলেছেন যে "প্রথম" এবং "দ্বিতীয়" স্বেচ্ছাচারী নয়, যখন "কী" এবং "মান" - হয়? তারপরে এসডিকে তেমন ক্লাস না থাকার এটি একটি ভাল কারণ। "যথাযথ" নামকরণ সম্পর্কে চিরন্তন বিরোধ হবে be

— fdreger

Answer 1

ইন উপর একটি থ্রেডcomp.lang.java.help , হান্টার Gratzner একটি উপস্থিতিতে বিরুদ্ধে আর্গুমেন্ট দেয় Pairজাভা কনস্ট্রাক্ট। মূল যুক্তিটি হ'ল একটি শ্রেণি Pairদুটি মানগুলির মধ্যে সম্পর্ক সম্পর্কে কোনও শব্দার্থবিজ্ঞান প্রকাশ করে না (আপনি কীভাবে জানেন যে "প্রথম" এবং "দ্বিতীয়" অর্থ কী?)

আরও ভাল অনুশীলন হ'ল একটি মাইক প্রস্তাবিত একটি খুব সাধারণ ক্লাস লিখতে হবে, প্রতিটি প্রয়োগের জন্য আপনি Pairক্লাসটি তৈরি করতেন । Map.Entryএটি এমন একটি জুটির উদাহরণ যা তার নামে অর্থ বহন করে।

সংক্ষেপে বলতে গেলে আমার মতে জেনেরিকের চেয়ে ক্লাস Position(x,y), ক্লাস Range(begin,end)এবং ক্লাস থাকা ভাল যা আমাকে কী করা উচিত বলে কিছু বলে না।Entry(key,value)Pair(first,second)

Comments

গ্রেটজনার চুল বিভাজন করছে। আমরা কোনও একক মানকে কোনও শ্রেণিতে আবদ্ধ না করে আদিম বা অন্তর্নির্মিত শ্রেণি হিসাবে একক মান ফেরত দিতে বেশ খুশি। আমরা যদি এক ডজন উপাদানগুলির একটি গোছা ফেরত পাঠাতে পারি তবে কারও পক্ষে এটির নিজস্ব শ্রেণি হওয়া উচিত নয়। মাঝখানে কোথাও একটি (অস্পষ্ট) বিভাজক রেখা। আমি মনে করি আমাদের টিকটিকি ব্রেইন সহজেই জোড়গুলি সামলাতে পারে।

— আয়ান

আমি ইয়ান এর সাথে একমত জাভা আপনাকে প্রত্যাবর্তন করতে দেয়; এটি প্রতিবার আপনি যখন কোনওটি ব্যবহার করেন তখন এটির জন্য একটি উপকরণ তৈরি করতে আপনাকে বাধ্য করে না। জোড়গুলি খুব আলাদা নয়।

— ক্লিমেট

যদি আমরা সরাসরি আপনার স্থানীয় ভেরিয়েবলগুলিতে একটি জুড়ি আনপ্যাক করতে পারি বা এটি দুটি পদ্ধতিতে যুক্তিযুক্ত পদ্ধতিতে ফরোয়ার্ড করতে পারি তবে জোড় একটি দরকারী বর্গ হবে। যেহেতু আমরা এটিকে আনপ্যাক করতে পারি না, তাই একটি অর্থবহ শ্রেণি তৈরি করা এবং মানগুলি একত্রে রাখা খুব খারাপ লাগে না। এবং, যদি আপনি সীমাবদ্ধতা থাকা সত্ত্বেও সত্যিই একটি জুটি চান, তবে সর্বদা অবজেক্ট [2] + কাস্টস রয়েছে :-)

— মার্কাস

জিনিসটি হ'ল যদি আপনি গ্র্যাটজনারের সাথে একমত না হন তবে বেশ কয়েকটি জায়গায় জুটি প্রয়োগ রয়েছে। অ্যাপাচি কমন্স এবং পেয়ারা উভয়েরই এটি আইআইআরসি রয়েছে। সেগুলি ব্যবহার করুন। তবে প্রধান জাভা লাইব্রেরিতে কিছু রাখার অর্থ হল এটি একটি নোবেল এবং অনুমোদিত উপায় যা করার জিনিস (মূলধন সহ) এবং যেহেতু লোকেরা তাতে একমত হয় না, তাই আমাদের এটি রাখা উচিত নয়। পুরানো libs মধ্যে যথেষ্ট ক্রাফট আছে যেমন আছে, আসুন অগত্যা সেখানে আরও রাখা উচিত।

— হাকন লাটভিট

@ ড্রাগাস যখন আমার মূল্যবোধের একটি জোড় দরকার তখন জাভাটি গুরুতর নয়?

— idclev 463035818

Answer 2

এটি জাভা। বর্ণনামূলক শ্রেণি এবং ক্ষেত্রের নামগুলি সহ আপনাকে নিজের নিজস্ব তৈরি জোড় শ্রেণি তৈরি করতে হবে এবং আপনি হ্যাশকোড () / সমান () লিখে বা বারবার তুলনামূলক প্রয়োগ করে চাকাটিকে পুনর্বহাল করবেন তা মনে রাখবেন না।

Comments

এটি "কেন" প্রশ্নের উত্তর দেয় না। (যদি না আপনি 'এটি জাভা' একটি উত্তর বিবেচনা না করেন)

— নিকিতা রাইবাক

জাভাটির ভার্বোসেসকে উপহাস করার জন্য +1। -1 আসলে প্রশ্নের উত্তর না দেওয়ার জন্য।

— বেনেট ম্যাকএলউই

জাভা-মশকরা যদি আপনি জোড় ক্লাস ধারণ করে অ্যাপাচি কমং ল্যাংকে নির্দেশ করে থাকেন তবে তা ঠিক হয়ে যেত।

— হাইলেম

অথবা আপনি কেবল ব্যবহার করতে পারেনSimpleImmutableEntry

— কার্টেনডোগ

প্রথম বাক্যটি "কেন?" প্রশ্নের উত্তর দেয়। এটি জাভা, এবং এটিই।

— মাস্টারজিভ

Answer 3

হ্যাশম্যাপ সুসংগত জুটি ক্লাস:

public class Pair<A, B> {
    private A first;
    private B second;

    public Pair(A first, B second) {
        super();
        this.first = first;
        this.second = second;
    }

    public int hashCode() {
        int hashFirst = first != null ? first.hashCode() : 0;
        int hashSecond = second != null ? second.hashCode() : 0;

        return (hashFirst + hashSecond) * hashSecond + hashFirst;
    }

    public boolean equals(Object other) {
        if (other instanceof Pair) {
            Pair otherPair = (Pair) other;
            return 
            ((  this.first == otherPair.first ||
                ( this.first != null && otherPair.first != null &&
                  this.first.equals(otherPair.first))) &&
             (  this.second == otherPair.second ||
                ( this.second != null && otherPair.second != null &&
                  this.second.equals(otherPair.second))) );
        }

        return false;
    }

    public String toString()
    { 
           return "(" + first + ", " + second + ")"; 
    }

    public A getFirst() {
        return first;
    }

    public void setFirst(A first) {
        this.first = first;
    }

    public B getSecond() {
        return second;
    }

    public void setSecond(B second) {
        this.second = second;
    }
}

Comments

আপনি সম্ভবত সেটারগুলি মুছতে এবং প্রথম এবং দ্বিতীয় ফাইনাল তৈরি করতে চান, যাতে এই জুটিটি অনিবার্য হয়ে পড়ে। (যদি কেউ হ্যাশ কী হিসাবে ব্যবহার করার পরে উপাদানগুলি পরিবর্তন করে তবে অদ্ভুত জিনিসগুলি ঘটবে)।

— থিলো

toString () পদ্ধতিতে "(" + first.toString () + "," + second.toString () + ")" রিটার্ন নালপয়েন্টারএক্সেপশন নিক্ষেপ করতে পারে। এটি আরও ভাল: ফিরে "(" + প্রথম + "," + দ্বিতীয় + ")";

— জুহা সিরাজিলা 8

এছাড়াও, হয় জোড়াকে "চূড়ান্ত" হিসাবে চিহ্নিত করুন বা সমান প্রথম পংক্তিকে 'if (অন্যান্য! = নাল && this.getClass () == other.getClass ())'

— সারগাসে

এলোমেলো ছোট্ট প্রশ্নের জন্য দুঃখিত, তবে আপনি কেন কনস্ট্রাক্টরে সুপার () এ কল করবেন?

— ইব্রাহিম

@ ইব্রাহিম: এক্ষেত্রে এটি অতিমাত্রায় --- আপনি যদি super()বাইরে বেরোনেন তবে আচরণটি ঠিক একই রকম । সাধারণত এটি যদি এখানে থাকে তবে এটি optionচ্ছিক হলে আমি কেবল এটি বন্ধ করে দেব।

— ক্রিস জেস্টার-ইয়াং

Answer 4

লম্বোক ব্যবহার করে আমি যে সংক্ষিপ্ততম জুটিটি নিয়ে আসতে পারি তা হ'ল :

@Data
@AllArgsConstructor(staticName = "of")
public class Pair<F, S> {
    private F first;
    private S second;
}

এটা সব বেনিফিট আছে @arturh থেকে উত্তর (তুলনামূলক ব্যতীত) এটা আছে, hashCode, equals, toStringএবং একটি স্ট্যাটিক "কনস্ট্রাকটর"।

Comments

নিফটি! পছন্দ হয়েছে!

— আহমেট ইপকিন

Answer 5

অ্যাপাচি কমন্স ল্যাং +.০+ এর কয়েকটি জোড় ক্লাস রয়েছে: http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/package-summary.html

Answer 6

এর সাথে জুটি প্রয়োগের আর একটি উপায়।

• পাবলিক অপরিবর্তনীয় ক্ষেত্র, অর্থাত্ সরল ডেটা স্ট্রাকচার।
• তুলনাযোগ্য.
• সাধারণ হ্যাশ এবং সমান।

• সাধারণ কারখানা যাতে আপনাকে প্রকারগুলি সরবরাহ করতে না হয়। যেমন পেয়ার.ওফ ("হ্যালো", 1);

  public class Pair<FIRST, SECOND> implements Comparable<Pair<FIRST, SECOND>> {
  
      public final FIRST first;
      public final SECOND second;
  
      private Pair(FIRST first, SECOND second) {
          this.first = first;
          this.second = second;
      }
  
      public static <FIRST, SECOND> Pair<FIRST, SECOND> of(FIRST first,
              SECOND second) {
          return new Pair<FIRST, SECOND>(first, second);
      }
  
      @Override
      public int compareTo(Pair<FIRST, SECOND> o) {
          int cmp = compare(first, o.first);
          return cmp == 0 ? compare(second, o.second) : cmp;
      }
  
      // todo move this to a helper class.
      private static int compare(Object o1, Object o2) {
          return o1 == null ? o2 == null ? 0 : -1 : o2 == null ? +1
                  : ((Comparable) o1).compareTo(o2);
      }
  
      @Override
      public int hashCode() {
          return 31 * hashcode(first) + hashcode(second);
      }
  
      // todo move this to a helper class.
      private static int hashcode(Object o) {
          return o == null ? 0 : o.hashCode();
      }
  
      @Override
      public boolean equals(Object obj) {
          if (!(obj instanceof Pair))
              return false;
          if (this == obj)
              return true;
          return equal(first, ((Pair) obj).first)
                  && equal(second, ((Pair) obj).second);
      }
  
      // todo move this to a helper class.
      private boolean equal(Object o1, Object o2) {
          return o1 == null ? o2 == null : (o1 == o2 || o1.equals(o2));
      }
  
      @Override
      public String toString() {
          return "(" + first + ", " + second + ')';
      }
  }

Comments

আমি স্থির কারখানার পদ্ধতি পছন্দ করি of। এটি গুগল পেয়ারা অপরিবর্তনীয় সংগ্রহগুলির স্মরণ করিয়ে দেয় ।

— জেরেক প্রাইজিডজকি

আপনি কিছুটা সময় castালাই o1করছেন Comparable, যদিও কিছুই ইঙ্গিত করে না যে এটি আসলে সেই ইন্টারফেসটি বাস্তবায়ন করবে। যদি এটির প্রয়োজন হয় তবে FIRSTটাইপ প্যারামিটারটি হওয়া উচিত FIRST extends Comparable<?>।

— জিএইচএইচ

আমি জাভা লোক নই, তাই দয়া করে আমার অজ্ঞতার জন্য আমাকে ক্ষমা করুন, তবে আপনি টোডো মন্তব্যে কোন ধরণের সহায়ক শ্রেণীর কথা ভাবছিলেন?

31 হ্যাশকোডের জন্য খারাপ ধ্রুবক। উদাহরণস্বরূপ, যদি আপনি 2D মানচিত্রের জন্য জো <<<<<<<<<<<<<<<<<<<<<<<<< উদাহরণস্বরূপ (একটি * 65497) ^ বি আরও উপযুক্ত হবে।

— মিশা জিলিয়েস্কি

@MarioCarneiro ^ XOR না শক্তি

— মাইকেল Zieliński

Answer 7

Http://www.javatuples.org/index.html সম্পর্কে কীভাবে আমি এটি খুব দরকারী বলে মনে করেছি।

জাভাটুপলস আপনাকে এক থেকে দশটি উপাদান থেকে দ্বিগুণ ক্লাস সরবরাহ করে:

Unit<A> (1 element)
Pair<A,B> (2 elements)
Triplet<A,B,C> (3 elements)
Quartet<A,B,C,D> (4 elements)
Quintet<A,B,C,D,E> (5 elements)
Sextet<A,B,C,D,E,F> (6 elements)
Septet<A,B,C,D,E,F,G> (7 elements)
Octet<A,B,C,D,E,F,G,H> (8 elements)
Ennead<A,B,C,D,E,F,G,H,I> (9 elements)
Decade<A,B,C,D,E,F,G,H,I,J> (10 elements)

Comments

মজার, তবে কমপক্ষে আরও 5 টি ক্লাস রয়েছে যা আমি কখনও কল্পনা করতে পারি না could

— মার্টিনাস

@ maaartinus আমার ব্যবহারের চেয়ে কমপক্ষে 10 টি বেশি

— বোয়ান

@ বনান: ঠিক আছে, আমি সংশোধন করছি। আমি ব্যবহার করতাম Pairএবং Tripletপ্রতি 50 বছরে একবার ব্যবহার করার কল্পনা করতে পারি । এখন আমি লম্বোক ব্যবহার করি এবং প্রতিবার আমার জোড়া লাগার সময় একটি ছোট 4-লাইনের ক্লাস তৈরি করি। সুতরাং "10 খুব বেশি" সঠিক।

— মার্টিনাস

আমাদের কি Bottom (0 element)ক্লাস দরকার ? :)

— আর্থ ইঞ্জিন

বাহ এটা কুরুচিপূর্ণ। আমি জানি তারা এটিকে সুস্পষ্ট করার চেষ্টা করছে, তবে সি # এর মতো ওভারলোড হওয়া প্যারামগুলির সাথে একটি টুপল ভাল লাগত।

— আরভিমান

Answer 8

এটি আপনি কীসের জন্য ব্যবহার করতে চান তার উপর নির্ভর করে। এটি করার সাধারণ কারণ হ'ল মানচিত্রগুলি পুনরাবৃত্তি করা, যার জন্য আপনি কেবল এটি করেন (জাভা 5+):

Map<String, Object> map = ... ; // just an example
for (Map.Entry<String, Object> entry : map.entrySet()) {
  System.out.printf("%s -> %s\n", entry.getKey(), entry.getValue());
}

Comments

আমি নিশ্চিত না যে কোনও কাস্টম শ্রেণি এই ক্ষেত্রে সহায়তা করবে :)

— নিকিতা রায়বাক

"এটি করার সাধারণ কারণ হ'ল মানচিত্রের পুনরাবৃত্তি"। সত্যি?

— বেনেট ম্যাকএলউই

Answer 9

অ্যান্ড্রয়েড এখানে Pairক্লাস সরবরাহ করে ( http://developer.android.com/references/android/util/Pair.html ), এখানে বাস্তবায়ন:

public class Pair<F, S> {
    public final F first;
    public final S second;

    public Pair(F first, S second) {
        this.first = first;
        this.second = second;
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Pair)) {
            return false;
        }
        Pair<?, ?> p = (Pair<?, ?>) o;
        return Objects.equal(p.first, first) && Objects.equal(p.second, second);
    }

    @Override
    public int hashCode() {
        return (first == null ? 0 : first.hashCode()) ^ (second == null ? 0 : second.hashCode());
    }

    public static <A, B> Pair <A, B> create(A a, B b) {
        return new Pair<A, B>(a, b);
    }
}

Comments

Objects.equal(..)পেয়ারা গ্রন্থাগার প্রয়োজন

— মার্কাস এল

Objects.equals(...)২০১১ সাল থেকে জাভাতে এটি পরিবর্তন করুন (১.7)

— অ্যান্ড্রুএফ

Answer 10

সবচেয়ে বড় সমস্যা সম্ভবত এটি যে এ এবং বি এর অপরিবর্তনযোগ্যতা নিশ্চিত করতে পারে না (দেখুন যে ধরণের পরামিতিগুলি অপরিবর্তনীয় তা কীভাবে নিশ্চিত করা যায় ) উদাহরণস্বরূপ কোনও সংকলন সন্নিবেশ করানোর পরেhashCode() একই পেয়ারের জন্য অসঙ্গতিপূর্ণ ফলাফল দিতে পারে (এটি অনির্ধারিত আচরণ দেবে , পরিবর্তনীয় ক্ষেত্রের ক্ষেত্রে সংজ্ঞা সমান দেখুন )। একটি নির্দিষ্ট (নন জেনেরিক) জোড় শ্রেণীর জন্য প্রোগ্রামার সাবধানতার সাথে এ এবং বি অপসারণযোগ্য হিসাবে বেছে নেওয়ার মাধ্যমে অদৃশ্যতা নিশ্চিত করতে পারে।

যাইহোক, @ পিটারলওয়ারির উত্তর (জবা ১.)) থেকে জেনেরিকের সতর্কতাগুলি সাফ করা:

public class Pair<A extends Comparable<? super A>,
                    B extends Comparable<? super B>>
        implements Comparable<Pair<A, B>> {

    public final A first;
    public final B second;

    private Pair(A first, B second) {
        this.first = first;
        this.second = second;
    }

    public static <A extends Comparable<? super A>,
                    B extends Comparable<? super B>>
            Pair<A, B> of(A first, B second) {
        return new Pair<A, B>(first, second);
    }

    @Override
    public int compareTo(Pair<A, B> o) {
        int cmp = o == null ? 1 : (this.first).compareTo(o.first);
        return cmp == 0 ? (this.second).compareTo(o.second) : cmp;
    }

    @Override
    public int hashCode() {
        return 31 * hashcode(first) + hashcode(second);
    }

    // TODO : move this to a helper class.
    private static int hashcode(Object o) {
        return o == null ? 0 : o.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Pair))
            return false;
        if (this == obj)
            return true;
        return equal(first, ((Pair<?, ?>) obj).first)
                && equal(second, ((Pair<?, ?>) obj).second);
    }

    // TODO : move this to a helper class.
    private boolean equal(Object o1, Object o2) {
        return o1 == o2 || (o1 != null && o1.equals(o2));
    }

    @Override
    public String toString() {
        return "(" + first + ", " + second + ')';
    }
}

সংযোজন / সংশোধন অনেক স্বাগত :) বিশেষত আমি আমার ব্যবহার সম্পর্কে যথেষ্ট নিশ্চিত নই Pair<?, ?>।

এই সিনট্যাক্সটি কেন দেখতে পারে সে সম্পর্কে আরও তথ্যের জন্য নিশ্চিত করুন যে বস্তুগুলি তুলনামূলক কার্যকর করে এবং একটি বিশদ ব্যাখ্যার জন্য max(Comparable a, Comparable b)জাভাতে জেনেরিক ফাংশন কীভাবে প্রয়োগ করা যায়?

Comments

জাভা ইন্টিজারগুলি 32 বিট হিসাবে, প্রথম হ্যাশকোডটি 31 দ্বারা গুণ করলে এর অর্থ হবে না যে এটি প্রবাহিত হবে? একচেটিয়া ওআর সম্পাদন করা কি ভাল হবে না?

— ডান

@ ডান এডিট করতে নির্দ্বিধায় আমি জাভা থেকে দূরে সরে এসেছি :)

— মিঃ_আর_ম্রিএস_ডি

Answer 11

আমার মতে, জাভাতে কোনও জুড়ি নেই কারণ আপনি যদি সরাসরি জুটিতে অতিরিক্ত কার্যকারিতা যুক্ত করতে চান (যেমন তুলনামূলক), আপনার অবশ্যই প্রকারগুলি আবদ্ধ করতে হবে। সি ++ এ, আমরা কেবল যত্ন নিই না এবং যদি কোনও জোড় তৈরির প্রকারগুলি না থাকে operator <তবে pair::operator <সেগুলিও সংকলন করবে না।

কোন সীমানা ছাড়াই তুলনাযোগ্য একটি উদাহরণ:

public class Pair<F, S> implements Comparable<Pair<? extends F, ? extends S>> {
    public final F first;
    public final S second;
    /* ... */
    public int compareTo(Pair<? extends F, ? extends S> that) {
        int cf = compare(first, that.first);
        return cf == 0 ? compare(second, that.second) : cf;
    }
    //Why null is decided to be less than everything?
    private static int compare(Object l, Object r) {
        if (l == null) {
            return r == null ? 0 : -1;
        } else {
            return r == null ? 1 : ((Comparable) (l)).compareTo(r);
        }
    }
}

/* ... */

Pair<Thread, HashMap<String, Integer>> a = /* ... */;
Pair<Thread, HashMap<String, Integer>> b = /* ... */;
//Runtime error here instead of compile error!
System.out.println(a.compareTo(b));

টাইপ আর্গুমেন্ট তুলনাযোগ্য কিনা তা জন্য সংকলন-সময়ের সাথে চেক করার সাথে তুলনার উদাহরণ:

public class Pair<
        F extends Comparable<? super F>, 
        S extends Comparable<? super S>
> implements Comparable<Pair<? extends F, ? extends S>> {
    public final F first;
    public final S second;
    /* ... */
    public int compareTo(Pair<? extends F, ? extends S> that) {
        int cf = compare(first, that.first);
        return cf == 0 ? compare(second, that.second) : cf;
    }
    //Why null is decided to be less than everything?
    private static <
            T extends Comparable<? super T>
    > int compare(T l, T r) {
        if (l == null) {
            return r == null ? 0 : -1;
        } else {
            return r == null ? 1 : l.compareTo(r);
        }
    }
}

/* ... */

//Will not compile because Thread is not Comparable<? super Thread>
Pair<Thread, HashMap<String, Integer>> a = /* ... */;
Pair<Thread, HashMap<String, Integer>> b = /* ... */;
System.out.println(a.compareTo(b));

এটি ভাল তবে এবার আপনি জোড়ায় টাইপের আর্গুমেন্ট হিসাবে তুলনামূলক অ-প্রকার ব্যবহার করতে পারবেন না। কেউ কেউ কিছু ইউটিলিটি ক্লাসে জোড়ের জন্য প্রচুর তুলনামূলক ব্যবহার করতে পারে তবে সি ++ লোকেরা এটি নাও পেতে পারে। আর একটি উপায় হ'ল টাইপ আন্ডারর্কে বিভিন্ন ধরণের আর্গুমেন্টের সাথে টাইপ হায়ারার্কিতে প্রচুর ক্লাস লেখা, তবে অনেকগুলি সম্ভাব্য সীমানা এবং তাদের সংমিশ্রণ রয়েছে ...

Answer 12

জাভাএফএক্স (যা জাভা 8 এর সাথে বান্ডেল হয়ে আসে) এর পেয়ার <এ, বি> শ্রেণি রয়েছে

Comments

Javafx.util.Pair মধ্যে হ্যাশকোড বাস্তবায়ন তুচ্ছ ক্ষেত্রে দুর্ঘটনায় হতে পারে। এটি হ্যাশম্যাপ / হ্যাশ টেবিলটিতে ব্যবহার করা এখনও কার্যকর হবে যেহেতু জাভা হ্যাশ কোডগুলি ছাড়াও মানগুলির সমতার জন্য পরীক্ষা করে তবে এটি সচেতন হওয়ার মতো কিছু।

— এসএফসিসি

এটি একটি খুব মানক এবং সাধারণভাবে প্রস্তাবিত হ্যাশকোড বাস্তবায়ন। সংঘর্ষগুলি যে কোনও কোডের মাধ্যমে কল করা উচিত hashCode()। নোট করুন যে জাভা নিজেই এই পদ্ধতিটিকে কল করে না। এটি গ্রন্থাগার সহ ব্যবহারকারী কোডের জন্য।

— অ্যান্ড্রুএফ

Answer 13

অন্য অনেকে ইতিমধ্যে জানিয়েছে যে, একটি জোড় শ্রেণি কার্যকর হয় বা না সেগুলি ব্যবহারের ক্ষেত্রে নির্ভর করে।

আমি মনে করি কোনও প্রাইভেট হেল্পার ফাংশনের জন্য পেয়ার ক্লাস ব্যবহার করা সম্পূর্ণ বৈধ এবং যদি এটি আপনার কোডটিকে আরও পঠনযোগ্য করে তোলে এবং তার সমস্ত বয়লার প্লেট কোডের সাথে আরও একটি মান শ্রেণি তৈরি করার প্রচেষ্টাটির পক্ষে মূল্যবান নয়।

অন্যদিকে, যদি আপনার বিমূর্ত স্তরটি আপনাকে ক্লাসের শব্দার্থতাকে দুটি আইটেম বা মান ধারণ করে স্পষ্টভাবে নথিভুক্ত করার প্রয়োজন হয়, তবে আপনার অবশ্যই এটির জন্য একটি ক্লাস লিখতে হবে। তথ্যটি যদি কোনও ব্যবসায়ের অবজেক্ট হয় তবে তা সাধারণত।

সর্বদা হিসাবে, এটি দক্ষ রায় প্রয়োজন।

আপনার দ্বিতীয় প্রশ্নের জন্য আমি অ্যাপাচি কমন্স লাইব্রেরি থেকে জো ক্লাসের প্রস্তাব দিচ্ছি। এগুলি জাভা জন্য বর্ধিত মানক গ্রন্থাগার হিসাবে বিবেচিত হতে পারে:

https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/Pair.html

আপনি অ্যাপাচি কমন্সের সমতুল্য বিল্ডার , হ্যাশকোডবিল্ডার এবং টসস্ট্রিংবিল্ডার যা আপনার ব্যবসায়িক বিষয়গুলির জন্য লেখার মান ক্লাসকে সহজতর করে তাও দেখতে চাইতে পারেন ।

Comments

Commons.apache.org/lang/api-release/index.html?org/apache/… আপডেট হওয়া ইউআরএল কমন্স-ল্যাং 3 বিটা ছাড়ার পরে of এটা আমার নিজের Lombok সমাধান চেয়ে আরও খাটো যদি আপনি ইতিমধ্যে Commons-ল্যাঙ 3. ব্যবহার

— মাইকেল Piefel

Answer 14

আপনি জাভাফ্যাক্স ইউটিলিটি ক্লাসটি ব্যবহার করতে পারেন, Pairযা সি ++ এ <> জোড় হিসাবে একই উদ্দেশ্যে কাজ করে। https://docs.oracle.com/javafx/2/api/javafx/util/Pair.html

Answer 15

গুড নিউজ JavaFXএকটি কী মান জোড়া হয়েছে।

কেবল জাভাফেক্সকে নির্ভরতা এবং আমদানি হিসাবে যুক্ত করুন javafx.util.Pair;

এবং হিসাবে সহজভাবে ব্যবহার করুন c++।

Pair <Key, Value> 

যেমন

Pair <Integer, Integer> pr = new Pair<Integer, Integer>()

pr.get(key);// will return corresponding value

Comments

খারাপ খবর হ'ল সবাই জাভাএফএক্স ব্যবহার করে না

— মাইচা ডবি ডব্রাজেস্কি

Answer 16

মানচিত্র.এন্ট্রি ইন্টারফেস সি ++ জুটির বেশ কাছাকাছি আসে। কংক্রিট বাস্তবায়ন দেখুন, যেমন অ্যাস্ট্রাক্টম্যাপ.সিম্পলএন্ট্রি এবং অ্যাবস্ট্রাকম্যাপ.সিম্পলআইমিউটেবল এন্ট্রি প্রথম আইটেমটি getKey () এবং দ্বিতীয়টি getValue ()।

Comments

ওপি এই বিকল্পটি সম্পর্কে ইতিমধ্যে অবগত এবং এটি দীর্ঘ আলোচনা করা হয়েছিল।

— কেগান

Answer 17

Collections.singletonMap(left, rigth);

Answer 18

জাভা ভাষার প্রকৃতি অনুসারে, আমি মনে করি লোকেরা আসলে একটি প্রয়োজন হয় না Pair, একটি ইন্টারফেস সাধারণত তাদের প্রয়োজন হয়। এখানে একটি উদাহরণ:

interface Pair<L, R> {
    public L getL();
    public R getR();
}

সুতরাং, যখন লোকেরা দুটি মান ফিরিয়ে দিতে চায় তারা নিম্নলিখিতগুলি করতে পারে:

... //Calcuate the return value
final Integer v1 = result1;
final String v2 = result2;
return new Pair<Integer, String>(){
    Integer getL(){ return v1; }
    String getR(){ return v2; }
}

এটি একটি হালকা ওজনের একটি হালকা সমাধান এবং এটি "এ এর সিনেমিক কী Pair<L,R>?" প্রশ্নের উত্তর দেয় । উত্তরটি হ'ল, এটি দুটি (বিভিন্ন হতে পারে) ধরণের একটি ইন্টারফেস বিল্ড এবং এর প্রতিটিটি ফেরত দেওয়ার পদ্ধতি রয়েছে। এটিতে আরও শব্দার্থকতা যুক্ত করা আপনার উপর নির্ভর করে। উদাহরণস্বরূপ, যদি আপনি অবস্থান ব্যবহার করেন এবং সত্যিই আপনি কোডে এটা ইঙ্গিত চান, আপনি নির্ধারণ করতে পারেন PositionXএবং PositionYযে রয়েছে Integer, একটি আপ করতে Pair<PositionX,PositionY>। যদি জেএসআর 308 উপলভ্য থাকে তবে আপনি এটি Pair<@PositionX Integer, @PositionY Ingeger>সরল করতেও ব্যবহার করতে পারেন ।

সম্পাদনা: একটি জিনিস এখানে আমাকে নির্দেশ করা উচিত যে উপরের সংজ্ঞাটি স্পষ্টভাবে প্যারামিটারের নাম এবং পদ্ধতির নামটি সম্পর্কিত করে। এটি সেই যুক্তিগুলির একটি উত্তর যা একটি Pairশব্দার্থক তথ্যের অভাব। আসলে, পদ্ধতিটির getLঅর্থ "আমাকে এমন উপাদান দিন যা প্যারামিটার এল টাইপের সাথে মিল রাখে", যার অর্থ কিছু।

সম্পাদনা: এখানে একটি সাধারণ ইউটিলিটি শ্রেণি যা জীবনকে সহজ করে তুলতে পারে:

class Pairs {
    static <L,R> Pair<L,R> makePair(final L l, final R r){
        return new Pair<L,R>(){
            public L getL() { return l; }
            public R getR() { return r; }   
        };
    }
}

ব্যবহার:

return Pairs.makePair(new Integer(100), "123");

Comments

কি সম্পর্কে equals, hashCodeএবং toString?

— sdgfsdh

ঠিক আছে, এটি কেবলমাত্র একটি ন্যূনতম বাস্তবায়ন। আপনার যদি এর চেয়ে বেশি প্রয়োজন হয় তবে আপনি আরও সহজ করার জন্য কিছু সহায়ক ফাংশন লিখতে পারেন, তবে তবুও আপনাকে কোডটি লিখতে হবে।

— আর্থ ইঞ্জিন

বাস্তবায়নের জন্য toStringআপনার দুটি ক্ষেত্রের মধ্যে সম্পর্ক সম্পর্কে আরও জ্ঞান দরকার।

— আর্থ ইঞ্জিন

আমার বক্তব্যটি সরবরাহ করা classকেবলমাত্র একটি চেয়ে ভাল হতে পারে interfaceকারণ এটি এই বিষয়গুলি বাস্তবায়ন করতে পারে।

— sdgfsdh

Answer 19

সিনথেটিকভাবে একই রকম হওয়া সত্ত্বেও, জাভা এবং সি ++ এর খুব আলাদা প্যারাডিজম রয়েছে। জাভার মতো সি ++ লেখা খারাপ সি ++, এবং সি ++ এর মতো জাভা লেখা খারাপ জাভা।

Eclipse এর মতো প্রতিবিম্ব ভিত্তিক IDE সহ, "জোড়" শ্রেণীর প্রয়োজনীয় কার্যকারিতা লেখা দ্রুত এবং সহজ। ক্লাস তৈরি করুন, দুটি ক্ষেত্র নির্ধারণ করুন, কয়েক সেকেন্ডের মধ্যে ক্লাসটি পূরণ করতে বিভিন্ন "জেনারেট এক্সএক্স" মেনু বিকল্পগুলি ব্যবহার করুন। আপনি যদি তুলনামূলক ইন্টারফেস চান তবে সম্ভবত আপনাকে একটি "তুলনামূলক" রিয়েল দ্রুত টাইপ করতে হবে।

ভাষাতে পৃথক ঘোষণা / সংজ্ঞা বিকল্পের সাথে সি ++ কোড জেনারেটরগুলি এতটা ভাল নয়, তাই হাতের সামান্য ইউটিলিটি ক্লাসগুলি লেখার সময় বেশি সময় লাগে ed জুড়িটি একটি টেম্পলেট হিসাবে, আপনার ব্যবহার না করা ফাংশনগুলির জন্য আপনাকে অর্থ প্রদান করতে হবে না, এবং টাইপডিফ সুবিধা কোডটিতে অর্থপূর্ণ টাইপনেমগুলি নির্ধারণ করতে দেয়, সুতরাং "কোনও শব্দার্থবিজ্ঞান" সম্পর্কে আপত্তিগুলি সত্যই ধরে না don't

Answer 20

জটিল জেনেরিকের জন্য প্রাথমিক নির্মাণ ইউনিট হওয়ার জন্য জোড়টি খুব ভাল জিনিস হবে, উদাহরণস্বরূপ, এটি আমার কোড থেকে:

WeakHashMap<Pair<String, String>, String> map = ...

এটি হাস্কেলের টুপলের মতোই

Comments

এখন আমি বলতে পারি যে, পেয়ার <ক, বি> কোডটি কোড কম তথ্যবহুল করে তোলে এবং পেয়ার ব্যবহার না করে বিশেষ অবজেক্টগুলি প্রয়োগ করা আরও ভাল

— ইলারিওন কোভালচুক

ভালো অথবা মন্দ. কল্পনা করুন আপনার দুটি ফর্ম যুক্ত করে একটি ফাংশন রয়েছে (উদাহরণস্বরূপ গ্রাফগুলি একের মধ্যে মার্জ করা) এবং এটি ক্যাশে করা দরকার। এখানে Pairকোনও বিশেষ শব্দার্থবিজ্ঞান না হওয়ায় এটি অনুকূল। সুস্পষ্ট ধারণার জন্য একটি সুস্পষ্ট নাম রাখা ভাল তবে এমন একটি নাম সন্ধান করা যেখানে "প্রথম" এবং "দ্বিতীয়" কাজটি ভাল নয়।

— মার্টিনাস

Answer 21

সরল উপায় অবজেক্ট [] - আনুমেন্ট টিউপল হিসাবে ব্যবহার করা যেতে পারে

Comments

হ্যাঁ, কোন মাত্রা। তবে: তৈরি করা জটিল এবং টাইপ-সেফ নয়।

— মাইকেল পিফেল

Answer 22

জাভার মতো প্রোগ্রামিং ভাষার জন্য, বেশিরভাগ প্রোগ্রামাররা ডেটা-স্ট্রাকচারের মতো জোড়া উপস্থাপনের জন্য ব্যবহৃত বিকল্প ডাটা স্ট্রাকচার দুটি অ্যারে হয় এবং একই সূচির মাধ্যমে ডেটা অ্যাক্সেস করা হয়

উদাহরণ: http://www-igm.univ-MLv.fr/~lecroq/string/node8.html#SECTION0080

এটি আদর্শ নয় কারণ ডেটাগুলি একত্রে আবদ্ধ হওয়া উচিত, তবে এটি খুব সস্তা হিসাবেও সক্রিয়। এছাড়াও, যদি আপনার ব্যবহারের ক্ষেত্রে সমন্বয়গুলি সংরক্ষণের দাবি করে তবে আপনার নিজের ডেটা কাঠামো তৈরি করা আরও ভাল।

আমার লাইব্রেরিতে আমি এরকম কিছু করেছি

public class Pair<First,Second>{.. }

Answer 23

আপনি গুগলের অটোভ্যালু গ্রন্থাগারটি ব্যবহার করতে পারেন - https://github.com/google/auto/tree/master/value ।

আপনি একটি খুব ছোট বিমূর্ত ক্লাস তৈরি করেন এবং এটিকে @ অটোভ্যালু দিয়ে টিকা দেবেন এবং এ্যানোটেশন প্রসেসর আপনার জন্য একটি কংক্রিট বর্গ তৈরি করে যার মান মূল্যবান।

Answer 24

এখানে কিছু লাইব্রেরি রয়েছে যা আপনার সুবিধার জন্য একাধিক ডিগ্রি টিপল রয়েছে:

• জাভাটুপলস । 1-10 ডিগ্রি থেকে টিপলস যা আছে তা সমস্ত।
• জাভাস্ল্যাং । 0-8 ডিগ্রি থেকে টিপলস এবং প্রচুর অন্যান্য কার্যকরী গুডিজ।
• jooλ । 0-16 ডিগ্রি এবং অন্যান্য কিছু কার্যকরী গুডিজ থেকে টিপলস। (অস্বীকৃতি, আমি রক্ষণাবেক্ষণকারী সংস্থার পক্ষে কাজ করি)
• প্রায়োগিক জাভা । 0-8 ডিগ্রি থেকে টিপলস এবং প্রচুর অন্যান্য কার্যকরী গুডিজ।

অন্যান্য গ্রন্থাগারে কমপক্ষে Pairটিপল রয়েছে বলে উল্লেখ করা হয়েছে ।

বিশেষত, ফাংশনাল প্রোগ্রামিংয়ের প্রেক্ষাপটে যা নামমাত্র টাইপিংয়ের পরিবর্তে ( স্বীকৃত উত্তরে পরামর্শ হিসাবে ) প্রচুর কাঠামোগত টাইপিং ব্যবহার করে , সেই গ্রন্থাগারগুলি এবং তাদের টিপলগুলি খুব কাজে আসে।

Answer 25

ব্রায়ান গোয়েটস, পল সানডোজ এবং স্টুয়ার্ট মার্কস ব্যাখ্যা করেছেন কেন দেভোএক্সএক্স'এক'এর QA অধিবেশন চলাকালীন।

স্ট্যান্ডার্ড লাইব্রেরিতে জেনেরিক জোড় শ্রেণীর মানটি প্রকারের প্রবর্তনের পরে প্রযুক্তিগত debtণে পরিণত হবে ।

আরও দেখুন: জাভা এসই 8 এর কি জোড় বা টিপলস রয়েছে?

Answer 26

অপর একটি লম্পট বাস্তবায়ন

import lombok.Value;

@Value(staticConstructor = "of")
public class Pair<F, S> {
    private final F first;
    private final S second;
}

Answer 27

আমি লক্ষ্য করেছি যে এখানে সমস্ত জোড় কার্যকর করা হয়েছে যা দুটি মানের ক্রমের সাথে সম্পর্কিত। আমি যখন একটি জুটির কথা চিন্তা করি, তখন আমি দুটি আইটেমের সংমিশ্রনের কথা ভাবি যেখানে দুটির ক্রমের কোনও গুরুত্ব নেই। এখানে একটি unordered যুগল আমার বাস্তবায়ন নেই, hashCodeএবং equalsসংগ্রহের কাঙ্ক্ষিত আচরণ নিশ্চিত করার ওভাররাইড করে। ক্লোনযোগ্যও।

/**
 * The class <code>Pair</code> models a container for two objects wherein the
 * object order is of no consequence for equality and hashing. An example of
 * using Pair would be as the return type for a method that needs to return two
 * related objects. Another good use is as entries in a Set or keys in a Map
 * when only the unordered combination of two objects is of interest.<p>
 * The term "object" as being a one of a Pair can be loosely interpreted. A
 * Pair may have one or two <code>null</code> entries as values. Both values
 * may also be the same object.<p>
 * Mind that the order of the type parameters T and U is of no importance. A
 * Pair&lt;T, U> can still return <code>true</code> for method <code>equals</code>
 * called with a Pair&lt;U, T> argument.<p>
 * Instances of this class are immutable, but the provided values might not be.
 * This means the consistency of equality checks and the hash code is only as
 * strong as that of the value types.<p>
 */
public class Pair<T, U> implements Cloneable {

    /**
     * One of the two values, for the declared type T.
     */
    private final T object1;
    /**
     * One of the two values, for the declared type U.
     */
    private final U object2;
    private final boolean object1Null;
    private final boolean object2Null;
    private final boolean dualNull;

    /**
     * Constructs a new <code>Pair&lt;T, U&gt;</code> with T object1 and U object2 as
     * its values. The order of the arguments is of no consequence. One or both of
     * the values may be <code>null</code> and both values may be the same object.
     *
     * @param object1 T to serve as one value.
     * @param object2 U to serve as the other value.
     */
    public Pair(T object1, U object2) {

        this.object1 = object1;
        this.object2 = object2;
        object1Null = object1 == null;
        object2Null = object2 == null;
        dualNull = object1Null && object2Null;

    }

    /**
     * Gets the value of this Pair provided as the first argument in the constructor.
     *
     * @return a value of this Pair.
     */
    public T getObject1() {

        return object1;

    }

    /**
     * Gets the value of this Pair provided as the second argument in the constructor.
     *
     * @return a value of this Pair.
     */
    public U getObject2() {

        return object2;

    }

    /**
     * Returns a shallow copy of this Pair. The returned Pair is a new instance
     * created with the same values as this Pair. The values themselves are not
     * cloned.
     *
     * @return a clone of this Pair.
     */
    @Override
    public Pair<T, U> clone() {

        return new Pair<T, U>(object1, object2);

    }

    /**
     * Indicates whether some other object is "equal" to this one.
     * This Pair is considered equal to the object if and only if
     * <ul>
     * <li>the Object argument is not null,
     * <li>the Object argument has a runtime type Pair or a subclass,
     * </ul>
     * AND
     * <ul>
     * <li>the Object argument refers to this pair
     * <li>OR this pair's values are both null and the other pair's values are both null
     * <li>OR this pair has one null value and the other pair has one null value and
     * the remaining non-null values of both pairs are equal
     * <li>OR both pairs have no null values and have value tuples &lt;v1, v2> of
     * this pair and &lt;o1, o2> of the other pair so that at least one of the
     * following statements is true:
     * <ul>
     * <li>v1 equals o1 and v2 equals o2
     * <li>v1 equals o2 and v2 equals o1
     * </ul>
     * </ul>
     * In any other case (such as when this pair has two null parts but the other
     * only one) this method returns false.<p>
     * The type parameters that were used for the other pair are of no importance.
     * A Pair&lt;T, U> can return <code>true</code> for equality testing with
     * a Pair&lt;T, V> even if V is neither a super- nor subtype of U, should
     * the the value equality checks be positive or the U and V type values
     * are both <code>null</code>. Type erasure for parameter types at compile
     * time means that type checks are delegated to calls of the <code>equals</code>
     * methods on the values themselves.
     *
     * @param obj the reference object with which to compare.
     * @return true if the object is a Pair equal to this one.
     */
    @Override
    public boolean equals(Object obj) {

        if(obj == null)
            return false;

        if(this == obj)
            return true;

        if(!(obj instanceof Pair<?, ?>))
            return false;

        final Pair<?, ?> otherPair = (Pair<?, ?>)obj;

        if(dualNull)
            return otherPair.dualNull;

        //After this we're sure at least one part in this is not null

        if(otherPair.dualNull)
            return false;

        //After this we're sure at least one part in obj is not null

        if(object1Null) {
            if(otherPair.object1Null) //Yes: this and other both have non-null part2
                return object2.equals(otherPair.object2);
            else if(otherPair.object2Null) //Yes: this has non-null part2, other has non-null part1
                return object2.equals(otherPair.object1);
            else //Remaining case: other has no non-null parts
                return false;
        } else if(object2Null) {
            if(otherPair.object2Null) //Yes: this and other both have non-null part1
                return object1.equals(otherPair.object1);
            else if(otherPair.object1Null) //Yes: this has non-null part1, other has non-null part2
                return object1.equals(otherPair.object2);
            else //Remaining case: other has no non-null parts
                return false;
        } else {
            //Transitive and symmetric requirements of equals will make sure
            //checking the following cases are sufficient
            if(object1.equals(otherPair.object1))
                return object2.equals(otherPair.object2);
            else if(object1.equals(otherPair.object2))
                return object2.equals(otherPair.object1);
            else
                return false;
        }

    }

    /**
     * Returns a hash code value for the pair. This is calculated as the sum
     * of the hash codes for the two values, wherein a value that is <code>null</code>
     * contributes 0 to the sum. This implementation adheres to the contract for
     * <code>hashCode()</code> as specified for <code>Object()</code>. The returned
     * value hash code consistently remain the same for multiple invocations
     * during an execution of a Java application, unless at least one of the pair
     * values has its hash code changed. That would imply information used for 
     * equals in the changed value(s) has also changed, which would carry that
     * change onto this class' <code>equals</code> implementation.
     *
     * @return a hash code for this Pair.
     */
    @Override
    public int hashCode() {

        int hashCode = object1Null ? 0 : object1.hashCode();
        hashCode += (object2Null ? 0 : object2.hashCode());
        return hashCode;

    }

}

এই প্রয়োগটি যথাযথভাবে ইউনিট পরীক্ষিত হয়েছে এবং একটি সেট এবং মানচিত্রে ব্যবহারের চেষ্টা করা হয়েছে।

লক্ষ্য করুন আমি পাবলিক ডোমেনে এটি প্রকাশ করার দাবি করছি না। এই কোডটি আমি স্রেফ একটি অ্যাপ্লিকেশনটিতে ব্যবহারের জন্য লিখেছি তাই আপনি যদি এটি ব্যবহার করতে চলেছেন তবে অনুগ্রহ করে মন্তব্য এবং নামগুলি সম্পর্কে সরাসরি কপি তৈরি করতে এবং বিরক্ত করার বিষয়টি থেকে বিরত থাকুন। আমার ড্রিফট ধর?

Comments

প্রকৃতপক্ষে, প্রতিটি পৃষ্ঠার নীচে চেক করুন: "ব্যবহারকারীর অবদানগুলি সিসি-উইকির অধীনে লাইসেন্স দেওয়া হয়েছে"

— আমারা

আহ, আমি এটা লক্ষ্য করিনি। সতর্ক থাকুন জন্য ধন্যবাদ. সেক্ষেত্রে সেই লাইসেন্সের অধীনে আপনি যেভাবে ফিট দেখবেন কোডটি ব্যবহার করুন।

— জিএইচ

প্রশ্নটি একটি সি ++ সমতুল্য জুটি সম্পর্কে - যা অর্ডার করা হয়। এছাড়াও আমি মনে করি যে যতক্ষণ পর্যন্ত কারও কাছে পয়ারের অবজেক্টের একটি উল্লেখ রয়েছে এবং সেগুলি সংগ্রহগুলিতে জুটিগুলি areোকানো যায় তা অপরিজ্ঞাত আচরণের দিকে পরিচালিত করতে পারে।

— মিস্টার_আর_আমস_ডি

Answer 28

যদি কেউ একটি ডেড-সিম্পল এবং সহজেই ব্যবহারযোগ্য সংস্করণ চান তবে আমি https://github.com/lfac-pt/Java-Pair এ আমার উপলব্ধ করে দিয়েছি । এছাড়াও, উন্নতিগুলি অনেক ধন্যবাদ!

Answer 29

com.sun.tools.javac.util.Pair একটি জুটির একটি সহজ বাস্তবায়ন। এটি jdk1.7.0_51 b lib \ ટૂেলস.জারে পাওয়া যাবে।

Org.apache.commons.lang3.tuple.Pair ব্যতীত, এটি কেবল একটি ইন্টারফেস নয়।

Comments

যদিও জেডিকে অভ্যন্তরীণ এপিআইগুলি ব্যবহার করা উচিত নয়।

— jpangamarca

Answer 30

public class Pair<K, V> {

    private final K element0;
    private final V element1;

    public static <K, V> Pair<K, V> createPair(K key, V value) {
        return new Pair<K, V>(key, value);
    }

    public Pair(K element0, V element1) {
        this.element0 = element0;
        this.element1 = element1;
    }

    public K getElement0() {
        return element0;
    }

    public V getElement1() {
        return element1;
    }

}

ব্যবহার:

Pair<Integer, String> pair = Pair.createPair(1, "test");
pair.getElement0();
pair.getElement1();

অপরিবর্তনীয়, এক জোড়া!

Comments

কি শান্তি. আরেকটা? আপনার আরও জটিল জেনারিকসের সাথে ব্যবহার করার চেষ্টা করুন - এক পর্যায়ে, এটি উপযুক্ত প্রকারগুলি নির্ধারণ করতে ব্যর্থ হবে। এছাড়াও, নিম্নলিখিতটি সম্ভব হওয়া উচিত: Pair<Object, Object> pair = Pair.createPair("abc", "def")তবে আমার Pair.createPair((Object)"abc", (Object)"def")কোডটি আপনার কোড দিয়ে লিখতে হবে ?

— কিট আছে - অ্যানি-মৌসেস

আপনি এটি দ্বারা স্থির পদ্ধতিটি প্রতিস্থাপন করতে পারেন: @SuppressWarnings("unchecked") public static <K, V, X, Y> Pair<X, Y> createPair(K key, V value) { return new Pair<X, Y>((X) key, (Y) value); } তবে এটি একটি ভাল অনুশীলন কিনা তা আমি জানি না

— বাস্টিফ্লিউ

না, এটি সম্ভবত আরও কিছু আরও খারাপ করবে। আমার অভিজ্ঞতায় কমপক্ষে একটি সংকলক (চেষ্টা করুন জাভা,, জাভা,, জাভাডোক এবং এক্সলিপস জাভা সংকলক) অভিযোগ করবেন। new Pair<Object, Object>("abc", "def")আমার পরীক্ষাগুলিতে প্রচলিত ছিল সবচেয়ে নির্ভরযোগ্য।

— কিট আছে - অ্যানি-মৌসে