Tabnine Logo
Stream.anyMatch
Code IndexAdd Tabnine to your IDE (free)

How to use
anyMatch
method
in
java.util.stream.Stream

Best Java code snippets using java.util.stream.Stream.anyMatch (Showing top 20 results out of 23,157)

Refine searchRefine arrow

  • List.stream
  • Stream.filter
  • Set.stream
  • Stream.map
  • Collection.stream
  • List.size
  • Test.<init>
  • List.isEmpty
  • Stream.collect
origin: spring-projects/spring-framework

private AcceptPredicate(Set<MediaType> mediaTypes) {
  super(headers -> {
    List<MediaType> acceptedMediaTypes = acceptedMediaTypes(headers);
    boolean match = acceptedMediaTypes.stream()
        .anyMatch(acceptedMediaType -> mediaTypes.stream()
            .anyMatch(acceptedMediaType::isCompatibleWith));
    traceMatch("Accept", mediaTypes, acceptedMediaTypes, match);
    return match;
  });
  this.mediaTypes = mediaTypes;
}
origin: prestodb/presto

private static boolean isS3Storage(String path)
{
  return SUPPORTED_S3_PREFIXES.stream().anyMatch(path::startsWith);
}
origin: prestodb/presto

private static <T> boolean containsNoneDomain(Map<T, Domain> domains)
{
  return domains.values().stream().anyMatch(Domain::isNone);
}
origin: spring-projects/spring-data-mongodb

@Override
public boolean inheritsFields() {
  return projections.stream().filter(FieldProjection.class::isInstance) //
      .map(FieldProjection.class::cast) //
      .anyMatch(FieldProjection::isExcluded);
}
origin: speedment/speedment

  private boolean splitFields(Method model) {
    return model.getFields().size() >= 3 || model.getFields().stream()
      .anyMatch(f -> !f.getAnnotations().isEmpty());
  }
}
origin: graphql-java/graphql-java

private boolean hasComments(List<? extends Node> nodes) {
  return nodes.stream().anyMatch(it -> it.getComments().size() > 0);
}
origin: prestodb/presto

private static Map<String, PartitionStatistics> getPartitionsStatistics(SemiTransactionalHiveMetastore metastore, SchemaTableName table, List<HivePartition> hivePartitions)
{
  if (hivePartitions.isEmpty()) {
    return ImmutableMap.of();
  }
  boolean unpartitioned = hivePartitions.stream().anyMatch(partition -> partition.getPartitionId().equals(UNPARTITIONED_ID));
  if (unpartitioned) {
    checkArgument(hivePartitions.size() == 1, "expected only one hive partition");
    return ImmutableMap.of(UNPARTITIONED_ID, metastore.getTableStatistics(table.getSchemaName(), table.getTableName()));
  }
  Set<String> partitionNames = hivePartitions.stream()
      .map(HivePartition::getPartitionId)
      .collect(toImmutableSet());
  return metastore.getPartitionStatistics(table.getSchemaName(), table.getTableName(), partitionNames);
}
origin: SonarSource/sonarqube

private static void validatePropertySet(SetRequest request, @Nullable PropertyDefinition definition) {
 checkRequest(definition != null, "Setting '%s' is undefined", request.getKey());
 checkRequest(PropertyType.PROPERTY_SET.equals(definition.type()), "Parameter '%s' is used for setting of property set type only", PARAM_FIELD_VALUES);
 Set<String> fieldKeys = definition.fields().stream().map(PropertyFieldDefinition::key).collect(Collectors.toSet());
 ListMultimap<String, String> valuesByFieldKeys = ArrayListMultimap.create(fieldKeys.size(), request.getFieldValues().size() * fieldKeys.size());
 request.getFieldValues().stream()
  .map(oneFieldValues -> readOneFieldValues(oneFieldValues, request.getKey()))
  .peek(map -> checkRequest(map.values().stream().anyMatch(StringUtils::isNotBlank), MSG_NO_EMPTY_VALUE))
  .flatMap(map -> map.entrySet().stream())
  .peek(entry -> valuesByFieldKeys.put(entry.getKey(), entry.getValue()))
  .forEach(entry -> checkRequest(fieldKeys.contains(entry.getKey()), "Unknown field key '%s' for setting '%s'", entry.getKey(), request.getKey()));
 checkFieldType(request, definition, valuesByFieldKeys);
}
origin: oracle/helidon

