Returns whether no elements of this List match the provided predicate.

@param filter
@return
974298
public <E extends Exception> boolean noneMatch(Try.IntPredicate<E> filter) throws E {
        return noneMatch(0, size(), filter);
    }
244933
public static <T> List<T> filter( Iterable<T> collection, Predicate<T> predicate)
    {
        List<T> filtered = new ArrayList<T>();
        for (T element : collection)
        {
        	if (predicate.isVerifiedBy(element))
        	{
        		filtered.add(element);
        	}
        }
        return filtered;
    }
641292
public static <T> Predicate<T> not(Predicate<T> predicate) {
        dbc.precondition(predicate != null, "cannot negate a null predicate");
        return predicate.negate();
    }
227383
public <E extends Exception> boolean allMatch(Try.BytePredicate<E> filter) throws E {
        return allMatch(0, size(), filter);
    }
843484
public NetworkFilter where(Predicate<NetworkMetadata> filter) {
        checkNotNull(filter, "Filter predicate must be not a null");

        this.predicate = this.predicate.and(filter);

        return this;
    }
612056
public boolean matchesFilter(String filter, int param) {

        filter = filter.toLowerCase();
        return m_parameters[param].toLowerCase().contains(filter);
    }
1771
public Optional<T> filter(final Predicate<? super T> predicate) {
        if (isPresent() && predicate.test(get())) {
            return this;
        }

        return empty();
    }
1072413
@NotNull
    public OptionalBoolean filterNot(@NotNull BooleanPredicate predicate) {
        return filter(BooleanPredicate.Util.negate(predicate));
    }
504416
public static <E> List<E> filter(final Iterable<E> iterable, final Predicate<E> pred) {
        final List<E> filtered = newArrayList();
        for (E element : iterable) {
            if (pred.test(element)) {
                filtered.add(element);
            }
        }
        return filtered;
    }
903046
public OperationFuture<List<AntiAffinityPolicy>> delete(AntiAffinityPolicyFilter filter) {
        List<AntiAffinityPolicy> policyRefs = getRefsFromFilter(filter);
        return delete(policyRefs.toArray(new AntiAffinityPolicy[policyRefs.size()]));
    }
1122472
public boolean isNameFilter() {

        return (m_structureId == null)
            && (m_name != null)
            && (m_namePattern == null)
            && (m_states == null)
            && (m_rejectStructureId == null)
            && (m_locale == null);
    }
590252
public static <E> Filter<E> notFilter(Filter<E> filter) {
    return (new NegatedFilter<E>(filter));
  }
710109
@NotNull
    public LongStream filterNot(@NotNull final LongPredicate predicate) {
        return filter(LongPredicate.Util.negate(predicate));
    }
88640
public <E extends Exception> boolean anyMatch(Try.ShortPredicate<E> filter) throws E {
        return anyMatch(0, size(), filter);
    }
1180858
public static <T> List<T> filtered(Collection<T> data, Filter<T> filter) {
        List<T> list = new ArrayList<>();
        if (!Utils.isEmpty(data)) {
            for (T item : data) {
                if (filter.accept(item)) {
                    list.add(item);
                }
            }
        }
        return list;
    }
566092
public <E extends Exception> boolean anyMatch(Try.LongPredicate<E> filter) throws E {
        return anyMatch(0, size(), filter);
    }
1322754
public boolean matchesFilter(String filter) {

        filter = filter.toLowerCase();
        return m_title.toLowerCase().contains(filter) || m_path.toLowerCase().contains(filter);
    }