Как лучше всего фильтровать коллекцию Java?

StackOverflow https://stackoverflow.com/questions/122105

  •  02-07-2019
  •  | 
  •  

Вопрос

Я хочу отфильтровать java.util.Collection на основе предиката.

Это было полезно?

Решение

Ява 8 (2014) решает эту проблему, используя потоки и лямбды в одной строке кода:

List<Person> beerDrinkers = persons.stream()
    .filter(p -> p.getAge() > 16).collect(Collectors.toList());

Вот руководство.

Использовать Collection#removeIf чтобы изменить коллекцию на месте.(Уведомление:В этом случае предикат удалит объекты, удовлетворяющие предикату):

persons.removeIf(p -> p.getAge() <= 16);

ламбдадж позволяет фильтровать коллекции без написания циклов или внутренних классов:

List<Person> beerDrinkers = select(persons, having(on(Person.class).getAge(),
    greaterThan(16)));

Можете ли вы представить себе что-то более читабельное?

Отказ от ответственности: Я участник Lambdaj

Другие советы

Предполагая, что вы используете Ява 1.5, и что вы не можете добавить Коллекции Google, Я бы сделал что-то очень похожее на то, что сделали ребята из Google.Это небольшая вариация комментариев Джона.

Сначала добавьте этот интерфейс в свою кодовую базу.

public interface IPredicate<T> { boolean apply(T type); }

Его разработчики могут ответить, когда определенный предикат истинен для определенного типа.Например.Если T были User и AuthorizedUserPredicate<User> реализует IPredicate<T>, затем AuthorizedUserPredicate#apply возвращает, передано ли User авторизован.

Тогда в каком-то служебном классе вы могли бы сказать

public static <T> Collection<T> filter(Collection<T> target, IPredicate<T> predicate) {
    Collection<T> result = new ArrayList<T>();
    for (T element: target) {
        if (predicate.apply(element)) {
            result.add(element);
        }
    }
    return result;
}

Итак, предполагая, что вы используете вышеизложенное, может быть

Predicate<User> isAuthorized = new Predicate<User>() {
    public boolean apply(User user) {
        // binds a boolean method in User to a reference
        return user.isAuthorized();
    }
};
// allUsers is a Collection<User>
Collection<User> authorizedUsers = filter(allUsers, isAuthorized);

Если производительность линейной проверки вызывает беспокойство, возможно, мне захочется иметь объект домена, имеющий целевую коллекцию.Объект домена, имеющий целевую коллекцию, будет иметь логику фильтрации для методов, которые инициализируют, добавляют и устанавливают целевую коллекцию.

ОБНОВЛЯТЬ:

В служебный класс (скажем, Predicate) я добавил метод select с опцией для значения по умолчанию, когда предикат не возвращает ожидаемое значение, а также статическое свойство для параметров, которые будут использоваться внутри нового IPredicate.

public class Predicate {
    public static Object predicateParams;

    public static <T> Collection<T> filter(Collection<T> target, IPredicate<T> predicate) {
        Collection<T> result = new ArrayList<T>();
        for (T element : target) {
            if (predicate.apply(element)) {
                result.add(element);
            }
        }
        return result;
    }

    public static <T> T select(Collection<T> target, IPredicate<T> predicate) {
        T result = null;
        for (T element : target) {
            if (!predicate.apply(element))
                continue;
            result = element;
            break;
        }
        return result;
    }

    public static <T> T select(Collection<T> target, IPredicate<T> predicate, T defaultValue) {
        T result = defaultValue;
        for (T element : target) {
            if (!predicate.apply(element))
                continue;
            result = element;
            break;
        }
        return result;
    }
}

В следующем примере выполняется поиск отсутствующих объектов между коллекциями:

List<MyTypeA> missingObjects = (List<MyTypeA>) Predicate.filter(myCollectionOfA,
    new IPredicate<MyTypeA>() {
        public boolean apply(MyTypeA objectOfA) {
            Predicate.predicateParams = objectOfA.getName();
            return Predicate.select(myCollectionB, new IPredicate<MyTypeB>() {
                public boolean apply(MyTypeB objectOfB) {
                    return objectOfB.getName().equals(Predicate.predicateParams.toString());
                }
            }) == null;
        }
    });

В следующем примере выполняется поиск экземпляра в коллекции и возвращается первый элемент коллекции как значение по умолчанию, если экземпляр не найден:

