# Uses of Annotation Interface
org.springframework.lang.Nullable

Packages that use Nullable
Package
Description
org.springframework.aot.generate
Support classes for components that contribute generated code equivalent to a runtime behavior.
org.springframework.aot.hint
Support for registering the need for reflection, resources, java serialization and proxies at runtime.
org.springframework.aot.hint.support
Convenience classes for using runtime hints.
org.springframework.aot.nativex
Support for generating GraalVM native configuration from runtime hints.
org.springframework.core
Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
org.springframework.core.annotation
Core support package for annotations, meta-annotations, and merged annotations with attribute overrides.
org.springframework.core.codec
`Encoder` and `Decoder` abstractions to convert between a reactive stream of bytes and Java objects.
org.springframework.core.convert
Type conversion system API.
org.springframework.core.convert.converter
SPI to implement Converters for the type conversion system.
org.springframework.core.convert.support
Default implementation of the type conversion system.
org.springframework.core.env
Spring's environment abstraction consisting of bean definition profile and hierarchical property source support.
org.springframework.core.io
Generic abstraction for (file-based) resources, used throughout the framework.
org.springframework.core.io.buffer
Generic abstraction for working with byte buffer implementations.
org.springframework.core.io.support
Support classes for Spring's resource abstraction.
org.springframework.core.log
Useful delegates for Spring's logging conventions.
org.springframework.core.metrics
Support package for recording metrics during application startup.
org.springframework.core.serializer
Root package for Spring's serializer interfaces and implementations.
org.springframework.core.serializer.support
Support classes for Spring's serializer abstraction.
org.springframework.core.style
Support for styling values as Strings, with ToStringCreator as central class.
org.springframework.core.task
This package defines Spring's core TaskExecutor abstraction, and provides SyncTaskExecutor and SimpleAsyncTaskExecutor implementations.
org.springframework.core.task.support
Support classes for Spring's TaskExecutor abstraction.
org.springframework.core.type
Core support package for type introspection.
org.springframework.core.type.classreading
Support classes for reading annotation and class-level metadata.
org.springframework.core.type.filter
Core support package for type filtering (for example, for classpath scanning).
org.springframework.util
Miscellaneous utility classes, such as utilities for working with strings, classes, collections, reflection, etc.
org.springframework.util.comparator
Useful generic `java.util.Comparator` implementations, such as an invertible comparator and a compound comparator.
org.springframework.util.concurrent
Useful generic `java.util.concurrent.Future` extensions.
org.springframework.util.function
Useful generic `java.util.function` helper classes.
org.springframework.util.unit
Useful unit data types.
org.springframework.util.xml
Miscellaneous utility classes for XML parsing and transformation, such as error handlers that log warnings via Commons Logging.

## Uses of Nullable in org.springframework.aot.generate

Methods in org.springframework.aot.generate with annotations of type Nullable
Modifier and Type
Method
Description
`org.springframework.javapoet.CodeBlock`
MethodReference.ArgumentCodeGenerator.`generateCode(org.springframework.javapoet.TypeName argumentType)`
Generate the code for the given argument type.
`org.springframework.javapoet.CodeBlock`
ValueCodeGenerator.Delegate.`generateCode(ValueCodeGenerator valueCodeGenerator, Object value)`
Generate the code for the specified non-null `value`.
`org.springframework.javapoet.CodeBlock`
ValueCodeGeneratorDelegates.CollectionDelegate.`generateCode(ValueCodeGenerator valueCodeGenerator, Object value)`
`org.springframework.javapoet.CodeBlock`
ValueCodeGeneratorDelegates.MapDelegate.`generateCode(ValueCodeGenerator valueCodeGenerator, Object value)`
`protected org.springframework.javapoet.CodeBlock`
ValueCodeGeneratorDelegates.MapDelegate.`generateMapCode(ValueCodeGenerator valueCodeGenerator, Map<?,?> map)`
Generate the code for a non-empty `Map`.
`InputStreamSource`
GeneratedFiles.FileHandler.`getContent()`
Return an `InputStreamSource` for the content of the file or `null` if the file does not exist.
`GeneratedClass`
GeneratedClass.`getEnclosingClass()`
Return the enclosing `GeneratedClass` or `null` if this instance represents a top-level class.
`InputStreamSource`
InMemoryGeneratedFiles.`getGeneratedFile(GeneratedFiles.Kind kind, String path)`
Return the `InputStreamSource` of specified file.
`String`
InMemoryGeneratedFiles.`getGeneratedFileContent(GeneratedFiles.Kind kind, String path)`
Return the content of the specified file.
`GeneratedMethods`
ValueCodeGenerator.`getGeneratedMethods()`
Return the `GeneratedMethods` that represents the scope in which code generated by this instance will be added, or `null` if no specific scope is set.
`Object`
ValueCodeGenerationException.`getValue()`
Return the value that failed to be generated.
Method parameters in org.springframework.aot.generate with annotations of type Nullable
Modifier and Type
Method
Description
`org.springframework.javapoet.ClassName`
ClassNameGenerator.`generateClassName(String featureName, org.springframework.javapoet.ClassName target)`
Generate a unique `ClassName` based on the specified `featureName` and `target`.
`org.springframework.javapoet.CodeBlock`
ValueCodeGenerator.`generateCode(Object value)`
Generate the code that represents the specified `value`.
`org.springframework.javapoet.CodeBlock`
DefaultMethodReference.`toInvokeCodeBlock(MethodReference.ArgumentCodeGenerator argumentCodeGenerator, org.springframework.javapoet.ClassName targetClassName)`
`org.springframework.javapoet.CodeBlock`
MethodReference.`toInvokeCodeBlock(MethodReference.ArgumentCodeGenerator argumentCodeGenerator, org.springframework.javapoet.ClassName targetClassName)`
Return this method reference as a `CodeBlock` using the specified `MethodReference.ArgumentCodeGenerator`.
Constructor parameters in org.springframework.aot.generate with annotations of type Nullable
Modifier
Constructor
Description
``
`DefaultMethodReference(org.springframework.javapoet.MethodSpec method, org.springframework.javapoet.ClassName declaringClass)`
``
`ValueCodeGenerationException(Object value, Throwable cause)`
`protected`
`ValueCodeGenerationException(String message, Object value, Throwable cause)`
`protected`
`ValueCodeGenerationException(String message, Object value, Throwable cause)`

## Uses of Nullable in org.springframework.aot.hint

Methods in org.springframework.aot.hint with annotations of type Nullable
Modifier and Type
Method
Description
`TypeReference`
AbstractTypeReference.`getEnclosingType()`
`TypeReference`
TypeReference.`getEnclosingType()`
Return the enclosing type reference, or `null` if this type reference does not have an enclosing type.
`TypeReference`
ConditionalHint.`getReachableType()`
Return the type that should be reachable for this hint to apply, or `null` if this hint should always been applied.
`TypeReference`
JavaSerializationHint.`getReachableType()`
`TypeReference`
JdkProxyHint.`getReachableType()`
`TypeReference`
ResourceBundleHint.`getReachableType()`
`TypeReference`
ResourcePatternHint.`getReachableType()`
`TypeReference`
TypeHint.`getReachableType()`
`TypeHint`
ReflectionHints.`getTypeHint(Class<?> type)`
Return the reflection hints for the specified type.
`TypeHint`
ReflectionHints.`getTypeHint(TypeReference type)`
Return the reflection hints for the type defined by the specified `TypeReference`.
Method parameters in org.springframework.aot.hint with annotations of type Nullable
Modifier and Type
Method
Description
`boolean`
AbstractTypeReference.`equals(Object other)`
`boolean`
JavaSerializationHint.`equals(Object other)`
`boolean`
JdkProxyHint.`equals(Object other)`
`boolean`
ResourceBundleHint.`equals(Object other)`
`boolean`
ResourcePatternHint.`equals(Object other)`
`ResourcePatternHints.Builder`
ResourcePatternHints.Builder.`excludes(TypeReference reachableType, String... excludes)`
Exclude resources matching the specified patterns.
`ResourcePatternHints.Builder`
ResourcePatternHints.Builder.`includes(TypeReference reachableType, String... includes)`
Include resources matching the specified patterns.
`void`
RuntimeHintsRegistrar.`registerHints(RuntimeHints hints, ClassLoader classLoader)`
Contribute hints to the given `RuntimeHints` instance.
`ResourceHints`
ResourceHints.`registerPattern(Consumer<ResourcePatternHints.Builder> resourceHint)`
Register that the resources matching the specified pattern should be made available at runtime.
`ResourceHints`
ResourceHints.`registerPatternIfPresent(ClassLoader classLoader, String location, Consumer<ResourcePatternHints.Builder> resourceHint)`
Register a pattern if the given `location` is available on the classpath.
`ResourceHints`
ResourceHints.`registerResourceBundle(String baseName, Consumer<ResourceBundleHint.Builder> resourceHint)`
Register that the resource bundle with the specified base name should be made available at runtime.
`SerializationHints`
SerializationHints.`registerType(Class<? extends Serializable> type, Consumer<JavaSerializationHint.Builder> serializationHint)`
Register that the specified type need to be serialized using java serialization.
`SerializationHints`
SerializationHints.`registerType(TypeReference type, Consumer<JavaSerializationHint.Builder> serializationHint)`
Register that the type defined by the specified `TypeReference` need to be serialized using java serialization.
`ReflectionHints`
ReflectionHints.`registerTypeIfPresent(ClassLoader classLoader, String typeName, Consumer<TypeHint.Builder> typeHint)`
Register or customize reflection hints for the specified type if it is available using the specified `ClassLoader`.
`ReflectionHints`
ReflectionHints.`registerTypeIfPresent(ClassLoader classLoader, String typeName, MemberCategory... memberCategories)`
Register or customize reflection hints for the specified type if it is available using the specified `ClassLoader`.
Constructor parameters in org.springframework.aot.hint with annotations of type Nullable
Modifier
Constructor
Description
`protected`
`AbstractTypeReference(String packageName, String simpleName, TypeReference enclosingType)`

## Uses of Nullable in org.springframework.aot.hint.support

Method parameters in org.springframework.aot.hint.support with annotations of type Nullable
Modifier and Type
Method
Description
`void`
FilePatternResourceHintsRegistrar.Builder.`registerHints(ResourceHints hints, ClassLoader classLoader)`
Register resource hints for the current state of this builder.
`void`
FilePatternResourceHintsRegistrar.`registerHints(ResourceHints hints, ClassLoader classLoader)`
Deprecated, for removal: This API element is subject to removal in a future version.

## Uses of Nullable in org.springframework.aot.nativex

Constructor parameters in org.springframework.aot.nativex with annotations of type Nullable
Modifier
Constructor
Description
``
`FileNativeConfigurationWriter(Path basePath, String groupId, String artifactId)`
``
`FileNativeConfigurationWriter(Path basePath, String groupId, String artifactId)`

## Uses of Nullable in org.springframework.core

