जावा लैम्ब्डा तुलनित्र रूपांतरण के लिए - मध्यवर्ती प्रतिनिधित्व

Question

मैं यह समझने की कोशिश कर रहा हूं कि Comparator.comparing फ़ंक्शन कैसे काम करता है। मैंने इसे समझने के लिए अपनी तुलनात्मक विधि बनाई।

private static <T,U extends Comparable<U>> Comparator<T> comparing(Function<T,U> f) { 
    BiFunction<T,T,Integer> bfun = (T a, T b) -> f.apply(a).compareTo(f.apply(b)); 
    return (Comparator<T>) bfun; 
} 

इस फ़ंक्शन में अंतिम पंक्ति अपवाद फेंकता है।

हालांकि, अगर मैं

private static <T,U extends Comparable<U>> Comparator<T> comparing(Function<T,U> f) { 
    return (T a, T b) -> f.apply(a).compareTo(f.apply(b)); 
} 

को यह समारोह बदल यह ठीक अपेक्षा के अनुरूप काम करता है।

मध्यवर्ती कार्यात्मक इंटरफ़ेस क्या है जो दूसरा प्रयास उपयोग करता है, जो लैम्ब्डा को Comparator में परिवर्तित करने में सक्षम है?

Answer 1

मध्यवर्ती कार्यात्मक इंटरफ़ेस क्या है जो दूसरा प्रयास उपयोग करता है, जो लैम्ब्डा को तुलनात्मक में परिवर्तित करने में सक्षम है?

Comparator स्वयं।

दूसरी विधि के भीतर, आपने Comparator परिभाषित किया है, एक मध्यवर्ती वस्तु नहीं है जिसे Comparator पर डाला गया है।

इस फ़ंक्शन में अंतिम पंक्ति अपवाद फेंकता है।

हां, यह चाहिए।

यदि दो वर्ग कार्यात्मक इंटरफेस हैं और समान विधियां हैं (समान हस्ताक्षर और समान वापसी प्रकार के साथ), इसका मतलब यह नहीं है कि इन्हें एक दूसरे के लिए उपयोग किया जा सकता है। -

---

एक दिलचस्प चाल आप BiFunction<T, T, Integer> bfun की विधि apply का हवाला देते हुए एक Comparator<T> कर सकते हैं:

private static <T,U extends Comparable<U>> Comparator<T> comparing(Function<T,U> f) { 
    final BiFunction<T,T,Integer> bfun = (T a, T b) -> f.apply(a).compareTo(f.apply(b)); 
    return bfun::apply; // (a, b) -> bfun.apply(a, b); 
} 

Answer 2

अपने दूसरे प्रयास में मध्यवर्ती कार्यात्मक इंटरफ़ेस बस Comparator<T> है:

आप इसे देख सकते हैं क्योंकि आपका कोड-स्निपेट निम्न के बराबर है:

private static <T,U extends Comparable<U>> Comparator<T> comparing(Function<T,U> f) { 
    Comparator<T> comparator = (T a, T b) -> f.apply(a).compareTo(f.apply(b)); 
    return comparator; 
}