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

@param filter
@return
184168
public <E extends Exception> boolean noneMatch(Try.ShortPredicate<E> filter) throws E {
        return noneMatch(0, size(), filter);
    }
428279
@NotNull
    public OptionalInt filterNot(@NotNull IntPredicate predicate) {
        return filter(IntPredicate.Util.negate(predicate));
    }
1072910
public Collection<FileInfo> getFileInfo(final Predicate<FileInfo> filter) {
        return files.values().stream()
                .filter(filter)
                .collect(Collectors.toList());
    }
680501
public static <T> List<T> filter(Collection<T> c, Filter<T> filter){
        if(c.size()==0)
            return Collections.emptyList();

        List<T> filteredList = new ArrayList<T>(c.size());
        for(T element: c){
            if(filter.select(element))
                filteredList.add(element);
        }
        return filteredList;
    }
1079175
public static <T> Collector<T, ?, Boolean> noneMatch(Predicate<? super T> predicate) {
        return allMatch(predicate.negate());
    }
632586
public static boolean matchesFilter(String key, List<String> filters) {
		boolean rets = (null == filters);
		if (!rets) {
			for (Iterator<String> it = filters.iterator(); it.hasNext() && !rets;)
				rets = key.startsWith(it.next());
		}

		return rets;
	}
120941
public boolean contains(PropertyFilter<S> propFilter) {
        if (mPropFilter == propFilter) {
            return true;
        }
        if (mNext == null) {
            return false;
        }
        // Tail recursion.
        return mNext.contains(propFilter);
    }
1322754
public boolean matchesFilter(String filter) {

        filter = filter.toLowerCase();
        return m_title.toLowerCase().contains(filter) || m_path.toLowerCase().contains(filter);
    }
1173505
List<IntArrayList> findSubnetworks(PrepEdgeFilter filter) {
        final BooleanEncodedValue accessEnc = filter.getAccessEnc();
        final EdgeExplorer explorer = ghStorage.createEdgeExplorer(filter);
        int locs = ghStorage.getNodes();
        List<IntArrayList> list = new ArrayList<>(100);
        final GHBitSet bs = new GHBitSetImpl(locs);
        for (int start = 0; start < locs; start++) {
            if (bs.contains(start))
                continue;

            final IntArrayList intList = new IntArrayList(20);
            list.add(intList);
            new BreadthFirstSearch() {
                int tmpCounter = 0;

                @Override
                protected GHBitSet createBitSet() {
                    return bs;
                }

                @Override
                protected final boolean goFurther(int nodeId) {
                    if (tmpCounter > maxEdgesPerNode.get())
                        maxEdgesPerNode.set(tmpCounter);

                    tmpCounter = 0;
                    intList.add(nodeId);
                    return true;
                }

                @Override
                protected final boolean checkAdjacent(EdgeIteratorState edge) {
                    if (edge.get(accessEnc) || edge.getReverse(accessEnc)) {
                        tmpCounter++;
                        return true;
                    }
                    return false;
                }

            }.start(explorer, start);
            intList.trimToSize();
        }
        return list;
    }
12911
@SuppressWarnings("unchecked")
    public static <E> List<E> without(final List<E> list, E ... values) {
        final List<E> valuesList = Arrays.asList(values);
        return filter(list, new Predicate<E>() {
            @Override
            public boolean test(E elem) {
                return !contains(valuesList, elem);
            }
        });
    }
1202164
public List<SquigglyNode> parse(String filter) {
        filter = StringUtils.trim(filter);

        if (StringUtils.isEmpty(filter)) {
            return Collections.emptyList();
        }

        // get it from the cache if we can
        List<SquigglyNode> cachedNodes = CACHE.getIfPresent(filter);

        if (cachedNodes != null) {
            return cachedNodes;
        }


        SquigglyExpressionLexer lexer = ThrowingErrorListener.overwrite(new SquigglyExpressionLexer(new ANTLRInputStream(filter)));
        SquigglyExpressionParser parser = ThrowingErrorListener.overwrite(new SquigglyExpressionParser(new CommonTokenStream(lexer)));

        Visitor visitor = new Visitor();
        List<SquigglyNode> nodes = Collections.unmodifiableList(visitor.visit(parser.parse()));

        CACHE.put(filter, nodes);
        return nodes;
    }
718610
public static<T> Filter<T> not(final Filter<T> filter) {
		return new AbstractFilter<T>() {
			@Override
			public boolean apply(final T x) {
				return ! filter.apply(x);
			}

			@Override
			public String toString() {
				return "(not " + filter + ")";
			}

			@Override
			public Filter<T> copy() {
				return not(filter.copy());
			}
		};
	}
520352
public <E extends Exception> boolean anyMatch(Try.FloatPredicate<E> filter) throws E {
        return anyMatch(0, size(), filter);
    }
105792
@Override
    public ListT<W,T> filter(final Predicate<? super T> test) {
        return of(run.map(seq -> seq.filter(test)));
    }
896848
@Override
	public M filter(BiPredicate<? super K, ? super V> filter) {
		MapBuilder<K, V, M> builder = builder();
		for (java.util.Map.Entry<K, V> entry : entrySet()) {
			if(filter.test(entry.getKey(), entry.getValue())) {
				builder.put(entry.getKey(), entry.getValue());
			}
		}
		return builder.build();
	}
760657
@NotNull
    public OptionalDouble filterNot(@NotNull DoublePredicate predicate) {
        return filter(DoublePredicate.Util.negate(predicate));
    }
710109
@NotNull
    public LongStream filterNot(@NotNull final LongPredicate predicate) {
        return filter(LongPredicate.Util.negate(predicate));
    }