Methods in org.springframework.core with annotations of type Nullable
Modifier and Type
Method
Description
`static String`
NestedExceptionUtils.`buildMessage(String message, Throwable cause)`
Deprecated.
as of 6.0, in favor of custom exception messages with selective inclusion of cause messages
`static Boolean`
SpringProperties.`checkFlag(String key)`
Retrieve the flag for the given property key, returning `null` instead of `false` in case of no actual flag set.
`protected Integer`
OrderComparator.`findOrder(Object obj)`
Find an order value indicated by the given object.
`ReactiveAdapter`
ReactiveAdapterRegistry.`getAdapter(Class<?> reactiveType)`
Get the adapter for the given reactive type.
`ReactiveAdapter`
ReactiveAdapterRegistry.`getAdapter(Class<?> reactiveType, Object source)`
Get the adapter for the given reactive type.
`Object`
AttributeAccessor.`getAttribute(String name)`
Get the value of the attribute identified by `name`.
`Object`
AttributeAccessorSupport.`getAttribute(String name)`
`Constructor<?>`
MethodParameter.`getConstructor()`
Return the wrapped Constructor, if any.
`protected ClassLoader`
ConfigurableObjectInputStream.`getFallbackClassLoader()`
Return the fallback ClassLoader to use when no ClassLoader was specified and ObjectInputStream's own default class loader failed.
`Method`
MethodParameter.`getMethod()`
Return the wrapped Method, if any.
`<A extends Annotation>
A`
MethodParameter.`getMethodAnnotation(Class<A> annotationType)`
Return the method/constructor annotation of the given type, if available.
`Object`
OrderComparator.OrderSourceProvider.`getOrderSource(Object obj)`
Return an order source for the specified object, i.e.
`<A extends Annotation>
A`
MethodParameter.`getParameterAnnotation(Class<A> annotationType)`
Return the parameter annotation of the given type, if available.
`String`
MethodParameter.`getParameterName()`
Return the name of the method/constructor parameter.
`String[]`
KotlinReflectionParameterNameDiscoverer.`getParameterNames(Constructor<?> ctor)`
`String[]`
KotlinReflectionParameterNameDiscoverer.`getParameterNames(Method method)`
`String[]`
ParameterNameDiscoverer.`getParameterNames(Constructor<?> ctor)`
Return parameter names for a constructor, or `null` if they cannot be determined.
`String[]`
ParameterNameDiscoverer.`getParameterNames(Method method)`
Return parameter names for a method, or `null` if they cannot be determined.
`String[]`
PrioritizedParameterNameDiscoverer.`getParameterNames(Constructor<?> ctor)`
`String[]`
PrioritizedParameterNameDiscoverer.`getParameterNames(Method method)`
`String[]`
StandardReflectionParameterNameDiscoverer.`getParameterNames(Constructor<?> ctor)`
`String[]`
StandardReflectionParameterNameDiscoverer.`getParameterNames(Method method)`
`Integer`
OrderComparator.`getPriority(Object obj)`
Determine a priority value for the given object, if any.
`static String`
SpringProperties.`getProperty(String key)`
Retrieve the property value for the given key, checking local Spring properties first and falling back to JVM-level system properties.
`Class<?>`
ResolvableType.`getRawClass()`
Return the underlying Java `Class` being managed, if available; otherwise `null`.
`ResolvableType`
ResolvableTypeProvider.`getResolvableType()`
Return the `ResolvableType` describing this instance (or `null` if some sort of default should be applied instead).
`Throwable`
NestedCheckedException.`getRootCause()`
Retrieve the innermost cause of this exception, if any.
`static Throwable`
NestedExceptionUtils.`getRootCause(Throwable original)`
Retrieve the innermost cause of the given exception, if any.
`Throwable`
NestedRuntimeException.`getRootCause()`
Retrieve the innermost cause of this exception, if any.
`Integer`
MethodParameter.`getTypeIndexForCurrentLevel()`
Return the type index for the current nesting level.
`Integer`
MethodParameter.`getTypeIndexForLevel(int nestingLevel)`
Return the type index for the specified nesting level.
`static String`
SpringVersion.`getVersion()`
Return the full version string of the present Spring codebase, or `null` if it cannot be determined.
`T`
MethodIntrospector.MetadataLookup.`inspect(Method method)`
Perform a lookup on the given method and return associated metadata, if any.
`protected byte[]`
OverridingClassLoader.`loadBytesForClass(String name)`
Load the defining bytes for the given class, to be turned into a Class object through a `ClassLoader.defineClass(byte[], int, int)` call.
`protected Class<?>`
OverridingClassLoader.`loadClassForOverriding(String name)`
Load the specified class for overriding purposes in this ClassLoader.
`protected InputStream`
OverridingClassLoader.`openStreamForClass(String name)`
Open an InputStream for the specified class.
`Object`
AttributeAccessor.`removeAttribute(String name)`
Remove the attribute identified by `name` and return its value.
`Object`
AttributeAccessorSupport.`removeAttribute(String name)`
`Class<?>`
ResolvableType.`resolve()`
Resolve this type to a `Class`, returning `null` if the type cannot be resolved.
`Class<?>`
ResolvableType.`resolveGeneric(int... indexes)`
Convenience method that will `get` and `resolve` a specific generic parameter.
`static Class<?>`
GenericTypeResolver.`resolveReturnTypeArgument(Method method, Class<?> genericType)`
Resolve the single type argument of the given generic type against the given target method which is assumed to return the given type or an implementation of it.
`static Class<?>`
GenericTypeResolver.`resolveTypeArgument(Class<?> clazz, Class<?> genericType)`
Resolve the single type argument of the given generic type against the given target class which is assumed to implement the given type and possibly declare a concrete type for its type variable.
`static Class<?>[]`
GenericTypeResolver.`resolveTypeArguments(Class<?> clazz, Class<?> genericType)`
Resolve the type arguments of the given generic type against the given target class which is assumed to implement or extend from the given type and possibly declare concrete types for its type variables.
Method parameters in org.springframework.core with annotations of type Nullable
Modifier and Type
Method
Description
`static String`
NestedExceptionUtils.`buildMessage(String message, Throwable cause)`
Deprecated.
as of 6.0, in favor of custom exception messages with selective inclusion of cause messages
`static String`
NestedExceptionUtils.`buildMessage(String message, Throwable cause)`
Deprecated.
as of 6.0, in favor of custom exception messages with selective inclusion of cause messages
`int`
OrderComparator.`compare(Object o1, Object o2)`
`int`
OrderComparator.`compare(Object o1, Object o2)`
`boolean`
NestedCheckedException.`contains(Class<?> exType)`
Check whether this exception contains an exception of the given type: either it is of the given class itself or it contains a nested cause of the given type.
`boolean`
NestedRuntimeException.`contains(Class<?> exType)`
Check whether this exception contains an exception of the given type: either it is of the given class itself or it contains a nested cause of the given type.
`static <E> Collection<E>`
CollectionFactory.`createApproximateCollection(Object collection, int capacity)`
Create the most approximate collection for the given collection.
`static <K, V> Map<K,V>`
CollectionFactory.`createApproximateMap(Object map, int capacity)`
Create the most approximate map for the given map.
`static <E> Collection<E>`
CollectionFactory.`createCollection(Class<?> collectionType, Class<?> elementType, int capacity)`
Create the most appropriate collection for the given collection type.
`static <K, V> Map<K,V>`
CollectionFactory.`createMap(Class<?> mapType, Class<?> keyType, int capacity)`
Create the most appropriate map for the given map type.
`boolean`
AttributeAccessorSupport.`equals(Object other)`
`boolean`
MethodClassKey.`equals(Object other)`
`boolean`
MethodParameter.`equals(Object other)`
`boolean`
ParameterizedTypeReference.`equals(Object other)`
`boolean`
ReactiveTypeDescriptor.`equals(Object other)`
`boolean`
ResolvableType.`equals(Object other)`
Check for full equality of all type resolution artifacts: type as well as `TypeProvider` and `VariableResolver`.
`static ResolvableType`
ResolvableType.`forClass(Class<?> clazz)`
Return a `ResolvableType` for the specified `Class`, using the full generic type information for assignability checks.
`static ResolvableType`
ResolvableType.`forClassWithGenerics(Class<?> clazz, ResolvableType... generics)`
Return a `ResolvableType` for the specified `Class` with pre-declared generics.
`static ResolvableType`
ResolvableType.`forField(Field field, int nestingLevel, Class<?> implementationClass)`
Return a `ResolvableType` for the specified `Field` with a given implementation and the given nesting level.
`static ResolvableType`
ResolvableType.`forField(Field field, ResolvableType implementationType)`
Return a `ResolvableType` for the specified `Field` with a given implementation.
`static ResolvableType`
ResolvableType.`forInstance(Object instance)`
Return a `ResolvableType` for the specified instance.
`static ResolvableType`
ResolvableType.`forMethodParameter(MethodParameter methodParameter, Type targetType)`
Return a `ResolvableType` for the specified `MethodParameter`, overriding the target type to resolve with a specific given type.
`static ResolvableType`
ResolvableType.`forMethodParameter(MethodParameter methodParameter, ResolvableType implementationType)`
Return a `ResolvableType` for the specified `MethodParameter` with a given implementation type.
`static ResolvableType`
ResolvableType.`forRawClass(Class<?> clazz)`
Return a `ResolvableType` for the specified `Class`, doing assignability checks against the raw class only (analogous to `Class.isAssignableFrom(java.lang.Class<?>)`, which this serves as a wrapper for).
`static ResolvableType`
ResolvableType.`forType(Type type)`
Return a `ResolvableType` for the specified `Type`.
`static ResolvableType`
ResolvableType.`forType(Type type, ResolvableType owner)`
Return a `ResolvableType` for the specified `Type` backed by the given owner type.
`static ResolvableType`
ResolvableType.`forType(Type type, ResolvableType owner)`
Return a `ResolvableType` for the specified `Type` backed by the given owner type.
`ReactiveAdapter`
ReactiveAdapterRegistry.`getAdapter(Class<?> reactiveType, Object source)`
Get the adapter for the given reactive type.
`ReactiveAdapter`
ReactiveAdapterRegistry.`getAdapter(Class<?> reactiveType, Object source)`
Get the adapter for the given reactive type.
`ResolvableType`
ResolvableType.`getGeneric(int... indexes)`
Return a `ResolvableType` representing the generic parameter for the given indexes.
`static Method`
BridgeMethodResolver.`getMostSpecificMethod(Method bridgeMethod, Class<?> targetClass)`
Determine the most specific method for the supplied `bridge Method` in the given class hierarchy, even if not available on the local declaring class.
`Set<String>`
Constants.`getNames(String namePrefix)`
Deprecated.
Return all names of the given group of constants.
`Set<String>`
Constants.`getNamesForSuffix(String nameSuffix)`
Deprecated.
Return all names of the given group of constants.
`ResolvableType`
ResolvableType.`getNested(int nestingLevel, Map<Integer,Integer> typeIndexesPerLevel)`
Return a `ResolvableType` for the specified nesting level.
`protected int`
OrderComparator.`getOrder(Object obj)`
Determine the order value for the given object.
`static Throwable`
NestedExceptionUtils.`getRootCause(Throwable original)`
Retrieve the innermost cause of the given exception, if any.
`Set<Object>`
Constants.`getValues(String namePrefix)`
Deprecated.
Return all values of the given group of constants.
`Set<Object>`
Constants.`getValuesForSuffix(String nameSuffix)`
Deprecated.
Return all values of the given group of constants.
`static String`
Conventions.`getVariableNameForReturnType(Method method, Class<?> resolvedType, Object value)`
Determine the conventional variable name for the return type of the given method, taking the generic collection type, if any, into account, falling back on the given return value if the method declaration is not specific enough, for example, `Object` return type or untyped collection.
`static String`
Conventions.`getVariableNameForReturnType(Method method, Object value)`
Determine the conventional variable name for the return type of the given method, taking the generic collection type, if any, into account, falling back on the given actual return value if the method declaration is not specific enough, for example, `Object` return type or untyped collection.
`void`
MethodParameter.`initParameterNameDiscovery(ParameterNameDiscoverer parameterNameDiscoverer)`
Initialize parameter name discovery for this method parameter.
`static Publisher<?>`
CoroutinesUtils.`invokeSuspendingFunction(Method method, Object target, Object... args)`
Invoke a suspending function and convert it to `Mono` or `Flux`.
`static Publisher<?>`
CoroutinesUtils.`invokeSuspendingFunction(kotlin.coroutines.CoroutineContext context, Method method, Object target, Object... args)`
Invoke a suspending function and convert it to `Mono` or `Flux`.
`static Publisher<?>`
CoroutinesUtils.`invokeSuspendingFunction(kotlin.coroutines.CoroutineContext context, Method method, Object target, Object... args)`
Invoke a suspending function and convert it to `Mono` or `Flux`.
`static boolean`
CollectionFactory.`isApproximableCollectionType(Class<?> collectionType)`
Determine whether the given collection type is an approximable type, i.e.
`static boolean`
CollectionFactory.`isApproximableMapType(Class<?> mapType)`
Determine whether the given map type is an approximable type, i.e.
`boolean`
ResolvableType.`isInstance(Object obj)`
Determine whether the given object is an instance of this `ResolvableType`.
`MethodParameter`
MethodParameter.`nested(Integer typeIndex)`
Return a variant of this `MethodParameter` which points to the same parameter but one nesting level deeper.
`default Class<?>`
SmartClassLoader.`publicDefineClass(String name, byte[] b, ProtectionDomain protectionDomain)`
Define a custom class (typically a CGLIB proxy class) in this class loader.
`static Type`
GenericTypeResolver.`resolveType(Type genericType, Class<?> contextClass)`
Resolve the given generic type against the given context class, substituting type variables as far as possible.
`void`
AttributeAccessor.`setAttribute(String name, Object value)`
Set the attribute defined by `name` to the supplied `value`.
`void`
AttributeAccessorSupport.`setAttribute(String name, Object value)`
`static void`
SpringProperties.`setProperty(String key, String value)`
Programmatically set a local property, overriding an entry in the `spring.properties` file (if any).
`String`
Constants.`toCode(Object value, String namePrefix)`
Deprecated.
Look up the given value within the given group of constants.
`String`
Constants.`toCodeForSuffix(Object value, String nameSuffix)`
Deprecated.
Look up the given value within the given group of constants.
`<T> Publisher<T>`
ReactiveAdapter.`toPublisher(Object source)`
Adapt the given instance to a Reactive Streams `Publisher`.
`MethodParameter`
MethodParameter.`withContainingClass(Class<?> containingClass)`
Return a variant of this `MethodParameter` which refers to the given containing class.
Constructor parameters in org.springframework.core with annotations of type Nullable
Modifier
Constructor
Description
``
`ConfigurableObjectInputStream(InputStream in, ClassLoader classLoader)`
Create a new ConfigurableObjectInputStream for the given InputStream and ClassLoader.
``
`ConfigurableObjectInputStream(InputStream in, ClassLoader classLoader, boolean acceptProxyClasses)`
Create a new ConfigurableObjectInputStream for the given InputStream and ClassLoader.
``
`DecoratingClassLoader(ClassLoader parent)`
Create a new DecoratingClassLoader using the given parent ClassLoader for delegation.
``
`MethodClassKey(Method method, Class<?> targetClass)`
Create a key object for the given method and target class.
``
`NestedCheckedException(String msg, Throwable cause)`
Construct a `NestedCheckedException` with the specified detail message and nested exception.
``
`NestedCheckedException(String msg, Throwable cause)`
Construct a `NestedCheckedException` with the specified detail message and nested exception.
``
`NestedRuntimeException(String msg)`
Construct a `NestedRuntimeException` with the specified detail message.
``
`NestedRuntimeException(String msg, Throwable cause)`
Construct a `NestedRuntimeException` with the specified detail message and nested exception.
``
`NestedRuntimeException(String msg, Throwable cause)`
Construct a `NestedRuntimeException` with the specified detail message and nested exception.
``
`OverridingClassLoader(ClassLoader parent)`
Create a new OverridingClassLoader for the given ClassLoader.
``
`OverridingClassLoader(ClassLoader parent, ClassLoader overrideDelegate)`
Create a new OverridingClassLoader for the given ClassLoader.
``
`OverridingClassLoader(ClassLoader parent, ClassLoader overrideDelegate)`
Create a new OverridingClassLoader for the given ClassLoader.

## Uses of Nullable in org.springframework.core.annotation

