Как удалить не равные объекты с помощью ArrayList в Java

Question

Если у меня есть ArrayList книг, и я хочу удалить определенное количество книг, только если они разные (с использованием равенства). Как я могу подойти к проблеме?

Например, если у меня есть 3 разные книги, а мой quantitytoremove равен 3 .., то эти 3 книги необходимо удалить. Предполагая, что quantitytoremove не может быть больше, чем количество РАЗНЫХ книг в массиве.

Я пробовал что-то вроде этого, но знаю, что есть проблемы с тем, что я написал. Есть ли функция, доступная для потоков, или она может мне помочь?

   public Basket removeDifferent(int quantitytoremove) {
        int removed=0;

        for (int i = 0; i < this.numberBooks && removed<quantitytoremove ; i++) {
            for (int j = i+1; j < this.numberBooks && removed<quantitytoremove; j++) {
                if (!(this.BooksArray.get(i).equals(this.BooksArray.get(j)))) {

                    Book Book_i= this.BooksArray.get(i);
                    Book Book_j= this.BooksArray.get(j);
                    this.BooksArray.remove(Book_i);
                    this.BooksArray.remove(Book_j);

                    removed=removed+2;
                    this.numberBooks=numberBooks-2;
                    i=0;j=1;

                }

            } 
        }
    }

Answer 1

Используйте Java Stream и удалите, если ：

List<Book> books = new ArrayList<>();
// init the books
List<Book> distinctBooks = books.stream().distinct().collect(Collectors.toList());
int quantitytoremove = 3;
List<Book> needToDeleted = new ArrayList<>();
for (int i = 0; i < quantitytoremove; i++) {
    needToDeleted.add(distinctBooks.get(i));
}

books.removeIf(needToDeleted::contains);
System.out.println(books);

Answer 2

Шаги, которые необходимо выполнить:

1. Поместите bookList в Set, чтобы удалить повторяющиеся элементы, а затем создайте List, books из Set.
2. Добавить quantityToRemove элементы из books в другой List, toBeRemovedList.
3. Добавить все элементы, кроме одного элемента, каждый из которых также принадлежит tobeRemovedList, из bookList в другой List, toBeReturnedList.

Примечание: Вы можете заменить первый шаг, используя Stream API, как показано ниже:

static List<Book> removeDifferent(List<Book> bookList, int quantityToRemove) {
    // Put `bookList` into a Set to remove the duplicate elements and then create
    // a List, `books` out of the Set
    List<Book> books = new ArrayList<Book>(new HashSet<Book>(bookList));

    // You can replace the above code with Stream code given below:
    // List<Book> books = bookList.stream().distinct().collect(Collectors.toList());

    // Add `quantityToRemove` elements from `books` to another List,
    // `toBeRemovedList`
    List<Book> toBeRemovedList = new ArrayList<Book>();
    for (int i = 0; i < quantityToRemove; i++) {
        toBeRemovedList.add(books.get(i));
    }

    // Add all elements, except one item each also belonging to `tobeRemovedList`
    // from `bookList` to another List, `toBeReturnedList`
    List<Book> toBeReturnedList = new ArrayList<Book>();
    int c = 0;// Counter
    for (Book book : toBeRemovedList) {
        for (int i = c; i < bookList.size(); i++) {
            if (book.equals(bookList.get(i))) {
                c = i;
                break;
            }
            toBeReturnedList.add(bookList.get(i));
        }
        c++;
    }
    for (int i = c; i < bookList.size(); i++) {
        toBeReturnedList.add(bookList.get(i));
    }

    // Return toBeReturnedList
    return toBeReturnedList;
}

Демо:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;

class Book {
    int id;

    public Book(int id) {
        this.id = id;
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }

    @Override
    public boolean equals(Object obj) {
        Book other = (Book) obj;
        return this.id == other.id;
    }

    @Override
    public String toString() {
        return "Book [id=" + id + "]";
    }
}

public class Main {
    public static void main(String[] args) {
        List<Book> books = new ArrayList<Book>();
        books.add(new Book(1));
        books.add(new Book(1));
        books.add(new Book(1));
        books.add(new Book(2));
        books.add(new Book(3));

        List<Book> updatedList = removeDifferent(books, 3);

        // Display updated list
        updatedList.stream().forEach(System.out::println);
    }

