## Uses of Interface
java.io.Serializable

- Packages that use Serializable
  Package | Description
  --- | ---
  java.beans |
  java.io |
  java.lang |
  java.lang.annotation |
  java.lang.invoke |
  java.lang.reflect | Provides classes and interfaces for obtaining reflective information about classes and objects.
  java.math | Provides classes for performing arbitrary-precision integer arithmetic (`BigInteger`) and arbitrary-precision decimal arithmetic (`BigDecimal`).
  java.net |
  java.nio.charset |
  java.security |
  java.text |
  java.util |
  java.util.concurrent | Utility classes commonly useful in concurrent programming.
  java.util.concurrent.atomic | A small toolkit of classes that support lock-free thread-safe programming on single variables.
  java.util.concurrent.locks | Interfaces and classes providing a framework for locking and waiting for conditions that is distinct from built-in synchronization and monitors.
  java.util.logging |
  java.util.regex | Classes for matching character sequences against patterns specified by regular expressions.
  java.util.stream | Classes to support functional-style operations on streams of elements, such as map-reduce transformations on collections.
  org.apidesign.vm4brwsr |
  org.openide.util | Client API part of the Lookup interfaces.
  org.openide.util.lookup | Support classes for the Registration and `Lookup` extension mechanism.

- - ### Uses of Serializable in java.beans

    Classes in java.beans that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `IndexedPropertyChangeEvent` An "IndexedPropertyChange" event gets delivered whenever a component that conforms to the JavaBeans™ specification (a "bean") changes a bound indexed property.
    `class` | `PropertyChangeEvent` A "PropertyChange" event gets delivered whenever a bean changes a "bound" or "constrained" property.
    `class` | `PropertyChangeSupport` This is a utility class that can be used by beans that support bound properties.
    `class` | `PropertyVetoException` A PropertyVetoException is thrown when a proposed change to a property represents an unacceptable value.
    `class` | `VetoableChangeSupport` This is a utility class that can be used by beans that support constrained properties.

  - ### Uses of Serializable in java.io

    Subinterfaces of Serializable in java.io
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `Externalizable` Only the identity of the class of an Externalizable instance is written in the serialization stream and it is the responsibility of the class to save and restore the contents of its instances.

    Classes in java.io that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `EOFException` Signals that an end of file or end of stream has been reached unexpectedly during input.
    `class` | `File` An abstract representation of file and directory pathnames.
    `class` | `FileNotFoundException` Signals that an attempt to open the file denoted by a specified pathname has failed.
    `class` | `InterruptedIOException` Signals that an I/O operation has been interrupted.
    `class` | `InvalidClassException` Thrown when the Serialization runtime detects one of the following problems with a Class.
    `class` | `InvalidObjectException` Indicates that one or more deserialized objects failed validation tests.
    `class` | `IOException` Signals that an I/O exception of some sort has occurred.
    `class` | `NotActiveException` Thrown when serialization or deserialization is not active.
    `class` | `NotSerializableException` Thrown when an instance is required to have a Serializable interface.
    `class` | `ObjectStreamClass` Serialization's descriptor for classes.
    `class` | `ObjectStreamException` Superclass of all exceptions specific to Object Stream classes.
    `class` | `OptionalDataException` Exception indicating the failure of an object read operation due to unread primitive data, or the end of data belonging to a serialized object in the stream.
    `class` | `StreamCorruptedException` Thrown when control information that was read from an object stream violates internal consistency checks.
    `class` | `SyncFailedException` Signals that a sync operation has failed.
    `class` | `UnsupportedEncodingException` The Character Encoding is not supported.
    `class` | `UTFDataFormatException` Signals that a malformed string in modified UTF-8 format has been read in a data input stream or by any class that implements the data input interface.
    `class` | `WriteAbortedException` Signals that one of the ObjectStreamExceptions was thrown during a write operation.

  - ### Uses of Serializable in java.lang

    Classes in java.lang that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractMethodError` Thrown when an application tries to call an abstract method.
    `class` | `ArithmeticException` Thrown when an exceptional arithmetic condition has occurred.
    `class` | `ArrayIndexOutOfBoundsException` Thrown to indicate that an array has been accessed with an illegal index.
    `class` | `ArrayStoreException` Thrown to indicate that an attempt has been made to store the wrong type of object into an array of objects.
    `class` | `AssertionError` Thrown to indicate that an assertion has failed.
    `class` | `Boolean` The Boolean class wraps a value of the primitive type `boolean` in an object.
    `class` | `Byte` The `Byte` class wraps a value of primitive type `byte` in an object.
    `class` | `Character` The `Character` class wraps a value of the primitive type `char` in an object.
    `class` | `Class<T>` Instances of the class `Class` represent classes and interfaces in a running Java application.
    `class` | `ClassCastException` Thrown to indicate that the code has attempted to cast an object to a subclass of which it is not an instance.
    `class` | `ClassFormatError` Thrown when the Java Virtual Machine attempts to read a class file and determines that the file is malformed or otherwise cannot be interpreted as a class file.
    `class` | `ClassNotFoundException` Thrown when an application tries to load in a class through its string name using: The `forName` method in class `Class`.
    `class` | `CloneNotSupportedException` Thrown to indicate that the `clone` method in class `Object` has been called to clone an object, but that the object's class does not implement the `Cloneable` interface.
    `class` | `Double` The `Double` class wraps a value of the primitive type `double` in an object.
    `class` | `Enum<E extends Enum<E>>` This is the common base class of all Java language enumeration types.
    `class` | `Error` An `Error` is a subclass of `Throwable` that indicates serious problems that a reasonable application should not try to catch.
    `class` | `Exception` The class `Exception` and its subclasses are a form of `Throwable` that indicates conditions that a reasonable application might want to catch.
    `class` | `Float` The `Float` class wraps a value of primitive type `float` in an object.
    `class` | `IllegalAccessError` Thrown if an application attempts to access or modify a field, or to call a method that it does not have access to.
    `class` | `IllegalAccessException` An IllegalAccessException is thrown when an application tries to reflectively create an instance (other than an array), set or get a field, or invoke a method, but the currently executing method does not have access to the definition of the specified class, field, method or constructor.
    `class` | `IllegalArgumentException` Thrown to indicate that a method has been passed an illegal or inappropriate argument.
    `class` | `IllegalMonitorStateException` Thrown to indicate that a thread has attempted to wait on an object's monitor or to notify other threads waiting on an object's monitor without owning the specified monitor.
    `class` | `IllegalStateException` Signals that a method has been invoked at an illegal or inappropriate time.
    `class` | `IncompatibleClassChangeError` Thrown when an incompatible class change has occurred to some class definition.
    `class` | `IndexOutOfBoundsException` Thrown to indicate that an index of some sort (such as to an array, to a string, or to a vector) is out of range.
    `class` | `InstantiationException` Thrown when an application tries to create an instance of a class using the `newInstance` method in class `Class`, but the specified class object cannot be instantiated.
    `class` | `Integer` The `Integer` class wraps a value of the primitive type `int` in an object.
    `class` | `InternalError` Thrown to indicate some unexpected internal error has occurred in the Java Virtual Machine.
    `class` | `InterruptedException` Thrown when a thread is waiting, sleeping, or otherwise occupied, and the thread is interrupted, either before or during the activity.
    `class` | `LinkageError` Subclasses of `LinkageError` indicate that a class has some dependency on another class; however, the latter class has incompatibly changed after the compilation of the former class.
    `class` | `Long` The `Long` class wraps a value of the primitive type `long` in an object.
    `class` | `NegativeArraySizeException` Thrown if an application tries to create an array with negative size.
    `class` | `NoSuchFieldError` Thrown if an application tries to access or modify a specified field of an object, and that object no longer has that field.
    `class` | `NoSuchMethodError` Thrown if an application tries to call a specified method of a class (either static or instance), and that class no longer has a definition of that method.
    `class` | `NoSuchMethodException` Thrown when a particular method cannot be found.
    `class` | `NullPointerException` Thrown when an application attempts to use `null` in a case where an object is required.
    `class` | `Number` The abstract class `Number` is the superclass of classes `BigDecimal`, `BigInteger`, `Byte`, `Double`, `Float`, `Integer`, `Long`, and `Short`.
    `class` | `NumberFormatException` Thrown to indicate that the application has attempted to convert a string to one of the numeric types, but that the string does not have the appropriate format.
    `class` | `OutOfMemoryError` Thrown when the Java Virtual Machine cannot allocate an object because it is out of memory, and no more memory could be made available by the garbage collector.
    `class` | `ReflectiveOperationException` Common superclass of exceptions thrown by reflective operations in core reflection.
    `class` | `RuntimeException` `RuntimeException` is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.
    `class` | `SecurityException` Thrown by the security manager to indicate a security violation.
    `class` | `Short` The `Short` class wraps a value of primitive type `short` in an object.
    `class` | `StackOverflowError` Thrown when a stack overflow occurs because an application recurses too deeply.
    `class` | `StackTraceElement` An element in a stack trace, as returned by `Throwable.getStackTrace()`.
    `class` | `String` The `String` class represents character strings.
    `class` | `StringBuffer` A thread-safe, mutable sequence of characters.
    `class` | `StringBuilder` A mutable sequence of characters.
    `class` | `StringIndexOutOfBoundsException` Thrown by `String` methods to indicate that an index is either negative or greater than the size of the string.
    `static class` | `System.Logger.Level`
    `static class` | `Thread.State` A thread state.
    `class` | `Throwable` The `Throwable` class is the superclass of all errors and exceptions in the Java language.
    `class` | `UnsupportedOperationException` Thrown to indicate that the requested operation is not supported.
    `class` | `VirtualMachineError` Thrown to indicate that the Java Virtual Machine is broken or has run out of resources necessary for it to continue operating.

  - ### Uses of Serializable in java.lang.annotation

    Classes in java.lang.annotation that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AnnotationFormatError` Thrown when the annotation parser attempts to read an annotation from a class file and determines that the annotation is malformed.
    `class` | `AnnotationTypeMismatchException` Thrown to indicate that a program has attempted to access an element of an annotation whose type has changed after the annotation was compiled (or serialized).
    `class` | `ElementType` A program element type.
    `class` | `IncompleteAnnotationException` Thrown to indicate that a program has attempted to access an element of an annotation type that was added to the annotation type definition after the annotation was compiled (or serialized).
    `class` | `RetentionPolicy` Annotation retention policy.

  - ### Uses of Serializable in java.lang.invoke

    Classes in java.lang.invoke that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MethodType` A method type represents the arguments and return type accepted and returned by a method handle, or the arguments and return type passed and expected by a method handle caller.
    `class` | `SerializedLambda` Serialized form of a lambda expression.

  - ### Uses of Serializable in java.lang.reflect

    Classes in java.lang.reflect that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `InvocationTargetException` InvocationTargetException is a checked exception that wraps an exception thrown by an invoked method or constructor.
    `class` | `Proxy` `Proxy` provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods.
    `class` | `UndeclaredThrowableException` Thrown by a method invocation on a proxy instance if its invocation handler's `invoke` method throws a checked exception (a `Throwable` that is not assignable to `RuntimeException` or `Error`) that is not assignable to any of the exception types declared in the `throws` clause of the method that was invoked on the proxy instance and dispatched to the invocation handler.

  - ### Uses of Serializable in java.math

    Classes in java.math that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BigDecimal` Immutable, arbitrary-precision signed decimal numbers.
    `class` | `BigInteger` Immutable arbitrary-precision integers.
    `class` | `MathContext` Immutable objects which encapsulate the context settings which describe certain rules for numerical operators, such as those implemented by the `BigDecimal` class.
    `class` | `RoundingMode` Specifies a rounding behavior for numerical operations capable of discarding precision.

  - ### Uses of Serializable in java.net

    Classes in java.net that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MalformedURLException` Thrown to indicate that a malformed URL has occurred.
    `class` | `URI` Represents a Uniform Resource Identifier (URI) reference.
    `class` | `URISyntaxException` Checked exception thrown to indicate that a string could not be parsed as a URI reference.
    `class` | `URL` Class `URL` represents a Uniform Resource Locator, a pointer to a "resource" on the World Wide Web.

  - ### Uses of Serializable in java.nio.charset

    Classes in java.nio.charset that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `IllegalCharsetNameException` Unchecked exception thrown when a string that is not a legal charset name is used as such.
    `class` | `UnsupportedCharsetException` Unchecked exception thrown when no support is available for a requested charset.

  - ### Uses of Serializable in java.security

    Classes in java.security that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `PrivilegedActionException` This exception is thrown by `doPrivileged(PrivilegedExceptionAction)` and `doPrivileged(PrivilegedExceptionAction, AccessControlContext context)` to indicate that the action being performed threw a checked exception.

  - ### Uses of Serializable in java.text

    Classes in java.text that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `AttributedCharacterIterator.Attribute` Defines attribute keys that are used to identify text attributes.
    `class` | `ChoiceFormat` A `ChoiceFormat` allows you to attach a format to a range of numbers.
    `class` | `DateFormat` `DateFormat` is an abstract class for date/time formatting subclasses which formats and parses dates or time in a language-independent manner.
    `static class` | `DateFormat.Field` Defines constants that are used as attribute keys in the `AttributedCharacterIterator` returned from `DateFormat.formatToCharacterIterator` and as field identifiers in `FieldPosition`.
    `class` | `DateFormatSymbols` `DateFormatSymbols` is a public class for encapsulating localizable date-time formatting data, such as the names of the months, the names of the days of the week, and the time zone data.
    `class` | `DecimalFormat` `DecimalFormat` is a concrete subclass of `NumberFormat` that formats decimal numbers.
    `class` | `DecimalFormatSymbols` This class represents the set of symbols (such as the decimal separator, the grouping separator, and so on) needed by `DecimalFormat` to format numbers.
    `class` | `Format` `Format` is an abstract base class for formatting locale-sensitive information such as dates, messages, and numbers.
    `static class` | `Format.Field` Defines constants that are used as attribute keys in the `AttributedCharacterIterator` returned from `Format.formatToCharacterIterator` and as field identifiers in `FieldPosition`.
    `class` | `MessageFormat` `MessageFormat` provides a means to produce concatenated messages in a language-neutral way.
    `static class` | `MessageFormat.Field` Defines constants that are used as attribute keys in the `AttributedCharacterIterator` returned from `MessageFormat.formatToCharacterIterator`.
    `class` | `NumberFormat` `NumberFormat` is the abstract base class for all number formats.
    `static class` | `NumberFormat.Field` Defines constants that are used as attribute keys in the `AttributedCharacterIterator` returned from `NumberFormat.formatToCharacterIterator` and as field identifiers in `FieldPosition`.
    `class` | `ParseException` Signals that an error has been reached unexpectedly while parsing.
    `class` | `SimpleDateFormat` `SimpleDateFormat` is a concrete class for formatting and parsing dates in a locale-sensitive manner.

  - ### Uses of Serializable in java.util

    Classes in java.util that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `AbstractMap.SimpleEntry<K,V>` An Entry maintaining a key and a value.
    `static class` | `AbstractMap.SimpleImmutableEntry<K,V>` An Entry maintaining an immutable key and value.
    `class` | `ArrayDeque<E>` Resizable-array implementation of the `Deque` interface.
    `class` | `ArrayList<E>` Resizable-array implementation of the `List` interface.
    `class` | `BitSet` This class implements a vector of bits that grows as needed.
    `class` | `Calendar` The `Calendar` class is an abstract class that provides methods for converting between a specific instant in time and a set of `calendar fields` such as `YEAR`, `MONTH`, `DAY_OF_MONTH`, `HOUR`, and so on, and for manipulating the calendar fields, such as getting the date of the next week.
    `class` | `ConcurrentModificationException` This exception may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible.
    `class` | `Currency` Represents a currency.
    `class` | `Date` The class `Date` represents a specific instant in time, with millisecond precision.
    `class` | `EmptyStackException` Thrown by methods in the `Stack` class to indicate that the stack is empty.
    `class` | `EnumMap<K extends Enum<K>,V>` A specialized `Map` implementation for use with enum type keys.
    `class` | `EnumSet<E extends Enum<E>>` A specialized `Set` implementation for use with enum types.
    `class` | `EventObject` The root class from which all event state objects shall be derived.
    `class` | `HashMap<K,V>` Hash table based implementation of the `Map` interface.
    `class` | `HashSet<E>` This class implements the `Set` interface, backed by a hash table (actually a `HashMap` instance).
    `class` | `Hashtable<K,V>` This class implements a hash table, which maps keys to values.
    `class` | `IdentityHashMap<K,V>` This class implements the `Map` interface with a hash table, using reference-equality in place of object-equality when comparing keys (and values).
    `class` | `LinkedHashMap<K,V>` Hash table and linked list implementation of the `Map` interface, with predictable iteration order.
    `class` | `LinkedHashSet<E>` Hash table and linked list implementation of the `Set` interface, with predictable iteration order.
    `class` | `LinkedList<E>` Doubly-linked list implementation of the `List` and `Deque` interfaces.
    `class` | `Locale` A `Locale` object represents a specific geographical, political, or cultural region.
    `static class` | `Locale.Category` Enum for locale categories.
    `class` | `MissingResourceException` Signals that a resource is missing.
    `class` | `NoSuchElementException` Thrown by the `nextElement` method of an `Enumeration` to indicate that there are no more elements in the enumeration.
    `class` | `PriorityQueue<E>` An unbounded priority queue based on a priority heap.
    `class` | `Properties` The `Properties` class represents a persistent set of properties.
    `class` | `Random` An instance of this class is used to generate a stream of pseudorandom numbers.
    `class` | `ServiceConfigurationError` Error thrown when something goes wrong while loading a service provider.
    `class` | `SimpleTimeZone` `SimpleTimeZone` is a concrete subclass of `TimeZone` that represents a time zone for use with a Gregorian calendar.
    `class` | `Stack<E>` The `Stack` class represents a last-in-first-out (LIFO) stack of objects.
    `class` | `TimeZone` `TimeZone` represents a time zone offset, and also figures out daylight savings.
    `class` | `TreeMap<K,V>` A Red-Black tree based `NavigableMap` implementation.
    `class` | `TreeSet<E>` A `NavigableSet` implementation based on a `TreeMap`.
    `class` | `Vector<E>` The `Vector` class implements a growable array of objects.

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

    Classes in java.util.concurrent that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ArrayBlockingQueue<E>` A bounded blocking queue backed by an array.
    `class` | `BrokenBarrierException` Exception thrown when a thread tries to wait upon a barrier that is in a broken state, or which enters the broken state while the thread is waiting.
    `class` | `CancellationException` Exception indicating that the result of a value-producing task, such as a `FutureTask`, cannot be retrieved because the task was cancelled.
    `class` | `ConcurrentHashMap<K,V>` A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updates.
    `class` | `ConcurrentLinkedDeque<E>` An unbounded concurrent deque based on linked nodes.
    `class` | `ConcurrentLinkedQueue<E>` An unbounded thread-safe queue based on linked nodes.
    `class` | `ConcurrentSkipListMap<K,V>` A scalable concurrent `ConcurrentNavigableMap` implementation.
    `class` | `ConcurrentSkipListSet<E>` A scalable concurrent `NavigableSet` implementation based on a `ConcurrentSkipListMap`.
    `class` | `CopyOnWriteArrayList<E>` A thread-safe variant of `ArrayList` in which all mutative operations (`add`, `set`, and so on) are implemented by making a fresh copy of the underlying array.
    `class` | `CopyOnWriteArraySet<E>` A `Set` that uses an internal `CopyOnWriteArrayList` for all of its operations.
    `class` | `CountedCompleter<T>` A `ForkJoinTask` with a completion action performed when triggered and there are no remaining pending actions.
    `class` | `ExecutionException` Exception thrown when attempting to retrieve the result of a task that aborted by throwing an exception.
    `class` | `ForkJoinTask<V>` Abstract base class for tasks that run within a `ForkJoinPool`.
    `class` | `LinkedBlockingDeque<E>` An optionally-bounded blocking deque based on linked nodes.
    `class` | `LinkedBlockingQueue<E>` An optionally-bounded blocking queue based on linked nodes.
    `class` | `LinkedTransferQueue<E>` An unbounded `TransferQueue` based on linked nodes.
    `class` | `PriorityBlockingQueue<E>` An unbounded blocking queue that uses the same ordering rules as class `PriorityQueue` and supplies blocking retrieval operations.
    `class` | `RecursiveAction` A recursive resultless `ForkJoinTask`.
    `class` | `RecursiveTask<V>` A recursive result-bearing `ForkJoinTask`.
    `class` | `RejectedExecutionException` Exception thrown by an `Executor` when a task cannot be accepted for execution.
    `class` | `Semaphore` A counting semaphore.
    `class` | `SynchronousQueue<E>` A blocking queue in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa.
    `class` | `ThreadLocalRandom` A random number generator isolated to the current thread.
    `class` | `TimeoutException` Exception thrown when a blocking operation times out.
    `class` | `TimeUnit` A `TimeUnit` represents time durations at a given unit of granularity and provides utility methods to convert across units, and to perform timing and delay operations in these units.

  - ### Uses of Serializable in java.util.concurrent.atomic

    Classes in java.util.concurrent.atomic that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AtomicBoolean` A `boolean` value that may be updated atomically.
    `class` | `AtomicInteger` An `int` value that may be updated atomically.
    `class` | `AtomicIntegerArray` An `int` array in which elements may be updated atomically.
    `class` | `AtomicLong` A `long` value that may be updated atomically.
    `class` | `AtomicLongArray` A `long` array in which elements may be updated atomically.
    `class` | `AtomicReference<V>` An object reference that may be updated atomically.
    `class` | `AtomicReferenceArray<E>` An array of object references in which elements may be updated atomically.

  - ### Uses of Serializable in java.util.concurrent.locks

    Classes in java.util.concurrent.locks that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractOwnableSynchronizer` A synchronizer that may be exclusively owned by a thread.
    `class` | `AbstractQueuedLongSynchronizer` A version of `AbstractQueuedSynchronizer` in which synchronization state is maintained as a `long`.
    `class` | `AbstractQueuedLongSynchronizer.ConditionObject` Condition implementation for a `AbstractQueuedLongSynchronizer` serving as the basis of a `Lock` implementation.
    `class` | `AbstractQueuedSynchronizer` Provides a framework for implementing blocking locks and related synchronizers (semaphores, events, etc) that rely on first-in-first-out (FIFO) wait queues.
    `class` | `AbstractQueuedSynchronizer.ConditionObject` Condition implementation for a `AbstractQueuedSynchronizer` serving as the basis of a `Lock` implementation.
    `class` | `ReentrantLock` A reentrant mutual exclusion `Lock` with the same basic behavior and semantics as the implicit monitor lock accessed using `synchronized` methods and statements, but with extended capabilities.
    `class` | `ReentrantReadWriteLock` An implementation of `ReadWriteLock` supporting similar semantics to `ReentrantLock`.
    `static class` | `ReentrantReadWriteLock.ReadLock` The lock returned by method `ReentrantReadWriteLock.readLock()`.
    `static class` | `ReentrantReadWriteLock.WriteLock` The lock returned by method `ReentrantReadWriteLock.writeLock()`.

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

    Classes in java.util.logging that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Level` The Level class defines a set of standard logging levels that can be used to control logging output.
    `class` | `LogRecord` LogRecord objects are used to pass logging requests between the logging framework and individual log Handlers.

  - ### Uses of Serializable in java.util.regex

    Classes in java.util.regex that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `Pattern` A compiled representation of a regular expression.
    `class` | `PatternSyntaxException` Unchecked exception thrown to indicate a syntax error in a regular-expression pattern.

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

    Classes in java.util.stream that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `Collector.Characteristics` Characteristics indicating properties of a `Collector`, which can be used to optimize reduction implementations.

  - ### Uses of Serializable in org.apidesign.vm4brwsr

    Classes in org.apidesign.vm4brwsr that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ObfuscationLevel` Defines obfuscation level of produced JavaScript files.

  - ### Uses of Serializable in org.openide.util

    Classes in org.openide.util that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `LookupEvent` An event describing the change in the lookup's result.

  - ### Uses of Serializable in org.openide.util.lookup

    Classes in org.openide.util.lookup that implement Serializable
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractLookup` Implementation of the lookup from OpenAPIs that is based on the introduction of Item.
    `static class` | `AbstractLookup.Content` A class that can be used by the creator of the `AbstractLookup` to control its content (a kind of Privileged API giving creator of the lookup more rights than subsequent users of the lookup).
    `static class` | `AbstractLookup.Pair<T>` Extension to the default lookup item that offers additional information for the data structures use in AbstractLookup
    `class` | `InstanceContent` A special content implementation that can be passed to AbstractLookup and provides methods for registration of instances and lazy instances.

Copyright © 2025 API Design. All Rights Reserved.