Java Predicates类代码示例

import com.google.common.base.Predicates; //导入依赖的package包/类
@Override
public Ordering<Element> enclosedBy(Element element) {
  if (element instanceof ElementImpl &&
      Iterables.all(element.getEnclosedElements(), Predicates.instanceOf(ElementImpl.class))) {

    ElementImpl implementation = (ElementImpl) element;
    if (implementation._binding instanceof SourceTypeBinding) {
      SourceTypeBinding sourceBinding = (SourceTypeBinding) implementation._binding;

      return Ordering.natural().onResultOf(
          Functions.compose(bindingsToSourceOrder(sourceBinding), this));
    }
  }

  return DEFAULT_PROVIDER.enclosedBy(element);
}
 

import com.google.common.base.Predicates; //导入依赖的package包/类
protected void collideWithNearbyEntities()
{
    List<Entity> list = this.worldObj.getEntitiesInAABBexcluding(this, this.getEntityBoundingBox().expand(0.20000000298023224D, 0.0D, 0.20000000298023224D), Predicates.<Entity> and (EntitySelectors.NOT_SPECTATING, new Predicate<Entity>()
    {
        public boolean apply(Entity p_apply_1_)
        {
            return p_apply_1_.canBePushed();
        }
    }));

    if (!list.isEmpty())
    {
        for (int i = 0; i < list.size(); ++i)
        {
            Entity entity = (Entity)list.get(i);
            this.collideWithEntity(entity);
        }
    }
}
 

import com.google.common.base.Predicates; //导入依赖的package包/类
/**
 * This test passes if the {@code concat(…).filter(…).filter(…)} statement at the end compiles.
 * That statement compiles only if {@link FluentIterable#concat concat(aIterable, bIterable)}
 * returns a {@link FluentIterable} of elements of an anonymous type whose supertypes are the
 * <a href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.9">intersection</a>
 * of the supertypes of {@code A} and the supertypes of {@code B}.
 */
public void testConcatIntersectionType() {
  Iterable<A> aIterable = ImmutableList.of();
  Iterable<B> bIterable = ImmutableList.of();

  Predicate<X> xPredicate = Predicates.alwaysTrue();
  Predicate<Y> yPredicate = Predicates.alwaysTrue();

  FluentIterable<?> unused =
      FluentIterable.concat(aIterable, bIterable).filter(xPredicate).filter(yPredicate);

  /* The following fails to compile:
   *
   * The method append(Iterable<? extends FluentIterableTest.A>) in the type
   * FluentIterable<FluentIterableTest.A> is not applicable for the arguments
   * (Iterable<FluentIterableTest.B>)
   */
  // FluentIterable.from(aIterable).append(bIterable);

  /* The following fails to compile:
   *
   * The method filter(Predicate<? super Object>) in the type FluentIterable<Object> is not
   * applicable for the arguments (Predicate<FluentIterableTest.X>)
   */
  // FluentIterable.of().append(aIterable).append(bIterable).filter(xPredicate);
}
 

import com.google.common.base.Predicates; //导入依赖的package包/类
private ResourceLocation findResourceFile(SourceGroup[] resSG, final String value, final String folderName) {
    FileObject resFile = Iterables.find(
            Iterables.transform(
                    Arrays.asList(resSG),
                    new Function<SourceGroup, FileObject>() {
                @Override
                public FileObject apply(SourceGroup sg) {
                    return sg.getRootFolder().getFileObject(folderName + "/" + value + ".xml");
                }
            }),
            Predicates.notNull(),
            null);
    if (resFile == null) {
        LOG.log(Level.FINE, "Resource file {0} not found for {0}.", value);
        return null;
    }
    return new ResourceLocation(resFile, -1);
}
 

import com.google.common.base.Predicates; //导入依赖的package包/类
/**
 * Returns whether the EntityAIBase should begin execution.
 */
