ما يعادل C++ زوج<L,R> في جافا ؟

StackOverflow https://stackoverflow.com/questions/156275

  •  03-07-2019
  •  | 
  •  

سؤال

هل هناك سبب وجيه لماذا لا يوجد Pair<L,R> في جافا ؟ ما يعادل هذا C++ بناء?أود أن بدلا من ذلك تجنب reimplementing بلدي.

يبدو أن 1.6 هو تقديم شيء مماثل (AbstractMap.SimpleEntry<K,V>), ولكن هذا يبدو تماما الملتوية.

هل كانت مفيدة؟

المحلول

في موضوع على comp.lang.java.help, هنتر Gratzner يعطي بعض الحجج ضد وجود Pair بناء في جافا.والحجة الرئيسية هي أن فئة Pair لا ينقل أي دلالات عن العلاقة بين القيم (كيف يمكنك أن تعرف ما "الأولى" و "الثانية" يعني؟).

أفضل الممارسات في كتابة بسيطة جدا صف واحد مايك المقترحة لكل تطبيق من شأنها أن تجعل من Pair فئة. Map.Entry مثال على زوج التي تحمل معناها في اسمها.

والحاصل في رأيي أنه من الأفضل أن يكون لديك الدرجة Position(x,y), فئة Range(begin,end) و فئة Entry(key,value) بدلا من عام Pair(first,second) لا تقل لي أي شيء عن ما يفترض أن تفعله.

نصائح أخرى

هذا هو جافا.لديك لجعل الخاصة بك مصممة زوج الدرجة مع وصفي الدرجة أسماء الحقول ، وليس إلى الذهن أنه سوف اختراع العجلة من خلال كتابة hashCode()/يساوي() أو تنفيذ مماثلة مرارا وتكرارا.

HashMap الزوج متوافق الدرجة:

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;
    }
}

أقصر الزوج أن يأتي هو التالي ، وذلك باستخدام لومبوك:

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

كان لديه كل فوائد الجواب من @arturh (ما عدا المقارنة) ، فقد hashCode, equals, toString و ثابت "منشئ".

أباتشي العموم Lang 3.0+ لديها عدد قليل من زوج فصول:http://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/package-summary.html

طريقة أخرى لتنفيذ الزوج مع.

  • العامة ثابتة المجالات ، أيبسيطة بنية البيانات.
  • قابلة للمقارنة.
  • بسيطة تجزئة و يساوي.

  • مصنع بسيط حتى لا تضطر إلى تقديم أنواع.على سبيل المثالالزوج.من("مرحبا", 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 + ')';
    }
}

ماذا عن http://www.javatuples.org/index.html لقد وجدت أنه من المفيد جدا.

على javatuples يقدم لك tuple الفصول من واحد إلى عشرة عناصر:

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)

ذلك يعتمد على ما كنت ترغب في استخدامه.نموذجية سبب للقيام بذلك هو أن تكرار عبر الخرائط التي يمكنك ببساطة فعل هذا (جافا 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());
}

الروبوت يوفر Pairالدرجة (http://developer.android.com/reference/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);
    }
}

المشكلة الأكبر هي ربما التي لا يمكن للمرء التأكد من ثبات على A و B (انظر كيفية التأكد من أن نوع المعلمات غير قابلة للتغيير) حتى hashCode() قد تعطي نتائج غير متناسقة على نفس الزوج بعد يتم إدراجها في مجموعة على سبيل المثال (هذا من شأنه أن يعطي السلوك غير معرف راجع تحديد متساوين في الشروط قابلة للتغيير المجالات).معين (غير العامة) زوج الدرجة مبرمج قد تضمن ثبات طريق اختيار بعناية A و B إلى أن تكون ثابتة.

على أي حال, المقاصة العامة تحذيرات من @PeterLawrey الجواب (جافا 1.7) :

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) وظيفة في جافا ؟

في رأيي لا يوجد زوج في جافا لأنه إذا كنت ترغب في إضافة وظائف إضافية مباشرة على الزوج (مثلا ، للمقارنة) ، يجب ربط أنواع.في C++, نحن لا نبالي ، وإذا أنواع تأليف زوج لا 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));

