जावा जेनेरिक्स और इन्फिनिटी (तुलनीय)

Question

प्रकार पूर्णांक आप यह कर सकते हैं:

int lowest = Integer.MIN_VALUE; 

अगर मैं जेनरिक का उपयोग मैं क्या कर सकता है?

K lowest = <...>; 

मुझे प्राथमिकता क्यूई के समान कुछ लागू करने के लिए इसकी आवश्यकता है। मेरे पास उस नोड तक पहुंच है जिसे मैं कतार से हटाना चाहता हूं, लेकिन यह न्यूनतम नहीं है।

1. I need to make it the min by decreasing the key of that node, 
2. And then remove the min. 

मैं पहले चरण पर फंस गया हूं। केवल एक चीज जो मैं कर सकता हूं वह नोड की कुंजी को वर्तमान मिनट में सेट कर देता है। यकीन नहीं है कि यह पर्याप्त है।

Answer 1

यह किसी भी मतलब नहीं है ...

को देखते हुए आप जानते हैं कि नहीं क्या कश्मीर उस बिंदु पर है, (यानी आप इसे सामान्य रूप से लागू कर रहे हैं ... ओह!) आप नहीं कर सकते इसके लिए एक न्यूनतम/अधिकतम बाध्य निर्दिष्ट करें।

एक मामले में जहां कश्मीर एक पूर्णांक, लंबे, स्ट्रिंग या वस्तु हो सकता है में

, तो आप समझदारी से

Integer.MIN_VALUE, "" या नल का उपयोग करने लगता है नहीं कर सका।

मुझे लगता है कि आप जो खोज रहे हैं वह एक K.MIN_VALUE_OF_EVENTUAL_TYPE है लेकिन यह अस्तित्व में नहीं है।

Answer 2

उह यह किस प्रकार के पर निर्भर करता है?

जेनरिक का मुद्दा यह है कि के किसी भी प्रकार (या किसी निश्चित प्रकार का कोई उप-वर्ग) हो सकता है; के या उसके गुणों के उपयोग पर विधियों को कॉल करने में सक्षम होने के लिए, आपको वाइल्डकार्ड के साथ इसकी प्रकार सीमा को प्रतिबंधित करने की आवश्यकता है।

Answer 3

सभी तुलनात्मक प्रकारों के लिए MIN_VALUE या MAX_VALUE का कोई सामान्य रूप नहीं है।

Time कक्षा के बारे में सोचें जो तुलनीय लागू करता है। समय के लिए MAX_VALUE नहीं है, भले ही यह तुलनात्मक हो।

Answer 4

सिर्फ इसलिए कि कोई वस्तु तुलनीय है इसका मतलब यह नहीं है कि इसका न्यूनतम मूल्य होना चाहिए। कारण int का न्यूनतम मान है - (2^(31)) क्योंकि आपको एक संकेत के लिए 1 बिट की आवश्यकता है, इसलिए 2^31 सबसे बड़ा (या सबसे छोटा) संभव पूर्णांक है जिसे संग्रहीत किया जा सकता है। स्ट्रिंग जैसी चीजों के लिए, यह कोई समझ नहीं आता है क्योंकि कोई सबसे बड़ी/छोटी संभव स्ट्रिंग नहीं है, यह स्मृति बाध्य है।

Answer 5

आपको एक इंटरफ़ेस "IInfinity" बनाना पड़ सकता है, और K ने IInfinity, और IInfinity को "getInfinityValue()" विधि बनाने के लिए विस्तारित किया है, और फिर एक वर्ग में पूर्णांक, डबल, बिगडिसीमल इत्यादि को लपेटें/बढ़ाएं IInfinity ... और उह!

Answer 6

असल में आप किसी भी प्रकार के के कुछ स्थिर कार्यों को लागू करने के लिए चाहते हैं जो निम्नतम और उच्चतम मानक गणितीय गुणों का पालन करते हैं।

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

Answer 7

मैं कल्पना करने की कोशिश कर रहा हूं कि इस परिदृश्य के लिए किस परिदृश्य की आवश्यकता होगी। यह सबसे अच्छा है जिसके साथ मैं आ सकता हूं ...

चेतावनी: यह कोड खतरनाक है। इस तरह के घृणा को पोस्ट करने के लिए कृपया मेरे लिए दयालु रहें। यह अवधारणा का केवल एक प्रमाण है।

public class Lowest<K> implements Comparable<K> { 
    public int compareTo(K other) { 
     return -1; 
    } 
} 

और फिर ...

public class Test { 
    public <K extends Comparable<K>> K findMaximum(List<K> values) throws Exception { 
     K lowest = (K) new Lowest<K>(); /// XXX DANGER! Losing compile-time safety!!! 

     K maximum = lowest; 
     for (K value : values) { 
      if (maximum.compareTo(value) < 0) { 
       maximum = value; 
      } 
     } 

     if (maximum == lowest) { 
      throw new Exception("Could not find a maximum value"); 
     } else { 
      return maximum; 
     } 
    } 
} 

