Java Predicate類代碼示例

import org.apache.commons.collections4.Predicate; //導入依賴的package包/類
/**
 * Validate the predicates to ensure that all is well.
 *
 * @param predicates  the predicates to validate
 * @return predicate array
 */
static <T> Predicate<? super T>[] validate(final Collection<? extends Predicate<? super T>> predicates) {
    if (predicates == null) {
        throw new NullPointerException("The predicate collection must not be null");
    }
    // convert to array like this to guarantee iterator() ordering
    @SuppressWarnings("unchecked") // OK
    final Predicate<? super T>[] preds = new Predicate[predicates.size()];
    int i = 0;
    for (final Predicate<? super T> predicate : predicates) {
        preds[i] = predicate;
        if (preds[i] == null) {
            throw new NullPointerException(
                    "The predicate collection must not contain a null predicate, index " + i + " was null");
        }
        i++;
    }
    return preds;
}
 

import org.apache.commons.collections4.Predicate; //導入依賴的package包/類
private <T extends Abi.Entry> T find(Class<T> resultClass, final Abi.Entry.Type type, final Predicate<T> searchPredicate) {
    return (T) CollectionUtils.find(this, new Predicate<Abi.Entry>() {
        @Override
        public boolean evaluate(Abi.Entry entry) {
            return entry.type == type && searchPredicate.evaluate((T) entry);
        }
    });
}
 

import org.apache.commons.collections4.Predicate; //導入依賴的package包/類
private List<Param> filteredInputs(final boolean indexed) {
    return select(inputs, new Predicate<Param>() {
        @Override
        public boolean evaluate(Param param) {
            return param.indexed == indexed;
        }
    });
}
 

import org.apache.commons.collections4.Predicate; //導入依賴的package包/類
public boolean checkMoment(Date date) {
    if (calendar != null) {
        Period period = new Period(new DateTime(date), new Dur(0, 0, 0, 0));
        Predicate<CalendarComponent> periodRule = new PeriodRule<>(period);
        Filter<CalendarComponent> filter = new Filter<>(new Predicate[] {periodRule}, Filter.MATCH_ANY);
        Collection<CalendarComponent> events = filter.filter(calendar.getComponents(CalendarComponent.VEVENT));
        if (events != null && !events.isEmpty()) {
            return true;
        }
    }
    return false;
}
 

import org.apache.commons.collections4.Predicate; //導入依賴的package包/類
/**
 * Factory method that performs validation.
 *
 * @param <E> the type that the closure acts on
 * @param predicate  predicate to switch on
 * @param trueClosure  closure used if true
 * @param falseClosure  closure used if false
 * @return the <code>if</code> closure
 * @throws NullPointerException if any argument is null
 */
public static <E> Closure<E> ifClosure(final Predicate<? super E> predicate,
                                       final Closure<? super E> trueClosure,
                                       final Closure<? super E> falseClosure) {
    if (predicate == null) {
        throw new NullPointerException("Predicate must not be null");
    }
    if (trueClosure == null || falseClosure == null) {
        throw new NullPointerException("Closures must not be null");
    }
    return new IfClosure<E>(predicate, trueClosure, falseClosure);
}
 

import org.apache.commons.collections4.Predicate; //導入依賴的package包/類
/**
 * Factory to create the comparator predicate
 *
 * @param <T> the type that the predicate queries
 * @param object  the object to compare to
 * @param comparator  the comparator to use for comparison
 * @param criterion  the criterion to use to evaluate comparison
 * @return the predicate
 * @throws NullPointerException if comparator or criterion is null
 */
public static <T> Predicate<T> comparatorPredicate(final T object, final Comparator<T> comparator,
                                                   final Criterion criterion) {
    if (comparator == null) {
        throw new NullPointerException("Comparator must not be null.");
    }
    if (criterion == null) {
        throw new NullPointerException("Criterion must not be null.");
    }
    return new ComparatorPredicate<T>(object, comparator, criterion);
}
 

import org.apache.commons.collections4.Predicate; //導入依賴的package包/類
/**
 * Evaluates the predicate returning true if only one decorated predicate
 * returns true.
 *
 * @param object  the input object
 * @return true if only one decorated predicate returns true
 */
public boolean evaluate(final T object) {
    boolean match = false;
    for (final Predicate<? super T> iPredicate : iPredicates) {
        if (iPredicate.evaluate(object)) {
            if (match) {
                return false;
            }
            match = true;
        }
    }
    return match;
}
 

