¿Pueden las transmisiones Java 8 operar en un elemento de una colección y luego eliminarlo?

En una línea no, pero tal vez usted podría hacer uso de la partitioningBy colector:

Map<Boolean, Set<Item>> map = 
    set.stream()
       .collect(partitioningBy(Item::qualify, toSet()));

map.get(true).forEach(i -> ((Qualifier)i).operate());
set = map.get(false);

Podría ser más eficiente, ya que evita iterar el conjunto dos veces, una para filtrar el flujo y luego otra para eliminar los elementos correspondientes.

De lo contrario, creo que su enfoque es relativamente bueno.

Lo que realmente quiere hacer es particionar su conjunto. Desafortunadamente, en Java 8 el particionamiento solo es posible a través del método terminal "collect". Terminas con algo como esto:

// test data set
Set<Integer> set = ImmutableSet.of(1, 2, 3, 4, 5);
// predicate separating even and odd numbers
Predicate<Integer> evenNumber = n -> n % 2 == 0;

// initial set partitioned by the predicate
Map<Boolean, List<Integer>> partitioned = set.stream().collect(Collectors.partitioningBy(evenNumber));

// print even numbers
partitioned.get(true).forEach(System.out::println);
// do something else with the rest of the set (odd numbers)
doSomethingElse(partitioned.get(false))

Actualizado:

Versión Scala del código anterior

val set = Set(1, 2, 3, 4, 5)
val partitioned = set.partition(_ % 2 == 0)
partitioned._1.foreach(println)
doSomethingElse(partitioned._2)`

Hay muchos enfoques. Si usa myList.remove (element) debe anular equals (). Segundo lo que prefiero es:

allList.removeIf(item -> item.getId().equals(elementToDelete.getId()));

Buena suerte y feliz codificación:)

No, su implementación es probablemente la más simple. Podría hacer algo profundamente malo modificando el estado en el predicado removeIf, pero por favor no lo haga. Por otro lado, podría ser razonable cambiar a una implementación imperativa basada en iteradores, que en realidad podría ser más apropiada y eficiente para este caso de uso.

Si entiendo su pregunta correctamente:

set = set.stream().filter(item -> {
    if (item.qualify()) {
        ((Qualifier) item).operate();
        return false;
    }
    return true;
}).collect(Collectors.toSet());

Después de la operación, no sirven para otro propósito, y deben eliminarse del conjunto original. El código funciona bien, pero no puedo quitarme la sensación de que hay una operación en Stream que podría hacer esto por mí, en una sola línea.

No puede eliminar elementos de la fuente de la secuencia con la secuencia. Desde el Javadoc:

La mayoría de las operaciones de flujo aceptan parámetros que describen el comportamiento especificado por el usuario..... Para preservar el comportamiento correcto, estos parámetros de comportamiento:

• debe ser no interferente (no modifican la fuente de flujo) ; y
• en la mayoría de los casos debe ser apátrida (su resultado no debe depender de ningún estado que pueda cambiar durante la ejecución de la canalización de flujo).

Veo la preocupación de la claridad de Pablo al usar las corrientes, expresada en la respuesta superior. Tal vez agregar la variable explicativa aclara un poco las intenciones.

set.removeIf(item -> {
  boolean removeItem=item.qualify();
  if (removeItem){
    item.operate();
  }
  return removeItem;
});