Methods in org.springframework.core.annotation with annotations of type Nullable
Modifier and Type
Method
Description
`Class<? extends Annotation>`
AnnotationAttributes.`annotationType()`
Get the type of annotation represented by this `AnnotationAttributes`.
`static <A extends Annotation>
A`
AnnotationUtils.`findAnnotation(Class<?> clazz, Class<A> annotationType)`
Find a single `Annotation` of `annotationType` on the supplied `Class`, traversing its interfaces, annotations, and superclasses if the annotation is not directly present on the given class itself.
`static <A extends Annotation>
A`
AnnotationUtils.`findAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType)`
Find a single `Annotation` of `annotationType` on the supplied `AnnotatedElement`.
`static <A extends Annotation>
A`
AnnotationUtils.`findAnnotation(Method method, Class<A> annotationType)`
Find a single `Annotation` of `annotationType` on the supplied `Method`, traversing its super methods (i.e.
`static Class<?>`
AnnotationUtils.`findAnnotationDeclaringClass(Class<? extends Annotation> annotationType, Class<?> clazz)`
Deprecated.
as of 5.2 since it is superseded by the `MergedAnnotations` API
`static Class<?>`
AnnotationUtils.`findAnnotationDeclaringClassForTypes(List<Class<? extends Annotation>> annotationTypes, Class<?> clazz)`
Deprecated.
as of 5.2 since it is superseded by the `MergedAnnotations` API
`static <A extends Annotation>
A`
AnnotatedElementUtils.`findMergedAnnotation(AnnotatedElement element, Class<A> annotationType)`
Find the first annotation of the specified `annotationType` within the annotation hierarchy above the supplied `element`, merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy, and synthesize the result back into an annotation of the specified `annotationType`.
`static AnnotationAttributes`
AnnotatedElementUtils.`findMergedAnnotationAttributes(AnnotatedElement element, Class<? extends Annotation> annotationType, boolean classValuesAsString, boolean nestedAnnotationsAsMap)`
Find the first annotation of the specified `annotationType` within the annotation hierarchy above the supplied `element` and merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy.
`static AnnotationAttributes`
AnnotatedElementUtils.`findMergedAnnotationAttributes(AnnotatedElement element, String annotationName, boolean classValuesAsString, boolean nestedAnnotationsAsMap)`
Find the first annotation of the specified `annotationName` within the annotation hierarchy above the supplied `element` and merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy.
`protected Integer`
AnnotationAwareOrderComparator.`findOrder(Object obj)`
This implementation checks for `@Order` or `@Priority` on various kinds of elements, in addition to the `Ordered` check in the superclass.
`protected static Object`
AnnotatedMethod.`findProvidedArgument(MethodParameter parameter, Object... providedArgs)`
`static AnnotationAttributes`
AnnotationAttributes.`fromMap(Map<String,Object> map)`
Return an `AnnotationAttributes` instance based on the given map.
`static MultiValueMap<String,Object>`
AnnotatedElementUtils.`getAllAnnotationAttributes(AnnotatedElement element, String annotationName)`
Get the annotation attributes of all annotations of the specified `annotationName` in the annotation hierarchy above the supplied `AnnotatedElement` and store the results in a `MultiValueMap`.
`static MultiValueMap<String,Object>`
AnnotatedElementUtils.`getAllAnnotationAttributes(AnnotatedElement element, String annotationName, boolean classValuesAsString, boolean nestedAnnotationsAsMap)`
Get the annotation attributes of all annotations of the specified `annotationName` in the annotation hierarchy above the supplied `AnnotatedElement` and store the results in a `MultiValueMap`.
`static <A extends Annotation>
A`
AnnotationUtils.`getAnnotation(Annotation annotation, Class<A> annotationType)`
Get a single `Annotation` of `annotationType` from the supplied annotation: either the given annotation itself or a direct meta-annotation thereof.
`static <A extends Annotation>
A`
AnnotationUtils.`getAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType)`
Get a single `Annotation` of `annotationType` from the supplied `AnnotatedElement`, where the annotation is either present or meta-present on the `AnnotatedElement`.
`static <A extends Annotation>
A`
AnnotationUtils.`getAnnotation(Method method, Class<A> annotationType)`
Get a single `Annotation` of `annotationType` from the supplied `Method`, where the annotation is either present or meta-present on the method.
`static Annotation[]`
AnnotationUtils.`getAnnotations(AnnotatedElement annotatedElement)`
Deprecated.
as of 5.2 since it is superseded by the `MergedAnnotations` API
`static Annotation[]`
AnnotationUtils.`getAnnotations(Method method)`
Deprecated.
as of 5.2 since it is superseded by the `MergedAnnotations` API
`static Object`
AnnotationUtils.`getDefaultValue(Annotation annotation)`
Retrieve the default value of the `value` attribute of a single-element Annotation, given an annotation instance.
`static Object`
AnnotationUtils.`getDefaultValue(Annotation annotation, String attributeName)`
Retrieve the default value of a named attribute, given an annotation instance.
`static Object`
AnnotationUtils.`getDefaultValue(Class<? extends Annotation> annotationType)`
Retrieve the default value of the `value` attribute of a single-element Annotation, given the `annotation type`.
`static Object`
AnnotationUtils.`getDefaultValue(Class<? extends Annotation> annotationType, String attributeName)`
Retrieve the default value of a named attribute, given the `annotation type`.
`static <A extends Annotation>
A`
AnnotatedElementUtils.`getMergedAnnotation(AnnotatedElement element, Class<A> annotationType)`
Get the first annotation of the specified `annotationType` within the annotation hierarchy above the supplied `element`, merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy, and synthesize the result back into an annotation of the specified `annotationType`.
`static AnnotationAttributes`
AnnotatedElementUtils.`getMergedAnnotationAttributes(AnnotatedElement element, Class<? extends Annotation> annotationType)`
Get the first annotation of the specified `annotationType` within the annotation hierarchy above the supplied `element` and merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy.
`static AnnotationAttributes`
AnnotatedElementUtils.`getMergedAnnotationAttributes(AnnotatedElement element, String annotationName)`
Get the first annotation of the specified `annotationName` within the annotation hierarchy above the supplied `element` and merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy.
`static AnnotationAttributes`
AnnotatedElementUtils.`getMergedAnnotationAttributes(AnnotatedElement element, String annotationName, boolean classValuesAsString, boolean nestedAnnotationsAsMap)`
Get the first annotation of the specified `annotationName` within the annotation hierarchy above the supplied `element` and merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy.
`MergedAnnotation<?>`
MergedAnnotation.`getMetaSource()`
Get the source of the meta-annotation, or `null` if the annotation is not meta-present.
`<T extends Annotation>
T`
AnnotatedMethod.AnnotatedMethodParameter.`getMethodAnnotation(Class<T> annotationType)`
`<A extends Annotation>
A`
AnnotatedMethod.`getMethodAnnotation(Class<A> annotationType)`
Return a single annotation on the underlying method, traversing its super methods if no annotation can be found on the given method itself.
`static Integer`
OrderUtils.`getOrder(Class<?> type)`
Return the order on the specified `type`.
`static Integer`
OrderUtils.`getOrder(Class<?> type, Integer defaultOrder)`
Return the order on the specified `type`, or the specified default value if none can be found.
`static Integer`
OrderUtils.`getOrder(AnnotatedElement element)`
Return the order declared on the specified `element`.
`Integer`
AnnotationAwareOrderComparator.`getPriority(Object obj)`
This implementation retrieves an @`jakarta.annotation.Priority` value, allowing for additional semantics over the regular @`Order` annotation: typically, selecting one object over another in case of multiple matches but only one object to be returned.
`static Integer`
OrderUtils.`getPriority(Class<?> type)`
Return the value of the `jakarta.annotation.Priority` annotation declared on the specified type, or `null` if none.
`Object`
MergedAnnotation.`getSource()`
Get the source that ultimately declared the root annotation, or `null` if the source is not known.
`static Object`
AnnotationUtils.`getValue(Annotation annotation)`
Retrieve the value of the `value` attribute of a single-element Annotation, given an annotation instance.
`static Object`
AnnotationUtils.`getValue(Annotation annotation, String attributeName)`
Retrieve the value of a named attribute, given an annotation instance.
Method parameters in org.springframework.core.annotation with annotations of type Nullable
Modifier and Type
Method
Description
`boolean`
AnnotatedMethod.`equals(Object other)`
`boolean`
RepeatableContainers.`equals(Object other)`
`static <A extends Annotation>
A`
AnnotationUtils.`findAnnotation(Class<?> clazz, Class<A> annotationType)`
Find a single `Annotation` of `annotationType` on the supplied `Class`, traversing its interfaces, annotations, and superclasses if the annotation is not directly present on the given class itself.
`static <A extends Annotation>
A`
AnnotationUtils.`findAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType)`
Find a single `Annotation` of `annotationType` on the supplied `AnnotatedElement`.
`static <A extends Annotation>
A`
AnnotationUtils.`findAnnotation(Method method, Class<A> annotationType)`
Find a single `Annotation` of `annotationType` on the supplied `Method`, traversing its super methods (i.e.
`static Class<?>`
AnnotationUtils.`findAnnotationDeclaringClass(Class<? extends Annotation> annotationType, Class<?> clazz)`
Deprecated.
as of 5.2 since it is superseded by the `MergedAnnotations` API
`static Class<?>`
AnnotationUtils.`findAnnotationDeclaringClassForTypes(List<Class<? extends Annotation>> annotationTypes, Class<?> clazz)`
Deprecated.
as of 5.2 since it is superseded by the `MergedAnnotations` API
`static <A extends Annotation>
Set<A>`
AnnotatedElementUtils.`findMergedRepeatableAnnotations(AnnotatedElement element, Class<A> annotationType, Class<? extends Annotation> containerType)`
Find all repeatable annotations of the specified `annotationType` within the annotation hierarchy above the supplied `element`; and for each annotation found, merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy and synthesize the results back into an annotation of the specified `annotationType`.
`protected static Object`
AnnotatedMethod.`findProvidedArgument(MethodParameter parameter, Object... providedArgs)`
`static <A extends Annotation>
MergedAnnotation<A>`
MergedAnnotation.`from(Object source, A annotation)`
Create a new `MergedAnnotation` instance from the specified annotation.
`static AnnotationAttributes`
AnnotationAttributes.`fromMap(Map<String,Object> map)`
Return an `AnnotationAttributes` instance based on the given map.
`<A extends Annotation>
MergedAnnotation<A>`
MergedAnnotations.`get(Class<A> annotationType, Predicate<? super MergedAnnotation<A>> predicate)`
Get the nearest matching annotation or meta-annotation of the specified type, or `MergedAnnotation.missing()` if none is present.
`<A extends Annotation>
MergedAnnotation<A>`
MergedAnnotations.`get(Class<A> annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)`
Get a matching annotation or meta-annotation of the specified type, or `MergedAnnotation.missing()` if none is present.
`<A extends Annotation>
MergedAnnotation<A>`
MergedAnnotations.`get(Class<A> annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)`
Get a matching annotation or meta-annotation of the specified type, or `MergedAnnotation.missing()` if none is present.
`<A extends Annotation>
MergedAnnotation<A>`
MergedAnnotations.`get(String annotationType, Predicate<? super MergedAnnotation<A>> predicate)`
Get the nearest matching annotation or meta-annotation of the specified type, or `MergedAnnotation.missing()` if none is present.
`<A extends Annotation>
MergedAnnotation<A>`
MergedAnnotations.`get(String annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)`
Get a matching annotation or meta-annotation of the specified type, or `MergedAnnotation.missing()` if none is present.
`<A extends Annotation>
MergedAnnotation<A>`
MergedAnnotations.`get(String annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)`
Get a matching annotation or meta-annotation of the specified type, or `MergedAnnotation.missing()` if none is present.
`static AnnotationAttributes`
AnnotationUtils.`getAnnotationAttributes(AnnotatedElement annotatedElement, Annotation annotation)`
Retrieve the given annotation's attributes as an `AnnotationAttributes` map.
`static AnnotationAttributes`
AnnotationUtils.`getAnnotationAttributes(AnnotatedElement annotatedElement, Annotation annotation, boolean classValuesAsString, boolean nestedAnnotationsAsMap)`
Retrieve the given annotation's attributes as an `AnnotationAttributes` map.
`static <A extends Annotation>
Set<A>`
AnnotationUtils.`getDeclaredRepeatableAnnotations(AnnotatedElement annotatedElement, Class<A> annotationType, Class<? extends Annotation> containerAnnotationType)`
Deprecated.
as of 5.2 since it is superseded by the `MergedAnnotations` API
`static Object`
AnnotationUtils.`getDefaultValue(Annotation annotation, String attributeName)`
Retrieve the default value of a named attribute, given an annotation instance.
`static Object`
AnnotationUtils.`getDefaultValue(Annotation annotation, String attributeName)`
Retrieve the default value of a named attribute, given an annotation instance.
`static Object`
AnnotationUtils.`getDefaultValue(Class<? extends Annotation> annotationType, String attributeName)`
Retrieve the default value of a named attribute, given the `annotation type`.
`static Object`
AnnotationUtils.`getDefaultValue(Class<? extends Annotation> annotationType, String attributeName)`
Retrieve the default value of a named attribute, given the `annotation type`.
`static <A extends Annotation>
Set<A>`
AnnotatedElementUtils.`getMergedRepeatableAnnotations(AnnotatedElement element, Class<A> annotationType, Class<? extends Annotation> containerType)`
Get all repeatable annotations of the specified `annotationType` within the annotation hierarchy above the supplied `element`; and for each annotation found, merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy and synthesize the results back into an annotation of the specified `annotationType`.
`static Integer`
OrderUtils.`getOrder(Class<?> type, Integer defaultOrder)`
Return the order on the specified `type`, or the specified default value if none can be found.
`static <A extends Annotation>
Set<A>`
AnnotationUtils.`getRepeatableAnnotations(AnnotatedElement annotatedElement, Class<A> annotationType, Class<? extends Annotation> containerAnnotationType)`
Deprecated.
as of 5.2 since it is superseded by the `MergedAnnotations` API
`MethodParameter`
AnnotatedMethod.`getReturnValueType(Object returnValue)`
Return a `MethodParameter` for the actual return value type.
`static Object`
AnnotationUtils.`getValue(Annotation annotation, String attributeName)`
Retrieve the value of a named attribute, given an annotation instance.
`static Object`
AnnotationUtils.`getValue(Annotation annotation, String attributeName)`
Retrieve the value of a named attribute, given an annotation instance.
`static boolean`
AnnotationUtils.`isAnnotationMetaPresent(Class<? extends Annotation> annotationType, Class<? extends Annotation> metaAnnotationType)`
Deprecated.
as of 5.2 since it is superseded by the `MergedAnnotations` API
`static boolean`
AnnotationUtils.`isCandidateClass(Class<?> clazz, Class<? extends Annotation> annotationType)`
Determine whether the given class is a candidate for carrying the specified annotation (at type, method or field level).
`static boolean`
AnnotationUtils.`isInJavaLangAnnotationPackage(Annotation annotation)`
Determine if the supplied `Annotation` is defined in the core JDK `java.lang.annotation` package.
`static boolean`
AnnotationUtils.`isInJavaLangAnnotationPackage(String annotationType)`
Determine if the `Annotation` with the supplied name is defined in the core JDK `java.lang.annotation` package.
`static boolean`
AnnotationUtils.`isSynthesizedAnnotation(Annotation annotation)`
Determine if the supplied `Annotation` has been synthesized by Spring (i.e.
`static <A extends Annotation>
MergedAnnotation<A>`
MergedAnnotation.`of(Class<A> annotationType, Map<String,?> attributes)`
Create a new `MergedAnnotation` instance of the specified annotation type with attribute values supplied by a map.
`static <A extends Annotation>
MergedAnnotation<A>`
MergedAnnotation.`of(ClassLoader classLoader, Object source, Class<A> annotationType, Map<String,?> attributes)`
Create a new `MergedAnnotation` instance of the specified annotation type with attribute values supplied by a map.
`static <A extends Annotation>
MergedAnnotation<A>`
MergedAnnotation.`of(ClassLoader classLoader, Object source, Class<A> annotationType, Map<String,?> attributes)`
Create a new `MergedAnnotation` instance of the specified annotation type with attribute values supplied by a map.
`static <A extends Annotation>
MergedAnnotation<A>`
MergedAnnotation.`of(ClassLoader classLoader, Object source, Class<A> annotationType, Map<String,?> attributes)`
Create a new `MergedAnnotation` instance of the specified annotation type with attribute values supplied by a map.
`static <A extends Annotation>
MergedAnnotation<A>`
MergedAnnotation.`of(AnnotatedElement source, Class<A> annotationType, Map<String,?> attributes)`
Create a new `MergedAnnotation` instance of the specified annotation type with attribute values supplied by a map.
`static <A extends Annotation>
MergedAnnotation<A>`
MergedAnnotation.`of(AnnotatedElement source, Class<A> annotationType, Map<String,?> attributes)`
Create a new `MergedAnnotation` instance of the specified annotation type with attribute values supplied by a map.
`static RepeatableContainers`
RepeatableContainers.`of(Class<? extends Annotation> repeatable, Class<? extends Annotation> container)`
Create a `RepeatableContainers` instance that uses predefined repeatable and container types.
`static void`
AnnotationUtils.`postProcessAnnotationAttributes(Object annotatedElement, AnnotationAttributes attributes, boolean classValuesAsString)`
Post-process the supplied `AnnotationAttributes`, preserving nested annotations as `Annotation` instances.
`static void`
AnnotationUtils.`postProcessAnnotationAttributes(Object annotatedElement, AnnotationAttributes attributes, boolean classValuesAsString)`
Post-process the supplied `AnnotationAttributes`, preserving nested annotations as `Annotation` instances.
`static <A extends Annotation>
A`
AnnotationUtils.`synthesizeAnnotation(A annotation, AnnotatedElement annotatedElement)`
Synthesize an annotation from the supplied `annotation` by wrapping it in a dynamic proxy that transparently enforces attribute alias semantics for annotation attributes that are annotated with `@AliasFor`.
`static <A extends Annotation>
A`
AnnotationUtils.`synthesizeAnnotation(Map<String,Object> attributes, Class<A> annotationType, AnnotatedElement annotatedElement)`
Synthesize an annotation from the supplied map of annotation attributes by wrapping the map in a dynamic proxy that implements an annotation of the specified `annotationType` and transparently enforces attribute alias semantics for annotation attributes that are annotated with `@AliasFor`.
Constructor parameters in org.springframework.core.annotation with annotations of type Nullable
Modifier
Constructor
Description
``
`AnnotationAttributes(String annotationType, ClassLoader classLoader)`
Create a new, empty `AnnotationAttributes` instance for the specified `annotationType`.

## Uses of Nullable in org.springframework.core.codec

Methods in org.springframework.core.codec with annotations of type Nullable
Modifier and Type
Method
Description
`default T`
Decoder.`decode(DataBuffer buffer, ResolvableType targetType, MimeType mimeType, Map<String,Object> hints)`
Decode a data buffer to an Object of type T.
`protected T`
AbstractDataBufferDecoder.`decodeDataBuffer(DataBuffer buffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
Deprecated.
as of 5.2, please implement `Decoder.decode(DataBuffer, ResolvableType, MimeType, Map)` instead
Method parameters in org.springframework.core.codec with annotations of type Nullable
Modifier and Type
Method
Description
`boolean`
AbstractDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
`boolean`
ByteArrayDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
`boolean`
ByteBufferDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
`boolean`
CharBufferDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
`boolean`
DataBufferDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
`boolean`
Decoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
Whether the decoder supports the given target element type and the MIME type of the source stream.
`boolean`
Netty5BufferDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
`boolean`
NettyByteBufDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
`boolean`
ResourceDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
`boolean`
StringDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
`boolean`
AbstractEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
`boolean`
ByteArrayEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
`boolean`
ByteBufferEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
`boolean`
CharSequenceEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
`boolean`
DataBufferEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
`boolean`
Encoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
Whether the encoder supports the given source element type and the MIME type for the output stream.
`boolean`
Netty5BufferEncoder.`canEncode(ResolvableType type, MimeType mimeType)`
`boolean`
NettyByteBufEncoder.`canEncode(ResolvableType type, MimeType mimeType)`
`boolean`
ResourceEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
`boolean`
ResourceRegionEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
`final reactor.core.publisher.Flux<T>`
AbstractCharSequenceDecoder.`decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`final reactor.core.publisher.Flux<T>`
AbstractCharSequenceDecoder.`decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`final T`
AbstractCharSequenceDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`final T`
AbstractCharSequenceDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<T>`
AbstractDataBufferDecoder.`decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<T>`
AbstractDataBufferDecoder.`decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`byte[]`
ByteArrayDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`byte[]`
ByteArrayDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`ByteBuffer`
ByteBufferDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`ByteBuffer`
ByteBufferDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
DataBufferDecoder.`decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
DataBufferDecoder.`decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`DataBuffer`
DataBufferDecoder.`decode(DataBuffer buffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`DataBuffer`
DataBufferDecoder.`decode(DataBuffer buffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<T>`
Decoder.`decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
Decode a `DataBuffer` input stream into a Flux of `T`.
`reactor.core.publisher.Flux<T>`
Decoder.`decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
Decode a `DataBuffer` input stream into a Flux of `T`.
`default T`
Decoder.`decode(DataBuffer buffer, ResolvableType targetType, MimeType mimeType, Map<String,Object> hints)`
Decode a data buffer to an Object of type T.
`default T`
Decoder.`decode(DataBuffer buffer, ResolvableType targetType, MimeType mimeType, Map<String,Object> hints)`
Decode a data buffer to an Object of type T.
`io.netty5.buffer.Buffer`
Netty5BufferDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`io.netty5.buffer.Buffer`
Netty5BufferDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`io.netty.buffer.ByteBuf`
NettyByteBufDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`io.netty.buffer.ByteBuf`
NettyByteBufDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<Resource>`
ResourceDecoder.`decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<Resource>`
ResourceDecoder.`decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`Resource`
ResourceDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`Resource`
ResourceDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`protected T`
AbstractDataBufferDecoder.`decodeDataBuffer(DataBuffer buffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
Deprecated.
as of 5.2, please implement `Decoder.decode(DataBuffer, ResolvableType, MimeType, Map)` instead
`protected T`
AbstractDataBufferDecoder.`decodeDataBuffer(DataBuffer buffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
Deprecated.
as of 5.2, please implement `Decoder.decode(DataBuffer, ResolvableType, MimeType, Map)` instead
`reactor.core.publisher.Mono<T>`
AbstractDataBufferDecoder.`decodeToMono(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Mono<T>`
AbstractDataBufferDecoder.`decodeToMono(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Mono<T>`
AbstractDecoder.`decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Mono<T>`
AbstractDecoder.`decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Mono<T>`
Decoder.`decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
Decode a `DataBuffer` input stream into a Mono of `T`.
`reactor.core.publisher.Mono<T>`
Decoder.`decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
Decode a `DataBuffer` input stream into a Mono of `T`.
`final reactor.core.publisher.Flux<DataBuffer>`
AbstractSingleValueEncoder.`encode(Publisher<? extends T> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`final reactor.core.publisher.Flux<DataBuffer>`
AbstractSingleValueEncoder.`encode(Publisher<? extends T> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`protected abstract reactor.core.publisher.Flux<DataBuffer>`
AbstractSingleValueEncoder.`encode(T t, DataBufferFactory dataBufferFactory, ResolvableType type, MimeType mimeType, Map<String,Object> hints)`
Encode `T` to an output `DataBuffer` stream.
`protected abstract reactor.core.publisher.Flux<DataBuffer>`
AbstractSingleValueEncoder.`encode(T t, DataBufferFactory dataBufferFactory, ResolvableType type, MimeType mimeType, Map<String,Object> hints)`
Encode `T` to an output `DataBuffer` stream.
`reactor.core.publisher.Flux<DataBuffer>`
ByteArrayEncoder.`encode(Publisher<? extends byte[]> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
ByteArrayEncoder.`encode(Publisher<? extends byte[]> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
ByteBufferEncoder.`encode(Publisher<? extends ByteBuffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
ByteBufferEncoder.`encode(Publisher<? extends ByteBuffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
CharSequenceEncoder.`encode(Publisher<? extends CharSequence> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
CharSequenceEncoder.`encode(Publisher<? extends CharSequence> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
DataBufferEncoder.`encode(Publisher<? extends DataBuffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
DataBufferEncoder.`encode(Publisher<? extends DataBuffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
Encoder.`encode(Publisher<? extends T> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
Encode a stream of Objects of type `T` into a `DataBuffer` output stream.
`reactor.core.publisher.Flux<DataBuffer>`
Encoder.`encode(Publisher<? extends T> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
Encode a stream of Objects of type `T` into a `DataBuffer` output stream.
`reactor.core.publisher.Flux<DataBuffer>`
Netty5BufferEncoder.`encode(Publisher<? extends io.netty5.buffer.Buffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
Netty5BufferEncoder.`encode(Publisher<? extends io.netty5.buffer.Buffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
NettyByteBufEncoder.`encode(Publisher<? extends io.netty.buffer.ByteBuf> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
NettyByteBufEncoder.`encode(Publisher<? extends io.netty.buffer.ByteBuf> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`protected reactor.core.publisher.Flux<DataBuffer>`
ResourceEncoder.`encode(Resource resource, DataBufferFactory bufferFactory, ResolvableType type, MimeType mimeType, Map<String,Object> hints)`
`protected reactor.core.publisher.Flux<DataBuffer>`
ResourceEncoder.`encode(Resource resource, DataBufferFactory bufferFactory, ResolvableType type, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
ResourceRegionEncoder.`encode(Publisher<? extends ResourceRegion> input, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
ResourceRegionEncoder.`encode(Publisher<? extends ResourceRegion> input, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`DataBuffer`
ByteArrayEncoder.`encodeValue(byte[] bytes, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
`DataBuffer`
ByteArrayEncoder.`encodeValue(byte[] bytes, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
`DataBuffer`
ByteBufferEncoder.`encodeValue(ByteBuffer byteBuffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
`DataBuffer`
ByteBufferEncoder.`encodeValue(ByteBuffer byteBuffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
`DataBuffer`
CharSequenceEncoder.`encodeValue(CharSequence charSequence, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
`DataBuffer`
CharSequenceEncoder.`encodeValue(CharSequence charSequence, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
`DataBuffer`
DataBufferEncoder.`encodeValue(DataBuffer buffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
`DataBuffer`
DataBufferEncoder.`encodeValue(DataBuffer buffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
`default DataBuffer`
Encoder.`encodeValue(T value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
Encode an Object of type T to a data buffer.
`default DataBuffer`
Encoder.`encodeValue(T value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
Encode an Object of type T to a data buffer.
`DataBuffer`
Netty5BufferEncoder.`encodeValue(io.netty5.buffer.Buffer buffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
`DataBuffer`
Netty5BufferEncoder.`encodeValue(io.netty5.buffer.Buffer buffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
`DataBuffer`
NettyByteBufEncoder.`encodeValue(io.netty.buffer.ByteBuf byteBuf, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
`DataBuffer`
NettyByteBufEncoder.`encodeValue(io.netty.buffer.ByteBuf byteBuf, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
`static String`
Hints.`getLogPrefix(Map<String,Object> hints)`
Obtain the hint `Hints.LOG_PREFIX_HINT`, if present, or an empty String.
`static <T> T`
Hints.`getRequiredHint(Map<String,Object> hints, String hintName)`
Obtain the value for a required hint.
`static boolean`
Hints.`isLoggingSuppressed(Map<String,Object> hints)`
Whether to suppress logging based on the hint `Hints.SUPPRESS_LOGGING_HINT`.
`static Map<String,Object>`
Hints.`merge(Map<String,Object> hints, String hintName, Object hintValue)`
Merge a single hint into a map of hints, possibly creating and copying all hints into a new map, or otherwise if the map of hints is empty, creating a new single entry map.
`static Map<String,Object>`
Hints.`merge(Map<String,Object> hints1, Map<String,Object> hints2)`
Merge two maps of hints, creating and copying into a new map if both have values, or returning the non-empty map, or an empty map if both are empty.
`static Map<String,Object>`
Hints.`merge(Map<String,Object> hints1, Map<String,Object> hints2)`
Merge two maps of hints, creating and copying into a new map if both have values, or returning the non-empty map, or an empty map if both are empty.
`static void`
Hints.`touchDataBuffer(DataBuffer buffer, Map<String,Object> hints, org.apache.commons.logging.Log logger)`
If the hints contain a `Hints.LOG_PREFIX_HINT` and the given logger has DEBUG level enabled, apply the log prefix as a hint to the given buffer via `DataBufferUtils.touch(DataBuffer, Object)`.
Constructor parameters in org.springframework.core.codec with annotations of type Nullable
Modifier
Constructor
Description
``
`CodecException(String msg)`
Create a new CodecException.
``
`CodecException(String msg, Throwable cause)`
Create a new CodecException.
``
`CodecException(String msg, Throwable cause)`
Create a new CodecException.
``
`DecodingException(String msg)`
Create a new DecodingException.
``
`DecodingException(String msg, Throwable cause)`
Create a new DecodingException.
``
`DecodingException(String msg, Throwable cause)`
Create a new DecodingException.
``
`EncodingException(String msg, Throwable cause)`
Create a new EncodingException.

## Uses of Nullable in org.springframework.core.convert

Methods in org.springframework.core.convert with annotations of type Nullable
Modifier and Type
Method
Description
`static TypeDescriptor`
TypeDescriptor.`array(TypeDescriptor elementTypeDescriptor)`
Create a new type descriptor as an array of the specified type.
`<T> T`
ConversionService.`convert(Object source, Class<T> targetType)`
Convert the given `source` to the specified `targetType`.
`default Object`
ConversionService.`convert(Object source, TypeDescriptor targetType)`
Convert the given `source` to the specified `targetType`.
`Object`
ConversionService.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)`
Convert the given `source` to the specified `targetType`.
`TypeDescriptor`
TypeDescriptor.`elementTypeDescriptor(Object element)`
If this type is a `Collection` or an array, creates an element TypeDescriptor from the provided collection or array element.
`static TypeDescriptor`
TypeDescriptor.`forObject(Object source)`
Create a new type descriptor for an object.
`<T extends Annotation>
T`
TypeDescriptor.`getAnnotation(Class<T> annotationType)`
Obtain the annotation of the specified `annotationType` that is on this type descriptor.
`TypeDescriptor`
TypeDescriptor.`getElementTypeDescriptor()`
If this type is an array, returns the array's component type.
`TypeDescriptor`
TypeDescriptor.`getMapKeyTypeDescriptor()`
If this type is a `Map` and its key type is parameterized, returns the map's key type.
`TypeDescriptor`
TypeDescriptor.`getMapKeyTypeDescriptor(Object mapKey)`
If this type is a `Map`, creates a mapKey `TypeDescriptor` from the provided map key.
`TypeDescriptor`
TypeDescriptor.`getMapValueTypeDescriptor()`
If this type is a `Map` and its value type is parameterized, returns the map's value type.
`TypeDescriptor`
TypeDescriptor.`getMapValueTypeDescriptor(Object mapValue)`
If this type is a `Map`, creates a mapValue `TypeDescriptor` from the provided map value.
`Method`
Property.`getReadMethod()`
The property getter method: for example, `getFoo()`.
`TypeDescriptor`
ConversionFailedException.`getSourceType()`
Return the source type we tried to convert the value from.
`TypeDescriptor`
ConverterNotFoundException.`getSourceType()`
Return the source type that was requested to convert from.
`Object`
ConversionFailedException.`getValue()`
Return the offending value.
`Method`
Property.`getWriteMethod()`
The property setter method: for example, `setFoo(String)`.
`TypeDescriptor`
TypeDescriptor.`nested(int nestingLevel)`
Create a type descriptor for a nested type declared within this descriptor.
`static TypeDescriptor`
TypeDescriptor.`nested(Field field, int nestingLevel)`
Create a type descriptor for a nested type declared within the field.
`static TypeDescriptor`
TypeDescriptor.`nested(Property property, int nestingLevel)`
Create a type descriptor for a nested type declared within the property.
`static TypeDescriptor`
TypeDescriptor.`nested(MethodParameter methodParameter, int nestingLevel)`
Create a type descriptor for a nested type declared within the method parameter.
`TypeDescriptor`
TypeDescriptor.`upcast(Class<?> superType)`
Cast this `TypeDescriptor` to a superclass or implemented interface preserving annotations and nested type context.
Method parameters in org.springframework.core.convert with annotations of type Nullable
Modifier and Type
Method
Description
`static TypeDescriptor`
TypeDescriptor.`array(TypeDescriptor elementTypeDescriptor)`
Create a new type descriptor as an array of the specified type.
`boolean`
ConversionService.`canConvert(Class<?> sourceType, Class<?> targetType)`
Return `true` if objects of `sourceType` can be converted to the `targetType`.
`boolean`
ConversionService.`canConvert(TypeDescriptor sourceType, TypeDescriptor targetType)`
Return `true` if objects of `sourceType` can be converted to the `targetType`.
`static TypeDescriptor`
TypeDescriptor.`collection(Class<?> collectionType, TypeDescriptor elementTypeDescriptor)`
Create a new type descriptor from a `Collection` type.
`<T> T`
ConversionService.`convert(Object source, Class<T> targetType)`
Convert the given `source` to the specified `targetType`.
`default Object`
ConversionService.`convert(Object source, TypeDescriptor targetType)`
Convert the given `source` to the specified `targetType`.
`Object`
ConversionService.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)`
Convert the given `source` to the specified `targetType`.
`Object`
ConversionService.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)`
Convert the given `source` to the specified `targetType`.
`boolean`
Property.`equals(Object other)`
`boolean`
TypeDescriptor.`equals(Object other)`
`static TypeDescriptor`
TypeDescriptor.`forObject(Object source)`
Create a new type descriptor for an object.
`TypeDescriptor`
TypeDescriptor.`getMapValueTypeDescriptor(Object mapValue)`
If this type is a `Map`, creates a mapValue `TypeDescriptor` from the provided map value.
`static TypeDescriptor`
TypeDescriptor.`map(Class<?> mapType, TypeDescriptor keyTypeDescriptor, TypeDescriptor valueTypeDescriptor)`
Create a new type descriptor from a `Map` type.
`static TypeDescriptor`
TypeDescriptor.`map(Class<?> mapType, TypeDescriptor keyTypeDescriptor, TypeDescriptor valueTypeDescriptor)`
Create a new type descriptor from a `Map` type.
`TypeDescriptor`
TypeDescriptor.`narrow(Object value)`
Narrows this `TypeDescriptor` by setting its type to the class of the provided value.
`TypeDescriptor`
TypeDescriptor.`upcast(Class<?> superType)`
Cast this `TypeDescriptor` to a superclass or implemented interface preserving annotations and nested type context.
`static TypeDescriptor`
TypeDescriptor.`valueOf(Class<?> type)`
Create a new type descriptor from the given type.
Constructor parameters in org.springframework.core.convert with annotations of type Nullable
Modifier
Constructor
Description
``
`ConversionFailedException(TypeDescriptor sourceType, TypeDescriptor targetType, Object value, Throwable cause)`
Create a new conversion exception.
``
`ConversionFailedException(TypeDescriptor sourceType, TypeDescriptor targetType, Object value, Throwable cause)`
Create a new conversion exception.
``
`ConverterNotFoundException(TypeDescriptor sourceType, TypeDescriptor targetType)`
Create a new conversion executor not found exception.
``
`Property(Class<?> objectType, Method readMethod, Method writeMethod)`
``
`Property(Class<?> objectType, Method readMethod, Method writeMethod)`
``
`Property(Class<?> objectType, Method readMethod, Method writeMethod, String name)`
``
`Property(Class<?> objectType, Method readMethod, Method writeMethod, String name)`
``
`Property(Class<?> objectType, Method readMethod, Method writeMethod, String name)`
``
`TypeDescriptor(ResolvableType resolvableType, Class<?> type, Annotation[] annotations)`
Create a new type descriptor from a `ResolvableType`.
``
`TypeDescriptor(ResolvableType resolvableType, Class<?> type, Annotation[] annotations)`
Create a new type descriptor from a `ResolvableType`.

## Uses of Nullable in org.springframework.core.convert.converter

Methods in org.springframework.core.convert.converter with annotations of type Nullable
Modifier and Type
Method
Description
`T`
Converter.`convert(S source)`
Convert the source object of type `S` to target type `T`.
`Object`
GenericConverter.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)`
Convert the source object to the targetType described by the `TypeDescriptor`.
`Set<GenericConverter.ConvertiblePair>`
GenericConverter.`getConvertibleTypes()`
Return the source and target types that this converter can convert between.
Method parameters in org.springframework.core.convert.converter with annotations of type Nullable
Modifier and Type
Method
Description
`Object`
GenericConverter.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)`
Convert the source object to the targetType described by the `TypeDescriptor`.
`boolean`
GenericConverter.ConvertiblePair.`equals(Object other)`

## Uses of Nullable in org.springframework.core.convert.support

Methods in org.springframework.core.convert.support with annotations of type Nullable
Modifier and Type
Method
Description
`<T> T`
GenericConversionService.`convert(Object source, Class<T> targetType)`
`Object`
GenericConversionService.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)`
`protected Object`
GenericConversionService.`convertNullSource(TypeDescriptor sourceType, TypeDescriptor targetType)`
Template method to convert a `null` source.
`String`
ConvertingPropertyEditorAdapter.`getAsText()`
`protected GenericConverter`
GenericConversionService.`getConverter(TypeDescriptor sourceType, TypeDescriptor targetType)`
Hook method to look up the converter for a given sourceType/targetType pair.
`protected GenericConverter`
GenericConversionService.`getDefaultConverter(TypeDescriptor sourceType, TypeDescriptor targetType)`
Return the default converter if no converter is found for the given sourceType/targetType pair.
Method parameters in org.springframework.core.convert.support with annotations of type Nullable
Modifier and Type
Method
Description
`boolean`
GenericConversionService.`canBypassConvert(TypeDescriptor sourceType, TypeDescriptor targetType)`
Return whether conversion between the source type and the target type can be bypassed.
`boolean`
GenericConversionService.`canConvert(Class<?> sourceType, Class<?> targetType)`
`boolean`
GenericConversionService.`canConvert(TypeDescriptor sourceType, TypeDescriptor targetType)`
`<T> T`
GenericConversionService.`convert(Object source, Class<T> targetType)`
`Object`
GenericConversionService.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)`
`Object`
GenericConversionService.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)`
`protected Object`
GenericConversionService.`convertNullSource(TypeDescriptor sourceType, TypeDescriptor targetType)`
Template method to convert a `null` source.
`static void`
ConversionServiceFactory.`registerConverters(Set<?> converters, ConverterRegistry registry)`
Register the given Converter objects with the given target ConverterRegistry.
`void`
ConvertingPropertyEditorAdapter.`setAsText(String text)`

## Uses of Nullable in org.springframework.core.env

Methods in org.springframework.core.env with annotations of type Nullable
Modifier and Type
Method
Description
`protected <T> T`
AbstractPropertyResolver.`convertValueIfNecessary(Object value, Class<T> targetType)`
Convert the given value to the specified target type, if necessary.
`protected String`
AbstractEnvironment.`doGetActiveProfilesProperty()`
Return the property value for the active profiles.
`protected String`
AbstractEnvironment.`doGetDefaultProfilesProperty()`
Return the property value for the default profiles.
`PropertySource<?>`
MutablePropertySources.`get(String name)`
`PropertySource<?>`
PropertySources.`get(String name)`
Return the property source with the given name, `null` if not found.
`static Character`
AbstractPropertyResolver.`getDefaultEscapeCharacter()`
Get the default escape character to use when parsing strings for property placeholder resolution.
`protected abstract List<String>`
CommandLinePropertySource.`getOptionValues(String name)`
Return the collection of values associated with the command line option having the given name.
`List<String>`
JOptCommandLinePropertySource.`getOptionValues(String name)`
Deprecated.
`protected List<String>`
SimpleCommandLinePropertySource.`getOptionValues(String name)`
`String`
AbstractEnvironment.`getProperty(String key)`
`<T> T`
AbstractEnvironment.`getProperty(String key, Class<T> targetType)`
`String`
AbstractPropertyResolver.`getProperty(String key)`
`final String`
CommandLinePropertySource.`getProperty(String name)`
This implementation first checks to see if the name specified is the special "non-option arguments" property, and if so delegates to the abstract `CommandLinePropertySource.getNonOptionArgs()` method.
`Object`
CompositePropertySource.`getProperty(String name)`
`Object`
MapPropertySource.`getProperty(String name)`
`String`
PropertyResolver.`getProperty(String key)`
Resolve the property value associated with the given key, or `null` if the key cannot be resolved.
`<T> T`
PropertyResolver.`getProperty(String key, Class<T> targetType)`
Resolve the property value associated with the given key, or `null` if the key cannot be resolved.
`abstract Object`
PropertySource.`getProperty(String name)`
Return the value associated with the given name, or `null` if not found.
`String`
PropertySource.StubPropertySource.`getProperty(String name)`
Always returns `null`.
`String`
PropertySourcesPropertyResolver.`getProperty(String key)`
`<T> T`
PropertySourcesPropertyResolver.`getProperty(String key, Class<T> targetValueType)`
`protected <T> T`
PropertySourcesPropertyResolver.`getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders)`
`Object`
SystemEnvironmentPropertySource.`getProperty(String name)`
This implementation returns `true` if a property with the given name or any underscore/uppercase variant thereof exists in this property source.
`protected abstract String`
AbstractPropertyResolver.`getPropertyAsRawString(String key)`
Retrieve the specified property as a raw String, i.e.
`protected String`
PropertySourcesPropertyResolver.`getPropertyAsRawString(String key)`
`PropertySource<?>`
MutablePropertySources.`remove(String name)`
Remove and return the property source with the given name, `null` if not found.
Method parameters in org.springframework.core.env with annotations of type Nullable
Modifier and Type
Method
Description
`protected <T> T`
AbstractPropertyResolver.`convertValueIfNecessary(Object value, Class<T> targetType)`
Convert the given value to the specified target type, if necessary.
`boolean`
PropertySource.`equals(Object other)`
This `PropertySource` object is equal to the given object if: they are the same instance the `name` properties for both objects are equal
`void`
AbstractEnvironment.`setEscapeCharacter(Character escapeCharacter)`
`void`
AbstractPropertyResolver.`setEscapeCharacter(Character escapeCharacter)`
Set the escape character to use to ignore the placeholder prefix and the value separator, or `null` if no escaping should take place.
`void`
ConfigurablePropertyResolver.`setEscapeCharacter(Character escapeCharacter)`
Set the escape character to use to ignore the placeholder prefix and the value separator, or `null` if no escaping should take place.
`void`
AbstractEnvironment.`setValueSeparator(String valueSeparator)`
`void`
AbstractPropertyResolver.`setValueSeparator(String valueSeparator)`
Set the separating character to be honored between placeholders replaced by this resolver and their associated default values, or `null` if no such special character should be processed as a value separator.
`void`
ConfigurablePropertyResolver.`setValueSeparator(String valueSeparator)`
Set the separating character to be honored between placeholders replaced by this resolver and their associated default values, or `null` if no such special character should be processed as a value separator.
Constructor parameters in org.springframework.core.env with annotations of type Nullable
Modifier
Constructor
Description
``
`PropertySourcesPropertyResolver(PropertySources propertySources)`
Create a new resolver against the given property sources.

## Uses of Nullable in org.springframework.core.io

Methods in org.springframework.core.io with annotations of type Nullable
Modifier and Type
Method
Description
`protected static String`
VfsUtils.`doGetPath(Object resource)`
`protected static Object`
VfsUtils.`doGetVisitorAttributes()`
`String`
ResourceEditor.`getAsText()`
`final ClassLoader`
ClassPathResource.`getClassLoader()`
Return the `ClassLoader` that this resource will be obtained from.
`ClassLoader`
DefaultResourceLoader.`getClassLoader()`
Return the ClassLoader to load class path resources with.
`ClassLoader`
ResourceLoader.`getClassLoader()`
Expose the `ClassLoader` used by this `ResourceLoader`.
`String`
AbstractResource.`getFilename()`
This implementation always returns `null`, assuming that this resource type does not have a filename.
`String`
ClassPathResource.`getFilename()`
This implementation returns the name of the file that this class path resource refers to.
`String`
ModuleResource.`getFilename()`
`String`
Resource.`getFilename()`
Determine the filename for this resource — typically the last part of the path — for example, `"myfile.txt"`.
`String`
UrlResource.`getFilename()`
This implementation returns the URL-decoded name of the file that this URL refers to.
`Resource`
ProtocolResolver.`resolve(String location, ResourceLoader resourceLoader)`
Resolve the given location against the given resource loader if this implementation's protocol matches.
`protected URL`
ClassPathResource.`resolveURL()`
Resolves a `URL` for the underlying class path resource.
Method parameters in org.springframework.core.io with annotations of type Nullable
Modifier and Type
Method
Description
`boolean`
AbstractResource.`equals(Object other)`
This implementation compares description strings.
`boolean`
ByteArrayResource.`equals(Object other)`
This implementation compares the underlying byte array.
`boolean`
ClassPathResource.`equals(Object other)`
This implementation compares the underlying class path locations and associated class loaders.
`boolean`
DescriptiveResource.`equals(Object other)`
This implementation compares the underlying description String.
`boolean`
FileSystemResource.`equals(Object other)`
This implementation compares the underlying file paths.
`boolean`
InputStreamResource.`equals(Object other)`
This implementation compares the underlying InputStream.
`boolean`
ModuleResource.`equals(Object obj)`
`boolean`
PathResource.`equals(Object other)`
This implementation compares the underlying `Path` references.
`boolean`
UrlResource.`equals(Object other)`
This implementation compares the underlying URL references.
`boolean`
VfsResource.`equals(Object other)`
`protected static Object`
VfsUtils.`invokeVfsMethod(Method method, Object target, Object... args)`
`void`
DefaultResourceLoader.`setClassLoader(ClassLoader classLoader)`
Specify the ClassLoader to load class path resources with, or `null` for using the thread context class loader at the time of actual resource access.
Constructor parameters in org.springframework.core.io with annotations of type Nullable
Modifier
Constructor
Description
``
`ByteArrayResource(byte[] byteArray, String description)`
Create a new `ByteArrayResource` with a description.
``
`ClassPathContextResource(String path, ClassLoader classLoader)`
``
`ClassPathResource(String path, Class<?> clazz)`
Create a new `ClassPathResource` for `Class` usage.
``
`ClassPathResource(String path, ClassLoader classLoader)`
Create a new `ClassPathResource` for `ClassLoader` usage.
``
`DefaultResourceLoader(ClassLoader classLoader)`
Create a new DefaultResourceLoader.
``
`DescriptiveResource(String description)`
Create a new DescriptiveResource.
``
`InputStreamResource(InputStream inputStream, String description)`
Create a new `InputStreamResource` for an existing `InputStream`.
``
`InputStreamResource(InputStreamSource inputStreamSource, String description)`
Create a new `InputStreamResource` with a lazy `InputStream` for single use.
``
`ResourceEditor(ResourceLoader resourceLoader, PropertyResolver propertyResolver)`
Create a new instance of the `ResourceEditor` class using the given `ResourceLoader` and `PropertyResolver`.
``
`ResourceEditor(ResourceLoader resourceLoader, PropertyResolver propertyResolver, boolean ignoreUnresolvablePlaceholders)`
Create a new instance of the `ResourceEditor` class using the given `ResourceLoader`.
``
`UrlResource(String protocol, String location, String fragment)`
Create a new `UrlResource` based on a URI specification.

## Uses of Nullable in org.springframework.core.io.buffer

Method parameters in org.springframework.core.io.buffer with annotations of type Nullable
Modifier and Type
Method
Description
`boolean`
DefaultDataBuffer.`equals(Object other)`
`boolean`
Netty5DataBuffer.`equals(Object other)`
`boolean`
NettyDataBuffer.`equals(Object other)`
`static boolean`
DataBufferUtils.`release(DataBuffer dataBuffer)`
Release the given data buffer.

## Uses of Nullable in org.springframework.core.io.support

Fields in org.springframework.core.io.support with annotations of type Nullable
Modifier and Type
Field
Description
`protected Properties[]`
PropertiesLoaderSupport.`localProperties`
Methods in org.springframework.core.io.support with annotations of type Nullable
Modifier and Type
Method
Description
`String`
PropertySourceDescriptor.`encoding()`
Returns the value of the `encoding` record component.
`final Charset`
EncodedResource.`getCharset()`
Return the `Charset` to use for reading from the resource, or `null` if none specified.
`ClassLoader`
PathMatchingResourcePatternResolver.`getClassLoader()`
`final String`
EncodedResource.`getEncoding()`
Return the encoding to use for reading from the resource, or `null` if none specified.
`protected <T> T`
SpringFactoriesLoader.`instantiateFactory(String implementationName, Class<T> type, SpringFactoriesLoader.ArgumentResolver argumentResolver, SpringFactoriesLoader.FailureHandler failureHandler)`
`String`
PropertySourceDescriptor.`name()`
Returns the value of the `name` record component.
`Class<? extends PropertySourceFactory>`
PropertySourceDescriptor.`propertySourceFactory()`
Returns the value of the `propertySourceFactory` record component.
`<T> T`
SpringFactoriesLoader.ArgumentResolver.`resolve(Class<T> type)`
Resolve the given argument if possible.
Method parameters in org.springframework.core.io.support with annotations of type Nullable
Modifier and Type
Method
Description
`protected void`
PathMatchingResourcePatternResolver.`addAllClassLoaderJarRoots(ClassLoader classLoader, Set<Resource> result)`
Search all `URLClassLoader` URLs for jar file references and add each to the given set of resources in the form of a pointer to the root of the jar file content.
`PropertySource<?>`
DefaultPropertySourceFactory.`createPropertySource(String name, EncodedResource resource)`
`PropertySource<?>`
PropertySourceFactory.`createPropertySource(String name, EncodedResource resource)`
Create a `PropertySource` that wraps the given resource.
`boolean`
EncodedResource.`equals(Object other)`
`Resource`
LocalizedResourceHelper.`findLocalizedResource(String name, String extension, Locale locale)`
Find the most specific localized resource for the given name, extension and locale:
`static SpringFactoriesLoader`
SpringFactoriesLoader.`forDefaultResourceLocation(ClassLoader classLoader)`
Create a `SpringFactoriesLoader` instance that will load and instantiate the factory implementations from "META-INF/spring.factories", using the given class loader.
`static SpringFactoriesLoader`
SpringFactoriesLoader.`forResourceLocation(String resourceLocation, ClassLoader classLoader)`
Create a `SpringFactoriesLoader` instance that will load and instantiate the factory implementations from the given location, using the given class loader.
`static ResourcePatternResolver`
ResourcePatternUtils.`getResourcePatternResolver(ResourceLoader resourceLoader)`
Return a default `ResourcePatternResolver` for the given `ResourceLoader`.
`protected <T> T`
SpringFactoriesLoader.`instantiateFactory(String implementationName, Class<T> type, SpringFactoriesLoader.ArgumentResolver argumentResolver, SpringFactoriesLoader.FailureHandler failureHandler)`
`static boolean`
ResourcePatternUtils.`isUrl(String resourceLocation)`
Return whether the given resource location is a URL: either a special "classpath" or "classpath*" pseudo URL or a standard URL.
`<T> List<T>`
SpringFactoriesLoader.`load(Class<T> factoryType, SpringFactoriesLoader.ArgumentResolver argumentResolver)`
Load and instantiate the factory implementations of the given type from "META-INF/spring.factories", using the configured class loader and the given argument resolver.
`<T> List<T>`
SpringFactoriesLoader.`load(Class<T> factoryType, SpringFactoriesLoader.ArgumentResolver argumentResolver, SpringFactoriesLoader.FailureHandler failureHandler)`
Load and instantiate the factory implementations of the given type from "META-INF/spring.factories", using the configured class loader, the given argument resolver, and custom failure handling provided by the given failure handler.
`<T> List<T>`
SpringFactoriesLoader.`load(Class<T> factoryType, SpringFactoriesLoader.ArgumentResolver argumentResolver, SpringFactoriesLoader.FailureHandler failureHandler)`
Load and instantiate the factory implementations of the given type from "META-INF/spring.factories", using the configured class loader, the given argument resolver, and custom failure handling provided by the given failure handler.
`<T> List<T>`
SpringFactoriesLoader.`load(Class<T> factoryType, SpringFactoriesLoader.FailureHandler failureHandler)`
Load and instantiate the factory implementations of the given type from "META-INF/spring.factories", using the configured class loader with custom failure handling provided by the given failure handler.
`static Properties`
PropertiesLoaderUtils.`loadAllProperties(String resourceName, ClassLoader classLoader)`
Load all properties from the specified class path resource (in ISO-8859-1 encoding), using the given class loader.
`static <T> List<T>`
SpringFactoriesLoader.`loadFactories(Class<T> factoryType, ClassLoader classLoader)`
Load and instantiate the factory implementations of the given type from "META-INF/spring.factories", using the given class loader.
`static List<String>`
SpringFactoriesLoader.`loadFactoryNames(Class<?> factoryType, ClassLoader classLoader)`
Deprecated.
as of 6.0 in favor of `SpringFactoriesLoader.load(Class, ArgumentResolver, FailureHandler)`
`void`
PropertiesLoaderSupport.`setPropertiesPersister(PropertiesPersister propertiesPersister)`
Set the PropertiesPersister to use for parsing properties files.
`void`
LocalizedResourceHelper.`setSeparator(String separator)`
Set the separator to use in-between file name parts.
Constructor parameters in org.springframework.core.io.support with annotations of type Nullable
Modifier
Constructor
Description
``
`EncodedResource(Resource resource, String encoding)`
Create a new `EncodedResource` for the given `Resource`, using the specified `encoding`.
``
`EncodedResource(Resource resource, Charset charset)`
Create a new `EncodedResource` for the given `Resource`, using the specified `Charset`.
``
`PathMatchingResourcePatternResolver(ClassLoader classLoader)`
Create a `PathMatchingResourcePatternResolver` with a `DefaultResourceLoader` and the supplied `ClassLoader`.
``
`PropertySourceDescriptor(List<String> locations, boolean ignoreResourceNotFound, String name, Class<? extends PropertySourceFactory> propertySourceFactory, String encoding)`
Creates an instance of a `PropertySourceDescriptor` record class.
``
`PropertySourceDescriptor(List<String> locations, boolean ignoreResourceNotFound, String name, Class<? extends PropertySourceFactory> propertySourceFactory, String encoding)`
Creates an instance of a `PropertySourceDescriptor` record class.
``
`PropertySourceDescriptor(List<String> locations, boolean ignoreResourceNotFound, String name, Class<? extends PropertySourceFactory> propertySourceFactory, String encoding)`
Creates an instance of a `PropertySourceDescriptor` record class.
``
`ResourceArrayPropertyEditor(ResourcePatternResolver resourcePatternResolver, PropertyResolver propertyResolver)`
Create a new ResourceArrayPropertyEditor with the given `ResourcePatternResolver` and `PropertyResolver` (typically an `Environment`).
``
`ResourceArrayPropertyEditor(ResourcePatternResolver resourcePatternResolver, PropertyResolver propertyResolver, boolean ignoreUnresolvablePlaceholders)`
Create a new ResourceArrayPropertyEditor with the given `ResourcePatternResolver` and `PropertyResolver` (typically an `Environment`).
`protected`
`SpringFactoriesLoader(ClassLoader classLoader, Map<String,List<String>> factories)`
Create a new `SpringFactoriesLoader` instance.

## Uses of Nullable in org.springframework.core.log

Method parameters in org.springframework.core.log with annotations of type Nullable
Modifier and Type
Method
Description
`static LogMessage`
LogMessage.`format(String format, Object arg1)`
Build a lazily formatted message from the given format string and argument.
`static LogMessage`
LogMessage.`format(String format, Object... args)`
Build a lazily formatted message from the given format string and varargs.
`static LogMessage`
LogMessage.`format(String format, Object arg1, Object arg2)`
Build a lazily formatted message from the given format string and arguments.
`static LogMessage`
LogMessage.`format(String format, Object arg1, Object arg2)`
Build a lazily formatted message from the given format string and arguments.
`static LogMessage`
LogMessage.`format(String format, Object arg1, Object arg2, Object arg3)`
Build a lazily formatted message from the given format string and arguments.
`static LogMessage`
LogMessage.`format(String format, Object arg1, Object arg2, Object arg3)`
Build a lazily formatted message from the given format string and arguments.
`static LogMessage`
LogMessage.`format(String format, Object arg1, Object arg2, Object arg3)`
Build a lazily formatted message from the given format string and arguments.
`static LogMessage`
LogMessage.`format(String format, Object arg1, Object arg2, Object arg3, Object arg4)`
Build a lazily formatted message from the given format string and arguments.
`static LogMessage`
LogMessage.`format(String format, Object arg1, Object arg2, Object arg3, Object arg4)`
Build a lazily formatted message from the given format string and arguments.
`static LogMessage`
LogMessage.`format(String format, Object arg1, Object arg2, Object arg3, Object arg4)`
Build a lazily formatted message from the given format string and arguments.
`static LogMessage`
LogMessage.`format(String format, Object arg1, Object arg2, Object arg3, Object arg4)`
Build a lazily formatted message from the given format string and arguments.
`static String`
LogFormatUtils.`formatValue(Object value, boolean limitLength)`
Convenience variant of `LogFormatUtils.formatValue(Object, int, boolean)` that limits the length of a log message to 100 characters and also replaces newline and control characters if `limitLength` is set to "true".
`static String`
LogFormatUtils.`formatValue(Object value, int maxLength, boolean replaceNewlinesAndControlCharacters)`
Format the given value via `toString()`, quoting it if it is a `CharSequence`, truncating at the specified `maxLength`, and compacting it into a single line when `replaceNewLines` is set.

## Uses of Nullable in org.springframework.core.metrics

Methods in org.springframework.core.metrics with annotations of type Nullable
Modifier and Type
Method
Description
`Long`
StartupStep.`getParentId()`
Return, if available, the id of the parent step.

## Uses of Nullable in org.springframework.core.serializer

Constructor parameters in org.springframework.core.serializer with annotations of type Nullable
Modifier
Constructor
Description
``
`DefaultDeserializer(ClassLoader classLoader)`
Create a `DefaultDeserializer` for using an `ObjectInputStream` with the given `ClassLoader`.

## Uses of Nullable in org.springframework.core.serializer.support

Constructor parameters in org.springframework.core.serializer.support with annotations of type Nullable
Modifier
Constructor
Description
``
`DeserializingConverter(ClassLoader classLoader)`
Create a `DeserializingConverter` for using an `ObjectInputStream` with the given `ClassLoader`.

## Uses of Nullable in org.springframework.core.style

Method parameters in org.springframework.core.style with annotations of type Nullable
Modifier and Type
Method
Description
`ToStringCreator`
ToStringCreator.`append(String fieldName, Object value)`
Append a field value.
`String`
DefaultValueStyler.`style(Object value)`
`String`
ValueStyler.`style(Object value)`
Style the given value, returning a String representation.
`void`
DefaultToStringStyler.`styleField(StringBuilder buffer, String fieldName, Object value)`
`void`
ToStringStyler.`styleField(StringBuilder buffer, String fieldName, Object value)`
Style a field value as a string.
`void`
DefaultToStringStyler.`styleValue(StringBuilder buffer, Object value)`
Constructor parameters in org.springframework.core.style with annotations of type Nullable
Modifier
Constructor
Description
``
`ToStringCreator(Object obj, ToStringStyler styler)`
Create a ToStringCreator for the given object, using the provided style.
``
`ToStringCreator(Object obj, ValueStyler styler)`
Create a ToStringCreator for the given object, using the provided style.

## Uses of Nullable in org.springframework.core.task

Methods in org.springframework.core.task with annotations of type Nullable
Modifier and Type
Method
Description
`final ThreadFactory`
SimpleAsyncTaskExecutor.`getThreadFactory()`
Return the external factory to use for creating new Threads, if any.
Method parameters in org.springframework.core.task with annotations of type Nullable
Modifier and Type
Method
Description
`void`
SimpleAsyncTaskExecutor.`setThreadFactory(ThreadFactory threadFactory)`
Specify an external factory to use for creating new Threads, instead of relying on the local properties of this executor.

## Uses of Nullable in org.springframework.core.task.support

Method parameters in org.springframework.core.task.support with annotations of type Nullable
Modifier and Type
Method
Description
`protected void`
TaskExecutorAdapter.`doExecute(Executor concurrentExecutor, TaskDecorator taskDecorator, Runnable runnable)`
Actually execute the given `Runnable` (which may be a user-supplied task or a wrapper around a user-supplied task) with the given executor.

## Uses of Nullable in org.springframework.core.type

Methods in org.springframework.core.type with annotations of type Nullable
Modifier and Type
Method
Description
`default MultiValueMap<String,Object>`
AnnotatedTypeMetadata.`getAllAnnotationAttributes(String annotationName)`
Retrieve all attributes of all annotations of the given type, if any (i.e.
`default MultiValueMap<String,Object>`
AnnotatedTypeMetadata.`getAllAnnotationAttributes(String annotationName, boolean classValuesAsString)`
Retrieve all attributes of all annotations of the given type, if any (i.e.
`MultiValueMap<String,Object>`
StandardAnnotationMetadata.`getAllAnnotationAttributes(String annotationName, boolean classValuesAsString)`
`MultiValueMap<String,Object>`
StandardMethodMetadata.`getAllAnnotationAttributes(String annotationName, boolean classValuesAsString)`
`default Map<String,Object>`
AnnotatedTypeMetadata.`getAnnotationAttributes(String annotationName)`
Retrieve the attributes of the annotation of the given type, if any (i.e.
`default Map<String,Object>`
AnnotatedTypeMetadata.`getAnnotationAttributes(String annotationName, boolean classValuesAsString)`
Retrieve the attributes of the annotation of the given type, if any (i.e.
`Map<String,Object>`
StandardAnnotationMetadata.`getAnnotationAttributes(String annotationName, boolean classValuesAsString)`
`Map<String,Object>`
StandardMethodMetadata.`getAnnotationAttributes(String annotationName, boolean classValuesAsString)`
`String`
ClassMetadata.`getEnclosingClassName()`
Return the name of the enclosing class of the underlying class, or `null` if the underlying class is a top-level class.
`String`
StandardClassMetadata.`getEnclosingClassName()`
`String`
ClassMetadata.`getSuperClassName()`
Return the name of the superclass of the underlying class, or `null` if there is no superclass defined.
`String`
StandardClassMetadata.`getSuperClassName()`
Method parameters in org.springframework.core.type with annotations of type Nullable
Modifier and Type
Method
Description
`boolean`
StandardClassMetadata.`equals(Object other)`
`boolean`
StandardMethodMetadata.`equals(Object other)`

## Uses of Nullable in org.springframework.core.type.classreading

Constructor parameters in org.springframework.core.type.classreading with annotations of type Nullable
Modifier
Constructor
Description
``
`CachingMetadataReaderFactory(ClassLoader classLoader)`
Create a new CachingMetadataReaderFactory for the given `ClassLoader`, using a local resource cache.
``
`CachingMetadataReaderFactory(ResourceLoader resourceLoader)`
Create a new CachingMetadataReaderFactory for the given `ResourceLoader`, using a shared resource cache if supported or a local resource cache otherwise.
``
`SimpleMetadataReaderFactory(ClassLoader classLoader)`
Create a new SimpleMetadataReaderFactory for the given class loader.
``
`SimpleMetadataReaderFactory(ResourceLoader resourceLoader)`
Create a new SimpleMetadataReaderFactory for the given resource loader.

## Uses of Nullable in org.springframework.core.type.filter

Methods in org.springframework.core.type.filter with annotations of type Nullable
Modifier and Type
Method
Description
`protected Boolean`
AnnotationTypeFilter.`hasAnnotation(String typeName)`
`protected Boolean`
AbstractTypeHierarchyTraversingFilter.`matchInterface(String interfaceName)`
Override this to match on interface type name.
`protected Boolean`
AnnotationTypeFilter.`matchInterface(String interfaceName)`
`protected Boolean`
AssignableTypeFilter.`matchInterface(String interfaceName)`
`protected Boolean`
AbstractTypeHierarchyTraversingFilter.`matchSuperClass(String superClassName)`
Override this to match on supertype name.
`protected Boolean`
AnnotationTypeFilter.`matchSuperClass(String superClassName)`
`protected Boolean`
AssignableTypeFilter.`matchSuperClass(String superClassName)`
`protected Boolean`
AssignableTypeFilter.`matchTargetType(String typeName)`
Constructor parameters in org.springframework.core.type.filter with annotations of type Nullable
Modifier
Constructor
Description
``
`AspectJTypeFilter(String typePatternExpression, ClassLoader classLoader)`

## Uses of Nullable in org.springframework.util

Fields in org.springframework.util with annotations of type Nullable
Modifier and Type
Field
Description
`protected Class<?>`
MethodInvoker.`targetClass`
Methods in org.springframework.util with annotations of type Nullable
Modifier and Type
Method
Description
`V`
LinkedCaseInsensitiveMap.`computeIfAbsent(String key, Function<? super String,? extends V> mappingFunction)`
`static String[]`
StringUtils.`concatenateStringArrays(String[] array1, String[] array2)`
Concatenate the given `String` arrays into one, with overlapping array elements included twice.
`String`
StopWatch.`currentTaskName()`
Get the name of the currently running task, if any.
`static Object`
SerializationUtils.`deserialize(byte[] bytes)`
Deprecated.
This utility uses Java Object Serialization, which allows arbitrary code to be run and is known for being the source of many Remote Code Execution (RCE) vulnerabilities.
`static Class<?>`
ClassUtils.`determineCommonAncestor(Class<?> clazz1, Class<?> clazz2)`
Determine the common ancestor of the given classes, if any.
`<T> T`
ConcurrentReferenceHashMap.Segment.`doTask(int hash, Object key, ConcurrentReferenceHashMap<K,V>.org.springframework.util.ConcurrentReferenceHashMap.Task<T> task)`
Apply an update operation to this segment.
`static Class<?>`
CollectionUtils.`findCommonElementType(Collection<?> collection)`
Find the common element type of the given Collection, if any.
`static Field`
ReflectionUtils.`findField(Class<?> clazz, String name)`
Attempt to find a `field` on the supplied `Class` with the supplied `name`.
`static Field`
ReflectionUtils.`findField(Class<?> clazz, String name, Class<?> type)`
Attempt to find a `field` on the supplied `Class` with the supplied `name` and/or `type`.
`static Field`
ReflectionUtils.`findFieldIgnoreCase(Class<?> clazz, String name)`
Attempt to find a `field` on the supplied `Class` with the supplied `name`.
`static <E> E`
CollectionUtils.`findFirstMatch(Collection<?> source, Collection<E> candidates)`
Return the first element in '`candidates`' that is contained in '`source`'.
`protected Method`
MethodInvoker.`findMatchingMethod()`
Find a matching method with the specified name for the specified arguments.
`static Method`
ReflectionUtils.`findMethod(Class<?> clazz, String name)`
Attempt to find a `Method` on the supplied class with the supplied name and no parameters.
`static Method`
ReflectionUtils.`findMethod(Class<?> clazz, String name, Class<?>... paramTypes)`
Attempt to find a `Method` on the supplied class with the supplied name and parameter types.
`static Object`
CollectionUtils.`findValueOfType(Collection<?> collection, Class<?>[] types)`
Find a single value of one of the given types in the given Collection: searching the Collection for a value of the first type, then searching for a value of the second type, etc.
`static <T> T`
CollectionUtils.`findValueOfType(Collection<?> collection, Class<T> type)`
Find a single value of the given type in the given Collection.
`static <T> T`
CollectionUtils.`firstElement(List<T> list)`
Retrieve the first element of the given List, accessing the zero index.
`static <T> T`
CollectionUtils.`firstElement(Set<T> set)`
Retrieve the first element of the given Set, using `SortedSet.first()` or otherwise using the iterator.
`V`
ConcurrentReferenceHashMap.`get(Object key)`
`ConcurrentReferenceHashMap.Entry<K,V>`
ConcurrentReferenceHashMap.Reference.`get()`
Return the referenced entry, or `null` if the entry is no longer available.
`V`
LinkedCaseInsensitiveMap.`get(Object key)`
`List<V>`
MultiValueMapAdapter.`get(Object key)`
`Charset`
MimeType.`getCharset()`
Return the character set, as indicated by a `charset` parameter, if any.
`static <T> Constructor<T>`
ClassUtils.`getConstructorIfAvailable(Class<T> clazz, Class<?>... paramTypes)`
Determine whether the given class has a public constructor with the given signature, and return it if available (else return `null`).
`static ClassLoader`
ClassUtils.`getDefaultClassLoader()`
Return the default ClassLoader to use: typically the thread context ClassLoader, if available; the ClassLoader that loaded the ClassUtils class will be used as fallback.
`static String`
ClassUtils.`getDescriptiveType(Object value)`
Return a descriptive name for the given object's type: usually simply the class name, but component type class name + "[]" for arrays, and an appended list of implemented interfaces for JDK proxies.
`static Object`
ReflectionUtils.`getField(Field field, Object target)`
Get the field represented by the supplied `field object` on the specified `target object`.
`static String`
StringUtils.`getFilename(String path)`
Extract the filename from the given Java resource path, for example, `"mypath/myfile.txt" &rarr; "myfile.txt"`.
`static String`
StringUtils.`getFilenameExtension(String path)`
Extract the filename extension from the given Java resource path, for example, "mypath/myfile.txt" → "txt".
`V`
MultiValueMap.`getFirst(K key)`
Return the first value for the given key.
`V`
MultiValueMapAdapter.`getFirst(K key)`
`K`
ConcurrentReferenceHashMap.Entry.`getKey()`
`static Method`
ClassUtils.`getMethodIfAvailable(Class<?> clazz, String methodName, Class<?>... paramTypes)`
Determine whether the given class has a public method with the given signature, and return it if available (else return `null`).
`ConcurrentReferenceHashMap.Reference<K,V>`
ConcurrentReferenceHashMap.Reference.`getNext()`
Return the next reference in the chain, or `null` if none.
`V`
ConcurrentReferenceHashMap.`getOrDefault(Object key, V defaultValue)`
`V`
LinkedCaseInsensitiveMap.`getOrDefault(Object key, V defaultValue)`
`String`
MimeType.`getParameter(String name)`
Return a generic parameter value, given a parameter name.
`protected final ConcurrentReferenceHashMap.Reference<K,V>`
ConcurrentReferenceHashMap.`getReference(Object key, ConcurrentReferenceHashMap.Restructure restructure)`
Return a `ConcurrentReferenceHashMap.Reference` to the `ConcurrentReferenceHashMap.Entry` for the specified `key`, or `null` if not found.
`ConcurrentReferenceHashMap.Reference<K,V>`
ConcurrentReferenceHashMap.Segment.`getReference(Object key, int hash, ConcurrentReferenceHashMap.Restructure restructure)`
`static Method`
ClassUtils.`getStaticMethod(Class<?> clazz, String methodName, Class<?>... args)`
Return a public static method of a class.
`String`
MimeType.`getSubtypeSuffix()`
Return the subtype suffix as defined in RFC 6839.
`Class<?>`
MethodInvoker.`getTargetClass()`
Return the target class on which to call the target method.
`String`
MethodInvoker.`getTargetMethod()`
Return the name of the method to be invoked.
`Object`
MethodInvoker.`getTargetObject()`
Return the target object on which to call the target method.
`ThreadGroup`
CustomizableThreadCreator.`getThreadGroup()`
Return the thread group that threads should be created in (or `null` for the default group).
`V`
ConcurrentReferenceHashMap.Entry.`getValue()`
`Object`
MethodInvoker.`invoke()`
Invoke the specified method.
`static Object`
ReflectionUtils.`invokeMethod(Method method, Object target)`
Invoke the specified `Method` against the supplied target object with no arguments.
`static Object`
ReflectionUtils.`invokeMethod(Method method, Object target, Object... args)`
Invoke the specified `Method` against the supplied target object with the supplied arguments.
`static <T> T`
CollectionUtils.`lastElement(List<T> list)`
Retrieve the last element of the given List, accessing the highest index.
`static <T> T`
CollectionUtils.`lastElement(Set<T> set)`
Retrieve the last element of the given Set, using `SortedSet.last()` or otherwise iterating over all elements (assuming a linked set).
`Map<String,String>`
RouteMatcher.`matchAndExtract(String pattern, RouteMatcher.Route route)`
Match the pattern to the route and extract template variables.
`Map<String,String>`
SimpleRouteMatcher.`matchAndExtract(String pattern, RouteMatcher.Route route)`
`static ClassLoader`
ClassUtils.`overrideThreadContextClassLoader(ClassLoader classLoaderToUse)`
Override the thread context ClassLoader with the environment's bean ClassLoader if necessary, i.e.
`static Locale`
StringUtils.`parseLocale(String localeValue)`
Parse the given `String` value into a `Locale`, accepting the `Locale.toString()` format as well as BCP 47 language tags as specified by `Locale.forLanguageTag(java.lang.String)`.
`static Locale`
StringUtils.`parseLocaleString(String localeString)`
Parse the given `String` representation into a `Locale`.
`ConcurrentReferenceHashMap.Reference<K,V>`
ConcurrentReferenceHashMap.ReferenceManager.`pollForPurge()`
Return any reference that has been garbage collected and can be purged from the underlying structure or `null` if no references need purging.
`V`
ConcurrentReferenceHashMap.`put(K key, V value)`
`V`
LinkedCaseInsensitiveMap.`put(String key, V value)`
`List<V>`
MultiValueMapAdapter.`put(K key, List<V> value)`
`V`
ConcurrentReferenceHashMap.`putIfAbsent(K key, V value)`
`V`
LinkedCaseInsensitiveMap.`putIfAbsent(String key, V value)`
`List<V>`
MultiValueMapAdapter.`putIfAbsent(K key, List<V> value)`
`static String`
StringUtils.`quote(String str)`
Quote the given `String` with single quotes.
`static Object`
StringUtils.`quoteIfString(Object obj)`
Turn the given Object into a `String` with single quotes if it is a `String`; keeping the Object as-is else.
`boolean`
ConcurrentLruCache.`remove(K key)`
Immediately remove the given key and any associated value.
`V`
ConcurrentReferenceHashMap.`remove(Object key)`
`V`
LinkedCaseInsensitiveMap.`remove(Object key)`
`List<V>`
MultiValueMapAdapter.`remove(Object key)`
`V`
ConcurrentReferenceHashMap.`replace(K key, V value)`
`String`
PropertyPlaceholderHelper.PlaceholderResolver.`resolvePlaceholder(String placeholderName)`
Resolve the supplied placeholder name to the replacement value.
`static Class<?>`
ClassUtils.`resolvePrimitiveClassName(String name)`
Resolve the given class name as primitive class, if appropriate, according to the JVM's naming rules for primitive classes.
`String`
StringValueResolver.`resolveStringValue(String strVal)`
Resolve the given String value, for example parsing placeholders.
`static byte[]`
SerializationUtils.`serialize(Object object)`
Serialize the given object to a byte array.
`V`
ConcurrentReferenceHashMap.Entry.`setValue(V value)`
`static String[]`
StringUtils.`split(String toSplit, String delimiter)`
Split a `String` at the first occurrence of the delimiter.
`static Properties`
StringUtils.`splitArrayElementsIntoProperties(String[] array, String delimiter)`
Take an array of strings and split each element based on the given delimiter.
`static Properties`
StringUtils.`splitArrayElementsIntoProperties(String[] array, String delimiter, String charsToDelete)`
Take an array of strings and split each element based on the given delimiter.
`static Object`
ObjectUtils.`unwrapOptional(Object obj)`
Unwrap the given object which is potentially a `Optional`.
Method parameters in org.springframework.util with annotations of type Nullable
Modifier and Type
Method
Description
`void`
MultiValueMap.`add(K key, V value)`
Add the given single value to the current list of values for the given key.
`void`
MultiValueMapAdapter.`add(K key, V value)`
`default void`
MultiValueMap.`addIfAbsent(K key, V value)`
`Add` the given value, only when the map does not `contain` the given key.
`static <A, O extends A>
A[]`
ObjectUtils.`addObjectToArray(A[] array, O obj)`
Append the given object to the given array, returning a new array consisting of the input array contents plus the given object.
`static <A, O extends A>
A[]`
ObjectUtils.`addObjectToArray(A[] array, O obj)`
Append the given object to the given array, returning a new array consisting of the input array contents plus the given object.
`static <A, O extends A>
A[]`
ObjectUtils.`addObjectToArray(A[] array, O obj, int position)`
Add the given object to the given array at the specified position, returning a new array consisting of the input array contents plus the given object.
`static <A, O extends A>
A[]`
ObjectUtils.`addObjectToArray(A[] array, O obj, int position)`
Add the given object to the given array at the specified position, returning a new array consisting of the input array contents plus the given object.
`static String[]`
StringUtils.`addStringToArray(String[] array, String str)`
Append the given `String` to the given `String` array, returning a new array consisting of the input array contents plus the given `String`.
`static String`
StringUtils.`arrayToCommaDelimitedString(Object[] arr)`
Convert a `String` array into a comma delimited `String` (i.e., CSV).
`static String`
StringUtils.`arrayToDelimitedString(Object[] arr, String delim)`
Convert a `String` array into a delimited `String` (for example, CSV).
`static List<?>`
CollectionUtils.`arrayToList(Object source)`
Convert the supplied array into a List.
`static String`
ClassUtils.`classNamesToString(Collection<Class<?>> classes)`
Build a String that consists of the names of the classes/interfaces in the given collection.
`static String`
ClassUtils.`classPackageAsResourcePath(Class<?> clazz)`
Given an input class object, return a string which consists of the class's package name as a pathname, i.e., all dots ('.') are replaced by slashes ('/').
`static String`
StringUtils.`collectionToCommaDelimitedString(Collection<?> coll)`
Convert a `Collection` into a delimited `String` (for example, CSV).
`static String`
StringUtils.`collectionToDelimitedString(Collection<?> coll, String delim)`
Convert a `Collection` into a delimited `String` (for example, CSV).
`static String`
StringUtils.`collectionToDelimitedString(Collection<?> coll, String delim, String prefix, String suffix)`
Convert a `Collection` to a delimited `String` (for example, CSV).
`static Set<String>`
StringUtils.`commaDelimitedListToSet(String str)`
Convert a comma delimited list (for example, a row from a CSV file) into a set.
`static String[]`
StringUtils.`commaDelimitedListToStringArray(String str)`
Convert a comma delimited list (for example, a row from a CSV file) into an array of strings.
`static <K, V> Map<K,V>`
CollectionUtils.`compositeMap(Map<K,V> first, Map<K,V> second, BiFunction<K,V,V> putFunction, Consumer<Map<K,V>> putAllFunction)`
Return a map that combines the provided maps.
`static <K, V> Map<K,V>`
CollectionUtils.`compositeMap(Map<K,V> first, Map<K,V> second, BiFunction<K,V,V> putFunction, Consumer<Map<K,V>> putAllFunction)`
Return a map that combines the provided maps.
`static String[]`
StringUtils.`concatenateStringArrays(String[] array1, String[] array2)`
Concatenate the given `String` arrays into one, with overlapping array elements included twice.
`static String[]`
StringUtils.`concatenateStringArrays(String[] array1, String[] array2)`
Concatenate the given `String` arrays into one, with overlapping array elements included twice.
`static boolean`
CollectionUtils.`contains(Enumeration<?> enumeration, Object element)`
Check whether the given Enumeration contains the given element.
`static boolean`
CollectionUtils.`contains(Iterator<?> iterator, Object element)`
Check whether the given Iterator contains the given element.
`static boolean`
ObjectUtils.`containsElement(Object[] array, Object element)`
Check whether the given array contains the given element.
`static boolean`
CollectionUtils.`containsInstance(Collection<?> collection, Object element)`
Check whether the given Collection contains the given element instance.
`boolean`
ConcurrentReferenceHashMap.`containsKey(Object key)`
`static boolean`
StringUtils.`containsWhitespace(CharSequence str)`
Check whether the given `CharSequence` contains any whitespace characters.
`static boolean`
StringUtils.`containsWhitespace(String str)`
Check whether the given `String` contains any whitespace characters.
`static byte[]`
FileCopyUtils.`copyToByteArray(InputStream in)`
Copy the contents of the given InputStream into a new byte array.
`static byte[]`
StreamUtils.`copyToByteArray(InputStream in)`
Copy the contents of the given InputStream into a new byte array.
`static String`
FileCopyUtils.`copyToString(Reader in)`
Copy the contents of the given Reader into a String.
`static String`
StreamUtils.`copyToString(InputStream in, Charset charset)`
Copy the contents of the given InputStream into a String.
`static Class<?>`
ClassUtils.`createCompositeInterface(Class<?>[] interfaces, ClassLoader classLoader)`
Create a composite interface Class for the given interfaces, implementing the given interfaces in one single Class.
`ConcurrentReferenceHashMap.Reference<K,V>`
ConcurrentReferenceHashMap.ReferenceManager.`createReference(ConcurrentReferenceHashMap.Entry<K,V> entry, int hash, ConcurrentReferenceHashMap.Reference<K,V> next)`
Factory method used to create a new `ConcurrentReferenceHashMap.Reference`.
`static String`
StringUtils.`deleteAny(String inString, String charsToDelete)`
Delete any character in a given `String`.
`static boolean`
FileSystemUtils.`deleteRecursively(File root)`
Delete the supplied `File` - for directories, recursively delete any nested directories or files as well.
`static boolean`
FileSystemUtils.`deleteRecursively(Path root)`
Delete the supplied `Path` — for directories, recursively delete any nested directories or files as well.
`static String[]`
StringUtils.`delimitedListToStringArray(String str, String delimiter)`
Take a `String` that is a delimited list and convert it into a `String` array.
`static String[]`
StringUtils.`delimitedListToStringArray(String str, String delimiter)`
Take a `String` that is a delimited list and convert it into a `String` array.
`static String[]`
StringUtils.`delimitedListToStringArray(String str, String delimiter, String charsToDelete)`
Take a `String` that is a delimited list and convert it into a `String` array.
`static String[]`
StringUtils.`delimitedListToStringArray(String str, String delimiter, String charsToDelete)`
Take a `String` that is a delimited list and convert it into a `String` array.
`static String[]`
StringUtils.`delimitedListToStringArray(String str, String delimiter, String charsToDelete)`
Take a `String` that is a delimited list and convert it into a `String` array.
`static Object`
SerializationUtils.`deserialize(byte[] bytes)`
Deprecated.
This utility uses Java Object Serialization, which allows arbitrary code to be run and is known for being the source of many Remote Code Execution (RCE) vulnerabilities.
`static Class<?>`
ClassUtils.`determineCommonAncestor(Class<?> clazz1, Class<?> clazz2)`
Determine the common ancestor of the given classes, if any.
`static Class<?>`
ClassUtils.`determineCommonAncestor(Class<?> clazz1, Class<?> clazz2)`
Determine the common ancestor of the given classes, if any.
`static void`
Assert.`doesNotContain(String textToSearch, String substring, String message)`
Assert that the given text does not contain the given substring.
`static void`
Assert.`doesNotContain(String textToSearch, String substring, Supplier<String> messageSupplier)`
Assert that the given text does not contain the given substring.
`protected boolean`
AntPathMatcher.`doMatch(String pattern, String path, boolean fullMatch, Map<String,String> uriTemplateVariables)`
Actually match the given `path` against the given `pattern`.
`protected boolean`
AntPathMatcher.`doMatch(String pattern, String path, boolean fullMatch, Map<String,String> uriTemplateVariables)`
Actually match the given `path` against the given `pattern`.
`<T> T`
ConcurrentReferenceHashMap.Segment.`doTask(int hash, Object key, ConcurrentReferenceHashMap<K,V>.org.springframework.util.ConcurrentReferenceHashMap.Task<T> task)`
Apply an update operation to this segment.
`static void`
ReflectionUtils.`doWithFields(Class<?> clazz, ReflectionUtils.FieldCallback fc, ReflectionUtils.FieldFilter ff)`
Invoke the given callback on all fields in the target class, going up the class hierarchy to get all declared fields.
`static void`
ReflectionUtils.`doWithMethods(Class<?> clazz, ReflectionUtils.MethodCallback mc, ReflectionUtils.MethodFilter mf)`
Perform the given callback operation on all matching methods of the given class and superclasses (or given interface and super-interfaces).
`static int`
StreamUtils.`drain(InputStream in)`
Drain the remaining content of the given `InputStream`.
`static boolean`
StringUtils.`endsWithIgnoreCase(String str, String suffix)`
Test if the given `String` ends with the specified suffix, ignoring upper/lower case.
`static boolean`
StringUtils.`endsWithIgnoreCase(String str, String suffix)`
Test if the given `String` ends with the specified suffix, ignoring upper/lower case.
`boolean`
AutoPopulatingList.`equals(Object other)`
`boolean`
ConcurrentReferenceHashMap.Entry.`equals(Object other)`
`boolean`
LinkedCaseInsensitiveMap.`equals(Object other)`
`boolean`
MimeType.`equals(Object other)`
`boolean`
MultiValueMapAdapter.`equals(Object other)`
`boolean`
MimeType.`equalsTypeAndSubtype(MimeType other)`
Similar to `MimeType.equals(Object)` but based on the type and subtype only, i.e.
`static Field`
ReflectionUtils.`findField(Class<?> clazz, String name, Class<?> type)`
Attempt to find a `field` on the supplied `Class` with the supplied `name` and/or `type`.
`static Field`
ReflectionUtils.`findField(Class<?> clazz, String name, Class<?> type)`
Attempt to find a `field` on the supplied `Class` with the supplied `name` and/or `type`.
`static Method`
ReflectionUtils.`findMethod(Class<?> clazz, String name, Class<?>... paramTypes)`
Attempt to find a `Method` on the supplied class with the supplied name and parameter types.
`static <T> T`
CollectionUtils.`findValueOfType(Collection<?> collection, Class<T> type)`
Find a single value of the given type in the given Collection.
`static <T> T`
CollectionUtils.`firstElement(List<T> list)`
Retrieve the first element of the given List, accessing the zero index.
`static <T> T`
CollectionUtils.`firstElement(Set<T> set)`
Retrieve the first element of the given Set, using `SortedSet.first()` or otherwise using the iterator.
`static Class<?>`
ClassUtils.`forName(String name, ClassLoader classLoader)`
Replacement for `Class.forName()` that also returns Class instances for primitives (for example, "int") and array class names (for example, "String[]").
`V`
ConcurrentReferenceHashMap.`get(Object key)`
`static Class<?>[]`
ClassUtils.`getAllInterfacesForClass(Class<?> clazz, ClassLoader classLoader)`
Return all interfaces that the given class implements as an array, including ones implemented by superclasses.
`static Set<Class<?>>`
ClassUtils.`getAllInterfacesForClassAsSet(Class<?> clazz, ClassLoader classLoader)`
Return all interfaces that the given class implements as a Set, including ones implemented by superclasses.
`static String`
ClassUtils.`getDescriptiveType(Object value)`
Return a descriptive name for the given object's type: usually simply the class name, but component type class name + "[]" for arrays, and an appended list of implemented interfaces for JDK proxies.
`static String`
ObjectUtils.`getDisplayString(Object obj)`
Return a content-based String representation if `obj` is not `null`; otherwise returns an empty String.
`static Object`
ReflectionUtils.`getField(Field field, Object target)`
Get the field represented by the supplied `field object` on the specified `target object`.
`static String`
StringUtils.`getFilename(String path)`
Extract the filename from the given Java resource path, for example, `"mypath/myfile.txt" &rarr; "myfile.txt"`.
`static String`
StringUtils.`getFilenameExtension(String path)`
Extract the filename extension from the given Java resource path, for example, "mypath/myfile.txt" → "txt".
`protected int`
ConcurrentReferenceHashMap.`getHash(Object o)`
Get the hash for a given object, apply an additional hash function to reduce collisions.
`static Method`
ClassUtils.`getInterfaceMethodIfPossible(Method method, Class<?> targetClass)`
Determine a corresponding interface method for the given method handle, if possible.
`static Method`
ClassUtils.`getMethod(Class<?> clazz, String methodName, Class<?>... paramTypes)`
Determine whether the given class has a public method with the given signature, and return it if available (else throws an `IllegalStateException`).
`static Method`
ClassUtils.`getMethodIfAvailable(Class<?> clazz, String methodName, Class<?>... paramTypes)`
Determine whether the given class has a public method with the given signature, and return it if available (else return `null`).
`static Method`
ClassUtils.`getMostSpecificMethod(Method method, Class<?> targetClass)`
Given a method, which may come from an interface, and a target class used in the current reflective invocation, find the corresponding target method if there is one — for example, the method may be `IFoo.bar()`, and the target class may be `DefaultFoo`.
`V`
ConcurrentReferenceHashMap.`getOrDefault(Object key, V defaultValue)`
`V`
ConcurrentReferenceHashMap.`getOrDefault(Object key, V defaultValue)`
`static Method`
ClassUtils.`getPubliclyAccessibleMethodIfPossible(Method method, Class<?> targetClass)`
Get the first publicly accessible method in the supplied method's type hierarchy that has a method signature equivalent to the supplied method, if possible.
`static String`
ClassUtils.`getQualifiedMethodName(Method method, Class<?> clazz)`
Return the qualified name of the given method, consisting of fully qualified interface/class name + "." + method name.
`protected final ConcurrentReferenceHashMap.Reference<K,V>`
ConcurrentReferenceHashMap.`getReference(Object key, ConcurrentReferenceHashMap.Restructure restructure)`
Return a `ConcurrentReferenceHashMap.Reference` to the `ConcurrentReferenceHashMap.Entry` for the specified `key`, or `null` if not found.
`ConcurrentReferenceHashMap.Reference<K,V>`
ConcurrentReferenceHashMap.Segment.`getReference(Object key, int hash, ConcurrentReferenceHashMap.Restructure restructure)`
`static Method[]`
ReflectionUtils.`getUniqueDeclaredMethods(Class<?> leafClass, ReflectionUtils.MethodFilter mf)`
Get the unique set of declared methods on the leaf class and all superclasses.
`static void`
Assert.`hasLength(String text, String message)`
Assert that the given String is not empty; that is, it must not be `null` and not the empty String.
`static void`
Assert.`hasLength(String text, Supplier<String> messageSupplier)`
Assert that the given String is not empty; that is, it must not be `null` and not the empty String.
`static boolean`
StringUtils.`hasLength(CharSequence str)`
Check that the given `CharSequence` is neither `null` nor of length 0.
`static boolean`
StringUtils.`hasLength(String str)`
Check that the given `String` is neither `null` nor of length 0.
`static void`
Assert.`hasText(String text, String message)`
Assert that the given String contains valid text content; that is, it must not be `null` and must contain at least one non-whitespace character.
`static void`
Assert.`hasText(String text, Supplier<String> messageSupplier)`
Assert that the given String contains valid text content; that is, it must not be `null` and must contain at least one non-whitespace character.
`static boolean`
StringUtils.`hasText(CharSequence str)`
Check whether the given `CharSequence` contains actual text.
`static boolean`
StringUtils.`hasText(String str)`
Check whether the given `String` contains actual text.
`static String`
ObjectUtils.`identityToString(Object obj)`
Return a String representation of an object's overall identity.
`boolean`
MimeType.`includes(MimeType other)`
Indicate whether this MIME Type includes the given MIME Type.
`static Object`
ReflectionUtils.`invokeMethod(Method method, Object target)`
Invoke the specified `Method` against the supplied target object with no arguments.
`static Object`
ReflectionUtils.`invokeMethod(Method method, Object target, Object... args)`
Invoke the specified `Method` against the supplied target object with the supplied arguments.
`static Object`
ReflectionUtils.`invokeMethod(Method method, Object target, Object... args)`
Invoke the specified `Method` against the supplied target object with the supplied arguments.
`static boolean`
ObjectUtils.`isArray(Object obj)`
Determine whether the given object is an array: either an Object array or a primitive array.
`static void`
Assert.`isAssignable(Class<?> superType, Class<?> subType)`
Assert that `superType.isAssignableFrom(subType)` is `true`.
`static void`
Assert.`isAssignable(Class<?> superType, Class<?> subType, String message)`
Assert that `superType.isAssignableFrom(subType)` is `true`.
`static void`
Assert.`isAssignable(Class<?> superType, Class<?> subType, Supplier<String> messageSupplier)`
Assert that `superType.isAssignableFrom(subType)` is `true`.
`static boolean`
TypeUtils.`isAssignableBound(Type lhsType, Type rhsType)`
`static boolean`
TypeUtils.`isAssignableBound(Type lhsType, Type rhsType)`
`static boolean`
ClassUtils.`isAssignableValue(Class<?> type, Object value)`
Determine if the given type is assignable from the given value, assuming setting by reflection.
`static boolean`
ClassUtils.`isCacheSafe(Class<?> clazz, ClassLoader classLoader)`
Check whether the given class is cache-safe in the given context, i.e.
`static boolean`
ClassUtils.`isCglibProxyClass(Class<?> clazz)`
Deprecated.
as of 5.2, in favor of custom (possibly narrower) checks or simply a check for containing `ClassUtils.CGLIB_CLASS_SEPARATOR`
`static boolean`
ClassUtils.`isCglibProxyClassName(String className)`
Deprecated.
as of 5.2, in favor of custom (possibly narrower) checks or simply a check for containing `ClassUtils.CGLIB_CLASS_SEPARATOR`
`boolean`
MimeType.`isCompatibleWith(MimeType other)`
Indicate whether this MIME Type is compatible with the given MIME Type.
`static boolean`
ObjectUtils.`isCompatibleWithThrowsClause(Throwable ex, Class<?>... declaredExceptions)`
Check whether the given exception is compatible with the specified exception types, as declared in a `throws` clause.
`static boolean`
CollectionUtils.`isEmpty(Collection<?> collection)`
Return `true` if the supplied Collection is `null` or empty.
`static boolean`
CollectionUtils.`isEmpty(Map<?,?> map)`
Return `true` if the supplied Map is `null` or empty.
`static boolean`
ObjectUtils.`isEmpty(Object obj)`
Determine whether the given object is empty.
`static boolean`
ObjectUtils.`isEmpty(Object[] array)`
Determine whether the given array is empty: i.e.
`static boolean`
StringUtils.`isEmpty(Object str)`
Deprecated.
as of 5.3, in favor of `StringUtils.hasLength(String)` and `StringUtils.hasText(String)` (or `ObjectUtils.isEmpty(Object)`)
`static boolean`
ReflectionUtils.`isEqualsMethod(Method method)`
Determine whether the given method is an "equals" method.
`static boolean`
ReflectionUtils.`isHashCodeMethod(Method method)`
Determine whether the given method is a "hashCode" method.
`static void`
Assert.`isInstanceOf(Class<?> type, Object obj)`
Assert that the provided object is an instance of the provided class.
`static void`
Assert.`isInstanceOf(Class<?> type, Object obj, String message)`
Assert that the provided object is an instance of the provided class.
`static void`
Assert.`isInstanceOf(Class<?> type, Object obj, Supplier<String> messageSupplier)`
Assert that the provided object is an instance of the provided class.
`static void`
Assert.`isNull(Object object, String message)`
Assert that an object is `null`.
`static void`
Assert.`isNull(Object object, Supplier<String> messageSupplier)`
Assert that an object is `null`.
`static boolean`
ReflectionUtils.`isObjectMethod(Method method)`
Determine whether the given method is originally declared by `Object`.
`boolean`
AntPathMatcher.`isPattern(String path)`
`static boolean`
ClassUtils.`isPresent(String className, ClassLoader classLoader)`
Determine whether the `Class` identified by the supplied name is present and can be loaded.
`static boolean`
ReflectionUtils.`isToStringMethod(Method method)`
Determine whether the given method is a "toString" method.
`static boolean`
ResourceUtils.`isUrl(String resourceLocation)`
Return whether the given resource location is a URL: either a special "classpath" pseudo URL or a standard URL.
`static boolean`
ClassUtils.`isVisible(Class<?> clazz, ClassLoader classLoader)`
Check whether the given class is visible in the given ClassLoader.
`static boolean`
ClassUtils.`isVoidType(Class<?> type)`
Determine if the given type represents either `Void` or `void`.
`static <T> T`
CollectionUtils.`lastElement(List<T> list)`
Retrieve the last element of the given List, accessing the highest index.
`static <T> T`
CollectionUtils.`lastElement(Set<T> set)`
Retrieve the last element of the given Set, using `SortedSet.last()` or otherwise iterating over all elements (assuming a linked set).
`static boolean`
StringUtils.`matchesCharacter(String str, char singleCharacter)`
Test if the given `String` matches the given single character.
`static boolean`
ClassUtils.`matchesTypeName(Class<?> clazz, String typeName)`
Check whether the given class matches the user-specified type name.
`boolean`
AntPathMatcher.AntPathStringMatcher.`matchStrings(String str, Map<String,String> uriTemplateVariables)`
Main entry point.
`static <E> void`
CollectionUtils.`mergeArrayIntoCollection(Object array, Collection<E> collection)`
Merge the given array into the given Collection.
`static <K, V> void`
CollectionUtils.`mergePropertiesIntoMap(Properties props, Map<K,V> map)`
Merge the given Properties instance into the given Map, copying all properties (key-value pairs) over.
`static void`
Assert.`noNullElements(Object[] array, String message)`
Assert that an array contains no `null` elements.
`static void`
Assert.`noNullElements(Object[] array, Supplier<String> messageSupplier)`
Assert that an array contains no `null` elements.
`static void`
Assert.`noNullElements(Collection<?> collection, String message)`
Assert that a collection contains no `null` elements.
`static void`
Assert.`noNullElements(Collection<?> collection, Supplier<String> messageSupplier)`
Assert that a collection contains no `null` elements.
`static void`
Assert.`notEmpty(Object[] array, String message)`
Assert that an array contains elements; that is, it must not be `null` and must contain at least one element.
`static void`
Assert.`notEmpty(Object[] array, Supplier<String> messageSupplier)`
Assert that an array contains elements; that is, it must not be `null` and must contain at least one element.
`static void`
Assert.`notEmpty(Collection<?> collection, String message)`
Assert that a collection contains elements; that is, it must not be `null` and must contain at least one element.
`static void`
Assert.`notEmpty(Collection<?> collection, Supplier<String> messageSupplier)`
Assert that a collection contains elements; that is, it must not be `null` and must contain at least one element.
`static void`
Assert.`notEmpty(Map<?,?> map, String message)`
Assert that a Map contains entries; that is, it must not be `null` and must contain at least one entry.
`static void`
Assert.`notEmpty(Map<?,?> map, Supplier<String> messageSupplier)`
Assert that a Map contains entries; that is, it must not be `null` and must contain at least one entry.
`static void`
Assert.`notNull(Object object, String message)`
Assert that an object is not `null`.
`static void`
Assert.`notNull(Object object, Supplier<String> messageSupplier)`
Assert that an object is not `null`.
`static String`
ObjectUtils.`nullSafeClassName(Object obj)`
Determine the class name for the given object.
`static String`
ObjectUtils.`nullSafeConciseToString(Object obj)`
Generate a null-safe, concise string representation of the supplied object as described below.
`static boolean`
ObjectUtils.`nullSafeEquals(Object o1, Object o2)`
Determine if the given objects are equal, returning `true` if both are `null` or `false` if only one is `null`.
`static boolean`
ObjectUtils.`nullSafeEquals(Object o1, Object o2)`
Determine if the given objects are equal, returning `true` if both are `null` or `false` if only one is `null`.
`static int`
ObjectUtils.`nullSafeHash(Object... elements)`
Return a hash code for the given elements, delegating to `ObjectUtils.nullSafeHashCode(Object)` for each element.
`static int`
ObjectUtils.`nullSafeHashCode(boolean[] array)`
Deprecated.
as of 6.1 in favor of `Arrays.hashCode(boolean[])`
`static int`
ObjectUtils.`nullSafeHashCode(byte[] array)`
Deprecated.
as of 6.1 in favor of `Arrays.hashCode(byte[])`
`static int`
ObjectUtils.`nullSafeHashCode(char[] array)`
Deprecated.
as of 6.1 in favor of `Arrays.hashCode(char[])`
`static int`
ObjectUtils.`nullSafeHashCode(double[] array)`
Deprecated.
as of 6.1 in favor of `Arrays.hashCode(double[])`
`static int`
ObjectUtils.`nullSafeHashCode(float[] array)`
Deprecated.
as of 6.1 in favor of `Arrays.hashCode(float[])`
`static int`
ObjectUtils.`nullSafeHashCode(int[] array)`
Deprecated.
as of 6.1 in favor of `Arrays.hashCode(int[])`
`static int`
ObjectUtils.`nullSafeHashCode(long[] array)`
Deprecated.
as of 6.1 in favor of `Arrays.hashCode(long[])`
`static int`
ObjectUtils.`nullSafeHashCode(short[] array)`
Deprecated.
as of 6.1 in favor of `Arrays.hashCode(short[])`
`static int`
ObjectUtils.`nullSafeHashCode(Object obj)`
Return a hash code for the given object, typically the value of `Object.hashCode()`.
`static int`
ObjectUtils.`nullSafeHashCode(Object[] array)`
Deprecated.
as of 6.1 in favor of `Arrays.hashCode(Object[])`
`static String`
ObjectUtils.`nullSafeToString(boolean[] array)`
Return a String representation of the contents of the specified array.
`static String`
ObjectUtils.`nullSafeToString(byte[] array)`
Return a String representation of the contents of the specified array.
`static String`
ObjectUtils.`nullSafeToString(char[] array)`
Return a String representation of the contents of the specified array.
`static String`
ObjectUtils.`nullSafeToString(double[] array)`
Return a String representation of the contents of the specified array.
`static String`
ObjectUtils.`nullSafeToString(float[] array)`
Return a String representation of the contents of the specified array.
`static String`
ObjectUtils.`nullSafeToString(int[] array)`
Return a String representation of the contents of the specified array.
`static String`
ObjectUtils.`nullSafeToString(long[] array)`
Return a String representation of the contents of the specified array.
`static String`
ObjectUtils.`nullSafeToString(short[] array)`
Return a String representation of the contents of the specified array.
`static String`
ObjectUtils.`nullSafeToString(Object obj)`
Return a String representation of the specified Object.
`static String`
ObjectUtils.`nullSafeToString(Object[] array)`
Return a String representation of the contents of the specified array.
`static ClassLoader`
ClassUtils.`overrideThreadContextClassLoader(ClassLoader classLoaderToUse)`
Override the thread context ClassLoader with the environment's bean ClassLoader if necessary, i.e.
`static <T extends Number>
T`
NumberUtils.`parseNumber(String text, Class<T> targetClass, NumberFormat numberFormat)`
Parse the given `text` into a `Number` instance of the given target class, using the supplied `NumberFormat`.
`V`
ConcurrentReferenceHashMap.`put(K key, V value)`
`V`
ConcurrentReferenceHashMap.`put(K key, V value)`
`V`
LinkedCaseInsensitiveMap.`put(String key, V value)`
`V`
ConcurrentReferenceHashMap.`putIfAbsent(K key, V value)`
`V`
ConcurrentReferenceHashMap.`putIfAbsent(K key, V value)`
`V`
LinkedCaseInsensitiveMap.`putIfAbsent(String key, V value)`
`static String`
StringUtils.`quote(String str)`
Quote the given `String` with single quotes.
`static Object`
StringUtils.`quoteIfString(Object obj)`
Turn the given Object into a `String` with single quotes if it is a `String`; keeping the Object as-is else.
`V`
ConcurrentReferenceHashMap.`remove(Object key)`
`boolean`
ConcurrentReferenceHashMap.`remove(Object key, Object value)`
`boolean`
ConcurrentReferenceHashMap.`remove(Object key, Object value)`
`V`
ConcurrentReferenceHashMap.`replace(K key, V value)`
`V`
ConcurrentReferenceHashMap.`replace(K key, V value)`
`boolean`
ConcurrentReferenceHashMap.`replace(K key, V oldValue, V newValue)`
`boolean`
ConcurrentReferenceHashMap.`replace(K key, V oldValue, V newValue)`
`boolean`
ConcurrentReferenceHashMap.`replace(K key, V oldValue, V newValue)`
`static String`
StringUtils.`replace(String inString, String oldPattern, String newPattern)`
Replace all occurrences of a substring within a string with another string.
`static Class<?>`
ClassUtils.`resolveClassName(String className, ClassLoader classLoader)`
Resolve the given class name into a Class instance.
`static Class<?>`
ClassUtils.`resolvePrimitiveClassName(String name)`
Resolve the given class name as primitive class, if appropriate, according to the JVM's naming rules for primitive classes.
`static void`
ReflectionUtils.`rethrowException(Throwable throwable)`
Rethrow the given `exception`, which is presumably the target exception of an `InvocationTargetException`.
`static void`
ReflectionUtils.`rethrowRuntimeException(Throwable ex)`
Rethrow the given `exception`, which is presumably the target exception of an `InvocationTargetException`.
`static byte[]`
SerializationUtils.`serialize(Object object)`
Serialize the given object to a byte array.
`void`
MultiValueMap.`set(K key, V value)`
Set the given single value under the given key.
`void`
MultiValueMapAdapter.`set(K key, V value)`
`void`
MethodInvoker.`setArguments(Object... arguments)`
Set arguments for the method invocation.
`static void`
ReflectionUtils.`setField(Field field, Object target, Object value)`
Set the field represented by the supplied field object on the specified target object to the specified `value`.
`static void`
ReflectionUtils.`setField(Field field, Object target, Object value)`
Set the field represented by the supplied field object on the specified target object to the specified `value`.
`void`
AntPathMatcher.`setPathSeparator(String pathSeparator)`
Set the path separator to use for pattern parsing.
`void`
MethodInvoker.`setTargetClass(Class<?> targetClass)`
Set the target class on which to call the target method.
`void`
MethodInvoker.`setTargetMethod(String targetMethod)`
Set the name of the method to be invoked.
`void`
MethodInvoker.`setTargetObject(Object targetObject)`
Set the target object on which to call the target method.
`void`
CustomizableThreadCreator.`setThreadGroup(ThreadGroup threadGroup)`
Specify the thread group that threads should be created in.
`void`
CustomizableThreadCreator.`setThreadNamePrefix(String threadNamePrefix)`
Specify the prefix to use for the names of newly created threads.
`V`
ConcurrentReferenceHashMap.Entry.`setValue(V value)`
`static boolean`
PatternMatchUtils.`simpleMatch(String[] patterns, String str)`
Match a String against the given patterns, supporting direct equality as well as the following simple pattern styles: `xxx*`, `*xxx`, `*xxx*`, and `xxx*yyy` (with an arbitrary number of pattern parts).
`static boolean`
PatternMatchUtils.`simpleMatch(String[] patterns, String str)`
Match a String against the given patterns, supporting direct equality as well as the following simple pattern styles: `xxx*`, `*xxx`, `*xxx*`, and `xxx*yyy` (with an arbitrary number of pattern parts).
`static boolean`
PatternMatchUtils.`simpleMatch(String pattern, String str)`
Match a String against the given pattern, supporting direct equality as well as the following simple pattern styles: `xxx*`, `*xxx`, `*xxx*`, and `xxx*yyy` (with an arbitrary number of pattern parts).
`static boolean`
PatternMatchUtils.`simpleMatch(String pattern, String str)`
Match a String against the given pattern, supporting direct equality as well as the following simple pattern styles: `xxx*`, `*xxx`, `*xxx*`, and `xxx*yyy` (with an arbitrary number of pattern parts).
`static boolean`
PatternMatchUtils.`simpleMatchIgnoreCase(String[] patterns, String str)`
Variant of `PatternMatchUtils.simpleMatch(String[], String)` that ignores upper/lower case.
`static boolean`
PatternMatchUtils.`simpleMatchIgnoreCase(String[] patterns, String str)`
Variant of `PatternMatchUtils.simpleMatch(String[], String)` that ignores upper/lower case.
`static boolean`
PatternMatchUtils.`simpleMatchIgnoreCase(String pattern, String str)`
Variant of `PatternMatchUtils.simpleMatch(String, String)` that ignores upper/lower case.
`static boolean`
PatternMatchUtils.`simpleMatchIgnoreCase(String pattern, String str)`
Variant of `PatternMatchUtils.simpleMatch(String, String)` that ignores upper/lower case.
`static String[]`
StringUtils.`split(String toSplit, String delimiter)`
Split a `String` at the first occurrence of the delimiter.
`static String[]`
StringUtils.`split(String toSplit, String delimiter)`
Split a `String` at the first occurrence of the delimiter.
`static Properties`
StringUtils.`splitArrayElementsIntoProperties(String[] array, String delimiter, String charsToDelete)`
Take an array of strings and split each element based on the given delimiter.
`static boolean`
StringUtils.`startsWithIgnoreCase(String str, String prefix)`
Test if the given `String` starts with the specified prefix, ignoring upper/lower case.
`static boolean`
StringUtils.`startsWithIgnoreCase(String str, String prefix)`
Test if the given `String` starts with the specified prefix, ignoring upper/lower case.
`static Class<?>[]`
ClassUtils.`toClassArray(Collection<Class<?>> collection)`
Copy the given `Collection` into a `Class` array.
`static <E> Iterator<E>`
CollectionUtils.`toIterator(Enumeration<E> enumeration)`
Adapt an `Enumeration` to an `Iterator`.
`static String[]`
StringUtils.`tokenizeToStringArray(String str, String delimiters)`
Tokenize the given `String` into a `String` array via a `StringTokenizer`.
`static String[]`
StringUtils.`tokenizeToStringArray(String str, String delimiters, boolean trimTokens, boolean ignoreEmptyTokens)`
Tokenize the given `String` into a `String` array via a `StringTokenizer`.
`static Object[]`
ObjectUtils.`toObjectArray(Object source)`
Convert the given array (which may be a primitive array) to an object array (if necessary, to an array of primitive wrapper objects).
`static String[]`
StringUtils.`toStringArray(Collection<String> collection)`
Copy the given `Collection` into a `String` array.
`static String[]`
StringUtils.`toStringArray(Enumeration<String> enumeration)`
Copy the given `Enumeration` into a `String` array.
`static Object`
ObjectUtils.`unwrapOptional(Object obj)`
Unwrap the given object which is potentially a `Optional`.
Constructor parameters in org.springframework.util with annotations of type Nullable
Modifier
Constructor
Description
``
`CustomizableThreadCreator(String threadNamePrefix)`
Create a new CustomizableThreadCreator with the given thread name prefix.
``
`Entry(K key, V value)`
``
`Entry(K key, V value)`
``
`InstanceFilter(Collection<? extends T> includes, Collection<? extends T> excludes, boolean matchIfEmpty)`
Create a new instance based on includes/excludes collections.
``
`InstanceFilter(Collection<? extends T> includes, Collection<? extends T> excludes, boolean matchIfEmpty)`
Create a new instance based on includes/excludes collections.
``
`LinkedCaseInsensitiveMap(int expectedSize, Locale locale)`
Create a new LinkedCaseInsensitiveMap that wraps a `LinkedHashMap` with an initial capacity that can accommodate the specified number of elements without any immediate resize/rehash operations to be expected, storing case-insensitive keys according to the given Locale (in lower case).
``
`LinkedCaseInsensitiveMap(Locale locale)`
Create a new LinkedCaseInsensitiveMap that stores case-insensitive keys according to the given Locale (in lower case).
``
`MimeType(String type, String subtype, Map<String,String> parameters)`
Create a new `MimeType` for the given type, subtype, and parameters.
``
`MimeType(MimeType other, Map<String,String> parameters)`
Copy-constructor that copies the type and subtype of the given `MimeType`, and allows for different parameter.
``
`PropertyPlaceholderHelper(String placeholderPrefix, String placeholderSuffix, String valueSeparator, boolean ignoreUnresolvablePlaceholders)`
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.2, in favor of `PropertyPlaceholderHelper(String, String, String, Character, boolean)`
``
`PropertyPlaceholderHelper(String placeholderPrefix, String placeholderSuffix, String valueSeparator, Character escapeCharacter, boolean ignoreUnresolvablePlaceholders)`
Create a new `PropertyPlaceholderHelper` that uses the supplied prefix and suffix.
``
`PropertyPlaceholderHelper(String placeholderPrefix, String placeholderSuffix, String valueSeparator, Character escapeCharacter, boolean ignoreUnresolvablePlaceholders)`
Create a new `PropertyPlaceholderHelper` that uses the supplied prefix and suffix.

## Uses of Nullable in org.springframework.util.comparator

Method parameters in org.springframework.util.comparator with annotations of type Nullable
Modifier and Type
Method
Description
`int`
NullSafeComparator.`compare(T left, T right)`
Deprecated.
`int`
NullSafeComparator.`compare(T left, T right)`
Deprecated.
`boolean`
BooleanComparator.`equals(Object other)`
`boolean`
NullSafeComparator.`equals(Object other)`
Deprecated.

## Uses of Nullable in org.springframework.util.concurrent

Methods in org.springframework.util.concurrent with annotations of type Nullable
Modifier and Type
Method
Description
`protected abstract T`
FutureAdapter.`adapt(S adapteeResult)`
Deprecated.
Adapts the given adaptee's result into T.
`T`
FutureAdapter.`get()`
Deprecated.
`T`
FutureAdapter.`get(long timeout, TimeUnit unit)`
Deprecated.
`T`
SettableListenableFuture.`get()`
Deprecated, for removal: This API element is subject to removal in a future version.
Retrieve the value.
`T`
SettableListenableFuture.`get(long timeout, TimeUnit unit)`
Deprecated, for removal: This API element is subject to removal in a future version.
Retrieve the value.
Method parameters in org.springframework.util.concurrent with annotations of type Nullable
Modifier and Type
Method
Description
`void`
SuccessCallback.`onSuccess(T result)`
Deprecated, for removal: This API element is subject to removal in a future version.
Called when the `ListenableFuture` completes with success.
`boolean`
SettableListenableFuture.`set(T value)`
Deprecated, for removal: This API element is subject to removal in a future version.
Set the value of this future.
`void`
ListenableFutureCallbackRegistry.`success(T result)`
Deprecated, for removal: This API element is subject to removal in a future version.
Trigger a `SuccessCallback.onSuccess(Object)` call on all added callbacks with the given result.
Constructor parameters in org.springframework.util.concurrent with annotations of type Nullable
Modifier
Constructor
Description
``
`ListenableFutureTask(Runnable runnable, T result)`
Deprecated, for removal: This API element is subject to removal in a future version.
Create a `ListenableFutureTask` that will, upon running, execute the given `Runnable`, and arrange that `FutureTask.get()` will return the given result on successful completion.

## Uses of Nullable in org.springframework.util.function

Methods in org.springframework.util.function with annotations of type Nullable
Modifier and Type
Method
Description
`T`
SingletonSupplier.`get()`
Get the shared singleton instance for this supplier.
`static <T> SingletonSupplier<T>`
SingletonSupplier.`ofNullable(Supplier<T> supplier)`
Build a `SingletonSupplier` with the given supplier.
`static <T> SingletonSupplier<T>`
SingletonSupplier.`ofNullable(T instance)`
Build a `SingletonSupplier` with the given singleton instance.
`static Object`
SupplierUtils.`resolve(Object candidate)`
Resolve a given `Supplier`, getting its result or immediately returning the given Object as-is if not a `Supplier`.
`static <T> T`
SupplierUtils.`resolve(Supplier<T> supplier)`
Resolve the given `Supplier`, getting its result or immediately returning `null` if the supplier itself was `null`.
Method parameters in org.springframework.util.function with annotations of type Nullable
Modifier and Type
Method
Description
`static <T> SingletonSupplier<T>`
SingletonSupplier.`ofNullable(Supplier<T> supplier)`
Build a `SingletonSupplier` with the given supplier.
`static <T> SingletonSupplier<T>`
SingletonSupplier.`ofNullable(T instance)`
Build a `SingletonSupplier` with the given singleton instance.
`static Object`
SupplierUtils.`resolve(Object candidate)`
Resolve a given `Supplier`, getting its result or immediately returning the given Object as-is if not a `Supplier`.
`static <T> T`
SupplierUtils.`resolve(Supplier<T> supplier)`
Resolve the given `Supplier`, getting its result or immediately returning `null` if the supplier itself was `null`.
Constructor parameters in org.springframework.util.function with annotations of type Nullable
Modifier
Constructor
Description
``
`SingletonSupplier(Supplier<? extends T> instanceSupplier, Supplier<? extends T> defaultSupplier)`
Build a `SingletonSupplier` with the given instance supplier and a default supplier for the case when the instance is `null`.
``
`SingletonSupplier(T instance, Supplier<? extends T> defaultSupplier)`
Build a `SingletonSupplier` with the given singleton instance and a default supplier for the case when the instance is `null`.

## Uses of Nullable in org.springframework.util.unit

Method parameters in org.springframework.util.unit with annotations of type Nullable
Modifier and Type
Method
Description
`boolean`
DataSize.`equals(Object other)`
`static DataSize`
DataSize.`parse(CharSequence text, DataUnit defaultUnit)`
Obtain a `DataSize` from a text string such as `12MB` using the specified default `DataUnit` if no unit is specified.

## Uses of Nullable in org.springframework.util.xml

Methods in org.springframework.util.xml with annotations of type Nullable
Modifier and Type
Method
Description
`static Element`
DomUtils.`getChildElementByTagName(Element ele, String childEleName)`
Utility method that returns the first child element identified by its name.
`static String`
DomUtils.`getChildElementValueByTagName(Element ele, String childEleName)`
Utility method that returns the first child element value identified by its name.
`String`
SimpleNamespaceContext.`getPrefix(String namespaceUri)`
`static XMLEventReader`
StaxUtils.`getXMLEventReader(Source source)`
Return the `XMLEventReader` for the given StAX Source.
`static XMLEventWriter`
StaxUtils.`getXMLEventWriter(Result result)`
Return the `XMLEventWriter` for the given StAX Result.
`static XMLStreamReader`
StaxUtils.`getXMLStreamReader(Source source)`
Return the `XMLStreamReader` for the given StAX Source.
`static XMLStreamWriter`
StaxUtils.`getXMLStreamWriter(Result result)`
Return the `XMLStreamWriter` for the given StAX Result.
Method parameters in org.springframework.util.xml with annotations of type Nullable
Modifier and Type
Method
Description
`void`
SimpleNamespaceContext.`removeBinding(String prefix)`
Remove the given prefix from this context.