यह जांचने के लिए कि तत्व लैम्बडा अभिव्यक्ति का उपयोग करते हुए मौजूद है या नहीं?

Question

विशेष रूप से, मेरे पास TabPane है, और मैं जानना चाहूंगा कि क्या इसमें विशिष्ट आईडी वाला तत्व है।

इसलिए, मैं जावा में लैम्ब्डा एक्सप्रेशन के साथ ऐसा करना चाहूंगा:

boolean idExists = false;
String idToCheck = "someId";

for (Tab t : tabPane.getTabs()){
    if(t.getId().equals(idToCheck)) {
        idExists = true;
    }
}

Answer 1

anyMatchलैम्ब्डा एक्सप्रेशन के उपयोग की कोशिश करें । यह बहुत बेहतर दृष्टिकोण है।

 boolean idExists = tabPane.getTabs().stream()
            .anyMatch(t -> t.getId().equals(idToCheck));

Comments

इसके अलावा ध्यान देने योग्य: यदि आप noneMatchइसके बजाय चेक उपयोग को नकारना चाहते हैं anyMatch।

— ब्लैकगेट

कॉल के लिए API स्तर 24

— FabioLux

Answer 2

हालांकि स्वीकृत उत्तर सही है, मैं अधिक सुरुचिपूर्ण संस्करण (मेरी राय में) जोड़ूंगा:

boolean idExists = tabPane.getTabs().stream()
    .map(Tab::getId)
    .anyMatch(idToCheck::equals);

स्ट्रीम # मैप () का उपयोग करने की उपेक्षा न करें जो आवेदन करने से पहले डेटा संरचना को समतल करने की अनुमति देता है Predicate।

Comments

यहाँ क्या बेहतर है? मैं केवल एक और ऑपरेशन देखता हूं। क्षमा करें, मैं इस लम्बा बात के लिए नया हूँ।

— TecHunter

@TecHunter यह अधिक स्पष्ट है। कल्पना कीजिए कि आप इस कोड को पहली बार पढ़ते हैं, या फिर थोड़ी देर बाद। कई फायदे हैं: सबसे पहले, हम तुरंत दिखाते हैं कि हम वास्तव में टैब में रुचि नहीं रखते हैं, लेकिन इसके कुछ मानचित्रण हैं। दूसरा, विधि संदर्भों का उपयोग करके (जो केवल इसलिए संभव है क्योंकि हम प्रारंभिक लैम्ब्डा को दो चरणों में तोड़ते हैं) हम दिखाते हैं कि कोड में कोई आश्चर्य नहीं छिपा है। तीसरा, विधि संदर्भों का उपयोग करके, हम एक नया Predicate नहीं बनाते हैं, लेकिन वास्तव में बस फिर से उपयोग करते हैं equals। यद्यपि, प्रदान किया गया है, यहाँ उदाहरण बहुत सरल है, लेकिन मुझे आशा है कि आपको वही मिलेगा जो मेरा मतलब है।

— माल्टे हार्टविग

@MalteHartwig धन्यवाद! हाँ, मुझे आपके 3 अंक मिलते हैं, लेकिन मैं mapइसके साथ समतल के बारे में पूछ रहा था , यह एक और प्रसंस्करण कदम नहीं करता है? मैं 2 विधियों की तुलना करने की कोशिश करूंगा :)

— TecHunter

@MalteHartwig ने 10kk ArrayList में एक साधारण वस्तु के साथ अंतिम तत्व को खोजने की कोशिश की। आपके लिए 133ms के मुकाबले 2ms का अंतर 131ms देता है। 1k सरणी पर आपकी सूची 2ms (55ms से 53ms) तक तेज़ होने पर। तो हम कह सकते हैं कि तुम्हारा बेहतर है :)

— TecHunter

@TecHunter पाने वाले सुपर-सस्ते हैं। अतिरिक्त 2 मिलीसेकंड को बचाने के लिए हमेशा कोड स्पष्टता पसंद करें (भले ही, मुझे संदेह है कि परिणाम सटीक हैं, यह प्रत्येक रन पर उतार-चढ़ाव हो सकता है)। इसके अलावा, याद रखें कि धाराओं पर (जैसे map) मध्यवर्ती संचालन स्वभाव से आलसी हैं। इसका मतलब है कि getIdसंग्रह के प्रत्येक तत्व पर यह विधि लागू नहीं होती है। यह जब तक lazily का मूल्यांकन किया है anyMatchरिटर्न सच ।

— jFrenetic

Answer 3

उपरोक्त उत्तरों के लिए आपको एक नई स्ट्रीम ऑब्जेक्ट को मेलॉक करने की आवश्यकता है।

public <T>
boolean containsByLambda(Collection<? extends T> c, Predicate<? super T> p) {

    for (final T z : c) {
        if (p.test(z)) {
            return true;
        }
    }
    return false;
}

public boolean containsTabById(TabPane tabPane, String id) {
    return containsByLambda(tabPane.getTabs(), z -> z.getId().equals(id));
}
...
if (containsTabById(tabPane, idToCheck))) {
   ...
}