अमरूद कैश (स्थानांतरण)

Question

के लिए एक जटिल कुंजी मैं एक बिंदु वस्तु है:

class Point { 
    final int x,y; 
    ... 
    } 

क्योंकि इन बातों का प्रयोग किया जाएगा/मेरी कोड में जगह भर में बनाया है, मैं अमरूद कैश का उपयोग शुरू करना चाहते हैं। असुविधाजनक रूप से कैशलोडर केवल एक पैरामीटर स्वीकार करता है। Another question यहां स्टैक ओवरफ्लो पर एक समान समस्या के लिए एक जोड़ी ऑब्जेक्ट का उपयोग करें। लेकिन मुझे हर कैश अनुरोध के लिए डमी ऑब्जेक्ट बनाने का विचार पसंद नहीं है। तो मैं अपने स्वयं के कामकाज के साथ आया:

क्योंकि ऑब्जेक्ट x और y द्वारा निर्दिष्ट किया गया है, मुझे लगता है कि मैं दोनों मानों को एक लंबे समय में विलय कर सकता हूं, जो मेरी कुंजी होगी।

void test(int x, int y) { 
    Long key = (long) ((long) (x) << Integer.SIZE | y); 
    Point point = cache.get(key); 
} 

CacheLoader<Long, Point> loader = new CacheLoader<Long, Point>() { 
    public Point load(Long key) throws Exception { 
    final int x,y; 
     // shift magic 
     x = (int) (key >> Integer.SIZE); 
     y = key.intValue(); 
     return new Point(x, y); 
    } 
}; 

मैं वास्तव में एक पारी noob हूँ। यह काम करेगा? क्या मैं कुछ भुल गया? क्या यह जोड़ी वर्ग की तुलना में "तेज" है? यह मेरा सवाल है!

हाँ, मैं कोड का परीक्षण करता हूं और यह अब तक काम करता है मैं बता सकता हूं।

Answer 1

कैसे इस बारे में? आपकी प्वाइंट क्लास को equals() और hashcode() को सही ढंग से कार्यान्वित करना होगा।

static class Points { 
    static final Interner<Point> INTERNER = Interners.newStrongInterner(); 

    public static Point cached(final int x, final int y) { 
    return INTERNER.intern(new Point(x, y)); 
    } 
} 

आपका वास्तविक उद्देश्य समान वस्तुओं को कैश करना था, है ना? इससे आपकी ज़रूरतें पूरी होंगी। उपयोग:

Point center = Points.cached(0, 0); 

या अपने कैश उदाहरण के एक समायोजित संस्करण:

CacheLoader<Point, Point> loader = new CacheLoader<Point, Point>() { 
    @Override 
    public Point load(final Point point) { 
    return point; 
    } 
} 
... 
Point center = cache.get(new Point(0, 0)); 

Answer 2

यह शायद तेज़ है (यदि अंतर बिल्कुल मापने योग्य है), लेकिन जोड़ी कक्षा आपके कोड को समझने या पुन: उपयोग करने के लिए बेहतर बनाती है। मैं एक सामान्य जोड़ी वर्ग के साथ जाना चाहते हैं:

public final class Pair<L, R> { 

    private final L left; 
    private final R right; 

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

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

    @Override 
    public boolean equals(final Object obj) { 
     if (obj instanceof Pair) { 
      final Pair<?,?> other = (Pair<?,?>) obj; 
      return Objects.equal(left, other.left) 
       && Objects.equal(right, other.right); 
     } else { 
      return false; 
     } 
    } 

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

    @Override 
    public String toString() { 
     return MoreObjects.toStringHelper(this) 
         .add("left", left) 
         .add("right", right) 
         .toString(); 
    } 

} 

एक बार जब आप है कि अपने कोड बेस में, आप इसके लिए एक से अधिक उपयोग मिलेगा है। बिट स्थानांतरण वास्तव में जावा की तरह नहीं है (हालांकि कई अन्य असहमत होंगे)।

Guava docs