public boolean shouldExecute()
{
    if (this.targetChance > 0 && this.taskOwner.getRNG().nextInt(this.targetChance) != 0)
    {
        return false;
    }
    else
    {
        double d0 = this.getTargetDistance();
        List<T> list = this.taskOwner.worldObj.<T>getEntitiesWithinAABB(this.targetClass, this.taskOwner.getEntityBoundingBox().expand(d0, 4.0D, d0), Predicates.<T> and (this.targetEntitySelector, EntitySelectors.NOT_SPECTATING));
        Collections.sort(list, this.theNearestAttackableTargetSorter);

        if (list.isEmpty())
        {
            return false;
        }
        else
        {
            this.targetEntity = (EntityLivingBase)list.get(0);
            return true;
        }
    }
}
 

import com.google.common.base.Predicates; //导入依赖的package包/类
@Override
public Iterator<FragmentExecutor> iterator() {
  return Iterators.unmodifiableIterator(
    FluentIterable
      .from(handlers.asMap().values())
      .transform(new Function<FragmentHandler, FragmentExecutor>() {
        @Nullable
        @Override
        public FragmentExecutor apply(FragmentHandler input) {
          return input.getExecutor();
        }
      })
      .filter(Predicates.<FragmentExecutor>notNull())
      .iterator()
  );
}
 

import com.google.common.base.Predicates; //导入依赖的package包/类
public PostProcessor[] scan(final Object instance) {
    return FluentIterable
            .from(ReflectionUtils.getDeclaredFields(instance.getClass(), true))
            .filter(new Predicate<Field>() {
                @Override
                public boolean apply(Field input) {
                    return input.isAnnotationPresent(Random.PostProcessor.class)
                            && PostProcessor.class.isAssignableFrom(input.getType());
                }
            })
            .transform(new Function<Field, PostProcessor>() {
                @Override
                public PostProcessor apply(Field field) {
                    try {
                        if (!ReflectionUtils.makeFieldAccessible(field)) {
                            return null;
                        }
                        return (PostProcessor) field.get(instance);
                    } catch (IllegalAccessException e) {
                        throw new RandomitoException(e);
                    }
                }
            })
            .filter(Predicates.<PostProcessor>notNull())
            .toArray(PostProcessor.class);
}
 

import com.google.common.base.Predicates; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public SimpleHelpMap(CraftServer server) {
    this.helpTopics = new TreeMap<String, HelpTopic>(HelpTopicComparator.topicNameComparatorInstance()); // Using a TreeMap for its explicit sorting on key
    this.topicFactoryMap = new HashMap<Class, HelpTopicFactory<Command>>();
    this.server = server;
    this.yaml = new HelpYamlReader(server);

    Predicate indexFilter = Predicates.not(Predicates.instanceOf(CommandAliasHelpTopic.class));
    if (!yaml.commandTopicsInMasterIndex()) {
        indexFilter = Predicates.and(indexFilter, Predicates.not(new IsCommandTopicPredicate()));
    }

    this.defaultTopic = new IndexHelpTopic("Index", null, null, Collections2.filter(helpTopics.values(), indexFilter), "Use /help [n] to get page n of help.");

    registerHelpTopicFactory(MultipleCommandAlias.class, new MultipleCommandAliasHelpTopicFactory());
}
 

import com.google.common.base.Predicates; //导入依赖的package包/类
/**
 * Warns about CAS offsets for Responses being inconsistent with actual document text for non-TIME
 * roles
 */
private void warnOnMissingOffsets(final File systemOutputStoreFile, final Symbol docID,
    final ImmutableSet<Response> responses,
    final Map<Symbol, File> docIDMap) throws IOException {
  final String text = Files.asCharSource(docIDMap.get(docID), Charsets.UTF_8).read();
  for (final Response r : FluentIterable.from(responses)
      .filter(Predicates.compose(not(equalTo(TIME)), ResponseFunctions.role()))) {
    final KBPString cas = r.canonicalArgument();
    final String casTextInRaw =
        resolveCharOffsets(cas.charOffsetSpan(), docID, text).replaceAll("\\s+", " ");
    // allow whitespace
    if (!casTextInRaw.contains(cas.string())) {
      log.warn("Warning for {} - response {} CAS does not match text span of {} ",
          systemOutputStoreFile.getAbsolutePath(), renderResponse(r, text), casTextInRaw);
    }
  }
}
 

