आपको java.awt.Dimension का उपयोग अपनी कुंजी के रूप में करना चाहिए।
आयाम कुंजी = नया आयाम (4, 12);
आयाम में एक बहुत अच्छी हैशकोड() विधि है जो सकारात्मक पूर्णांक की प्रत्येक जोड़ी के लिए एक अलग हैशकोड उत्पन्न करती है, ताकि हैशकोड (4, 12) और (12, 4) अलग हैं। तो ये तत्काल तेज़ हैं और बहुत अच्छे हैशकोड बनाते हैं।
मेरी इच्छा है कि उन्होंने कक्षा को अपरिवर्तनीय बना दिया हो, लेकिन आप आयाम पर अपना स्वयं का अपरिवर्तनीय वर्ग बना सकते हैं।
यहाँ चौड़ाई और ऊंचाई के विभिन्न मूल्यों के लिए hashCode दिखाने वाली एक तालिका है:
0 1 2 3 4 <-- width
+--------------------
0 | 0 2 5 9 14
1 | 1 4 8 13
2 | 3 7 12
3 | 6 11
4 | 10
^
|
height
आप 0 से 14 के क्रम में hashCodes का पालन करें, तो आप पैटर्न देखेंगे।
public int hashCode() {
int sum = width + height;
return sum * (sum + 1)/2 + width;
}
आप अंतिम पंक्ति के अंदर त्रिकोणीय संख्या के लिए सूत्र में पहचान सकते हैं:
यहाँ कोड है कि इस hashCode पैदा करता है। यही कारण है कि तालिका के पहले कॉलम में सभी त्रिकोणीय संख्याएं हैं।
गति के लिए, आपको कन्स्ट्रक्टर में हैशकोड की गणना करनी चाहिए। तो अपनी संपूर्ण कक्षा ऐसा दिखाई दे सकता:
public class PairHash {
private final int hash;
public PairHash(int a, int b) {
int sum = a+b;
hash = sum * (sum+1)/2 + a;
}
public int hashCode() { return hash; }
}
बेशक
, अगर आप शायद एक विधि के बराबर होती है की आवश्यकता होगी, लेकिन आप धनात्मक पूर्णांक है कि नहीं अतिप्रवाह, तो आप एक बहुत तेजी से एक जोड़ सकते हैं होगा तक सीमित:
public class PairHash {
// PAIR_LIMIT is 23170
// Keeping the inputs below this level prevents overflow, and guarantees
// the hash will be unique for each pair of positive integers. This
// lets you use the hashCode in the equals method.
public static final int PAIR_LIMIT = (int) (Math.sqrt(Integer.MAX_VALUE))/2;
private final int hash;
public PairHash(int a, int b) {
assert a >= 0;
assert b >= 0;
assert a < PAIR_LIMIT;
assert b < PAIR_LIMIT;
int sum = a + b;
hash = sum * (sum + 1)/2 + a;
}
public int hashCode() { return hash; }
public boolean equals(Object other) {
if (other instanceof PairHash){
return hash == ((PairHash) other).hash;
}
return false;
}
}
हम इसे सकारात्मक मानों तक सीमित करते हैं क्योंकि नकारात्मक मान कुछ डुप्लिकेट हैंश कोड उत्पन्न करेंगे। लेकिन इस प्रतिबंध के साथ, ये सबसे तेज़ हैशकोड() और बराबर() विधियां हैं जिन्हें लिखा जा सकता है। (बेशक, आप हैशकोड को कन्स्ट्रक्टर में हैशकोड की गणना करके किसी भी अपरिवर्तनीय कक्षा में जितनी तेजी से लिख सकते हैं।)
यदि आप उन प्रतिबंधों के साथ नहीं रह सकते हैं, तो आपको केवल पैरामीटर को सहेजने की आवश्यकता है।
public class PairHash {
private final int a, b, hash;
public PairHash(int a, int b) {
this.a = a;
this.b = b;
int sum = a+b;
hash = sum * (sum+1)/2 + a;
}
public int hashCode() { return hash; }
public boolean equals(Object other) {
if (other instanceof PairHash) {
PairHash otherPair = (PairHash)other;
return a == otherPair.a && b == otherPair.b;
}
return false;
}
लेकिन यहां किकर है। आपको इस कक्षा की बिल्कुल आवश्यकता नहीं है। चूंकि सूत्र आपको संख्याओं की प्रत्येक जोड़ी के लिए एक अद्वितीय पूर्णांक देता है, इसलिए आप उस इंटीजर को अपनी मानचित्र कुंजी के रूप में उपयोग कर सकते हैं। इंटीजर क्लास का अपना तेज़ बराबर होता है() और हैशकोड विधियां जो ठीक काम करती हैं। यह विधि हैश कुंजी को दो छोटे मानों से उत्पन्न करेगी। प्रतिबंध यह है कि आपके इनपुट को सकारात्मक लघु मान होने की आवश्यकता है। यह अतिप्रवाह नहीं होने की गारंटी है, और मध्यवर्ती राशि को लंबे समय तक कास्टिंग करके, इसकी पिछली विधि की तुलना में विस्तृत सीमा है: यह सभी सकारात्मक लघु मानों के साथ काम करता है।
static int hashKeyFromPair(short a, short b) {
assert a >= 0;
assert b >= 0;
long sum = (long) a + (long) b;
return (int) (sum * (sum + 1)/2) + a;
}
मुझे लगता है कि अल्पविराम-सीमित स्ट्रिंग एक अच्छा विचार है। मैं हर समय इस दृष्टिकोण का उपयोग करता हूं। – mob