जावा 8 लैम्ब्डा मिलता है और सूची से तत्व निकालते हैं

Question 1

तत्वों की सूची को देखते हुए, मैं किसी दिए गए संपत्ति के साथ तत्व को प्राप्त करना चाहता हूं और इसे सूची से हटा देना चाहता हूं । सबसे अच्छा समाधान मैंने पाया है:

ProducerDTO p = producersProcedureActive
                .stream()
                .filter(producer -> producer.getPod().equals(pod))
                .findFirst()
                .get();
producersProcedureActive.remove(p);

क्या एक लंबोदर अभिव्यक्ति में संयोजन और निकालना संभव है?

Question 2

सूची से तत्व निकालने के लिए

objectA.removeIf(x -> conditions);

उदाहरण के लिए:

objectA.removeIf(x -> blockedWorkerIds.contains(x));

List<String> str1 = new ArrayList<String>();
str1.add("A");
str1.add("B");
str1.add("C");
str1.add("D");

List<String> str2 = new ArrayList<String>();
str2.add("D");
str2.add("E");

str1.removeIf(x -> str2.contains(x)); 

str1.forEach(System.out::println);

OUTPUT: ए बी सी

Question 3

यद्यपि धागा काफी पुराना है, फिर भी समाधान प्रदान करने के लिए सोचा - उपयोग करना Java8।

removeIfफ़ंक्शन का उपयोग करें । समय जटिलता हैO(n)

producersProcedureActive.removeIf(producer -> producer.getPod().equals(pod));

एपीआई संदर्भ: RemoveIf डॉक्स

धारणा: producersProcedureActiveएक हैList

नोट: इस दृष्टिकोण के साथ आप हटाए गए आइटम की पकड़ पाने में सक्षम नहीं होंगे।

Question 4

कार्य करने के लिए वेनिला जावा पुनरावृत्तियों का उपयोग करने पर विचार करें:

public static <T> T findAndRemoveFirst(Iterable<? extends T> collection, Predicate<? super T> test) {
    T value = null;
    for (Iterator<? extends T> it = collection.iterator(); it.hasNext();)
        if (test.test(value = it.next())) {
            it.remove();
            return value;
        }
    return null;
}

लाभ :

यह सादा और स्पष्ट है।
यह केवल एक बार और केवल मिलान तत्व तक ट्रेस होता है।
आप इसे Iterableबिना किसी stream()सहारे के भी कर सकते हैं (कम से कम उन remove()पर लागू करने वाले ) ।

नुकसान :

आप इसे एक एकल अभिव्यक्ति (सहायक विधि या चर की आवश्यकता) के रूप में नहीं कर सकते

से संबंधित

क्या एक लंबोदर अभिव्यक्ति में संयोजन और निकालना संभव है?

अन्य उत्तर स्पष्ट रूप से दिखाते हैं कि यह संभव है, लेकिन आपको इसके बारे में पता होना चाहिए

खोज और निष्कासन सूची को दो बार पार कर सकते हैं
ConcurrentModificationException सूची से तत्व निकालते समय इसे फेंका जा सकता है

Question 5

प्रत्यक्ष समाधान ifPresent(consumer)द्वारा लौटाए गए वैकल्पिक पर आह्वान किया जाएगा findFirst()। वैकल्पिक खाली नहीं होने पर इस उपभोक्ता का चालान किया जाएगा। लाभ यह भी है कि यह एक अपवाद नहीं फेंकेगा यदि खोज ऑपरेशन एक खाली वैकल्पिक लौटा, जैसे आपका वर्तमान कोड करेगा; इसके बजाय, कुछ नहीं होगा।

यदि आपने निकाले गए मान देने के लिए चाहते हैं, तो आप कर सकते हैं बुला के परिणाम के :mapOptionalremove

producersProcedureActive.stream()
                        .filter(producer -> producer.getPod().equals(pod))
                        .findFirst()
                        .map(p -> {
                            producersProcedureActive.remove(p);
                            return p;
                        });

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

IntStream.range(0, producersProcedureActive.size())
         .filter(i -> producersProcedureActive.get(i).getPod().equals(pod))
         .boxed()
         .findFirst()
         .map(i -> producersProcedureActive.remove((int) i));

इस समाधान के साथ, remove(int)ऑपरेशन सीधे सूचकांक पर संचालित होता है।

Question 6

यदि आप पुरानी सूची को बदलना नहीं चाहते हैं, तो जावा 8 के फिल्टर का उपयोग कर सकते हैं, और दूसरी सूची बना सकते हैं:

List<ProducerDTO> result = producersProcedureActive
                            .stream()
                            .filter(producer -> producer.getPod().equals(pod))
                            .collect(Collectors.toList());

Question 7

मुझे यकीन है कि यह एक अलोकप्रिय जवाब होगा, लेकिन यह काम करता है ...