MyType myObject = Predicate.select(collectionOfMyType, new IPredicate<MyType>() {
public boolean apply(MyType objectOfMyType) {
    return objectOfMyType.isDefault();
}}, collectionOfMyType.get(0));

ОБНОВЛЕНИЕ (после выпуска Java 8):

Прошло несколько лет с тех пор, как я (Алан) впервые опубликовал этот ответ, и я до сих пор не могу поверить, что набираю ТАК баллы за этот ответ.В любом случае, теперь, когда в Java 8 появились замыкания в языке, мой ответ будет значительно другим и более простым.В Java 8 нет необходимости в отдельном статическом служебном классе.Итак, если вы хотите найти первый элемент, соответствующий вашему предикату.

final UserService userService = ... // perhaps injected IoC
final Optional<UserModel> userOption = userCollection.stream().filter(u -> {
    boolean isAuthorized = userService.isAuthorized(u);
    return isAuthorized;
}).findFirst();

API JDK 8 для дополнительных возможностей имеет возможность get(), isPresent(), orElse(defaultUser), orElseGet(userSupplier) и orElseThrow(exceptionSupplier), а также другие «монадические» функции, такие как map, flatMap и filter.

Если вы хотите просто собрать всех пользователей, соответствующих предикату, используйте Collectors чтобы завершить поток в нужной коллекции.

final UserService userService = ... // perhaps injected IoC
final List<UserModel> userOption = userCollection.stream().filter(u -> {
    boolean isAuthorized = userService.isAuthorized(u);
    return isAuthorized;
}).collect(Collectors.toList());

Видеть здесь дополнительные примеры работы потоков Java 8.

Использовать CollectionUtils.filter(Коллекция,Предикат), из Apache Commons.

«Лучший» способ — слишком широкий запрос.Это «самый короткий»?«Самый быстрый»?"Удобочитаемый"?Фильтр на месте или в другую коллекцию?

Самый простой (но не самый читаемый) способ — повторить его и использовать метод Iterator.remove():

Iterator<Foo> it = col.iterator();
while( it.hasNext() ) {
  Foo foo = it.next();
  if( !condition(foo) ) it.remove();
}

Теперь, чтобы сделать его более читабельным, вы можете обернуть его в служебный метод.Затем придумайте интерфейс IPredicate, создайте анонимную реализацию этого интерфейса и сделайте что-то вроде:

CollectionUtils.filterInPlace(col,
  new IPredicate<Foo>(){
    public boolean keepIt(Foo foo) {
      return foo.isBar();
    }
  });

где filterInPlace() выполняет итерацию коллекции и вызывает Predicate.keepIt(), чтобы узнать, следует ли сохранить экземпляр в коллекции.

Я не вижу оправдания использованию сторонней библиотеки только для этой задачи.

Учитывать Коллекции Google для обновленной платформы коллекций, которая поддерживает дженерики.

ОБНОВЛЯТЬ:Библиотека коллекций Google устарела.Вам следует использовать последнюю версию Гуава вместо.Он по-прежнему имеет все те же расширения структуры коллекций, включая механизм фильтрации на основе предиката.

Подождите Java 8:

List<Person> olderThan30 = 
  //Create a Stream from the personList
  personList.stream().
  //filter the element to select only those with age >= 30
  filter(p -> p.age >= 30).
  //put those filtered elements into a new List.
  collect(Collectors.toList());

Начиная с раннего выпуска Java 8, вы могли попробовать что-то вроде:

Collection<T> collection = ...;
Stream<T> stream = collection.stream().filter(...);

Например, если у вас есть список целых чисел и вы хотите отфильтровать числа > 10, а затем вывести эти числа на консоль, вы можете сделать что-то вроде:

List<Integer> numbers = Arrays.asList(12, 74, 5, 8, 16);
numbers.stream().filter(n -> n > 10).forEach(System.out::println);

я брошу RxJava на ринге, который также доступен на Андроид.RxJava не всегда может быть лучшим вариантом, но он даст вам больше гибкости, если вы захотите добавить больше преобразований в свою коллекцию или обработать ошибки при фильтрации.

Observable.from(Arrays.asList(1, 2, 3, 4, 5))
    .filter(new Func1<Integer, Boolean>() {
        public Boolean call(Integer i) {
            return i % 2 != 0;
        }
    })
    .subscribe(new Action1<Integer>() {
        public void call(Integer i) {
            System.out.println(i);
        }
    });