import org.apache.commons.collections4.Predicate; //導入依賴的package包/類
/**
 * Factory method that performs validation.
 *
 * @param <I>  input type for the transformer
 * @param <O>  output type for the transformer
 * @param predicate  predicate to switch on
 * @param trueTransformer  transformer used if true
 * @param falseTransformer  transformer used if false
 * @return the <code>if</code> transformer
 * @throws NullPointerException if either argument is null
 */
public static <I, O> Transformer<I, O> ifTransformer(final Predicate<? super I> predicate,
                                                     final Transformer<? super I, ? extends O> trueTransformer,
                                                     final Transformer<? super I, ? extends O> falseTransformer) {
    if (predicate == null) {
        throw new NullPointerException("Predicate must not be null");
    }
    if (trueTransformer == null || falseTransformer == null) {
        throw new NullPointerException("Transformers must not be null");
    }

    return new IfTransformer<I, O>(predicate, trueTransformer, falseTransformer);
}
 

import org.apache.commons.collections4.Predicate; //導入依賴的package包/類
/**
 * Constructor that performs no validation.
 * Use the static factory method <code>ifTransformer</code> if you want that.
 *
 * @param predicate  predicate to switch on, not null
 * @param trueTransformer  transformer used if true, not null
 * @param falseTransformer  transformer used if false, not null
 */
public IfTransformer(final Predicate<? super I> predicate,
    final Transformer<? super I, ? extends O> trueTransformer,
    final Transformer<? super I, ? extends O> falseTransformer) {

    super();
    iPredicate = predicate;
    iTrueTransformer = trueTransformer;
    iFalseTransformer = falseTransformer;
}
 

import org.apache.commons.collections4.Predicate; //導入依賴的package包/類
/**
 * Evaluates the predicate returning true if all predicates return true.
 *
 * @param object  the input object
 * @return true if all decorated predicates return true
 */
public boolean evaluate(final T object) {
    for (final Predicate<? super T> iPredicate : iPredicates) {
        if (!iPredicate.evaluate(object)) {
            return false;
        }
    }
    return true;
}
 

import org.apache.commons.collections4.Predicate; //導入依賴的package包/類
/**
 * Evaluates the predicate returning false if any stored predicate returns false.
 *
 * @param object  the input object
 * @return true if none of decorated predicates return true
 */
public boolean evaluate(final T object) {
    for (final Predicate<? super T> iPredicate : iPredicates) {
        if (iPredicate.evaluate(object)) {
            return false;
        }
    }
    return true;
}
 

import org.apache.commons.collections4.Predicate; //導入依賴的package包/類
/**
 * Evaluates the predicate returning true if any predicate returns true.
 *
 * @param object  the input object
 * @return true if any decorated predicate return true
 */
public boolean evaluate(final T object) {
    for (final Predicate<? super T> iPredicate : iPredicates) {
        if (iPredicate.evaluate(object)) {
            return true;
        }
    }
    return false;
}
 

import org.apache.commons.collections4.Predicate; //導入依賴的package包/類
/**
 * Constructs a PredicatedCollectionBuilder with the specified Predicate.
 *
 * @param predicate  the predicate to use
 * @throws NullPointerException if predicate is null
 */
public Builder(final Predicate<? super E> predicate) {
    if (predicate == null) {
        throw new NullPointerException("Predicate must not be null");
    }
    this.predicate = predicate;
}
 

import org.apache.commons.collections4.Predicate; //導入依賴的package包/類
public Value findField(final String fieldName){

        Value value;

        value = IterableUtils.find(this, new Predicate<Value>() {
            @Override
            public boolean evaluate(Value object) {
                return object.getMetadata().getName().equals(fieldName);
            }
        });

        return value;
    }
 

import org.apache.commons.collections4.Predicate; //導入依賴的package包/類
/**
 * Factory to create the predicate.
 *
 * @param <T> the type that the predicate queries
 * @param transformer  the transformer to call
 * @param predicate  the predicate to call with the result of the transform
 * @return the predicate
 * @throws NullPointerException if the transformer or the predicate is null
 */
public static <T> Predicate<T> transformedPredicate(final Transformer<? super T, ? extends T> transformer,
                                                    final Predicate<? super T> predicate) {
    if (transformer == null) {
        throw new NullPointerException("The transformer to call must not be null");
    }
    if (predicate == null) {
        throw new NullPointerException("The predicate to call must not be null");
    }
    return new TransformedPredicate<T>(transformer, predicate);
}