Java Predicate.test方法代码示例

import java.util.function.Predicate; //导入方法依赖的package包/类
/**
 * Trouve tous les éléments du magasin validant un prédicat.
 * 
 * @param predicate Prédicat.
 * @return Les éléments trouvés.
 */
public List<T> findAllItems(Predicate<T> predicate) {

	/* Obtient le nom du projet courant. */
	IProject currentProject = UiUtils.getCurrentEditorProject();

	List<T> found = new ArrayList<>();

	List<T> items = this.getAllItems();
	for (T item : items) {

		/* Filtre sur le nom du projet. */
		if (currentProject != null && !currentProject.equals(ResourceUtils.getProject(item))) {
			continue;
		}

		if (predicate.test(item)) {
			found.add(item);
		}
	}

	return found;
}
 

import java.util.function.Predicate; //导入方法依赖的package包/类
public static void main(String[] args) {

        List<String> text = Arrays.stream(scann.nextLine().split("\\s+"))
                .collect(Collectors.toList());

        Predicate<String> checkUpperCase = s ->
                s.charAt(0) == s.toUpperCase().charAt(0);
        ArrayList<String> result = new ArrayList<>();

        for (String str :
                text) {
            if(checkUpperCase.test(str)) {
                result.add(str);
            }
        }
        System.out.println(result.size());
        result.forEach(System.out::println);
    }
 

import java.util.function.Predicate; //导入方法依赖的package包/类
/**
 * Checks if a tile with the given width and height would overlap a pre-existing tile at the point {@code (col, row)},
 * ignoring some nodes when calculating collisions. Note that this method does <i>not</i> perform bounds checking;
 * use {@link #isOpen(int, int, int, int, Predicate) isOpen} to check if a widget can be placed at that point.
 *
 * @param col        the column index of the point to check
 * @param row        the row index of the point to check
 * @param tileWidth  the width of the tile
 * @param tileHeight the height of the tile
 * @param ignore     a predicate to use to ignore nodes when calculating collisions
 */
public boolean isOverlapping(int col, int row, int tileWidth, int tileHeight, Predicate<Node> ignore) {
  for (Node child : getChildren()) {
    if (ignore.test(child)) {
      continue;
    }
    // All "real" children have a column index, row index, and column and row spans
    // Other children (like the grid lines) don't have these properties and will throw null pointers
    // when trying to access these properties
    if (GridPane.getColumnIndex(child) != null) {
      int x = GridPane.getColumnIndex(child);
      int y = GridPane.getRowIndex(child);
      int width = GridPane.getColumnSpan(child);
      int height = GridPane.getRowSpan(child);
      if (x + width > col && y + height > row
          && x - tileWidth < col && y - tileHeight < row) {
        // There's an intersection
        return true;
      }
    }
  }
  return false;
}
 

import java.util.function.Predicate; //导入方法依赖的package包/类
public ListHelper<T> where(Predicate<? super T> filter) {
    Objects.requireNonNull(filter);

    final Iterator<T> each = this.items.iterator();
    while (each.hasNext()) {
        T item = each.next();
        if (!filter.test(item)) {
            each.remove();
        }
    }
    return this;
}
 

import java.util.function.Predicate; //导入方法依赖的package包/类
@Override
public final Array<T> filter(Predicate<ArrayValue<T>> predicate) {
    int count = 0;
    final int length = this.length();
    final ArrayCursor<T> cursor = cursor();
    final Array<T> matches = Array.of(type(), length, loadFactor());
    for (int i=0; i<length; ++i) {
        cursor.moveTo(i);
        final boolean match = predicate.test(cursor);
        if (match) matches.setValue(count++, cursor.getValue());
    }
    return count == length ? matches : matches.copy(0, count);
}
 

import java.util.function.Predicate; //导入方法依赖的package包/类
static @NonNull final Supplier<? extends String[]> createConditionalTarget(
        @NonNull final PropertyEvaluator eval,
        @NonNull final Predicate<PropertyEvaluator> predicate,
        @NonNull final String[] ifTargets,
        @NonNull final String[] elseTargets) {
    return () -> {
        return predicate.test(eval) ?
                ifTargets:
                elseTargets;
    };
}
 

import java.util.function.Predicate; //导入方法依赖的package包/类
public static PrivilegedResource from(Resource resource, Predicate<Resource> predicate) {
	if (resource == null) {
		return null;
	}
	if (!predicate.test(resource)) {
		return null;
	}
	PrivilegedResource result = new PrivilegedResource();
	convert(resource, result, predicate);
	return result;
}
 

import java.util.function.Predicate; //导入方法依赖的package包/类
public boolean removeIf(Predicate<? super Entry<K,V>> filter) {
    if (filter == null) throw new NullPointerException();
    if (m instanceof ConcurrentSkipListMap)
        return ((ConcurrentSkipListMap<K,V>)m).removeEntryIf(filter);
    // else use iterator
    Iterator<Map.Entry<K,V>> it =
        ((SubMap<K,V>)m).new SubMapEntryIterator();
    boolean removed = false;
    while (it.hasNext()) {
        Map.Entry<K,V> e = it.next();
        if (filter.test(e) && m.remove(e.getKey(), e.getValue()))
            removed = true;
    }
    return removed;
}
 