وهذا أمر جيد ، ولكن هذا الوقت لا يجوز لك استخدام غير قابلة للمقارنة أنواع حسب نوع الحجج في الزوج.واحدة قد تستخدم الكثير من الكائنات المرجعية الزوج في بعض المرافق فئة C++ ولكن الناس قد لا تحصل عليه.طريقة أخرى لكتابة الكثير من الطبقات في التسلسل الهرمي نوع مختلف الحدود على نوع الحجج ، ولكن هناك الكثير من الممكن حدود ومجموعاتها...

سكريبت (الذي يأتي المجمعة مع جافا 8) قد زوج< A ، B > الفئة

كما العديد من الآخرين ذكرت أنها حقا يتوقف على استخدام حالة إذا زوج الفئة هي مفيدة أم لا.

أعتقد الخاصة المساعد وظيفة تماما المشروعة إلى استخدام زوج من الدرجة إذا كان هذا يجعل التعليمات البرمجية الخاصة بك أكثر قابلية للقراءة و هو لا يستحق كل هذا الجهد من خلق آخر قيمة الدرجة مع جميع المرجل لوحة التعليمات البرمجية.

من ناحية أخرى, إذا كان التجريد مستوى يتطلب منك أن توثق بوضوح دلالات الصف الذي يحتوي على اثنين من الأشياء أو القيم ، ثم يجب عليك كتابة الدرجة لذلك.عادة ما يكون هذا هو الحال إذا كانت البيانات هو الكائن الأعمال.

كما هو الحال دائما ، فإنه يتطلب مهارة الحكم.

بالنسبة لسؤالك الثاني أوصي الزوج فئة من أباتشي العموم المكتبات.هذه قد تعتبر مدد قياسية مكتبات جافا:

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

قد ترغب أيضا في إلقاء نظرة على اباتشي المشاع EqualsBuilder, HashCodeBuilder و ToStringBuilder والتي تبسيط كتابة قيمة الطبقات لعملك الكائنات.

أخبار جيدة Java إضافة قيمة مفتاح الزوج .

فقط استيراد javafx.util.Pair;

واستخدام ببساطة كما في c++ .

Pair < Key , Value >

على سبيل المثال 

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

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

يمكنك استخدام سكريبت فائدة الصف ، Pair التي تخدم نفس الغرض كما زوج <> في c++. https://docs.oracle.com/javafx/2/api/javafx/util/Pair.html

خريطة.دخول واجهة تأتي قريبة جدا من c++ الزوج.نظرة على تنفيذ ملموسة ، مثل AbstractMap.SimpleEntry و AbstractMap.SimpleImmutableEntry البند الأول هو getKey() و الثاني هو getValue().

Collections.singletonMap(left, rigth);

وفقا لطبيعة لغة جافا ، أفترض أن الناس في الواقع لا تتطلب 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>.إذا JSR 308 المتاحة, يمكنك أيضا استخدام Pair<@PositionX Integer, @PositionY Ingeger> لتبسيط هذا.

تحرير:شيء واحد أود أن الإشارة هنا هي أن التعريف المذكور أعلاه صراحة تتعلق اكتب اسم المعلمة و اسم الأسلوب.هذا هو الجواب لمن يقول أن Pair هو الافتقار إلى المعلومات الدلالية.في الواقع, طريقة getL تعني "أعطني العناصر التي تتوافق مع نوع من نوع المعلمة L" الذي لا يعني شيئا.

تحرير:هنا هو أداة بسيطة الدرجة التي يمكن أن تجعل الحياة أسهل:

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");

على الرغم من كونه نحويا مماثلة, Java و C++ جدا من نماذج مختلفة.كتابة C++ مثل جافا سيئة C++ و كتابة جافا مثل C++ سيئة جافا.

مع انعكاس على أساس IDE مثل الكسوف ، كتابة بالضرورة وظيفة "زوج" صنف سريع و بسيط.إنشاء فئة تحديد اثنين من المجالات ، استخدام مختلف "توليد العشرين" القائمة خيارات لملء الطبقة في بضع ثوان.ربما عليك أن اكتب "compareTo" سريعا إذا أردت المقارنة واجهة.

منفصلة مع إعلان / تعريف الخيارات في لغة C++ code generators ليست جيدة جدا من ناحية الكتابة قليلا فئات الأداة المساعدة هو أكثر استهلاكا للوقت الملل.لأن الزوج هو قالب, لم يكن لديك لدفع ثمن الوظائف التي لا تستخدمها ، typedef المرفق يسمح تعيين معنى typenames إلى رمز ، لذا الاعتراضات حول "أي دلالات" لا تصمد.

