Java 8 lambda listeden öğe alma ve kaldırma

Öğelerin listesini göz önüne alındığında, belirli bir özelliğiyle eleman almak istiyorum ve listeden çıkarın. Bulduğum en iyi çözüm:

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

Bir lambda ifadesinde get ve remove birleştirmek mümkün müdür?

Elemanı listeden çıkarmak için

objectA.removeIf(x -> conditions);

Örneğin:

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

ÇIKIŞ: A B C

İş parçacığı oldukça eski olmasına rağmen, yine de çözüm - kullanım sağladığı düşünülüyor Java8.

removeIfFonksiyonu kullanın . Zaman karmaşıklığıO(n)

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

API referansı: removeIf docs

Varsayım: producersProcedureActivebirList

NOT: Bu yaklaşımla, silinen öğenin muhafazasını alamazsınız.

Görevi gerçekleştirmek için vanilya java yineleyicileri kullanmayı düşünün:

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

Avantajlar :

1. Açık ve net.
2. Yalnızca bir kez ve yalnızca eşleşen öğeye kadar hareket eder.
3. Bunu herhangi bir destek Iterableolmadan bile yapabilirsiniz (en azından kendi yineleyicilerinde uygulayanlar ) .stream()remove()

Dezavantajları :

1. Bunu tek bir ifade olarak yerinde yapamazsınız (yardımcı yöntem veya değişken gereklidir)

Gelince

Bir lambda ifadesinde get ve remove birleştirmek mümkün müdür?

diğer cevaplar bunun mümkün olduğunu açıkça gösteriyor, ancak farkında olmalısınız

1. Arama ve kaldırma, listeyi iki kez dolaşabilir
2. ConcurrentModificationException yinelenen listeden öğe kaldırılırken atılabilir

Doğrudan çözüm, ifPresent(consumer)tarafından döndürülen İsteğe Bağlı olarak çağırmak olacaktır findFirst(). Bu tüketici, isteğe bağlı boş olmadığında çağrılacaktır. Bunun yararı da, bulma işlemi, mevcut kodunuzun yapacağı gibi boş bir isteğe bağlı boş döndürdüyse bir istisna atmamasıdır; bunun yerine hiçbir şey olmayacak.

Kaldırılan değer döndürmek istiyorsanız, yapabilirsiniz arama sonucuna :mapOptionalremove

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

Ancak, remove(Object)işlemin, kaldırılacak öğeyi bulmak için listeden tekrar geçeceğini unutmayın . Bir gibi rastgele erişime sahip bir listeniz varsa, listenin ArrayListdizinleri üzerinde bir Akış oluşturmak ve yüklemle eşleşen ilk dizini bulmak daha iyi olacaktır:

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

Bu çözüm ile remove(int)işlem direkt olarak indeks üzerinde işlemektedir.

Java 8 filtresini kullanabilir ve eski listeyi değiştirmek istemiyorsanız başka bir liste oluşturabilirsiniz:

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

Eminim bu popüler olmayan bir cevap olacaktır, ama işe yarıyor ...

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

p[0] ya bulunan öğeyi tutacak ya da boş olacaktır.

Buradaki "hile" , etkili bir şekilde nihai olan ancak ilk elemanını ayarlayan bir dizi referansı kullanarak "etkili bir şekilde nihai" problemin üstesinden gelmektir.

İle Eclipse Koleksiyonları kullanabilirsiniz detectIndexbirlikte remove(int)herhangi java.util.List üzerinde.

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

MutableListEclipse Collections'daki türü kullanırsanız, detectIndexyöntemi doğrudan listeden çağırabilirsiniz .

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

Not: Eclipse Koleksiyonları için bir kaydediciyim

Bir Listeden birden fazla öğeyi yeni bir listeye almak (bir yüklem kullanarak filtrelemek) ve bunları mevcut listeden çıkarmak istediğimizde , hiçbir yerde uygun bir cevap bulamadım.

Java Streaming API bölümlemesini kullanarak bunu nasıl yapabileceğimiz aşağıda açıklanmıştır.

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

Bu şekilde, filtrelenmiş öğeleri orijinal listeden etkili bir şekilde kaldırır ve yeni bir listeye eklersiniz.

5.2'ye bakın . Collectors.partitioningBu makalenin bölümüne göre .

Başkalarının da önerdiği gibi, bu döngüler ve yinelemeler için bir kullanım durumu olabilir. Bence bu en basit yaklaşım. Listeyi yerinde değiştirmek istiyorsanız, bu zaten "gerçek" işlevsel programlama olarak kabul edilemez. Ancak Collectors.partitioningBy(), koşulunuzu karşılayan öğeler içeren yeni bir liste ve karşılamayanların yeni bir listesini almak için kullanabilirsiniz . Elbette bu yaklaşımla, koşulu karşılayan birden fazla öğeye sahipseniz, bunların tümü o listede olacak, sadece ilk değil.

Aşağıdaki mantık, orijinal listeyi değiştirmeden çözümdür

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

İlk fikrim ve cevaplarınızı birleştirerek, kendi sorumun çözümü gibi görünen şeye ulaştım:

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

Bu kullanarak nesneyi kaldırmak sağlar remove(int)(@Tunaki önerdiği gibi) bunu çapraz listeyi yeniden ve bu fonksiyon arayana kaldırılan nesneyi dönmesini sağlar.

Ben güvenli yöntemler gibi seçmemi önermek cevaplarınızı okumak ifPresentyerineget ama bu senaryoda kullanmanın bir yolunu bulamıyorum.

Bu tür bir çözümde önemli bir dezavantaj var mı?

@Holger tavsiyesini düzenleyin

İhtiyacım olan işlev bu olmalı

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

görev şudur: ✶ al ve ✶ listeden öğeyi kaldır

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