Выход:

1
3
5

Более подробная информация о RxJava filter может быть найден здесь.

Настройка:

public interface Predicate<T> {
  public boolean filter(T t);
}

void filterCollection(Collection<T> col, Predicate<T> predicate) {
  for (Iterator i = col.iterator(); i.hasNext();) {
    T obj = i.next();
    if (predicate.filter(obj)) {
      i.remove();
    }
  }
}

Использование:

List<MyObject> myList = ...;
filterCollection(myList, new Predicate<MyObject>() {
  public boolean filter(MyObject obj) {
    return obj.shouldFilter();
  }
});

Как насчет простой и понятной Java?

 List<Customer> list ...;
 List<Customer> newList = new ArrayList<>();
 for (Customer c : list){
    if (c.getName().equals("dd")) newList.add(c);
 }

Просто, читаемо и просто (и работает в Android!), Но если вы используете Java 8, вы можете сделать это на сладкой линии:

List<Customer> newList = list.stream().filter(c -> c.getName().equals("dd")).collect(toList());

Обратите внимание, что toList() статически импортируется.

Вы уверены, что хотите фильтровать саму коллекцию, а не итератор?

видеть org.apache.commons.collections.iterators.FilterIterator

или используя версию 4 Apache Commons org.apache.commons.collections4.iterators.FilterIterator

Давайте посмотрим, как фильтровать встроенный список JDK и Мутабельный список с использованием Коллекции затмений (ранее Коллекции GS).

List<Integer> jdkList = Arrays.asList(1, 2, 3, 4, 5);
MutableList<Integer> ecList = Lists.mutable.with(1, 2, 3, 4, 5);

Если вы хотите отфильтровать числа меньше 3, вы ожидаете получить следующие результаты.

List<Integer> selected = Lists.mutable.with(1, 2);
List<Integer> rejected = Lists.mutable.with(3, 4, 5);

Вот как вы можете фильтровать, используя анонимный внутренний класс в качестве Predicate.

Predicate<Integer> lessThan3 = new Predicate<Integer>()
{
    public boolean accept(Integer each)
    {
        return each < 3;
    }
};

Assert.assertEquals(selected, Iterate.select(jdkList, lessThan3));

Assert.assertEquals(selected, ecList.select(lessThan3));

Вот несколько альтернатив фильтрации списков JDK и Коллекции затмений MutableLists с использованием Предикаты фабрика.

Assert.assertEquals(selected, Iterate.select(jdkList, Predicates.lessThan(3)));

Assert.assertEquals(selected, ecList.select(Predicates.lessThan(3)));

Вот версия, в которой объект для предиката не выделяется с помощью метода Предикаты2 завод вместо этого с selectWith метод, который принимает Predicate2.

Assert.assertEquals(
    selected, ecList.selectWith(Predicates2.<Integer>lessThan(), 3));

Иногда требуется фильтровать по отрицательному условию.В Eclipse Collections есть специальный метод, называемый reject.

Assert.assertEquals(rejected, Iterate.reject(jdkList, lessThan3));

Assert.assertEquals(rejected, ecList.reject(lessThan3));

Вот как вы можете фильтровать, используя лямбду Java 8 в качестве Predicate.

Assert.assertEquals(selected, Iterate.select(jdkList, each -> each < 3));
Assert.assertEquals(rejected, Iterate.reject(jdkList, each -> each < 3));

Assert.assertEquals(selected, gscList.select(each -> each < 3));
Assert.assertEquals(rejected, gscList.reject(each -> each < 3));

Метод partition вернет две коллекции, содержащие элементы, выбранные и отклоненные Predicate.

PartitionIterable<Integer> jdkPartitioned = Iterate.partition(jdkList, lessThan3);
Assert.assertEquals(selected, jdkPartitioned.getSelected());
Assert.assertEquals(rejected, jdkPartitioned.getRejected());

PartitionList<Integer> ecPartitioned = gscList.partition(lessThan3);
Assert.assertEquals(selected, ecPartitioned.getSelected());
Assert.assertEquals(rejected, ecPartitioned.getRejected());

Примечание:Я являюсь коммиттером Eclipse Collections.

С помощью ForEach DSL вы можете написать

