Java 8 Lambda Holen und Entfernen Element aus der Liste

Question

Angesichts einer Liste von Elementen, möchte ich das Element mit einer bestimmten Eigenschaft und entfernen Sie es aus der Liste. Die beste Lösung, die ich fand, ist:

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

Ist es möglich zu kombinieren und in einem Lambda-Ausdruck zu entfernen?

Answer 1

Die direkte Lösung wäre ifPresent(consumer) auf der Optional von findFirst() zurückgegeben werden. Dieser Consumer wird aufgerufen, wenn das optionale nicht leer ist. Der Vorteil ist auch, dass es keine Ausnahme auslöst, wenn die Suche einen leeren optionalen Wert zurückgibt, wie es Ihr aktueller Code tun würde; stattdessen wird nichts passieren.

Wenn Sie den entfernten Wert zurückgeben möchten, können Sie die Optional auf das Ergebnis der mapremove Aufruf:

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

Aber beachten Sie, dass die remove(Object) Operation wird wieder die Liste durchlaufen, das Element zu finden zu entfernen. Wenn Sie eine Liste mit zufälligem Zugriff haben, wie ein ArrayList, wäre es besser, einen Strom, der über die Indizes der Liste zu machen und die erste Immersions das Prädikats finden:

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

Mit dieser Lösung des remove(int) Betrieb wirkt direkt auf den Index.

Answer 2

Ich bin sicher, dass dies eine unpopuläre Antwort sein wird, aber es funktioniert ...

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

p[0] entweder halten das gefundene Element oder null sein.

Der "Trick" hier ist die Umgehung der "effektiv endgültigen" Problem durch die Verwendung eines Array Referenz, die effektiv endgültig ist, aber die Einstellung ihres ersten Elements.

Answer 3

Betrachten Vanille Java-Iteratoren mit der Aufgabe auszuführen:

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

Vorteile:

1. es schlicht und klar.
2. Es wird nur einmal und nur bis zum passenden Element durchlaufen.
3. Sie können es auf jedem Iterable auch ohne stream() Unterstützung (mindestens die Implementierung remove() auf ihrem Iterator) tun.

Nachteile:

1. Sie können es nicht als ein einzelner Ausdruck (Hilfsmethode oder Variable erforderlich)

---

Was die

an Ort und Stelle tun

Ist es möglich zu kombiniere get und entferne in einem Lambda-Ausdruck?

anderen Antworten zeigen deutlich, dass es möglich ist, aber man sollte von

1. Suchen und Entfernen kann die Liste zweimal
2. ConcurrentModificationException kann geworfen werden durchqueren sich bewusst sein, wenn sie aus der Liste zu entfernen Element ist iterierter

Answer 4

mit Eclipse Collections können Sie detectIndex zusammen mit remove(int) auf jedem java.util.List verwenden.

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

Wenn Sie den MutableList Typen von Eclipse-Sammlungen verwenden, können Sie die detectIndex Methode direkt auf der Liste nennen.

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

Hinweis: Ich bin ein Committer für Eclipse Kollektionen

Answer 5

Wie andere vorgeschlagen haben, könnte dies ein Anwendungsfall für Schleifen und Iterables sein. Meiner Meinung nach ist dies der einfachste Ansatz. Wenn Sie die Liste an Ort und Stelle ändern wollen, kann sie sowieso nicht als "echte" funktionale Programmierung betrachtet werden. Aber Sie könnten Collectors.partitioningBy() verwenden, um eine neue Liste mit Elementen zu erhalten, die Ihre Bedingung erfüllen, und eine neue Liste von denen, die das nicht tun. Wenn Sie mehrere Elemente haben, die die Bedingung erfüllen, werden natürlich alle diese Elemente in dieser Liste aufgeführt, und nicht nur die erste.

Answer 6

Kombination meiner ersten Idee und Ihre Antworten erreichte ich, was die Lösung auf meine eigene Frage zu sein scheint:

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

Es lässt das Objekt entfernen remove(int) verwenden, die durchqueren nicht wieder die Liste (wie vorgeschlagen von @Tunaki) und lässt es das entfernte Objekt zu der Funktionsaufrufer zurückgeben.

Ich las Ihre Antworten, die vorschlagen, dass ich sichere Methoden wie ifPresent anstelle von get wählen, aber ich finde keine Möglichkeit, sie in diesem Szenario zu verwenden.

Gibt es einen wichtigen Nachteil bei dieser Art von Lösung?

bearbeiten folgende @Holger Beratung

Dies sollte die Funktion brauchte ich

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

Answer 7

Element zu entfernen aus der Liste

objectA.removeIf (x -> Bedingungen) ;

zB: 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: A B C

Answer 8

Obwohl der Faden ist ziemlich alt, dachte noch Lösung bieten - mit Java8.

Verwenden Sie die Funktion removeIf. Zeitkomplexität ist O(n)

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

API-Referenz: removeIf docs

Annahme: producersProcedureActive ist ein List

HINWEIS: Mit diesem Ansatz werden Sie nicht in der Lage sein, den Halt des gelöschten Elements zu erhalten.