import java.util.function.Predicate; //导入方法依赖的package包/类
private static Matcher findMatcher(Matcher matcher, Predicate<Matcher> predicate) {
    if (matcher instanceof AllOfMatcher) {
        for (Matcher entry: (AllOfMatcher)matcher) {
            if (predicate.test(entry)) {
                return entry;
            }
        }
    } else if (predicate.test(matcher)) {
        return matcher;
    }
    return null;
}
 

import java.util.function.Predicate; //导入方法依赖的package包/类
/**
 * Removes all elements satisfying the given predicate, from index
 * i (inclusive) to index end (exclusive).
 */
boolean removeIf(Predicate<? super E> filter, int i, final int end) {
    Objects.requireNonNull(filter);
    int expectedModCount = modCount;
    final Object[] es = elementData;
    // Optimize for initial run of survivors
    for (; i < end && !filter.test(elementAt(es, i)); i++)
        ;
    // Tolerate predicates that reentrantly access the collection for
    // read (but writers still get CME), so traverse once to find
    // elements to delete, a second pass to physically expunge.
    if (i < end) {
        final int beg = i;
        final long[] deathRow = nBits(end - beg);
        deathRow[0] = 1L;   // set bit 0
        for (i = beg + 1; i < end; i++)
            if (filter.test(elementAt(es, i)))
                setBit(deathRow, i - beg);
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        expectedModCount++;
        modCount++;
        int w = beg;
        for (i = beg; i < end; i++)
            if (isClear(deathRow, i - beg))
                es[w++] = es[i];
        shiftTailOverGap(es, w, end);
        return true;
    } else {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        return false;
    }
}
 

import java.util.function.Predicate; //导入方法依赖的package包/类
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onInventoryOpen(InventoryOpenEvent event) {
    final MatchPlayer opener = playerFinder.getParticipant(event.getActor());
    if(opener == null) return;

    final Inventory inventory = event.getInventory();
    final Predicate<Filter> passesFilter = passesFilter(inventory.getHolder());
    if(passesFilter == null) return;

    logger.fine(() -> opener.getName() + " opened a " + inventory.getHolder().getClass().getSimpleName());

    // Find all Fillers that apply to the holder of the opened inventory
    final List<Filler> fillers = this.fillers.stream()
                                             .filter(filler -> passesFilter.test(filler.filter()))
                                             .collect(Collectors.toImmutableList());
    if(fillers.isEmpty()) return;

    logger.fine(() -> "Found fillers " + fillers.stream()
                                                .map(Filler::identify)
                                                .collect(java.util.stream.Collectors.joining(", ")));

    // Find all Caches that the opened inventory is part of
    final List<Fillable> fillables = new ArrayList<>();
    for(Cache cache : caches) {
        if(passesFilter.test(cache.region()) && passesFilter.test(cache.filter())) {
            fillables.add(new FillableCache(cache));
        }
    }
    // If the inventory is not in any Cache, just fill it directly
    if(fillables.isEmpty()) {
        fillables.add(new FillableInventory(inventory));
    }

    fillables.forEach(fillable -> fillable.fill(opener, fillers));
}
 

import java.util.function.Predicate; //导入方法依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void handleCommand(final Object message) {
    Predicate drop = dropMessagesOfType.get(message.getClass());
    if (drop == null || !drop.test(message)) {
        super.handleCommand(message);
    }

    if (collectorActor != null) {
        collectorActor.tell(message, ActorRef.noSender());
    }
}
 

import java.util.function.Predicate; //导入方法依赖的package包/类
/**
 * Removes any link matching the predicate.
 *
 * @param predicate the predicate that decides which item to removeHotbar
 * @return true if the hotbar changed
 */
public boolean remove(Predicate<ConfigIcon> predicate) {
    int initialSize = size;
    for (int i = 0; i < 9; i++) {
        if (predicate.test(icons[i])) {
            if (icons[i] == null)
                size--;
            icons[i] = null;
        }
    }
    return size != initialSize;
}
 

import java.util.function.Predicate; //导入方法依赖的package包/类
/**
 * Compare Function.
 * 
 * @param compareOp Compare Operator function See {@link CompareOp}
 * @param value Value to compare with {@link #initialValue}
 * @param type Type of the column value See{@link DataType}
 * @param columnName Name of the column whose value to be compared
 * @return true if values matches otherwise false.
 */

public boolean doCompare(final CompareOp compareOp, final Object value, DataType type,
    byte[] columnName) {
  if (!(type instanceof TypePredicate)) {
    throw new MFilterException("Column type for column '" + Bytes.toString(columnName)
        + "' must implement TypePredicate to support push down predicates");
  }
  Predicate predicate = ((TypePredicate) type).getPredicate(compareOp, initialValue);
  return predicate.test(value);
}
 

import java.util.function.Predicate; //导入方法依赖的package包/类
@Override
public final Array<Long> filter(Predicate<ArrayValue<Long>> predicate) {
    final ArrayCursor<Long> cursor = cursor();
    final ArrayBuilder<Long> builder = ArrayBuilder.of(length(), type());
    for (int i=0; i<length(); ++i) {
        cursor.moveTo(i);
        final boolean match = predicate.test(cursor);
        if (match) {
            builder.addLong(cursor.getLong());
        }
    }
    return builder.toArray();
}