जावा स्ट्रीम वाले कर्मचारियों की सूची में शामिल होने की विशिष्ट तिथि से पहले और बाद में कर्मचारी प्राप्त करें

Question

मेरे पास है Listकी Employeeअलग तिथियों के साथ शामिल होने रों। मैं स्ट्रीम का उपयोग करके सूची से जुड़ने की विशिष्ट तिथि से पहले और बाद में कर्मचारी प्राप्त करना चाहता हूं।

मैंने निम्नलिखित कोड की कोशिश की,

 List<Employee> employeeListAfter = employeeList.stream()
                .filter(e -> e.joiningDate.isAfter(specificDate))
                .collect(Collectors.toList());

List<Employee> employeeListBefore = employeeList.stream()
        .filter(e -> e.joiningDate.isBefore(specificDate))
        .collect(Collectors.toList());

class Employee{
    int id;
    String name;
    LocalDate joiningDate;
}

क्या एकल धारा में ऐसा करने का कोई तरीका है?

Comments

आप उपयोग कर सकते हैंpartitioningBy

— Code_Mode

पहले और बाद में - तो आप सभी कर्मचारियों को चाहते हैं, सिवाय उन लोगों के जो डेट पर शामिल हुए?

— जॉन 03136

यह मानते हुए कि "कम से कम एक कर्मचारी रहा है", आप पहले और बाद में विभाजित करना चाहते हैं, इसके बारे में बिल्कुल भी परवाह नहीं करते।

— जॉली जोकर

Answer 1

आप partitioningByनीचे के रूप में उपयोग कर सकते हैं ,

Map<Boolean, List<Employee>> listMap = employeeList.stream()
        .collect(Collectors.partitioningBy(e -> e.joiningDate.isAfter(specificDate)));

List<Employee> employeeListAfter = listMap.get(true);
List<Employee> employeeListBefore = listMap.get(false);

partitioningBy एक कलेक्टर जो एक विधेय के अनुसार इनपुट तत्वों विभाजित कर देता है, और उन्हें एक में आयोजित करता हैMap<Boolean, List<T>>

ध्यान दें कि यह कर्मचारियों को संभाल नहीं पाएगा specificDate।

Comments

कोड का स्पष्टीकरण बहुत अच्छा होगा।

— विश्व रत्न

साथ कर्मचारियों - यह ठीक नहीं करता है, क्या सवाल में कोड करता है specificDateमें इच्छा भूमि falseविभाजन, कोई नहीं में प्रश्न में कोड में wheres

— एंड्रोनिकस

कैसे जोड़ने specificDate.plusDays(1)से समस्या हल हो जाती है? specificDateअभी भी falseभाग में होगा।

— एन्ड्रोनिकस

तब यह trueविभाजन में होगा ...

— एन्ड्रोनिकस

@ ऑन्ड्रोनिकस: केवल ओपी जानता है कि क्या यह व्यवहार बग या सुविधा है। मेरे लिए, यह किसी भी कर्मचारी को बाहर नहीं छोड़ने के लिए सुरक्षित लगता है।

— एरिक डुमिनील

Answer 2

यदि आपकी सूची में प्रविष्टियाँ होspecificDate सकती हैं, तो आप groupingByउपयोगी हो सकते हैं :

Map<Integer, List<Employee>> result = employeeList.stream()
    .map(emp -> new AbstractMap.SimpleEntry<>(specificDate.compareTo(emp.getJoiningDate()), emp))
    .collect(Collectors.groupingBy(entry -> entry.getKey() > 0 ? 1 : (entry.getKey() < 0 ? -1 : 0),
            Collectors.mapping(entry -> entry.getValue(), Collectors.toList())));

employeeListAfter = result.get(-1);
employeeListBefore = result.get(1);
employeeListOnSpecificDate = result.get(0);

resultनक्शा होता है Employeeअपेक्षाकृत करने के लिए स्थिति के आधार पर वर्गीकृत रिकॉर्ड specificDateताकि आप जो पहले में शामिल हो गए चुन सकते हैं, के बाद, या निर्धारित तिथि पर,।

Comments

यह स्वीकृत उत्तर होना चाहिए

— एन्ड्रोनिकस

-1। आप झूठी धारणा बना रहे हैं जो compareToकेवल -1, 0, या 1. पर लौटेगी। वास्तव में LocalDate.compareTo किसी भी int को वापस कर सकती है।

— मिकीफै

@MikeFHay कि बाहर इशारा करने के लिए धन्यवाद। मैंने बहुत जल्दी परीक्षण किया और निष्कर्ष पर पहुंच गया। बदला हुआ कार्यान्वयन (और अचानक यह जटिल दिखता है)।

— इर्नेस्ट_क

@ernest_k: आप मूल का उपयोग कर सकते हैं compareToऔर Integer.signumउस पर कॉल कर सकते हैं।

— एरिक डुमिनील

@ जॉलीजॉकर बस अगर आपको पता नहीं था, तो आप जीथब में एक विशिष्ट लाइन से लिंक कर सकते हैं: इस तरह । लाइन नंबर पर क्लिक करने से सीधे URL बदल जाता है। यदि आप पहले से ही जानते हैं या परवाह नहीं है तो अनदेखा करें। ;)

— एरिक डुमिनील

Answer 3

आपको इस विशेष तिथि वाले कर्मचारियों को फ़िल्टर करना होगा। तब आप विभाजन का उपयोग कर सकते हैं:

Map<Boolean, List<Employee>> partitioned = employeeList.stream()
    .filter(e -> !e.joiningDate.equals(specificDate))
    .collect(partitioningBy(e -> e.joiningDate.isAfter(specificDate)));

List<Employee> employeeListAfter = partitioned.get(true);
List<Employee> employeeListBefore = partitioned.get(false);

यदि वे विधेय को पूरा करते हैं तो इसके आधार पर संग्रह का एक मानचित्र तैयार करेगा।

Comments

partitioningBy आज सीखा ।

— विश्व रत्न

नहीं, आप दिनांक के साथ फ़िल्टर नहीं कर सकते क्योंकि यह केवल विशिष्ट के साथ कर्मचारियों को फ़िल्टर करेगा

— Code_Mode

@ कोड_मोडे ओह, हां, मैं चूक गया, धन्यवाद!

— एंड्रॉनिकस

Answer 4

आप पिछली, वर्तमान और भविष्य की तारीख के आधार पर कर्मचारियों की सूची को समूहीकृत करने के लिए विधि Collectors.groupingByका उपयोग और उपयोग कर सकते हैंcompareTo

Map<Integer, List<Employee>> result = employeeList.stream()
            .collect(Collectors.groupingBy(e-> e.joiningDate.compareTo(specificDate)< 0 ? -1 : (e.joiningDate.compareTo(specificDate) == 0 ? 0 : 1)));

तो आउटपुट होगा

key--> -1 ---> will have employees with previous date
key--> 0 ---> will have employees with current date
key--> 1 ---> will have employees with future date