import com.google.common.base.Predicates; //导入依赖的package包/类
public Iterable<Class<? extends RuleSource>> getDeclaredSources(Class<?> container) {
    try {
        return FluentIterable.from(cache.get(container))
                .transform(new Function<Reference<Class<? extends RuleSource>>, Class<? extends RuleSource>>() {
                    @Override
                    public Class<? extends RuleSource> apply(Reference<Class<? extends RuleSource>> input) {
                        return input.get();
                    }
                })
                .filter(Predicates.notNull());
    } catch (ExecutionException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
}
 

import com.google.common.base.Predicates; //导入依赖的package包/类
public Iterable<String> getManifestThemeNames(InputStream is) {
    return Iterables.filter(
            Iterables.transform(
                    getAttrNames(is, manifestXpathExp),
                    new Function<String, String>() {
                @Override
                public String apply(String name) {
                    return name.startsWith("@style/") ? name.substring("@style/".length()) : null;
                }
            }),
            Predicates.notNull());
}
 

import com.google.common.base.Predicates; //导入依赖的package包/类
/**
 * Support {@code clear()}, {@code removeAll()}, and {@code retainAll()} when
 * filtering a filtered navigable map.
 */
@GwtIncompatible // NavigableMap
private static <K, V> NavigableMap<K, V> filterFiltered(
    FilteredEntryNavigableMap<K, V> map, Predicate<? super Entry<K, V>> entryPredicate) {
  Predicate<Entry<K, V>> predicate =
      Predicates.<Entry<K, V>>and(map.entryPredicate, entryPredicate);
  return new FilteredEntryNavigableMap<K, V>(map.unfiltered, predicate);
}
 

import com.google.common.base.Predicates; //导入依赖的package包/类
private List<String> resolveFileResourceNames(ObjectListing objectListing) {
    List<S3ObjectSummary> objectSummaries = objectListing.getObjectSummaries();
    if (null != objectSummaries) {
        return ImmutableList.copyOf(Iterables.filter(
            Iterables.transform(objectSummaries, EXTRACT_FILE_NAME),
            Predicates.notNull()
        ));
    }
    return Collections.emptyList();

}
 

import com.google.common.base.Predicates; //导入依赖的package包/类
public void testFirstMatch() {
  FluentIterable<String> iterable = FluentIterable.from(Lists.newArrayList("cool", "pants"));
  assertThat(iterable.firstMatch(Predicates.equalTo("cool"))).hasValue("cool");
  assertThat(iterable.firstMatch(Predicates.equalTo("pants"))).hasValue("pants");
  assertThat(iterable.firstMatch(Predicates.alwaysFalse())).isAbsent();
  assertThat(iterable.firstMatch(Predicates.alwaysTrue())).hasValue("cool");
}
 

import com.google.common.base.Predicates; //导入依赖的package包/类
@Test
public void testSimpleFragment() {
  for (String inputUrl
       : new String[] { "#foo", "/bar#foo", "mailto:[email protected]#foo" }) {
    assertFragmentClassification(
        Classification.NOT_A_MATCH,
        inputUrl,
        FragmentClassifiers.builder().build());
    assertFragmentClassification(
        Classification.NOT_A_MATCH,
        inputUrl,
        FragmentClassifiers.builder()
            .match(Predicates.equalTo(Optional.<String>absent()))
            .build());
    assertFragmentClassification(
        Classification.MATCH,
        inputUrl,
        FragmentClassifiers.builder()
            .match(Predicates.equalTo(Optional.of("#foo")))
            .build());
    assertFragmentClassification(
        Classification.MATCH,
        inputUrl,
        FragmentClassifiers.builder()
            .matchAsUrl(
                new UrlClassifier() {

                  @Override
                  public Classification apply(
                      UrlValue x, Diagnostic.Receiver<? super UrlValue> r) {
                    assertEquals(
                        "http://example.org./foo", x.urlText);
                    assertTrue(x.inheritsPlaceholderAuthority);
                    return Classification.MATCH;
                  }

                })
            .build());
  }
}