Java 8 lambda ottiene e rimuove l'elemento dall'elenco

Dato un elenco di elementi, voglio ottenere l'elemento con una determinata proprietà e rimuoverlo dall'elenco. La migliore soluzione che ho trovato è:

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

È possibile combinare get e remove in un'espressione lambda?

Per rimuovere un elemento dall'elenco

objectA.removeIf(x -> conditions);

per esempio:

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

USCITA: A B C

Sebbene il thread sia piuttosto vecchio, si pensa ancora di fornire una soluzione: utilizzando Java8.

Usa la removeIffunzione. La complessità del tempo èO(n)

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

Riferimento API: removeIf docs

Presupposto: producersProcedureActiveè unList

NOTA: con questo approccio non sarai in grado di ottenere il blocco dell'elemento eliminato.

Prendi in considerazione l'utilizzo di iteratori java vanilla per eseguire l'attività:

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

Vantaggi :

1. È chiaro e ovvio.
2. Attraversa solo una volta e solo fino all'elemento corrispondente.
3. Puoi farlo su qualsiasi Iterableanche senza stream()supporto (almeno quelli che implementano remove()sul loro iteratore) .

Svantaggi :

1. Non puoi farlo sul posto come una singola espressione (metodo ausiliario o variabile richiesta)

Per quanto riguarda la

È possibile combinare get e remove in un'espressione lambda?

altre risposte mostrano chiaramente che è possibile, ma dovresti esserne consapevole

1. La ricerca e la rimozione possono attraversare l'elenco due volte
2. ConcurrentModificationException può essere lanciato quando si rimuove un elemento dall'elenco che viene iterato

La soluzione diretta sarebbe invocare ifPresent(consumer)sull'Opzionale restituito dafindFirst() . Questo consumatore verrà richiamato quando l'opzionale non è vuoto. Il vantaggio è anche che non genererà un'eccezione se l'operazione find restituisse un opzionale vuoto, come farebbe il codice corrente; invece, non accadrà nulla.

Se si desidera restituire il valore rimosso, è possibile mapil Optionalper il risultato della chiamata remove:

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

Ma si noti che l' remove(Object)operazione attraverserà nuovamente l'elenco per trovare l'elemento da rimuovere. Se hai una lista con accesso casuale, come un ArrayList, sarebbe meglio creare uno Stream sugli indici della lista e trovare il primo indice che corrisponde al predicato:

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

Con questa soluzione l' remove(int)operazione opera direttamente sull'indice.

L'utente può utilizzare il filtro di Java 8 e creare un altro elenco se non si desidera modificare il vecchio elenco:

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

Sono sicuro che questa sarà una risposta impopolare, ma funziona ...

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

p[0] o conterrà l'elemento trovato o sarà nullo.

Il "trucco" qui è aggirare il problema "effettivamente finale" utilizzando un riferimento di array che è effettivamente definitivo, ma impostando il suo primo elemento.

Con le collezioni Eclipse puoi usare detectIndexinsieme a remove(int)qualsiasi 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);

Se utilizzi il MutableListtipo da Eclipse Collections, puoi chiamare il detectIndexmetodo direttamente nell'elenco.

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

Nota: sono un committer per le collezioni Eclipse

Quando vogliamo ottenere più elementi da un elenco in un nuovo elenco (filtrare utilizzando un predicato) e rimuoverli dall'elenco esistente , non sono riuscito a trovare una risposta corretta da nessuna parte.

Ecco come possiamo farlo utilizzando il partizionamento API Java Streaming.

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

In questo modo rimuovi efficacemente gli elementi filtrati dall'elenco originale e li aggiungi a un nuovo elenco.

Fare riferimento alla sezione 5.2. Collectors.partitioning Dalla sezione di questo articolo .

Come altri hanno suggerito, questo potrebbe essere un caso d'uso per cicli e iterabili. Secondo me, questo è l'approccio più semplice. Se si desidera modificare l'elenco sul posto, non può essere considerato comunque una programmazione funzionale "reale". Ma potresti usarlo Collectors.partitioningBy()per ottenere un nuovo elenco con elementi che soddisfano la tua condizione e un nuovo elenco di quelli che non lo fanno. Ovviamente con questo approccio, se hai più elementi che soddisfano la condizione, saranno tutti in quell'elenco e non solo il primo.

La logica seguente è la soluzione senza modificare l'elenco originale

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

Combinando la mia idea iniziale e le tue risposte ho raggiunto quella che sembra essere la soluzione alla mia stessa domanda:

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

Consente di rimuovere l'oggetto utilizzando remove(int)che non attraversa nuovamente l'elenco (come suggerito da @Tunaki) e consente di restituire l'oggetto rimosso al chiamante della funzione.

Ho letto le tue risposte che mi suggeriscono di scegliere metodi sicuri come ifPresentinvece diget ma non trovo un modo per usarli in questo scenario.

Ci sono importanti inconvenienti in questo tipo di soluzione?

Modifica seguendo i consigli di @Holger

Questa dovrebbe essere la funzione di cui avevo bisogno

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

il compito è: ottenere ✶ e ✶ rimuovere l'elemento dalla lista

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