तुलनात्मक सूची की सूची से न्यूनतम और अधिकतम मान प्राप्त करने का सबसे अच्छा तरीका क्या है जिसमें मुख्य मूल्य शून्य होते हैं?

मैं कुछ के बारे में इस तरह सोच रहा हूँ:तुलनात्मक सूची की सूची से न्यूनतम और अधिकतम मान प्राप्त करने का सबसे अच्छा तरीका क्या है जिसमें मुख्य मूल्य शून्य होते हैं?

public static <T extends Comparable<T>> T minOf(T...ts){   
    SortedSet<T> set = new TreeSet<T>(Arrays.asList(ts)); 
    return set.first(); 
} 

public static <T extends Comparable<T>> T maxOf(T...ts){ 
    SortedSet<T> set = new TreeSet<T>(Arrays.asList(ts)); 
    return set.last(); 
}

लेकिन अशक्त सुरक्षित है, जो कुछ मैं भी चाहता हूँ नहीं है।

क्या आप इस समस्या को हल करने के लिए एक बेहतर तरीका जानते हैं?

संपादित करें:

टिप्पणी के बाद मैं भी कोशिश की है मिनट():

public static <T extends Comparable<T>> T minOf(T...ts){   
    return Collections.min(Arrays.asList(ts), new Comparator<T>(){ 

     public int compare(T o1, T o2) { 
      if(o1!=null && o2!=null){ 
       return o1.compareTo(o2); 
      }else if(o1!=null){ 
       return 1; 
      }else{ 
       return -1; 
      } 
     }}); 
}

क्या आप इस बात का लगता है?

स्रोत

2008-12-15 user2427

कि अक्षम है, क्योंकि आप हे की जरूरत है (एन एन लॉग इन करें) तुलना, के बाद से TreeSet प्रभावी रूप से संग्रह सॉर्ट करता है, जहां n पर्याप्त है। इसके अलावा, आप बहुत सारे अपर्याप्त कचरे का निर्माण करते हैं (Arrays.asList "ts" की एक प्रति बनाता है, और ट्रीसेट भी हल्का नहीं है)। – mfx

Arrays.asList सरणी की एक प्रति नहीं बनाता है। –

हां जो काम करेगा, लेकिन क्यों नहीं घोषित करें और उस तुलनित्र को नाम दें जहां यह पुन: प्रयोज्य है? फिर इस minOf फ़ंक्शन का उपयोग करने के बजाय, उस मानक तुलनित्र के साथ मानक संग्रह .min को कॉल करें। मानक लाइब्रेरी कॉल का उपयोग कर आपका कोड अधिक पठनीय हो जाता है। – Pyrolistical

Collections.max के साथ क्या गलत है?

और आप शून्य सुरक्षा की परवाह क्यों करते हैं? क्या आप वाकई अपने संग्रह में नल को अनुमति देना चाहते हैं?

स्रोत

2008-12-15 19:13:19 Pyrolistical

प्रश्न अधिकतम * और * मिनट के लिए था। Collections.max() प्रत्येक तत्व को देखेंगे। फिर Collections.min() फिर से प्रत्येक तत्व को देखेंगे। तो शायद एक बार तेजी से क्रमबद्ध करें। – Yetti99

@ यति 99 सॉर्टिंग धीमा हो जाएगा क्योंकि यह 'ओ (एन लॉग एन)' और 'अधिकतम' + मिनट' 'ओ (2 एन)' है। एक लूप करने के लिए थोड़ा बेहतर होगा और इसमें अधिकतम और न्यूनतम दोनों अपडेट करें। और ओपी को एक ही समारोह में दोनों की आवश्यकता नहीं लगती है। –

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

संपादित करें: यहां कुछ कोड है जो मुझे बताता है कि मैं किस बारे में बात कर रहा हूं। दुर्भाग्यवश एक बढ़िया मामला है जिस पर आपको विचार करने की आवश्यकता है - क्या होगा यदि सभी तर्क पारित किए गए हैं? आपकी विधि क्या लौटती है?

public static <T extends Comparable<T>> T minOf(T...ts){ 
    T min = null; 
    for (T t : ts) { 
     if (t != null && (min == null || t.compareTo(min) < 0)) { 
      min = t; 
     } 
    } 
    return min; 
} 

public static <T extends Comparable<T>> T maxOf(T...ts){ 
    T max = null; 
    for (T t : ts) { 
     if (t != null && (max == null || t.compareTo(max) > 0)) { 
      max = t; 
     } 
    } 
    return max; 
}

स्रोत

2008-12-15 19:19:10

आप Comparable नहीं लागू अशक्त स्वीकार करने के लिए, के रूप में यह इंटरफ़ेस का अनुबंध टूट जाता है चाहिए।

https://docs.oracle.com/javase/7/docs/api/java/lang/Comparable.html से: