# Uses of Annotation Interface
java.lang.FunctionalInterface

Packages that use FunctionalInterface
Package
Description
java.awt
Contains all of the classes for creating user interfaces and for painting graphics and images.
java.io
Provides for system input and output through data streams, serialization and the file system.
java.lang
Provides classes that are fundamental to the design of the Java programming language.
java.lang.classfile
Provides classfile parsing, generation, and transformation library.
java.lang.foreign
Provides low-level access to memory and functions outside the Java runtime.
java.net.http
HTTP Client and WebSocket APIs
java.nio.file
Defines interfaces and classes for the Java virtual machine to access files, file attributes, and file systems.
java.security
Provides the classes and interfaces for the security framework.
java.time.temporal
Access to date and time using fields and units, and date time adjusters.
java.util
Contains the collections framework, some internationalization support classes, a service loader, properties, random number generation, string parsing and scanning classes, base64 encoding and decoding, a bit array, and several miscellaneous utility classes.
java.util.concurrent
Utility classes commonly useful in concurrent programming.
java.util.function
Functional interfaces provide target types for lambda expressions and method references.
java.util.logging
Provides the classes and interfaces of the Java 2 platform's core logging facilities.
java.util.prefs
This package allows applications to store and retrieve user and system preference and configuration data.
java.util.stream
Classes to support functional-style operations on streams of elements, such as map-reduce transformations on collections.
jdk.dynalink.beans
Contains the linker for ordinary Java objects.
jdk.dynalink.linker
Contains interfaces and classes needed by language runtimes to implement their own language-specific object models and type conversions.

- ## Uses of FunctionalInterface in java.awt

  Classes in java.awt with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `interface`
  `KeyEventDispatcher`
  A KeyEventDispatcher cooperates with the current KeyboardFocusManager in the targeting and dispatching of all KeyEvents.
  `interface`
  `KeyEventPostProcessor`
  A KeyEventPostProcessor cooperates with the current KeyboardFocusManager in the final resolution of all unconsumed KeyEvents.

- ## Uses of FunctionalInterface in java.io

  Classes in java.io with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `interface`
  `FileFilter`
  A filter for abstract pathnames.
  `interface`
  `FilenameFilter`
  Instances of classes that implement this interface are used to filter filenames.
  `interface`
  `ObjectInputFilter`
  Filter classes, array lengths, and graph metrics during deserialization.

- ## Uses of FunctionalInterface in java.lang

  Classes in java.lang with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `interface`
  `Runnable`
  Represents an operation that does not return a result.
  `static interface`
  `ScopedValue.CallableOp<T, X extends Throwable>`
  An operation that returns a result and may throw an exception.
  `static interface`
  `Thread.UncaughtExceptionHandler`
  Interface for handlers invoked when a `Thread` abruptly terminates due to an uncaught exception.

- ## Uses of FunctionalInterface in java.lang.classfile

  Classes in java.lang.classfile with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `interface`
  `ClassHierarchyResolver`
  Provides class hierarchy information for stack maps generation and verification.
  `interface`
  `ClassTransform`
  A transformation on streams of `ClassElement`.
  `interface`
  `CodeTransform`
  A transformation on streams of `CodeElement`.
  `interface`
  `FieldTransform`
  A transformation on streams of `FieldElement`.
  `interface`
  `MethodTransform`
  A transformation on streams of `MethodElement`.

- ## Uses of FunctionalInterface in java.lang.foreign

  Classes in java.lang.foreign with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `interface`
  `SegmentAllocator`
  An object that may be used to allocate memory segments.
  `interface`
  `SymbolLookup`
  A symbol lookup retrieves the address of a symbol in one or more libraries.

- ## Uses of FunctionalInterface in java.net.http

  Classes in java.net.http with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `static interface`
  `HttpResponse.BodyHandler<T>`
  A handler for response bodies.

- ## Uses of FunctionalInterface in java.nio.file

  Classes in java.nio.file with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `static interface`
  `DirectoryStream.Filter<T>`
  An interface that is implemented by objects that decide if a directory entry should be accepted or filtered.
  `interface`
  `PathMatcher`
  An interface that is implemented by objects that perform match operations on paths.

- ## Uses of FunctionalInterface in java.security

  Classes in java.security with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `interface`
  `PrivilegedAction<T>`
  A computation to be performed by invoking `AccessController.doPrivileged` on the `PrivilegedAction` object.
  `interface`
  `PrivilegedExceptionAction<T>`
  A computation to be performed that throws one or more checked exceptions.

- ## Uses of FunctionalInterface in java.time.temporal

  Classes in java.time.temporal with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `interface`
  `TemporalAdjuster`
  Strategy for adjusting a temporal object.
  `interface`
  `TemporalQuery<R>`
  Strategy for querying a temporal object.

- ## Uses of FunctionalInterface in java.util

  Classes in java.util with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `interface`
  `Comparator<T>`
  A comparison function, which imposes a total ordering on some collection of objects.

- ## Uses of FunctionalInterface in java.util.concurrent

  Classes in java.util.concurrent with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `interface`
  `Callable<V>`
  A task that returns a result and may throw an exception.
  `static interface`
  `Flow.Publisher<T>`
  A producer of items (and related control messages) received by Subscribers.

- ## Uses of FunctionalInterface in java.util.function

  Classes in java.util.function with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `interface`
  `BiConsumer<T,U>`
  Represents an operation that accepts two input arguments and returns no result.
  `interface`
  `BiFunction<T,U,R>`
  Represents a function that accepts two arguments and produces a result.
  `interface`
  `BinaryOperator<T>`
  Represents an operation upon two operands of the same type, producing a result of the same type as the operands.
  `interface`
  `BiPredicate<T,U>`
  Represents a predicate (boolean-valued function) of two arguments.
  `interface`
  `BooleanSupplier`
  Represents a supplier of `boolean`-valued results.
  `interface`
  `Consumer<T>`
  Represents an operation that accepts a single input argument and returns no result.
  `interface`
  `DoubleBinaryOperator`
  Represents an operation upon two `double`-valued operands and producing a `double`-valued result.
  `interface`
  `DoubleConsumer`
  Represents an operation that accepts a single `double`-valued argument and returns no result.
  `interface`
  `DoubleFunction<R>`
  Represents a function that accepts a double-valued argument and produces a result.
  `interface`
  `DoublePredicate`
  Represents a predicate (boolean-valued function) of one `double`-valued argument.
  `interface`
  `DoubleSupplier`
  Represents a supplier of `double`-valued results.
  `interface`
  `DoubleToIntFunction`
  Represents a function that accepts a double-valued argument and produces an int-valued result.
  `interface`
  `DoubleToLongFunction`
  Represents a function that accepts a double-valued argument and produces a long-valued result.
  `interface`
  `DoubleUnaryOperator`
  Represents an operation on a single `double`-valued operand that produces a `double`-valued result.
  `interface`
  `Function<T,R>`
  Represents a function that accepts one argument and produces a result.
  `interface`
  `IntBinaryOperator`
  Represents an operation upon two `int`-valued operands and producing an `int`-valued result.
  `interface`
  `IntConsumer`
  Represents an operation that accepts a single `int`-valued argument and returns no result.
  `interface`
  `IntFunction<R>`
  Represents a function that accepts an int-valued argument and produces a result.
  `interface`
  `IntPredicate`
  Represents a predicate (boolean-valued function) of one `int`-valued argument.
  `interface`
  `IntSupplier`
  Represents a supplier of `int`-valued results.
  `interface`
  `IntToDoubleFunction`
  Represents a function that accepts an int-valued argument and produces a double-valued result.
  `interface`
  `IntToLongFunction`
  Represents a function that accepts an int-valued argument and produces a long-valued result.
  `interface`
  `IntUnaryOperator`
  Represents an operation on a single `int`-valued operand that produces an `int`-valued result.
  `interface`
  `LongBinaryOperator`
  Represents an operation upon two `long`-valued operands and producing a `long`-valued result.
  `interface`
  `LongConsumer`
  Represents an operation that accepts a single `long`-valued argument and returns no result.
  `interface`
  `LongFunction<R>`
  Represents a function that accepts a long-valued argument and produces a result.
  `interface`
  `LongPredicate`
  Represents a predicate (boolean-valued function) of one `long`-valued argument.
  `interface`
  `LongSupplier`
  Represents a supplier of `long`-valued results.
  `interface`
  `LongToDoubleFunction`
  Represents a function that accepts a long-valued argument and produces a double-valued result.
  `interface`
  `LongToIntFunction`
  Represents a function that accepts a long-valued argument and produces an int-valued result.
  `interface`
  `LongUnaryOperator`
  Represents an operation on a single `long`-valued operand that produces a `long`-valued result.
  `interface`
  `ObjDoubleConsumer<T>`
  Represents an operation that accepts an object-valued and a `double`-valued argument, and returns no result.
  `interface`
  `ObjIntConsumer<T>`
  Represents an operation that accepts an object-valued and a `int`-valued argument, and returns no result.
  `interface`
  `ObjLongConsumer<T>`
  Represents an operation that accepts an object-valued and a `long`-valued argument, and returns no result.
  `interface`
  `Predicate<T>`
  Represents a predicate (boolean-valued function) of one argument.
  `interface`
  `Supplier<T>`
  Represents a supplier of results.
  `interface`
  `ToDoubleBiFunction<T,U>`
  Represents a function that accepts two arguments and produces a double-valued result.
  `interface`
  `ToDoubleFunction<T>`
  Represents a function that produces a double-valued result.
  `interface`
  `ToIntBiFunction<T,U>`
  Represents a function that accepts two arguments and produces an int-valued result.
  `interface`
  `ToIntFunction<T>`
  Represents a function that produces an int-valued result.
  `interface`
  `ToLongBiFunction<T,U>`
  Represents a function that accepts two arguments and produces a long-valued result.
  `interface`
  `ToLongFunction<T>`
  Represents a function that produces a long-valued result.
  `interface`
  `UnaryOperator<T>`
  Represents an operation on a single operand that produces a result of the same type as its operand.