ProducerDTO[] p = new ProducerDTO[1];
producersProcedureActive
            .stream()
            .filter(producer -> producer.getPod().equals(pod))
            .findFirst()
            .ifPresent(producer -> {producersProcedureActive.remove(producer); p[0] = producer;}

p[0] या तो पाया गया तत्व धारण करेगा या अशक्त होगा।

यहां "ट्रिक" एक सरणी संदर्भ का उपयोग करके "प्रभावी ढंग से अंतिम" समस्या को दरकिनार कर रहा है जो प्रभावी रूप से अंतिम है, लेकिन इसके पहले तत्व को सेट कर रहा है।

Question 8

साथ ग्रहण संग्रह आप उपयोग कर सकते हैं detectIndexके साथ remove(int)किसी भी java.util.List पर।

List<Integer> integers = Lists.mutable.with(1, 2, 3, 4, 5);
int index = Iterate.detectIndex(integers, i -> i > 2);
if (index > -1) {
    integers.remove(index);
}

Assert.assertEquals(Lists.mutable.with(1, 2, 4, 5), integers);

यदि आप MutableListग्रहण संग्रह से प्रकार का उपयोग करते हैं , तो आप detectIndexविधि को सीधे सूची में कॉल कर सकते हैं ।

MutableList<Integer> integers = Lists.mutable.with(1, 2, 3, 4, 5);
int index = integers.detectIndex(i -> i > 2);
if (index > -1) {
    integers.remove(index);
}

Assert.assertEquals(Lists.mutable.with(1, 2, 4, 5), integers);

नोट: मैं ग्रहण संग्रहों के लिए एक कमिटेटर हूं

Question 9

जब हम एक सूची से एक नई सूची (एक विधेय का उपयोग करके फ़िल्टर) में कई तत्वों को प्राप्त करना चाहते हैं और उन्हें मौजूदा सूची से हटा देते हैं , तो मुझे कहीं भी उचित उत्तर नहीं मिला।

यहाँ हम जावा स्ट्रीमिंग एपीआई विभाजन का उपयोग करके इसे कैसे कर सकते हैं।

Map<Boolean, List<ProducerDTO>> classifiedElements = producersProcedureActive
    .stream()
    .collect(Collectors.partitioningBy(producer -> producer.getPod().equals(pod)));

// get two new lists 
List<ProducerDTO> matching = classifiedElements.get(true);
List<ProducerDTO> nonMatching = classifiedElements.get(false);

// OR get non-matching elements to the existing list
producersProcedureActive = classifiedElements.get(false);

इस तरह से आप फ़िल्टर किए गए तत्वों को मूल सूची से प्रभावी रूप से हटा देते हैं और उन्हें एक नई सूची में जोड़ देते हैं।

5.2 का संदर्भ लें । इस आलेख के संग्राहक .partingBy खंड ।

Question 10

जैसा कि दूसरों ने सुझाव दिया है, यह छोरों और पुनरावृत्तियों के लिए उपयोग का मामला हो सकता है। मेरी राय में, यह सबसे सरल तरीका है। यदि आप सूची को जगह में बदलना चाहते हैं, तो इसे वैसे भी "वास्तविक" कार्यात्मक प्रोग्रामिंग नहीं माना जा सकता है। लेकिन आप उन Collectors.partitioningBy()तत्वों के साथ एक नई सूची प्राप्त करने के लिए उपयोग कर सकते हैं जो आपकी स्थिति को संतुष्ट करते हैं, और उन लोगों की एक नई सूची जो नहीं करते हैं। बेशक इस दृष्टिकोण के साथ, यदि आपके पास कई तत्व हैं जो स्थिति को संतुष्ट करते हैं, तो वे सभी उस सूची में होंगे और न केवल पहले।

Question 11

मूल सूची को संशोधित किए बिना निम्न तर्क समाधान है

List<String> str1 = new ArrayList<String>();
str1.add("A");
str1.add("B");
str1.add("C");
str1.add("D");

List<String> str2 = new ArrayList<String>();
str2.add("D");
str2.add("E");

List<String> str3 = str1.stream()
                        .filter(item -> !str2.contains(item))
                        .collect(Collectors.toList());

str1 // ["A", "B", "C", "D"]
str2 // ["D", "E"]
str3 // ["A", "B", "C"]

Question 12

मेरे प्रारंभिक विचार और आपके उत्तरों को मिलाकर मैं अपने स्वयं के प्रश्न का हल ढूंढता हूं:

public ProducerDTO findAndRemove(String pod) {
    ProducerDTO p = null;
    try {
        p = IntStream.range(0, producersProcedureActive.size())
             .filter(i -> producersProcedureActive.get(i).getPod().equals(pod))
             .boxed()
             .findFirst()
             .map(i -> producersProcedureActive.remove((int)i))
             .get();
        logger.debug(p);
    } catch (NoSuchElementException e) {
        logger.error("No producer found with POD [" + pod + "]");
    }
    return p;
}

यह ऑब्जेक्ट का उपयोग करके उसे remove(int)फिर से सूची (@Tunaki द्वारा सुझाए गए) के रूप में नहीं निकालता है और यह फ़ंक्शन कॉलर को हटाए गए ऑब्जेक्ट को वापस करने देता है।

मैंने आपके उत्तर पढ़े जो मुझे ifPresentइसके बजाय सुरक्षित तरीके चुनने का सुझाव देते हैंget लेकिन मुझे इस परिदृश्य में उनका उपयोग करने का कोई तरीका नहीं मिला।

क्या इस तरह के समाधान में कोई महत्वपूर्ण कमी है?

@Holger सलाह के बाद संपादित करें

यह वह फ़ंक्शन होना चाहिए जिसकी मुझे आवश्यकता थी

public ProducerDTO findAndRemove(String pod) {
    return IntStream.range(0, producersProcedureActive.size())
            .filter(i -> producersProcedureActive.get(i).getPod().equals(pod))      
            .boxed()                                                                
            .findFirst()
            .map(i -> producersProcedureActive.remove((int)i))
            .orElseGet(() -> {
                logger.error("No producer found with POD [" + pod + "]"); 
                return null; 
            });
}

Question 13

कार्य यह है: सूची से तत्व ✶ और is निकालें

p.stream().collect( Collectors.collectingAndThen( Collector.of(
    ArrayDeque::new,
    (a, producer) -> {
      if( producer.getPod().equals( pod ) )
        a.addLast( producer );
    },
    (a1, a2) -> {
      return( a1 );
    },
    rslt -> rslt.pollFirst()
  ),
  (e) -> {
    if( e != null )
      p.remove( e );  // remove
    return( e );    // get
  } ) );