@Override
public boolean isAccepted(MediaType mediaType) {
  Objects.requireNonNull(mediaType, "Parameter 'mediaType' is null!");
  List<MediaType> acceptedTypes = acceptedTypes();
  return acceptedTypes.isEmpty() || acceptedTypes.stream().anyMatch(mediaType);
}
origin: apache/hbase

@Test
public void testHandleDeadWorker() throws Exception {
 Table table = TEST_UTIL.createTable(TABLE_NAME, FAMILY, TEST_UTIL.KEYS_FOR_HBA_CREATE_TABLE);
 for (int i = 0; i < 10; i++) {
  TEST_UTIL.loadTable(table, FAMILY);
 }
 HRegionServer testServer = TEST_UTIL.getHBaseCluster().getRegionServer(0);
 ProcedureExecutor<MasterProcedureEnv> masterPE = master.getMasterProcedureExecutor();
 List<FileStatus> wals = splitWALManager.getWALsToSplit(testServer.getServerName(), false);
 Assert.assertEquals(1, wals.size());
 TEST_UTIL.getHBaseCluster().killRegionServer(testServer.getServerName());
 TEST_UTIL.waitFor(30000, () -> master.getProcedures().stream()
   .anyMatch(procedure -> procedure instanceof SplitWALProcedure));
 Procedure splitWALProcedure = master.getProcedures().stream()
   .filter(procedure -> procedure instanceof SplitWALProcedure).findAny().get();
 Assert.assertNotNull(splitWALProcedure);
 TEST_UTIL.waitFor(5000, () -> ((SplitWALProcedure) splitWALProcedure).getWorker() != null);
 TEST_UTIL.getHBaseCluster()
   .killRegionServer(((SplitWALProcedure) splitWALProcedure).getWorker());
 ProcedureTestingUtility.waitProcedure(masterPE, splitWALProcedure.getProcId());
 Assert.assertTrue(splitWALProcedure.isSuccess());
 ProcedureTestingUtility.waitAllProcedures(masterPE);
}
origin: prestodb/presto

private static boolean hasSpatialPartitioningAggregation(AggregationNode aggregation)
{
  return aggregation.getAggregations().values().stream()
      .map(Aggregation::getCall)
      .anyMatch(call -> call.getName().toString().equals(NAME) && call.getArguments().size() == 1);
}
origin: apache/geode

@Test
public void testCommandManagerLoadsUserCommand() throws Exception {
 Properties props = new Properties();
 props.setProperty(ConfigurationProperties.USER_COMMAND_PACKAGES, "com.examples");
 CommandManager commandManager = new CommandManager(props, null);
 assertThat(
   commandManager.getCommandMarkers().stream().anyMatch(c -> c instanceof UserGfshCommand));
}
origin: apache/kafka

  private void validate(short version, List<AclBindingFilter> filters) {
    if (version == 0) {
      final boolean unsupported = filters.stream()
        .map(AclBindingFilter::patternFilter)
        .map(ResourcePatternFilter::patternType)
        .anyMatch(patternType -> patternType != PatternType.LITERAL && patternType != PatternType.ANY);
      if (unsupported) {
        throw new UnsupportedVersionException("Version 0 only supports literal resource pattern types");
      }
    }

    final boolean unknown = filters.stream().anyMatch(AclBindingFilter::isUnknown);
    if (unknown) {
      throw new IllegalArgumentException("Filters contain UNKNOWN elements");
    }
  }
}
origin: wuyouzhuguli/FEBS-Shiro

private boolean handleExcludeURL(HttpServletRequest request) {
  if (excludes == null || excludes.isEmpty()) {
    return false;
  }
  String url = request.getServletPath();
  return excludes.stream().map(pattern -> Pattern.compile("^" + pattern)).map(p -> p.matcher(url)).anyMatch(Matcher::find);
}
origin: hs-web/hsweb-framework