    static List<Book> removeDifferent(List<Book> bookList, int quantityToRemove) {
        // Put `bookList` into a Set to remove the duplicate elements and then create
        // a List, `books` out of the Set
        List<Book> books = new ArrayList<Book>(new HashSet<Book>(bookList));

        // You can replace the above code with Stream code given below:
        // List<Book> books = bookList.stream().distinct().collect(Collectors.toList());

        // Add `quantityToRemove` elements from `books` to another List,
        // `toBeRemovedList`
        List<Book> toBeRemovedList = new ArrayList<Book>();
        for (int i = 0; i < quantityToRemove; i++) {
            toBeRemovedList.add(books.get(i));
        }

        // Add all elements, except one item each also belonging to `tobeRemovedList`
        // from `bookList` to another List, `toBeReturnedList`
        List<Book> toBeReturnedList = new ArrayList<Book>();
        int c = 0;// Counter
        for (Book book : toBeRemovedList) {
            for (int i = c; i < bookList.size(); i++) {
                if (book.equals(bookList.get(i))) {
                    c = i;
                    break;
                }
                toBeReturnedList.add(bookList.get(i));
            }
            c++;
        }
        for (int i = c; i < bookList.size(); i++) {
            toBeReturnedList.add(bookList.get(i));
        }

        // Return toBeReturnedList
        return toBeReturnedList;
    }
}

Вывод:

Book [id=1]
Book [id=1]

Результат для removeDifferent(books, 2):

Book [id=1]
Book [id=1]
Book [id=3]

Результат для removeDifferent(books, 1):

Book [id=1]
Book [id=1]
Book [id=2]
Book [id=3]

Answer 3

Во-первых, @Override equals () в классе Foo, чтобы решить, какие атрибуты делают два объекта равными и удалить, используя recursion

Объясните, как работает рекурсия

qn представляет, сколько удалений выполнено

Начальная точка i = 0 j = 1 и рекурсия до достижения базового условия

Шаг 1, Базовый условие : если i или j превышает размер массива или qn превышает quantityToRemove return qn

Шаг 2. Проверьте равенство if элементы массива i и j не равны, затем удалите и увеличьте qn и уменьшите j, чтобы избежать пропущенного элемента

Шаг 3 для всех i и увеличить j Повторяйте до шага 3 до достижения базового условия

Шаг 4 приращение ++i

Шаг 5 начать новую рекурсию с приращением i и начните j с i+1

После завершения отвода проверьте, не превышает ли qn t он quantityToRemove и удаляем из массива, если он содержит 1 книгу. это для случая, когда у вас есть 4 разные книги и вы хотите удалить их все

...

Trace

i = 0, j = 1, 2, ...., N

i = 1, j = 2, 3, ...., N

i = 2, j = 3, 4, ...., N

i = 3, j = 4, 5, ...., N

...

   static class Book {
        int id;
        String title;

        public Book(int id, String title) {
            this.id = id;
            this.title = title;
        }

        @Override
        public boolean equals(Object obj) {
            Book other = (Book) obj;
            return this.title.equals(other.title);
        }

        @Override
        public String toString() {
            return id + ": " + title;
        }
    }

    public static void main(String[] a) {
        Book b1 = new Book(1, "b1");
        Book b2 = new Book(2, "b2");
        Book b3 = new Book(3, "b3");
        Book b4 = new Book(4, "b4");
        Book b5 = new Book(1, "b1");
        List<Book> list = new ArrayList<>();
        list.add(b1);
        list.add(b2);
        list.add(b3);
        list.add(b4);
        list.add(b5);
        list.add(new Book(1, "b1"));
        list.add(new Book(1, "b1"));
        list.add(new Book(1, "b1"));

        System.out.println(list);
        removeDifferent(list, 2);
        System.out.println(list);
    }

    static void removeDifferent(List<Book> booksArray, int quantityToRemove) {
        int qn = removeDifferent(booksArray, quantityToRemove, 0, 0, 1);
        if (booksArray.size() == 1 && qn < quantityToRemove)
            booksArray.remove(0);
    }

    static int removeDifferent(List<Book> booksArray, int quantityToRemove, int qn, int i, int j) {
        if (i >= booksArray.size() || j >= booksArray.size() || qn >= quantityToRemove)
            return qn;
        if (!booksArray.get(i).equals(booksArray.get(j))) {
            booksArray.remove(j);
            j--;
            qn++;
        }
        qn = removeDifferent(booksArray, quantityToRemove, qn, i, 1 + j);
        ++i;
        qn = removeDifferent(booksArray, quantityToRemove, qn, i, i + 1);
        return qn;
    }

, выход

[1: b1, 2: b2, 3: b3, 4: b4, 1: b1, 1: b1, 1: b1, 1: b1]
[1: b1, 4: b4, 1: b1, 1: b1, 1: b1, 1: b1]

, а для этого вход

        Book b1 = new Book(1, "b1");
        Book b2 = new Book(2, "b2");
        Book b3 = new Book(3, "b3");
        Book b4 = new Book(4, "b4");
        List<Book> list = new ArrayList<>();
        list.add(b1);
        list.add(b2);
        list.add(b3);
        list.add(b4);
        System.out.println(list);
        removeDifferent(list, 4);
        System.out.println(list);

, выход

[]