import static ch.akuhn.util.query.Query.select;
import static ch.akuhn.util.query.Query.$result;
import ch.akuhn.util.query.Select;

Collection<String> collection = ...

for (Select<String> each : select(collection)) {
    each.yield = each.value.length() > 3;
}

Collection<String> result = $result();

Учитывая набор [The, быстрый, коричневый, лиса, прыжки, над, the, ленивый, собака] это приводит к [быстрый, коричневый, прыжки, более, ленивый], т.е. все строки длиннее трех символов.

Все стили итерации, поддерживаемые ForEach DSL,

  • AllSatisfy
  • AnySatisfy
  • Collect
  • Counnt
  • CutPieces
  • Detect
  • GroupedBy
  • IndexOf
  • InjectInto
  • Reject
  • Select

Для получения более подробной информации см. https://www.iam.unibe.ch/scg/svn_repos/Sources/ForEach

А Collections2.filter(Коллекция,Предикат) метод в Библиотека Google Гуавы делает именно то, что вы ищете.

С Ява 9 Collectors.filtering включен:

public static <T, A, R>
    Collector<T, ?, R> filtering(Predicate<? super T> predicate,
                                 Collector<? super T, A, R> downstream)

Таким образом, фильтрация должна быть:

collection.stream().collect(Collectors.filtering(predicate, collector))

Пример:

List<Integer> oddNumbers = List.of(1, 19, 15, 10, -10).stream()
            .collect(Collectors.filtering(i -> i % 2 == 1, Collectors.toList()));

Это, в сочетании с отсутствием реальных замыканий, является моей самой большой претензией к Java.Честно говоря, большинство упомянутых выше методов довольно легко читать и ДЕЙСТВИТЕЛЬНО эффективны;однако, проведя время с .Net, Erlang и т. д.понимание списков, интегрированное на уровне языка, делает все намного чище.Без дополнений на уровне языка Java просто не может быть таким же чистым, как многие другие языки в этой области.

Если производительность имеет большое значение, лучше всего использовать коллекции Google (или написать собственную простую утилиту предикатов).Синтаксис Lambdaj для некоторых людей более читабелен, но он не так эффективен.

А еще есть библиотека, которую я написал.Я проигнорирую любые вопросы относительно его эффективности (да, это так плохо)......Да, я знаю, что он явно основан на отражениях, и нет, на самом деле я его не использую, но он работает:

LinkedList<Person> list = ......
LinkedList<Person> filtered = 
           Query.from(list).where(Condition.ensure("age", Op.GTE, 21));

ИЛИ

LinkedList<Person> list = ....
LinkedList<Person> filtered = Query.from(list).where("x => x.age >= 21");

JФильтр http://code.google.com/p/jfilter/ лучше всего подходит для ваших требований.

JFilter — это простая и высокопроизводительная библиотека с открытым исходным кодом для запроса коллекции Java-бинов.