Answer 8

K एक सामान्य बनाने पर विचार नहीं है, लेकिन एक अंतरफलक है कि आदिम आवरण लपेटता का उपयोग कर (एक डबल आवरण!)।

import java.util.HashMap; 


public class NodeWrapper<K extends Comparable<K>> implements Comparable<NodeWrapper<K>> { 

    private static HashMap<Class, NodeWrapper> minVals = new HashMap<Class, NodeWrapper>(); 

    private K value; 

    private NodeWrapper() { 
     super(); 
    } 

    public NodeWrapper(K value, Class<K> clazz) { 
     super(); 
     this.value = value; 

     if (minVals.get(clazz)==null) { 
      minVals.put(clazz, new NodeWrapper<K>()); 
     } 
    } 

    public K getValue() { 
     return value; 
    } 

    public static NodeWrapper getMinValue(Class clazz){ 
     return minVals.get(clazz); 
    } 

    public void setValue(K value) { 
     this.value = value; 
    } 

    @Override 
    public int compareTo(NodeWrapper<K> o) { 
     NodeWrapper min = minVals.get(this.getClass()); 
     if (this==min && o==min) { 
      return 0; 
     } else if (this==min){ 
      return -1; 
     } else if (o==min){ 
      return 1; 
     } else { 
      return this.value.compareTo(o.value); 
     } 
    } 

} 

संक्षेप में, यह विचार है कि जब भी एक नया वर्ग instantiated है, एक न्यूनतम मूल्य बनाया है और एक स्थिर hashmap कि प्रत्येक वर्ग के लिए न्यूनतम मान संग्रहीत कर लेता में डाल दिया जाता है। (वास्तव में, ये मान बिल्कुल कुछ नहीं हैं, केवल एक सेंटीनेल ऑब्जेक्ट है, लेकिन चूंकि हम ऑब्जेक्ट समानता का उपयोग यह निर्धारित करने के लिए करेंगे कि कुछ मूल्य न्यूनतम है या नहीं, यह कोई समस्या नहीं है।) यह आवश्यक है कि लपेटा हुआ वस्तु तुलनीय हो सामान्य रूप से खुद के अन्य उदाहरणों के लिए।

एक दोष यह है कि जब आप getMinValue पर कॉल करते हैं तो आपके पास कंपाइलर चेतावनियां होंगी, क्योंकि रिटर्न प्रकार की कोई सामान्य जानकारी नहीं होगी। इसके चारों ओर एक और अधिक शानदार तरीका हो सकता है, लेकिन मैं अभी इसके बारे में नहीं सोच सकता।

यह सामान्य विचार समग्र रूप से अच्छा हो सकता है। हालांकि, मुझे वास्तव में तनाव होना चाहिए: यदि आप इसे किसी भी बहुरूपता या परस्पर तुलनीय वर्गों के मिश्रण के साथ प्रयास करते हैं तो यह पूरी तरह टूट जाएगा। एक ही पेड़ में Long एस और Integer एस पूरी तरह से आपको नष्ट कर देगा।

Answer 9

एर ... फिर से समस्या क्या है?

PriorityQueue, सभी Collections की तरह, आपको संग्रह से remove पर ऑब्जेक्ट का एक उदाहरण उपयोग करने की अनुमति देता है।

Answer 10

आप एक रैपर वर्ग बना सकते हैं जो सभी प्रकारों के लिए न्यूनतम और अधिकतम मूल्य "जोड़ता है"। इसमें केवल दो स्थैतिक उदाहरण हैं जो न्यूनतम और अधिकतम का प्रतिनिधित्व करते हैं, और फिर अन्य उदाहरण कुछ प्रकार के किसी अन्य मूल्य को लपेटते हैं। जब हम तुलना करते हैं, तो हम जांचते हैं कि चीजों में से एक न्यूनतम या अधिकतम है, और उचित परिणाम लौटाएं; और अन्यथा हम अंतर्निहित प्रकार के समान तुलना करते हैं। इस तरह कुछ:

class Extended<T extends Comparable<? super T>> implements Comparable<Extended<T>> { 
    private Extended() { } 

    private static Extended min = new Extended(); 
    private static Extended max = new Extended(); 

    @SuppressWarnings("unchecked") 
    public static <T extends Comparable<? super T>> Extended<T> getMin() { 
     return (Extended<T>)min; 
    } 
    @SuppressWarnings("unchecked") 
    public static <T extends Comparable<? super T>> Extended<T> getMax() { 
     return (Extended<T>)max; 
    } 

    public T value; 

    public Extended(T x) { value = x; } 

    public int compareTo(Extended<T> other) { 
     if (this == other) return 0; 
     else if (this == min || other == max) return -1; 
     else if (this == max || other == min) return 1; 
     else return this.value.compareTo(other.value); 
    } 
}