Лямбда-Java 8 отримує та видаляє елемент зі списку

Враховуючи список елементів, я хочу отримати елемент із заданою властивістю та видалити його зі списку. Найкраще рішення, яке я знайшов:

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

Чи можна поєднати get і remove у лямбда-виразі?

Вилучити елемент зі списку

objectA.removeIf(x -> conditions);

наприклад:

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

ВИХІД: А Б В

Незважаючи на те, що нитка досить стара, все ще думають, що вона пропонує рішення Java8.

Використовуйте removeIfфункцію. Складність часуO(n)

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

Посилання на API: removeIf docs

Припущення: producersProcedureActiveє aList

ПРИМІТКА. Завдяки такому підходу ви не зможете отримати утримання видаленого елемента.

Подумайте про використання ванільних ітераторів Java для виконання завдання:

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

Переваги :

1. Це просто і очевидно.
2. Він проходить лише один раз і лише до відповідного елемента.
3. Ви можете зробити це на будь-якому Iterableнавіть без stream()підтримки (принаймні тих, хто реалізує remove()на своєму ітераторі) .

Недоліки :

1. Ви не можете зробити це на місці як єдиний вираз (потрібен допоміжний метод або змінна)

Що стосується

Чи можна поєднати get і remove у лямбда-виразі?

інші відповіді чітко показують, що це можливо, але ви повинні це знати

1. Пошук і вилучення можуть пройти по списку двічі
2. ConcurrentModificationException може бути викинуто під час вилучення елемента зі списку, що повторюється

Прямим рішенням було б звернення ifPresent(consumer)до необов’язкового, поверненого findFirst(). Цей споживач буде викликаний, якщо опція не є порожньою. Перевага також полягає в тому, що він не видасть виняток, якщо операція пошуку повертає порожній необов’язковий елемент, як це робив би ваш поточний код; натомість нічого не станеться.

Якщо ви хочете , щоб повернути зняте значення, ви можете до результату виклику :mapOptionalremove

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

Але зауважте, що remove(Object)операція знову перегляне список, щоб знайти елемент для видалення. Якщо у вас є список із довільним доступом, наприклад an ArrayList, було б краще зробити Stream по індексах списку і знайти перший індекс, що відповідає предикату:

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

За допомогою цього рішення remove(int)операція працює безпосередньо над індексом.

Use може використовувати фільтр Java 8 і створити інший список, якщо ви не хочете змінювати старий список:

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

Я впевнений, що це буде непопулярна відповідь, але це працює ...

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

p[0] або буде містити знайдений елемент, або буде нульовим.

Тут «фішка» полягає в тому, щоб обійти проблему «ефективно остаточної», використовуючи посилання на масив, яке є фактично остаточним, але встановлюючи його перший елемент.

З колекціями Eclipse ви можете використовувати detectIndexразом із remove(int)будь-яким 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);

Якщо ви використовуєте MutableListтип із колекцій Eclipse, ви можете викликати detectIndexметод безпосередньо зі списку.

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

Примітка: Я є учасником колекцій Eclipse

Коли ми хочемо отримати кілька елементів зі Списку в новий список (відфільтрувати за допомогою предиката) і видалити їх із існуючого списку , я ніде не міг знайти правильної відповіді.

Ось як ми можемо це зробити, використовуючи розділення Java Streaming API.

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

Таким чином ви ефективно видаляєте відфільтровані елементи з вихідного списку та додаєте їх до нового списку.

Зверніться до 5.2. Колекціонери. Розділення за розділом цієї статті .

Як припускали інші, це може бути випадком використання для циклів та ітерацій. На мій погляд, це найпростіший підхід. Якщо ви хочете змінити список на місці, його все одно не можна вважати "справжнім" функціональним програмуванням. Але ви можете скористатися Collectors.partitioningBy()для того, щоб отримати новий список з елементами, які задовольняють ваші умови, і новий список тих, які цього не роблять. Звичайно, при такому підході, якщо у вас є кілька елементів, що задовольняють умові, всі вони будуть у цьому списку, а не лише перші.

Наведена нижче логіка є рішенням без зміни вихідного списку

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

Поєднавши свою початкову ідею та ваші відповіді, я дійшов до того, що здається рішенням мого власного запитання:

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

Це дозволяє видалити об'єкт за допомогою, remove(int)який не перетинає список знову (як запропонував @Tunaki), і дозволяє повернути видалений об'єкт виклику функції.

Я прочитав ваші відповіді, які пропонують мені вибрати безпечні методи, наприклад ifPresentзамість, getале я не знаходжу способу використовувати їх у цьому сценарії.

Чи є у такого роду рішень важливі недоліки?

Редагуйте, дотримуючись порад @Holger

Це повинна бути функція, яка мені потрібна

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

завдання: отримати ✶ та ✶ вилучити елемент зі списку

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