canonical example by Tabnine
/** * Get all methods in the supplied {@link Class class} and its superclasses * which are annotated with the supplied {@code annotationType} but * which are not <em>shadowed</em> by methods overridden in subclasses. * <p>Default methods on interfaces are also detected. * @param clazz the class for which to retrieve the annotated methods * @param annotationType the annotation type for which to search * @return all annotated methods in the supplied class and its superclasses * as well as annotated interface default methods */ private List<Method> getAnnotatedMethods(Class<?> clazz, Class<? extends Annotation> annotationType) { return Arrays.stream(ReflectionUtils.getUniqueDeclaredMethods(clazz)) .filter(method -> AnnotatedElementUtils.hasAnnotation(method, annotationType)) .collect(Collectors.toList()); }
@Override List<? extends Entry<?, ?>> createAdversarialEntries(int power, CallsCounter counter) { List<?> keys = createAdversarialObjects(power, counter); List<?> values = createAdversarialObjects(power, counter); return Streams.zip(keys.stream(), values.stream(), Maps::immutableEntry).collect(toList()); } };
@Nullable private <T> T createSingleBean(Function<WebFluxConfigurer, T> factory, Class<T> beanType) { List<T> result = this.delegates.stream().map(factory).filter(Objects::nonNull).collect(Collectors.toList()); if (result.isEmpty()) { return null; } else if (result.size() == 1) { return result.get(0); } else { throw new IllegalStateException("More than one WebFluxConfigurer implements " + beanType.getSimpleName() + " factory method."); } }
private List<SyncHandlerMethodArgumentResolver> initBinderResolvers( ArgumentResolverConfigurer customResolvers, ReactiveAdapterRegistry reactiveRegistry, ConfigurableApplicationContext context) { return initResolvers(customResolvers, reactiveRegistry, context, false, Collections.emptyList()).stream() .filter(resolver -> resolver instanceof SyncHandlerMethodArgumentResolver) .map(resolver -> (SyncHandlerMethodArgumentResolver) resolver) .collect(Collectors.toList()); }
private static void addBindValue(Map<String, Object> params, String key, List<?> values) { if (!CollectionUtils.isEmpty(values)) { values = values.stream() .map(value -> value instanceof FormFieldPart ? ((FormFieldPart) value).value() : value) .collect(Collectors.toList()); params.put(key, values.size() == 1 ? values.get(0) : values); } }
private void updateFilters() { if (this.filters.isEmpty()) { return; } List<WebFilter> filtersToUse = this.filters.stream() .peek(filter -> { if (filter instanceof ForwardedHeaderTransformer && this.forwardedHeaderTransformer == null) { this.forwardedHeaderTransformer = (ForwardedHeaderTransformer) filter; } }) .filter(filter -> !(filter instanceof ForwardedHeaderTransformer)) .collect(Collectors.toList()); this.filters.clear(); this.filters.addAll(filtersToUse); }
/** * Parse the comma-separated string into a list of {@code MimeType} objects. * @param mimeTypes the string to parse * @return the list of mime types * @throws InvalidMimeTypeException if the string cannot be parsed */ public static List<MimeType> parseMimeTypes(String mimeTypes) { if (!StringUtils.hasLength(mimeTypes)) { return Collections.emptyList(); } return tokenize(mimeTypes).stream() .map(MimeTypeUtils::parseMimeType).collect(Collectors.toList()); }