public WebUserTokenInterceptor(UserTokenManager userTokenManager, List<UserTokenParser> userTokenParser,AopMethodAuthorizeDefinitionParser definitionParser) {
  this.userTokenManager = userTokenManager;
  this.userTokenParser = userTokenParser;
  this.parser=definitionParser;
  enableBasicAuthorization = userTokenParser.stream()
      .filter(UserTokenForTypeParser.class::isInstance)
      .anyMatch(parser -> "basic".equalsIgnoreCase(((UserTokenForTypeParser) parser).getTokenType()));
}
origin: spring-projects/spring-framework

@Override
public boolean canDecode(ResolvableType elementType, @Nullable MimeType mimeType) {
  if (mimeType == null) {
    return true;
  }
  return this.decodableMimeTypes.stream().anyMatch(candidate -> candidate.isCompatibleWith(mimeType));
}
origin: prestodb/presto

private static boolean hasSourceDistributedStage(Set<SqlStageExecution> phase)
{
  return phase.stream().anyMatch(stage -> !stage.getFragment().getPartitionedSources().isEmpty());
}
origin: SonarSource/sonarqube

public static List<String> getSansTop25(Collection<String> cwe) {
 return SANS_TOP_25_CWE_MAPPING
  .keySet()
  .stream()
  .filter(k -> cwe.stream().anyMatch(SANS_TOP_25_CWE_MAPPING.get(k)::contains))
  .collect(toList());
}
origin: prestodb/presto

  public static boolean dependsOn(WindowNode parent, WindowNode child)
  {
    return parent.getPartitionBy().stream().anyMatch(child.getCreatedSymbols()::contains)
        || (parent.getOrderingScheme().isPresent() && parent.getOrderingScheme().get().getOrderBy().stream().anyMatch(child.getCreatedSymbols()::contains))
        || parent.getWindowFunctions().values().stream()
        .map(WindowNode.Function::getFunctionCall)
        .map(SymbolsExtractor::extractUnique)
        .flatMap(Collection::stream)
        .anyMatch(child.getCreatedSymbols()::contains);
  }
}
origin: prestodb/presto

public boolean hasOrderings()
{
  return aggregations.values().stream()
      .map(Aggregation::getCall)
      .map(FunctionCall::getOrderBy)
      .anyMatch(Optional::isPresent);
}
java.util.streamStreamanyMatch

Javadoc

Returns whether any elements of this stream match the provided predicate. May not evaluate the predicate on all elements if not necessary for determining the result. If the stream is empty then false is returned and the predicate is not evaluated.

This is a short-circuiting terminal operation.

Popular methods of Stream

  • collect
  • map
  • filter
  • forEach
  • findFirst
  • of
  • flatMap
  • sorted
  • toArray
  • findAny
  • count
  • allMatch
  • count,
  • allMatch,
  • concat,
  • reduce,
  • mapToInt,
  • distinct,
  • empty,
  • noneMatch,
  • iterator

Popular in Java

  • Start an intent from android
  • onRequestPermissionsResult (Fragment)
  • addToBackStack (FragmentTransaction)
  • findViewById (Activity)
  • Point (java.awt)
    A point representing a location in (x,y) coordinate space, specified in integer precision.
  • LinkedHashMap (java.util)
    LinkedHashMap is an implementation of Map that guarantees iteration order. All optional operations a
  • ConcurrentHashMap (java.util.concurrent)
    A plug-in replacement for JDK1.5 java.util.concurrent.ConcurrentHashMap. This version is based on or
  • Pattern (java.util.regex)
    Patterns are compiled regular expressions. In many cases, convenience methods such as String#matches
  • ServletException (javax.servlet)
    Defines a general exception a servlet can throw when it encounters difficulty.
  • Logger (org.apache.log4j)
    This is the central class in the log4j package. Most logging operations, except configuration, are d
  • CodeWhisperer alternatives
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now