- ## Uses of FunctionalInterface in java.util.logging

  Classes in java.util.logging with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `interface`
  `Filter`
  A Filter can be used to provide fine grain control over what is logged, beyond the control provided by log levels.

- ## Uses of FunctionalInterface in java.util.prefs

  Classes in java.util.prefs with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `interface`
  `PreferenceChangeListener`
  A listener for receiving preference change events.

- ## Uses of FunctionalInterface in java.util.stream

  Classes in java.util.stream with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `static interface`
  `DoubleStream.DoubleMapMultiConsumer`
  Represents an operation that accepts a `double`-valued argument and a DoubleConsumer, and returns no result.
  `static interface`
  `Gatherer.Downstream<T>`
  A Downstream object is the next stage in a pipeline of operations, to which elements can be sent.
  `static interface`
  `Gatherer.Integrator<A,T,R>`
  An Integrator receives elements and processes them, optionally using the supplied state, and optionally sends incremental results downstream.
  `static interface`
  `Gatherer.Integrator.Greedy<A,T,R>`
  Greedy Integrators consume all their input, and may only relay that the downstream does not want more elements.
  `static interface`
  `IntStream.IntMapMultiConsumer`
  Represents an operation that accepts an `int`-valued argument and an IntConsumer, and returns no result.
  `static interface`
  `LongStream.LongMapMultiConsumer`
  Represents an operation that accepts a `long`-valued argument and a LongConsumer, and returns no result.

- ## Uses of FunctionalInterface in jdk.dynalink.beans

  Classes in jdk.dynalink.beans with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `interface`
  `MissingMemberHandlerFactory`
  A factory for creating method handles for linking missing member behavior in `BeansLinker`.

- ## Uses of FunctionalInterface in jdk.dynalink.linker

  Classes in jdk.dynalink.linker with annotations of type FunctionalInterface
  Modifier and Type
  Interface
  Description
  `interface`
  `GuardedInvocationTransformer`
  Interface for objects that are used to transform one guarded invocation into another one.
  `interface`
  `MethodHandleTransformer`
  A generic interface describing operations that transform method handles.
  `interface`
  `MethodTypeConversionStrategy`
  Interface for objects representing a strategy for converting a method handle to a new type.