Java 8 lambda obtenir et retirer l'élément de la liste

Bien que le fil est assez ancien, encore pensé à fournir la solution à l'aide de Java8.

De rendre l'utilisation de removeIf fonction. Complexité temporelle est O(n)

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

De référence de l'API: removeIf docs

Hypothèse: producersProcedureActive est un List

REMARQUE: Avec cette approche, vous ne serez pas en mesure d'obtenir le maintien de l'élément supprimé.

La solution directe serait d'invoquer ifPresent(consommateur) sur l'Option retourné par findFirst(). Cette consommation sera invoqué lorsque l'option n'est pas vide. L'avantage aussi est qu'il ne lance pas d'exception si l'opération de recherche a renvoyé un vide en option, comme votre code; au lieu de cela, il ne se passera rien.

Si vous voulez retourner à la disparition de la valeur, vous pouvez map la Optional au résultat de l'appel remove:

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

Mais notez que le remove(Object) opération sera de nouveau parcourir la liste pour trouver l'élément à supprimer. Si vous avez une liste avec accès aléatoire, comme un ArrayList, il serait préférable de créer un Flux de plus de l'index de la liste et de trouver le premier indice correspondant au prédicat:

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

Avec cette solution, les remove(int) opération s'opère directement sur l'index.

Je suis sûr que ce sera impopulaire réponse, mais il fonctionne...

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

p[0] permettra de conserver l'élément trouvé ou nulle.

Le "truc" c'est de contourner le "effectivement finale" du problème à l'aide d'un tableau de référence, qui est effectivement final, mais que la définition de son premier élément.

Comme d'autres l'ont suggéré, cela pourrait être un cas d'utilisation pour des boucles et des iterables. À mon avis, c'est l'approche la plus simple. Si vous souhaitez modifier la liste en place, il ne peut pas être considéré comme "réel" de la programmation fonctionnelle, de toute façon. Mais vous pouvez utiliser Collectors.partitioningBy() afin d'obtenir une nouvelle liste avec des éléments qui répondent à votre condition physique, et une nouvelle liste de ceux qui ne le sont pas. Bien sûr, avec cette approche, si vous avez plusieurs éléments satisfait à la condition, tous ceux qui seront dans la liste et pas seulement la première.

Combinant mon idée de départ et de vos réponses, j'ai atteint ce qui semble être la solution
à ma propre question:

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

Il permet de supprimer l'objet à l'aide remove(int) qui ne traversent pas encore la
liste (comme suggéré par @Tunaki) et il permet le retour de l'supprimé l'objet d'
la fonction de l'appelant.

J'ai lu vos réponses qui me suggère de choisir des méthodes sûres comme ifPresent au lieu de get mais je ne trouve pas le moyen de les utiliser dans ce scénario.

Il un inconvénient important dans ce type de solution?

Modifier suivant @Holger conseils

Ce devrait être la fonction que j'ai besoin de

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

la tâche est: ✶et✶ supprimer l'élément de la liste

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