Java 8 lambda pobiera i usuwa element z listy

Mając listę elementów, chcę pobrać element o danej właściwości i usunąć go z listy. Najlepsze rozwiązanie jakie znalazłem to:

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

Czy można łączyć get i remove w wyrażeniu lambda?

Aby usunąć element z listy

objectA.removeIf(x -> conditions);

na przykład:

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);

WYJŚCIE: A B C

Chociaż wątek jest dość stary, nadal uważa się, że zapewnia rozwiązanie - użycie Java8.

Skorzystaj z removeIffunkcji. Czas jest złożonyO(n)

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

Dokumentacja API: removeIf docs

Założenie: producersProcedureActivejestList

UWAGA: Przy takim podejściu nie będziesz w stanie przechwycić usuniętego elementu.

Rozważ użycie podstawowych iteratorów Java do wykonania zadania:

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;
}

Zalety :

1. To jest jasne i oczywiste.
2. Przechodzi tylko raz i tylko do pasującego elementu.
3. Możesz to zrobić na dowolnym, Iterablenawet bez stream()wsparcia (przynajmniej te implementujące remove()na swoim iteratorze) .

Wady :

1. Nie można tego zrobić w miejscu jako pojedynczego wyrażenia (wymagana jest metoda pomocnicza lub zmienna)

Jeśli chodzi o

Czy można łączyć get i remove w wyrażeniu lambda?

inne odpowiedzi jasno pokazują, że jest to możliwe, ale powinieneś być tego świadomy

1. Wyszukiwanie i usuwanie może dwukrotnie przechodzić przez listę
2. ConcurrentModificationException może zostać wyrzucony podczas usuwania elementu z iterowanej listy

Bezpośrednim rozwiązaniem byłoby wywołanie ifPresent(consumer)opcjonalnego zwróconego przez findFirst(). Ten konsument zostanie wywołany, gdy opcja nie jest pusta. Zaletą jest również to, że nie zgłosi wyjątku, jeśli operacja find zwróci pusty element opcjonalny, tak jak zrobiłby to twój obecny kod; zamiast tego nic się nie stanie.

Jeśli chcesz zwrócić wartość usunięta, możesz do wyniku powołania :mapOptionalremove

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

Pamiętaj jednak, że remove(Object)operacja ponownie przeszuka listę, aby znaleźć element do usunięcia. Jeśli masz listę z dostępem losowym, taką jak an ArrayList, lepiej byłoby utworzyć strumień na indeksach listy i znaleźć pierwszy indeks pasujący do predykatu:

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

Dzięki temu rozwiązaniu remove(int)operacja działa bezpośrednio na indeksie.

Użyj filtru Java 8 i utwórz kolejną listę, jeśli nie chcesz zmieniać starej listy:

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

Jestem pewien, że będzie to niepopularna odpowiedź, ale działa ...

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

p[0] albo będzie zawierał znaleziony element, albo będzie pusty.

„Sztuczka” polega tutaj na obejściu problemu „efektywnie ostatecznego” przez użycie odwołania do tablicy, które jest faktycznie ostateczne, ale ustawia swój pierwszy element.

Z Eclipse Kolekcje można używać detectIndexrazem z remove(int)na dowolnym 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);

Jeśli używasz MutableListtypu z kolekcji Eclipse, możesz wywołać detectIndexmetodę bezpośrednio z listy.

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);

Uwaga: jestem promotorem Eclipse Collections

Kiedy chcemy przenieść wiele elementów z listy do nowej listy (filtrować za pomocą predykatu) i usunąć je z istniejącej listy , nigdzie nie mogłem znaleźć poprawnej odpowiedzi.

Oto, jak możemy to zrobić za pomocą partycjonowania Java Streaming API.

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);

W ten sposób skutecznie usuniesz przefiltrowane elementy z oryginalnej listy i dodasz je do nowej listy.

Patrz 5.2. Kolektory. Partycjonowanie Według sekcji tego artykułu .

Jak sugerowali inni, może to być przypadek użycia dla pętli i elementów iteracyjnych. Moim zdaniem to najprostsze podejście. Jeśli chcesz zmodyfikować listę w miejscu, i tak nie można jej uznać za „rzeczywiste” programowanie funkcjonalne. Ale możesz użyć Collectors.partitioningBy(), aby uzyskać nową listę z elementami, które spełniają twój warunek, i nową listę tych, które nie spełniają. Oczywiście przy takim podejściu, jeśli masz wiele elementów spełniających warunek, wszystkie będą na tej liście, a nie tylko na pierwszym.

Poniższa logika jest rozwiązaniem bez modyfikowania oryginalnej listy

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"]

Łącząc mój wstępny pomysł i Twoje odpowiedzi, doszedłem do tego, co wydaje się być odpowiedzią na moje własne pytanie:

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;
}

Pozwala usunąć obiekt za pomocą remove(int)tego, że nie przechodzi ponownie przez listę (zgodnie z sugestią @Tunaki) i pozwala zwrócić usunięty obiekt do obiektu wywołującego funkcję.

Czytałem twoje odpowiedzi, które sugerują mi wybór bezpiecznych metod, takich jak ifPresentzamiast, getale nie znajduję sposobu, aby ich użyć w tym scenariuszu.

Czy jest jakaś istotna wada tego rodzaju rozwiązania?

Edytuj następujące porady @Holger

To powinna być funkcja, której potrzebowałem

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; 
            });
}

zadaniem jest: pobrać ✶ i ✶ usunąć element z listy

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
  } ) );