Ключевая особенность

  • Поддержка свойств коллекции (java.util.Collection, java.util.Map и Array).
  • Поддержка коллекции внутри коллекции любой глубины.
  • Поддержка внутренних запросов.
  • Поддержка параметризованных запросов.
  • Может фильтровать 1 миллион записей за несколько 100 мс.
  • Фильтр (запрос) задается в простом формате json, он похож на запросы Mangodb.Ниже приведены некоторые примеры.
  • { "id":{"$le":"10"}
    • где свойство идентификатора объекта меньше равно 10.
  • { "идентификатор":{"$in":["0", "100"]}}
    • где свойство идентификатора объекта равно 0 или 100.
  • {"lineItems":{"lineAmount":"1"}}
    • где свойство коллекции lineItems параметризованного типа имеет значение lineAmount, равное 1.
  • { "$and":[{"id":"0"}, {"billingAddress":{"city":"DEL"}}]}
    • где свойство id равно 0, а свойство billingAddress.city — DEL.
  • {"lineItems":{"taxes":{ "key":{"code":"GST"}, "value":{"$gt":"1.01"}}}}
    • где свойство коллекции lineItems параметризованного типа, которое имеет свойство типа карты налогов параметризованного типа, имеет код, равный значению GST, превышающему 1,01.
  • {'$or':[{'code':'10'},{'skus':{'$and':[{'price':{'$in':['20', '40']}}, {'code':'RedApple'}]}}]}
    • Выберите все продукты, у которых код продукта — 10 или цена — 20 и 40, а код — «RedApple».

Я написал расширенный класс Iterable которые поддерживают применение функциональных алгоритмов без копирования содержимого коллекции.

Использование:

List<Integer> myList = new ArrayList<Integer>(){ 1, 2, 3, 4, 5 }

Iterable<Integer> filtered = Iterable.wrap(myList).select(new Predicate1<Integer>()
{
    public Boolean call(Integer n) throws FunctionalException
    {
        return n % 2 == 0;
    }
})

for( int n : filtered )
{
    System.out.println(n);
}

Приведенный выше код действительно будет выполнен

for( int n : myList )
{
    if( n % 2 == 0 ) 
    {
        System.out.println(n);
    }
}

Использовать Механизм запросов к коллекциям (CQEngine).Это, безусловно, самый быстрый способ сделать это.

Смотрите также: Как вы запрашиваете коллекции объектов в Java (подобно критериям/SQL)?

Здесь есть действительно отличные ответы.Я бы хотел, чтобы все было как можно проще и читабельнее:

public abstract class AbstractFilter<T> {

    /**
     * Method that returns whether an item is to be included or not.
     * @param item an item from the given collection.
     * @return true if this item is to be included in the collection, false in case it has to be removed.
     */
    protected abstract boolean excludeItem(T item);

    public void filter(Collection<T> collection) {
        if (CollectionUtils.isNotEmpty(collection)) {
            Iterator<T> iterator = collection.iterator();
            while (iterator.hasNext()) {
                if (excludeItem(iterator.next())) {
                    iterator.remove();
                }
            }
        }
    }
}

Простое решение до Java8:

ArrayList<Item> filtered = new ArrayList<Item>(); 
for (Item item : items) if (condition(item)) filtered.add(item);

К сожалению, это решение не является полностью универсальным: оно выводит список, а не тип данной коллекции.Кроме того, использование библиотек или написание функций, которые обертывают этот код, кажется мне излишним, если только условие не является сложным, но тогда вы можете написать функцию для этого условия.

https://code.google.com/p/joquery/

Поддерживает различные возможности,

Учитывая коллекцию,

Collection<Dto> testList = new ArrayList<>();

типа,

class Dto
{
    private int id;
    private String text;

    public int getId()
    {
        return id;
    }

    public int getText()
    {
        return text;
    }
}

Фильтр

Ява 7

Filter<Dto> query = CQ.<Dto>filter(testList)
    .where()
    .property("id").eq().value(1);
Collection<Dto> filtered = query.list();

Ява 8

Filter<Dto> query = CQ.<Dto>filter(testList)
    .where()
    .property(Dto::getId)
    .eq().value(1);
Collection<Dto> filtered = query.list();

Также,

Filter<Dto> query = CQ.<Dto>filter()
        .from(testList)
        .where()
        .property(Dto::getId).between().value(1).value(2)
        .and()
        .property(Dto::grtText).in().value(new string[]{"a","b"});

Сортировка (также доступно для Java 7)

Filter<Dto> query = CQ.<Dto>filter(testList)
        .orderBy()
        .property(Dto::getId)
        .property(Dto::getName)
    Collection<Dto> sorted = query.list();

Группировка (также доступно для Java 7)

GroupQuery<Integer,Dto> query = CQ.<Dto,Dto>query(testList)
        .group()
        .groupBy(Dto::getId)
    Collection<Grouping<Integer,Dto>> grouped = query.list();

Присоединяется (также доступно для Java 7)

Данный,

class LeftDto
{
    private int id;
    private String text;

    public int getId()
    {
        return id;
    }

    public int getText()
    {
        return text;
    }
}

class RightDto
{
    private int id;
    private int leftId;
    private String text;

    public int getId()
    {
        return id;
    }

    public int getLeftId()
        {
            return leftId;
        }

    public int getText()
    {
        return text;
    }
}

class JoinedDto
{
    private int leftId;
    private int rightId;
    private String text;

    public JoinedDto(int leftId,int rightId,String text)
    {
        this.leftId = leftId;
        this.rightId = rightId;
        this.text = text;
    }

    public int getLeftId()
    {
        return leftId;
    }

    public int getRightId()
        {
            return rightId;
        }

    public int getText()
    {
        return text;
    }
}

Collection<LeftDto> leftList = new ArrayList<>();

Collection<RightDto> rightList = new ArrayList<>();

Можно присоединиться, например,

Collection<JoinedDto> results = CQ.<LeftDto, LeftDto>query().from(leftList)
                .<RightDto, JoinedDto>innerJoin(CQ.<RightDto, RightDto>query().from(rightList))
                .on(LeftFyo::getId, RightDto::getLeftId)
                .transformDirect(selection ->  new JoinedDto(selection.getLeft().getText()
                                                     , selection.getLeft().getId()
                                                     , selection.getRight().getId())
                                 )
                .list();

Выражения

Filter<Dto> query = CQ.<Dto>filter()
    .from(testList)
    .where()
    .exec(s -> s.getId() + 1).eq().value(2);

Мой ответ основан на ответе Кевина Вонга, здесь в виде однострочника, использующего CollectionUtils от весна и Java 8 лямбда выражение.

CollectionUtils.filter(list, p -> ((Person) p).getAge() > 16);

Это так же кратко и читабельно, как и любая другая альтернатива, которую я видел (без использования аспектных библиотек).

Весна КоллекцияUtils доступен начиная с весенней версии 4.0.2.RELEASE, и помните, что вам нужен JDK 1.8 и уровень языка 8+.

С использованием java 8, конкретно lambda expression, вы можете сделать это просто, как в примере ниже:

myProducts.stream().filter(prod -> prod.price>10).collect(Collectors.toList())

где для каждого product внутри myProducts сбор, если prod.price>10, затем добавьте этот товар в новый отфильтрованный список.

Мне нужно было отфильтровать список в зависимости от значений, уже присутствующих в списке.Например, удалите все следующие значения, которые меньше текущего значения.{2 5 3 4 7 5} -> {2 5 7}.Или например удалить все дубликаты {3 5 4 2 3 5 6} -> {3 5 4 2 6}.

public class Filter {
    public static <T> void List(List<T> list, Chooser<T> chooser) {
        List<Integer> toBeRemoved = new ArrayList<>();
        leftloop:
        for (int right = 1; right < list.size(); ++right) {
            for (int left = 0; left < right; ++left) {
                if (toBeRemoved.contains(left)) {
                    continue;
                }
                Keep keep = chooser.choose(list.get(left), list.get(right));
                switch (keep) {
                    case LEFT:
                        toBeRemoved.add(right);
                        continue leftloop;
                    case RIGHT:
                        toBeRemoved.add(left);
                        break;
                    case NONE:
                        toBeRemoved.add(left);
                        toBeRemoved.add(right);
                        continue leftloop;
                }
            }
        }

        Collections.sort(toBeRemoved, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

        for (int i : toBeRemoved) {
            if (i >= 0 && i < list.size()) {
                list.remove(i);
            }
        }
    }

    public static <T> void List(List<T> list, Keeper<T> keeper) {
        Iterator<T> iterator = list.iterator();
        while (iterator.hasNext()) {
            if (!keeper.keep(iterator.next())) {
                iterator.remove();
            }
        }
    }

    public interface Keeper<E> {
        boolean keep(E obj);
    }

    public interface Chooser<E> {
        Keep choose(E left, E right);
    }

    public enum Keep {
        LEFT, RIGHT, BOTH, NONE;
    }
}

Это будет использоваться следующим образом.

List<String> names = new ArrayList<>();
names.add("Anders");
names.add("Stefan");
names.add("Anders");
Filter.List(names, new Filter.Chooser<String>() {
    @Override
    public Filter.Keep choose(String left, String right) {
        return left.equals(right) ? Filter.Keep.LEFT : Filter.Keep.BOTH;
    }
});

С Гуавой:

Collection<Integer> collection = Lists.newArrayList(1, 2, 3, 4, 5);

Iterators.removeIf(collection.iterator(), new Predicate<Integer>() {
    @Override
    public boolean apply(Integer i) {
        return i % 2 == 0;
    }
});

System.out.println(collection); // Prints 1, 3, 5

В Java 8 вы можете напрямую использовать этот метод фильтра, а затем сделать это.

 List<String> lines = Arrays.asList("java", "pramod", "example");

 List<String> result = lines.stream()              
         .filter(line -> !"pramod".equals(line))     
         .collect(Collectors.toList());              

 result.forEach(System.out::println);
Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top