زوج من الأشياء الجيدة أن تكون وحدة البناء الأساسية لمجمع العوام ، على سبيل المثال ، هذا هو قانون بلدي:

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

هو مجرد نفس هاسكل Tuple

عن لغات البرمجة مثل جافا ، المناوبين بنية البيانات المستخدمة من قبل معظم المبرمجين تمثل زوج مثل البيانات-هياكل نوعان من مجموعة البيانات يتم الوصول إليها عبر نفس المؤشر

على سبيل المثال: http://www-igm.univ-mlv.fr/~lecroq/سلسلة/node8.html#SECTION0080

هذه ليست مثالية كما يجب أن تكون البيانات لا بد معا ، ولكن أيضا تتحول إلى أن تكون رخيصة جدا.أيضا, إذا كان لديك حالة استخدام المطالب تخزين تنسق ثم أفضل لبناء الخاصة بك هيكل البيانات.

لدي شيء مثل هذا في مكتبتي

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

يمكنك استخدام جوجل AutoValue المكتبة - https://github.com/google/auto/tree/master/value.

يمكنك إنشاء صغير جدا خلاصة الدرجة الحواشي مع @AutoValue و الشرح المعالج بإنشاء فئة محددة بالنسبة لك أن له قيمة دلالية.

وهنا بعض المكتبات التي تحتوي على عدة درجات من الصفوف لراحتك:

  • JavaTuples.الصفوف من درجة 1-10 هو كل ما لديه.
  • JavaSlang.الصفوف من درجة 0-8 والكثير الفنية الأخرى الجيدة.
  • jOOλ.الصفوف من درجة 0-16 وبعض الفنية الأخرى الجيدة.(تنويه, أنا أعمل بإدارة الشركة)
  • وظيفية جافا.الصفوف من درجة 0-8 والكثير الفنية الأخرى الجيدة.

مكتبات أخرى ذكرت أن يحتوي على الأقل Pair tuple.

على وجه التحديد في سياق البرمجة الوظيفية مما يجعل استخدام الكثير من الهيكلية الكتابة بدلا من الاسمية كتابة (كما دعا في قبول الإجابة) تلك المكتبات و الصفوف تأتي في سهل للغاية.

براين جويتز بول ساندوز و ستيوارت علامات يفسر لماذا خلال QA الدورة في Devoxx'14.

بعد أن عامة زوج الدرجة في المكتبة القياسية سوف تتحول إلى الدين التقنية مرة واحدة أنواع القيم أدخلت.

انظر أيضا: لا Java SE 8 أزواج أو الصفوف?

طريقة بسيطة كائن [] - يمكن استخدام أي القاس tuple

لاحظت كل زوج تطبيقات يجري تتناثر هنا سمة معنى أمر من اثنين القيم.عندما أفكر في زوج أعتقد من مزيج من اثنين من العناصر في أي أمر من اثنين لا أهمية.هنا هو بلدي تنفيذ غير مرتبة الزوج ، 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;

    }

}

هذا التنفيذ قد تم بشكل صحيح وحدة اختبارها واستخدامها في مجموعة وخريطة وقد حاول الخروج.

لاحظ أنا لا أدعي أن هذا الإصدار في المجال العام.هذا هو رمز كتبته فقط للاستخدام في التطبيق ، لذلك إذا كنت تنوي استخدام ذلك ، يرجى الامتناع عن صنع نسخة مباشرة و تعبث مع التعليقات الأسماء قليلا.فهمت قصدي ؟

إذا كان أي شخص يريد القتلى-بسيطة وسهلة الاستخدام نسخة قمت المتاحة في https://github.com/lfac-pt/Java-Pair.كما التحسينات نرحب كثيرا!

com.الشمس.أدوات.javac.util.الزوج هو بسيط تنفيذ زوج.ويمكن العثور عليها في jdk1.7.0_51\lib ools.jar.

بخلاف org.أباتشي.المشاع.lang3.tuple.زوج, انها ليست مجرد واجهة.

آخر مقتضب لومبوك تنفيذ

import lombok.Value;

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

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();

ثابتة فقط زوج !

مرخصة بموجب: CC-BY-SA مع الإسناد
لا تنتمي إلى StackOverflow
scroll top