概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 5.0

上一个下一个

框架 无框架

序列化表格

软件包 java.lang

类 java.lang.AbstractMethodError 继承 IncompatibleClassChangeError 实现 Serializable

类 java.lang.ArithmeticException 继承 RuntimeException 实现 Serializable

类 java.lang.ArrayIndexOutOfBoundsException 继承 IndexOutOfBoundsException 实现 Serializable

类 java.lang.ArrayStoreException 继承 RuntimeException 实现 Serializable

类 java.lang.AssertionError 继承 Error 实现 Serializable

类 java.lang.Boolean 继承 Object 实现 Serializable

serialVersionUID: -3665804199014368530L

序列化字段

value

boolean value

布尔值。

类 java.lang.Byte 继承 Number 实现 Serializable

serialVersionUID: -7183698231559129828L

序列化字段

value

byte value

Byte 的值。

类 java.lang.Character 继承 Object 实现 Serializable

serialVersionUID: 3786198910865385080L

序列化字段

value

char value

Character 的值。

类 java.lang.Class 继承 Object 实现 Serializable

serialVersionUID: 3206093459760846163L

序列化概述

Class 类是 Serialization Stream Protocol 中的一个特例。 Class 实例最初是以下列格式写入 ObjectOutputStream 的：

      TC_CLASS ClassDescriptor
      ClassDescriptor 是 java.io.ObjectStreamClass 实例的一个特殊序列化。

类描述符写入该流的初始时刻会生成一个新的句柄。未来对该类描述符的引用写作对此初始类描述符实例的引用。

另请参见：: ObjectStreamClass

序列化字段

类 java.lang.ClassCastException 继承 RuntimeException 实现 Serializable

类 java.lang.ClassCircularityError 继承 LinkageError 实现 Serializable

类 java.lang.ClassFormatError 继承 LinkageError 实现 Serializable

类 java.lang.ClassNotFoundException 继承 Exception 实现 Serializable

serialVersionUID: 9176873029745254542L

序列化字段

ex

Throwable ex

如果使用 ClassNotFoundException(String s, Throwable ex) 构造方法来实例化对象，则此字段保存异常 ex。

从以下版本开始：: 1.2

类 java.lang.CloneNotSupportedException 继承 Exception 实现 Serializable

类 java.lang.Double 继承 Number 实现 Serializable

serialVersionUID: -9172774392245257468L

序列化字段

value

double value

Double 的值。

类 java.lang.Enum 继承 Object 实现 Serializable

序列化字段

name

String name

此枚举常量的名称，在枚举声明中声明。大多数程序员应该使用 Enum.toString() 方法，而不是访问此字段。

ordinal

int ordinal

此枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。大多数程序员不会使用此字段。它被设计用于复杂的基于枚举的数据结构，比如 EnumSet 和 EnumMap。

类 java.lang.EnumConstantNotPresentException 继承 RuntimeException 实现 Serializable

序列化字段

enumType

Class<T> enumType

缺少的枚举常量的类型。

constantName

String constantName

缺少的枚举常量的名称。

类 java.lang.Error 继承 Throwable 实现 Serializable

serialVersionUID: 4980196508277280342L

类 java.lang.Exception 继承 Throwable 实现 Serializable

serialVersionUID: -3387516993124229948L

类 java.lang.ExceptionInInitializerError 继承 LinkageError 实现 Serializable

serialVersionUID: 1521711792217232256L

序列化字段

exception

Throwable exception

如果使用 ExceptionInInitializerError(Throwable thrown) 构造方法来实例化此对象，则该字段将保存异常

类 java.lang.Float 继承 Number 实现 Serializable

serialVersionUID: -2671257302660747028L

序列化字段

value

float value

Float 的值。

类 java.lang.IllegalAccessError 继承 IncompatibleClassChangeError 实现 Serializable

类 java.lang.IllegalAccessException 继承 Exception 实现 Serializable

类 java.lang.IllegalArgumentException 继承 RuntimeException 实现 Serializable

serialVersionUID: -5365630128856068164L

类 java.lang.IllegalMonitorStateException 继承 RuntimeException 实现 Serializable

类 java.lang.IllegalStateException 继承 RuntimeException 实现 Serializable

serialVersionUID: -1848914673093119416L

类 java.lang.IllegalThreadStateException 继承 IllegalArgumentException 实现 Serializable

类 java.lang.IncompatibleClassChangeError 继承 LinkageError 实现 Serializable

类 java.lang.IndexOutOfBoundsException 继承 RuntimeException 实现 Serializable

类 java.lang.InstantiationError 继承 IncompatibleClassChangeError 实现 Serializable

类 java.lang.InstantiationException 继承 Exception 实现 Serializable

类 java.lang.Integer 继承 Number 实现 Serializable

serialVersionUID: 1360826667806852920L

序列化字段

value

int value

Integer 的值。

类 java.lang.InternalError 继承 VirtualMachineError 实现 Serializable

类 java.lang.InterruptedException 继承 Exception 实现 Serializable

类 java.lang.LinkageError 继承 Error 实现 Serializable

类 java.lang.Long 继承 Number 实现 Serializable

serialVersionUID: 4290774380558885855L

序列化字段

value

long value

Long 的值。

类 java.lang.NegativeArraySizeException 继承 RuntimeException 实现 Serializable

类 java.lang.NoClassDefFoundError 继承 LinkageError 实现 Serializable

类 java.lang.NoSuchFieldError 继承 IncompatibleClassChangeError 实现 Serializable

类 java.lang.NoSuchFieldException 继承 Exception 实现 Serializable

类 java.lang.NoSuchMethodError 继承 IncompatibleClassChangeError 实现 Serializable

类 java.lang.NoSuchMethodException 继承 Exception 实现 Serializable

类 java.lang.NullPointerException 继承 RuntimeException 实现 Serializable

类 java.lang.Number 继承 Object 实现 Serializable

serialVersionUID: -8742448824652078965L

类 java.lang.NumberFormatException 继承 IllegalArgumentException 实现 Serializable

serialVersionUID: -2848938806368998894L

类 java.lang.OutOfMemoryError 继承 VirtualMachineError 实现 Serializable

类 java.lang.RuntimeException 继承 Exception 实现 Serializable

serialVersionUID: -7034897190745766939L

类 java.lang.RuntimePermission 继承 java.security.BasicPermission 实现 Serializable

serialVersionUID: 7399184964622342223L

类 java.lang.SecurityException 继承 RuntimeException 实现 Serializable

serialVersionUID: 6878364983674394167L

类 java.lang.Short 继承 Number 实现 Serializable

serialVersionUID: 7515723908773894738L

序列化字段

value

short value

Short 值。

类 java.lang.StackOverflowError 继承 VirtualMachineError 实现 Serializable

类 java.lang.StackTraceElement 继承 Object 实现 Serializable

serialVersionUID: 6992337162326171013L

序列化字段

declaringClass

String declaringClass

methodName

String methodName

fileName

String fileName

lineNumber

int lineNumber

类 java.lang.String 继承 Object 实现 Serializable

serialVersionUID: -6849794470754667710L

序列化概述

String 类被专门放入 Serialization Stream Protocol。 String 实例最初以如下格式被写入 ObjectOutputStream：

      TC_STRING (utf String)

该 String 由方法 DataOutput.writeUTF 写入。生成一个新句柄以访问流中对此字符串实例的所有将来引用。

序列化字段

类 java.lang.StringBuffer 继承 java.lang.AbstractStringBuilder 实现 Serializable

serialVersionUID: 3388685877147921107L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

调用 readObject，从流中恢复 StringBuffer 的状态。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

调用 readObject，从流中恢复 StringBuffer 的状态。

抛出：: java.io.IOException

序列化概述

StringBuffer 的可序列化字段。

序列化字段

count

int count

该 StringBuffer 中的字符数。

shared

boolean shared

指示是否共享底层数组的标志。在反序列化时忽略该值。

value

char[] value

该 StringBuffer 的底层字符数组。

类 java.lang.StringBuilder 继承 java.lang.AbstractStringBuilder 实现 Serializable

serialVersionUID: 4383685877147921099L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

调用 readObject，从流中恢复 StringBuffer 的状态。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将 StringBuilder 实例的状态保存到流中（也就是将其序列化）。

序列数据：: 当前存储在字符串生成器中的字符数（int），后跟字符串生成器中的字符（char[]）。char 数组的长度可能大于当前存储在字符串生成器中的字符数，在这种情况下，将忽略多出的字符。
抛出：: java.io.IOException

类 java.lang.StringIndexOutOfBoundsException 继承 IndexOutOfBoundsException 实现 Serializable

类 java.lang.ThreadDeath 继承 Error 实现 Serializable

类 java.lang.Throwable 继承 Object 实现 Serializable

serialVersionUID: -3042686055658047285L

序列化方法

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

抛出：: java.io.IOException

序列化字段

detailMessage

String detailMessage

有关 Throwable 的详细信息。例如，对于 FileNotFoundException，这包含了无法找到的文件名称。

cause

Throwable cause

由此 throwable 引起的 throwable 被抛出，或者如果 throwable 未由其他 throwable 引起，或如果作为 cause 的 throwable 未知，则为空。如果此字段等于该 throwable 本身，它表示该 throwable 的 cause 尚未初始化。

从以下版本开始：: 1.4

stackTrace

StackTraceElement[] stackTrace

堆栈跟踪，由 Throwable.getStackTrace() 返回。

从以下版本开始：: 1.4

类 java.lang.TypeNotPresentException 继承 RuntimeException 实现 Serializable

序列化字段

typeName

String typeName

类 java.lang.UnknownError 继承 VirtualMachineError 实现 Serializable

类 java.lang.UnsatisfiedLinkError 继承 LinkageError 实现 Serializable

类 java.lang.UnsupportedClassVersionError 继承 ClassFormatError 实现 Serializable

类 java.lang.UnsupportedOperationException 继承 RuntimeException 实现 Serializable

serialVersionUID: -1242599979055084673L

类 java.lang.VerifyError 继承 LinkageError 实现 Serializable

类 java.lang.VirtualMachineError 继承 Error 实现 Serializable

软件包 java.lang.annotation

类 java.lang.annotation.AnnotationFormatError 继承 Error 实现 Serializable

类 java.lang.annotation.AnnotationTypeMismatchException 继承 RuntimeException 实现 Serializable

序列化字段

element

Method element

注释元素的 Method 对象。

foundType

String foundType

在注释中找到的数据（错误）类型。该字符串可以，但不一定包含该值。字符串的确切格式没有指定。

类 java.lang.annotation.IncompleteAnnotationException 继承 RuntimeException 实现 Serializable

序列化字段

annotationType

Class<T> annotationType

elementName

String elementName

软件包 java.lang.instrument

类 java.lang.instrument.IllegalClassFormatException 继承 Exception 实现 Serializable

类 java.lang.instrument.UnmodifiableClassException 继承 Exception 实现 Serializable

软件包 java.lang.management

类 java.lang.management.ManagementPermission 继承 java.security.BasicPermission 实现 Serializable

软件包 java.lang.reflect

类 java.lang.reflect.GenericSignatureFormatError 继承 ClassFormatError 实现 Serializable

类 java.lang.reflect.InvocationTargetException 继承 Exception 实现 Serializable

serialVersionUID: 4085088731926701167L

序列化字段

target

Throwable target

如果使用 InvocationTargetException(Throwable target) 构造方法来实例化该对象，则此字段将保持目标

类 java.lang.reflect.MalformedParameterizedTypeException 继承 RuntimeException 实现 Serializable

类 java.lang.reflect.Proxy 继承 Object 实现 Serializable

serialVersionUID: -2222568056686623797L

序列化字段

h

InvocationHandler h

此代理实例的调用处理程序。

类 java.lang.reflect.ReflectPermission 继承 java.security.BasicPermission 实现 Serializable

serialVersionUID: 7412737110241507485L

类 java.lang.reflect.UndeclaredThrowableException 继承 RuntimeException 实现 Serializable

serialVersionUID: 330127114055056639L

序列化字段

undeclaredThrowable

Throwable undeclaredThrowable

抛出的经过检查的未声明异常

软件包 java.util

类 java.util.AbstractMap$1 继承 Object 实现 Serializable

类 java.util.AbstractMap$1$1 继承 Object 实现 Serializable

类 java.util.AbstractMap$2 继承 Object 实现 Serializable

类 java.util.AbstractMap$2$1 继承 Object 实现 Serializable

类 java.util.ArrayList 继承 AbstractList<E> 实现 Serializable

serialVersionUID: 8683452581122892189L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

从流中重构 ArrayList 实例（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将 ArrayList 实例的状态保存到流中（也就是将其序列化）。

序列数据：: 支持发出 ArrayList 实例的数组的长度 (int)，后面是以适当顺序排列的所有元素（每个元素都是一个 Object）。
抛出：: java.io.IOException

序列化字段

size

int size

ArrayList 的大小（它包含的元素数）。

类 java.util.Arrays.ArrayList 继承 AbstractList<E> 实现 Serializable

serialVersionUID: -2764017481108945198L

序列化字段

a

Object[] a

类 java.util.BitSet 继承 Object 实现 Serializable

serialVersionUID: 7997698588986878753L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        ClassNotFoundException

重写 readObject 方法可以确保 bitset 在反序列化时正确地设置 unitsInUse

抛出：: java.io.IOException; ClassNotFoundException

序列化字段

bits

long[] bits

此 BitSet 中的位。第 i 个位存储在数位位置为 i % 64 的 bits[i/64]中（其中数位位置 0 表示最低有效位，数位位置 63 表示最高有效位）。常量：bits[] 中超出 unitsInUse-1 的字恒为零。

类 java.util.Calendar 继承 Object 实现 Serializable

serialVersionUID: -1807547505821590642L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream stream)
                 throws java.io.IOException,
                        ClassNotFoundException

从流重构此对象（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream stream)
                  throws java.io.IOException

将此对象的状态保存到流中（也就是将其序列化）。理想情况下，Calendar 将只写出其状态数据和当前时间，并且不会写出任何字段数据，比如 fields[]、isTimeSet、areFieldsSet 和 isSet[]。nextStamp 不应该是持久存储状态的一部分。不幸的是，在发行 JDK 1.1 之前，事情并非如此。为了与 JDK 1.1 兼容，必须总是写出字段值和状态标志。不过，可以从序列化流中移除 nextStamp；可能在以后会实现。

抛出：: java.io.IOException

序列化字段

fields

int[] fields

此日历当前设置时间的日历字段值。这是一个 FIELD_COUNT 整数数组，索引值为 ERA 到 DST_OFFSET。

isSet

boolean[] isSet

通知是否设置了该日历某一指定日历字段的标志。新的对象没有设置任何字段。在第一次调用生成该字段的某一方法后，这些字段都将保留调用之后的设置。这是一个 FIELD_COUNT 布尔值数组，索引值为 ERA 到 DST_OFFSET。

time

long time

日历的当前设置时间，以毫秒为单位，表示自格林威治标准时间 1970 年 1月 1 日 0:00:00 后经过的时间。

另请参见：: Calendar.isTimeSet

isTimeSet

boolean isTimeSet

如果 time 值是一个有效值，则返回 true。通过更改 field[] 的项，可以使时间无效。

另请参见：: Calendar.time

areFieldsSet

boolean areFieldsSet

如果 fields[] 与当前的设置时间同步，则返回 true。如果返回 false，则在下一次试图获得某一字段的值时，将强行重新计算 time 当前值中的所有字段。

lenient

boolean lenient

如果此日历允许在计算 fields[] 中的 time 时使用超出范围的字段值，则返回 True。

另请参见：: Calendar.setLenient(boolean), Calendar.isLenient()

zone

TimeZone zone

此日历使用的 TimeZone。Calendar 使用时区数据来实现语言环境与 GMT 时间的转换。

firstDayOfWeek

int firstDayOfWeek

一星期中的第一天，可能的值是 SUNDAY、MONDAY，等等。这是一个同语言环境有关的值。

minimalDaysInFirstWeek

int minimalDaysInFirstWeek

一月或一年中第一个星期所需的天数，可能的值是从 1 到 7。这是一个同语言环境有关的值。

nextStamp

int nextStamp

stamp[]（一个内部数组）的下一个可用值。实际上不应该将该方法写出到流中，在以后，可能从流中将其移除。同时，应该使用 MINIMUM_USER_STAMP 值。

serialVersionOnStream

int serialVersionOnStream

流中序列化数据的版本。可能的值是：

0 或流中不存在该数据: JDK 1.1.5 或更早的版本。
1: JDK 1.1.6 或更高的版本。为其他字段编写一个正确的 'time' 值以及兼容的值。这是一种过渡格式。

在流出此类时，编写最新格式和所允许的最高 serialVersionOnStream。

从以下版本开始：: JDK1.1.6

类 java.util.Collections.CheckedCollection 继承 Object 实现 Serializable

serialVersionUID: 1578914078182001775L

序列化字段

c

Collection<E> c

type

Class<T> type

zeroLengthElementArray

Object[] zeroLengthElementArray

类 java.util.Collections.CheckedList 继承 java.util.Collections.CheckedCollection<E> 实现 Serializable

serialVersionUID: 65247728283967356L

序列化字段

list

List<E> list

类 java.util.Collections.CheckedMap 继承 Object 实现 Serializable

serialVersionUID: 5742860141034234728L

序列化字段

m

Map<K,V> m

keyType

Class<T> keyType

valueType

Class<T> valueType

zeroLengthKeyArray

Object[] zeroLengthKeyArray

zeroLengthValueArray

Object[] zeroLengthValueArray

类 java.util.Collections.CheckedRandomAccessList 继承 java.util.Collections.CheckedList<E> 实现 Serializable

serialVersionUID: 1638200125423088369L

类 java.util.Collections.CheckedSet 继承 java.util.Collections.CheckedCollection<E> 实现 Serializable

serialVersionUID: 4694047833775013803L

类 java.util.Collections.CheckedSortedMap 继承 java.util.Collections.CheckedMap<K,V> 实现 Serializable

serialVersionUID: 1599671320688067438L

序列化字段

sm

SortedMap<K,V> sm

类 java.util.Collections.CheckedSortedSet 继承 java.util.Collections.CheckedSet<E> 实现 Serializable

serialVersionUID: 1599911165492914959L

序列化字段

ss

SortedSet<E> ss

类 java.util.Collections.CopiesList 继承 AbstractList<E> 实现 Serializable

serialVersionUID: 2739099268398711800L

序列化字段

n

int n

element

Object element

类 java.util.Collections.EmptyList 继承 AbstractList<Object> 实现 Serializable

serialVersionUID: 8842843931221139166L

序列化方法

readResolve

private Object readResolve()

类 java.util.Collections.EmptySet 继承 AbstractSet<Object> 实现 Serializable

serialVersionUID: 1582296315990362920L

序列化方法

readResolve

private Object readResolve()

类 java.util.Collections.ReverseComparator 继承 Object 实现 Serializable

serialVersionUID: 7207038068494060240L

类 java.util.Collections.ReverseComparator2 继承 Object 实现 Serializable

serialVersionUID: 4374092139857L

序列化字段

cmp

Comparator<T> cmp

The comparator specified in the static factory. This will never be null, as the static factory returns a ReverseComparator instance if its argument is null.

类 java.util.Collections.SingletonSet 继承 AbstractSet<E> 实现 Serializable

serialVersionUID: 3193687207550431679L

序列化字段

element

Object element

类 java.util.Collections.SynchronizedCollection 继承 Object 实现 Serializable

serialVersionUID: 3053995032091335093L

序列化方法

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

抛出：: java.io.IOException

序列化字段

c

Collection<E> c

mutex

Object mutex

类 java.util.Collections.SynchronizedList 继承 java.util.Collections.SynchronizedCollection<E> 实现 Serializable

serialVersionUID: -7754090372962971524L

序列化方法

readResolve

private Object readResolve()

SynchronizedRandomAccessList instances are serialized as SynchronizedList instances to allow them to be deserialized in pre-1.4 JREs (which do not have SynchronizedRandomAccessList). This method inverts the transformation. As a beneficial side-effect, it also grafts the RandomAccess marker onto SynchronizedList instances that were serialized in pre-1.4 JREs. Note: Unfortunately, SynchronizedRandomAccessList instances serialized in 1.4.1 and deserialized in 1.4 will become SynchronizedList instances, as this method was missing in 1.4.

序列化字段

list

List<E> list

类 java.util.Collections.SynchronizedMap 继承 Object 实现 Serializable

serialVersionUID: 1978198479659022715L

序列化方法

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

抛出：: java.io.IOException

序列化字段

m

Map<K,V> m

mutex

Object mutex

类 java.util.Collections.SynchronizedRandomAccessList 继承 java.util.Collections.SynchronizedList<E> 实现 Serializable

serialVersionUID: 1530674583602358482L

序列化方法

writeReplace

private Object writeReplace()

Allows instances to be deserialized in pre-1.4 JREs (which do not have SynchronizedRandomAccessList). SynchronizedList has a readResolve method that inverts this transformation upon deserialization.

类 java.util.Collections.SynchronizedSet 继承 java.util.Collections.SynchronizedCollection<E> 实现 Serializable

serialVersionUID: 487447009682186044L

类 java.util.Collections.SynchronizedSortedMap 继承 java.util.Collections.SynchronizedMap<K,V> 实现 Serializable

serialVersionUID: -8798146769416483793L

序列化字段

sm

SortedMap<K,V> sm

类 java.util.Collections.SynchronizedSortedSet 继承 java.util.Collections.SynchronizedSet<E> 实现 Serializable

serialVersionUID: 8695801310862127406L

序列化字段

ss

SortedSet<E> ss

类 java.util.Collections.UnmodifiableCollection 继承 Object 实现 Serializable

serialVersionUID: 1820017752578914078L

序列化字段

c

Collection<E> c

类 java.util.Collections.UnmodifiableList 继承 java.util.Collections.UnmodifiableCollection<E> 实现 Serializable

serialVersionUID: -283967356065247728L

序列化方法

readResolve

private Object readResolve()

UnmodifiableRandomAccessList instances are serialized as UnmodifiableList instances to allow them to be deserialized in pre-1.4 JREs (which do not have UnmodifiableRandomAccessList). This method inverts the transformation. As a beneficial side-effect, it also grafts the RandomAccess marker onto UnmodifiableList instances that were serialized in pre-1.4 JREs. Note: Unfortunately, UnmodifiableRandomAccessList instances serialized in 1.4.1 and deserialized in 1.4 will become UnmodifiableList instances, as this method was missing in 1.4.

序列化字段

list

List<E> list

类 java.util.Collections.UnmodifiableMap 继承 Object 实现 Serializable

serialVersionUID: -1034234728574286014L

序列化字段

m

Map<K,V> m

类 java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet 继承 java.util.Collections.UnmodifiableSet<Map.Entry<K,V>> 实现 Serializable

serialVersionUID: 7854390611657943733L

类 java.util.Collections.UnmodifiableRandomAccessList 继承 java.util.Collections.UnmodifiableList<E> 实现 Serializable

serialVersionUID: -2542308836966382001L

序列化方法

writeReplace

private Object writeReplace()

Allows instances to be deserialized in pre-1.4 JREs (which do not have UnmodifiableRandomAccessList). UnmodifiableList has a readResolve method that inverts this transformation upon deserialization.

类 java.util.Collections.UnmodifiableSet 继承 java.util.Collections.UnmodifiableCollection<E> 实现 Serializable

serialVersionUID: -9215047833775013803L

类 java.util.Collections.UnmodifiableSortedMap 继承 java.util.Collections.UnmodifiableMap<K,V> 实现 Serializable

serialVersionUID: -8806743815996713206L

序列化字段

sm

SortedMap<K,V> sm

类 java.util.Collections.UnmodifiableSortedSet 继承 java.util.Collections.UnmodifiableSet<E> 实现 Serializable

serialVersionUID: -4929149591599911165L

序列化字段

ss

SortedSet<E> ss

类 java.util.Collections$1 继承 Object 实现 Serializable

类 java.util.Collections$CheckedList$1 继承 Object 实现 Serializable

类 java.util.Collections$CheckedMap$CheckedEntrySet$1 继承 Object 实现 Serializable

类 java.util.Collections$SingletonSet$1 继承 Object 实现 Serializable

类 java.util.Collections$UnmodifiableCollection$1 继承 Object 实现 Serializable

类 java.util.Collections$UnmodifiableList$1 继承 Object 实现 Serializable

类 java.util.Collections$UnmodifiableMap$UnmodifiableEntrySet$1 继承 Object 实现 Serializable

类 java.util.ConcurrentModificationException 继承 RuntimeException 实现 Serializable

类 java.util.Currency 继承 Object 实现 Serializable

serialVersionUID: -158308464356906721L

序列化方法

readResolve

private Object readResolve()

把正被反序列化的实例分析为每种货币的单个实例。

序列化字段

currencyCode

String currencyCode

此货币的 ISO 4217 货币代码。

类 java.util.Date 继承 Object 实现 Serializable

serialVersionUID: 7523967970034938905L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

从流重构此对象（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将此对象的状态保存到流中（也就是将其序列化）。

序列数据：: 发出由 getTime() 返回的值 (long)。它表示自 1970 年 1 月 1 日 00:00:00 GMT 的偏移量（以毫秒为单位）。
抛出：: java.io.IOException

类 java.util.DuplicateFormatFlagsException 继承 IllegalFormatException 实现 Serializable

serialVersionUID: 18890531L

序列化字段

flags

String flags

类 java.util.EmptyStackException 继承 RuntimeException 实现 Serializable

类 java.util.EnumMap 继承 AbstractMap<K extends Enum<K>,V> 实现 Serializable

serialVersionUID: 458661240069192865L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

重新构造来自流的 EnumMap 实例（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将 EnumMap 实例的状态保存到流中（也就是将其序列化）。

序列数据：: 发出枚举映射的 size（键-值映射关系数），后跟由枚举映射表示的每个键-值映射关系的键 (Object) 和值 (Object)。
抛出：: java.io.IOException

序列化字段

keyType

Class<T> keyType

此映射所有键的枚举类型的 Class 对象。

类 java.util.EnumSet.SerializationProxy 继承 Object 实现 Serializable

serialVersionUID: 362491234563181265L

序列化方法

readResolve

private Object readResolve()

序列化字段

elementType

Class<T> elementType

The element type of this enum set.

elements

Enum<E extends Enum<E>>[] elements

The elements contained in this enum set.

类 java.util.EventObject 继承 Object 实现 Serializable

serialVersionUID: 5516075349620653480L

类 java.util.FormatFlagsConversionMismatchException 继承 IllegalFormatException 实现 Serializable

serialVersionUID: 19120414L

序列化字段

f

String f

c

char c

类 java.util.FormatterClosedException 继承 IllegalStateException 实现 Serializable

serialVersionUID: 18111216L

类 java.util.GregorianCalendar 继承 Calendar 实现 Serializable

serialVersionUID: -8125100834729963327L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream stream)
                 throws java.io.IOException,
                        ClassNotFoundException

更新内部状态。

抛出：: java.io.IOException; ClassNotFoundException

序列化字段

gregorianCutover

long gregorianCutover

格里高利历规则的使用点，从标准新纪元开始以毫秒为单位来测量。默认时间 1582 年 10 月 15 日（格里高利历）00:00:00 UTC 或 -12219292800000L。对此默认值，1582 年 10 月 4 日（儒略历）之后是 1582 年 10 月 15 日（格里高利历）。这对应于儒略历日期号 2299161。

类 java.util.HashMap 继承 AbstractMap<K,V> 实现 Serializable

serialVersionUID: 362498820763181265L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

从流重构 HashMap 实例（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将 HashMap 实例的状态保存到流中（也就是将其序列化）。

序列数据：: 发出 HashMap 的容量（桶数组的长度，为 int 值），后跟 HashMap 的 size（键-值映射关系数），后跟由 HashMap 所表示的每个键-值映射关系的键 (Object) 和值 (Object)，发出键-值映射关系是为了它们可以由 entrySet().iterator() 返回。
抛出：: java.io.IOException

序列化字段

threshold

int threshold

The next size value at which to resize (capacity * load factor).

loadFactor

float loadFactor

哈希表的加载因子。

类 java.util.HashSet 继承 AbstractSet<E> 实现 Serializable

serialVersionUID: -5024744406713321676L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

从流重构 HashSet 实例（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将 HashSet 实例的状态保存到流中（也就是将此集合序列化）。

序列数据：: 发出底层 HashMap 实例的容量（int）及其加载因子（float），后跟集合的大小（所包含元素的数量（int）），再后跟着它的所有元素（每个元素都是一个对象），这些元素没有按特定顺序排列。
抛出：: java.io.IOException

类 java.util.Hashtable 继承 Dictionary<K,V> 实现 Serializable

serialVersionUID: 1421746759512286392L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

从流重构 Hashtable（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将 Hashtable 的状态保存到流中（也就是将其序列化）。

序列数据：: 发出 Hashtable 的容量（桶数组的长度（为 int）），后跟 Hashtable 的大小（键-值映射关系的数量），再后面是由 Hashtable 表示的每个键-值映射关系的键（Object）和值（Object），发出这些键-值映射关系没有按照任何特定顺序。
抛出：: java.io.IOException

序列化字段

threshold

int threshold

如果表的大小超出此阈值，则要对其执行 rehash 操作。（阈值是一个 int 值，等于容量与加载因子的乘积。）

loadFactor

float loadFactor

哈希表的加载因子。

类 java.util.IdentityHashMap 继承 AbstractMap<K,V> 实现 Serializable

serialVersionUID: 8188218128353913216L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

从流重构 IdentityHashMap 实例（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将 IdentityHashMap 实例的状态保存到流中（也就是将其序列化）。

序列数据：: HashMap（键-值映射关系数）的大小 (int)，然后是 IdentityHashMap 所表示的每个键-值映射关系的键（对象）和值（对象）。发出的键-值映射关系没有特定顺序。
抛出：: java.io.IOException

序列化字段

size

int size

返回此标识哈希映射中的键-值映射关系数。

类 java.util.IllegalFormatCodePointException 继承 IllegalFormatException 实现 Serializable

serialVersionUID: 19080630L

序列化字段

c

int c

类 java.util.IllegalFormatConversionException 继承 IllegalFormatException 实现 Serializable

serialVersionUID: 17000126L

序列化字段

c

char c

arg

Class<T> arg

类 java.util.IllegalFormatException 继承 IllegalArgumentException 实现 Serializable

serialVersionUID: 18830826L

类 java.util.IllegalFormatFlagsException 继承 IllegalFormatException 实现 Serializable

serialVersionUID: 790824L

序列化字段

flags

String flags

类 java.util.IllegalFormatPrecisionException 继承 IllegalFormatException 实现 Serializable

serialVersionUID: 18711008L

序列化字段

p

int p

类 java.util.IllegalFormatWidthException 继承 IllegalFormatException 实现 Serializable

serialVersionUID: 16660902L

序列化字段

w

int w

类 java.util.InputMismatchException 继承 NoSuchElementException 实现 Serializable

类 java.util.LinkedHashMap 继承 HashMap<K,V> 实现 Serializable

serialVersionUID: 3801124242820219131L

序列化字段

accessOrder

boolean accessOrder

此链接哈希映射的迭代排序方法：访问顺序为 true；插入顺序为 false。

类 java.util.LinkedHashSet 继承 HashSet<E> 实现 Serializable

serialVersionUID: -2851667679971038690L

类 java.util.LinkedList 继承 AbstractSequentialList<E> 实现 Serializable

serialVersionUID: 876323262645176354L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

从流重构此 LinkedList 实例（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将此 LinkedList 实例的状态保存到流中（也就是将其序列化）。

序列数据：: 列表的大小（它所包含的元素数）(int)，然后是其按正确顺序排列的所有元素（每个对象）。
抛出：: java.io.IOException

类 java.util.Locale 继承 Object 实现 Serializable

serialVersionUID: 9149081749638150636L

序列化方法

readResolve

private Object readResolve()
                    throws java.io.ObjectStreamException

用新创建的对象替换已反序列化的 Locale 对象。用较新的 ISO 代码替换较旧的语言代码。用内部 String 副本替换国家和变量代码。

抛出：: java.io.ObjectStreamException

序列化字段

language

String language

另请参见：: Locale.getLanguage()

country

String country

另请参见：: Locale.getCountry()

variant

String variant

另请参见：: Locale.getVariant()

hashcode

int hashcode

对象的哈希代码的占位符。总为 -1。

类 java.util.MissingFormatArgumentException 继承 IllegalFormatException 实现 Serializable

serialVersionUID: 19190115L

序列化字段

s

String s

类 java.util.MissingFormatWidthException 继承 IllegalFormatException 实现 Serializable

serialVersionUID: 15560123L

序列化字段

s

String s

类 java.util.MissingResourceException 继承 RuntimeException 实现 Serializable

序列化字段

className

String className

用户所请求的资源包的类名。

key

String key

用户所请求的特定资源名。

类 java.util.NoSuchElementException 继承 RuntimeException 实现 Serializable

类 java.util.PriorityQueue 继承 AbstractQueue<E> 实现 Serializable

serialVersionUID: -7720805057305804111L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

从流重构 ArrayList 实例（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将实例的状态保存到流中（也就是将其序列化）。

序列数据：: 底层实例数组的长度 (int)，然后是其按正确顺序排列的所有元素（每个 Object）。
抛出：: java.io.IOException

序列化字段

size

int size

优先级队列中的元素数目。

comparator

Comparator<T> comparator

比较器，或者如果优先级队列使用元素的自然排序，则为 null。

类 java.util.Properties 继承 Hashtable<Object,Object> 实现 Serializable

serialVersionUID: 4112578634029874840L

序列化字段

defaults

Properties defaults

一个属性列表，包含属性列表中所有未找到值的键的默认值。

类 java.util.PropertyPermissionCollection 继承 java.security.PermissionCollection 实现 Serializable

serialVersionUID: 7015263904581634791L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        ClassNotFoundException

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream out)
                  throws java.io.IOException

序列数据：: Default fields.
抛出：: java.io.IOException

序列化字段

all_allowed

boolean all_allowed

boolean saying if "*" is in the collection.

permissions

Hashtable<K,V> permissions

A table of the PropertyPermissions.

类 java.util.Random 继承 Object 实现 Serializable

serialVersionUID: 3905348978240129619L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

从流中重构 Random 实例（也就是将其反序列化）。出于历史原因，会以 long 读取种子，但会将其转换为 AtomicLong。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将 Random 实例保存到流中。出于历史原因，会将 Random 的种子作为 long 进行序列化。

抛出：: java.io.IOException

序列化概述

Random 的可序列化字段。

序列化字段

haveNextNextGaussian

boolean haveNextNextGaussian

nextNextGaussian 是有效的

nextNextGaussian

double；要返回的下一个 nextNextGaussian

Gaussian

seed

long； seed

随机计算的种子

类 java.util.SimpleTimeZone 继承 TimeZone 实现 Serializable

serialVersionUID: -403250971215465050L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream stream)
                 throws java.io.IOException,
                        ClassNotFoundException

从流重构此对象（也就是将其反序列化）。我们同时处理 JDK 1.1 二进制格式和具有打包字节数组的完全格式。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream stream)
                  throws java.io.IOException

将此对象的状态保存到流中（也就是将其序列化）。

序列数据：: 我们编写了两种格式，JDK 1.1 兼容格式，它使用 DOW_IN_MONTH_MODE 规则，在必需部分中后跟完全规则，在可选部分中则使用打包格式。在流入时 JDK 1.1 代码将忽略可选部分。
可选部分的内容：发出字节数组的长度 (int)；对于此版本为 4。发出给定长度的字节数组。字节数组的内容是字段 startDay、startDayOfWeek、endDay 和 endDayOfWeek 的 true 值。在必需部分中这些字段的值是适合于规则模式 DOW_IN_MONTH_MODE 的近似值，它是 JDK 1.1 惟一可识别的模式。
抛出：: java.io.IOException

序列化字段

startMonth

int startMonth

夏令时开始的月份。此值必须介于 Calendar.JANUARY 和 Calendar.DECEMBER（包含）之间。此值必须不能等于 endMonth。

如果 useDaylight 为 false，则忽略此值。

startDay

int startDay

此字段有两种可能的解释：

startMode == DOW_IN_MONTH

startDay 指示夏令时是在 startMonth 月份中的哪个日期开始的，该日期可以是从 1 到 28、30 或 31，具体取决于 startMonth。

startMode != DOW_IN_MONTH

startDay 指示夏令时是在 startMonth 月份中的哪个 startDayOfWeek 开始。例如，一个 +1 值和一个 Calendar.SUNDAY 的 startDayOfWeek 指示 startMonth 的第一个星期日。同样，+2 则指示第二个星期日，-1 指示最后一个星期日。0 值是非法的。

如果 useDaylight 为 false，则忽略此值。

startDayOfWeek

int startDayOfWeek

夏令时开始时是一周的星期几。此值必须介于 Calendar.SUNDAY 和 Calendar.SATURDAY（包括）之间。

如果 useDaylight 为 false 或 startMode == DAY_OF_MONTH，则忽略此值。

startTime

int startTime

夏令时开始日的子夜之后以毫秒表示的时间。此值表示为挂钟时间、标准时间或 UTC 时间，具体取决于 startTimeMode 的设置。

如果 useDaylight 为 false，则忽略此值。

startTimeMode

int startTimeMode

startTime 的格式，可为 WALL_TIME、STANDARD_TIME 或 UTC_TIME。

从以下版本开始：: 1.3

endMonth

int endMonth

夏令时结束的月份。此值必须介于 Calendar.JANUARY 和 Calendar.UNDECIMBER 之间。此值必须不能等于 startMonth。

如果 useDaylight 为 false，则忽略此值。

endDay

int endDay

此字段有两种可能的解释：

endMode == DOW_IN_MONTH

endDay 指示夏令时是在 endMonth 月份中的哪个日期结束的，该日期可以是从 1 到 28、30 或 31，具体取决于 endMonth。

endMode != DOW_IN_MONTH

endDay 指示夏令时是在 endMonth 月份中哪个 endDayOfWeek 结束。例如，一个 +1 值和一个 Calendar.SUNDAY 的 endDayOfWeek 指示 endMonth 的第一个星期日。同样，+2 则指示第二个星期日，-1 指示最后一个星期日。0 值是非法的。

如果 useDaylight 为 false，则忽略此值。

endDayOfWeek

int endDayOfWeek

夏令时结束时，一周的星期几。此值必须介于 Calendar.SUNDAY 和 Calendar.SATURDAY（包括）之间。

如果 useDaylight 为 false 或 endMode == DAY_OF_MONTH，则忽略此值。

endTime

int endTime

夏令时结束日的子夜之后以毫秒表示的时间。此值表示为挂钟时间、标准时间或 UTC 时间，具体取决于 endTimeMode 的设置。

如果 useDaylight 为 false，则忽略此值。

endTimeMode

int endTimeMode

endTime 的格式，可为 WALL_TIME、STANDARD_TIME 或 UTC_TIME。

从以下版本开始：: 1.3

startYear

int startYear

夏令时首次实施的年份。它是一个 AD 值。如果此值小于 1，则在所有的 AD 年份中都实施夏令时。

如果 useDaylight 为 false，则忽略此值。

rawOffset

int rawOffset

此时区与 GMT 之间以毫秒为单位的偏移量。负偏移表示西时区。要获得本地标准时间，可用偏移量加上 GMT 时间。要获取本地挂钟时间，则还须加上 dstSavings。

useDaylight

boolean useDaylight

一个布尔值，当且仅当此时区使用夏令时时才为 true。如果此值为 false，则忽略其他几个字段。

monthLength

byte[] monthLength

此字段在 JDK 1.1 中是序列化的，因此，我们必须保持该顺序，以维护序列化的兼容性。不过，无需在每次创建新时区时都重新创建此数组。

包含值 {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} 的字节数组。从 Java 2 平台 v1.2 开始忽略了此顺序，但为了保持与 JDK 1.1 的兼容性，还必须保持它的有序性。

startMode

int startMode

指定开始规则模式的变量。采用下面的值：

DOM_MODE: 具体日期；例如，3 月 1 日。
DOW_IN_MONTH_MODE: 一个月中的星期几；例如，3 月的最后一个星期日。
DOW_GE_DOM_MODE: 一个月的某一天之后的星期几；例如，3 月 15 日或之后的星期日。
DOW_LE_DOM_MODE: 一个月的某一天之前的星期几；例如，3 月 15 日或之前的星期日。

此字段的设置影响 startDay 字段的解释。

如果 useDaylight 为 false，则忽略此值。

从以下版本开始：: 1.1.4

endMode

int endMode

指定结束规则模式的变量。采用下面的值：

DOM_MODE: 具体日期；例如，3 月 1 日。
DOW_IN_MONTH_MODE: 一个月中的星期几；例如，3 月的最后一个星期日。
DOW_GE_DOM_MODE: 一个月的某一天之后的星期几；例如，3 月 15 日或之后的星期日。
DOW_LE_DOM_MODE: 一个月的某一天之前的星期几；例如，3 月 15 日或之前的星期日。

此字段的设置影响 endDay 字段的解释。

如果 useDaylight 为 false，则忽略此值。

从以下版本开始：: 1.1.4

dstSavings

int dstSavings

正值指示在 DST 期间节省的时间量（以毫秒为单位）。一般为 1 小时 (3600000)，有时为 30 分钟 (1800000)。

如果 useDaylight 为 false，则忽略此值。

从以下版本开始：: 1.1.4

serialVersionOnStream

int serialVersionOnStream

流上序列化数据的版本。可能的值：

0 或者在流上不出现: JDK 1.1.3 或较早版本。
1: JDK 1.1.4 或更高版本。包括三个新字段：startMode、endMode 和 dstSavings。
2: JDK 1.3 或更高版本。包括两个新字段：startTimeMode 和 endTimeMode。

在流出此类时，编写最新格式和所允许的最高 serialVersionOnStream。

从以下版本开始：: 1.1.4

类 java.util.Stack 继承 Vector<E> 实现 Serializable

serialVersionUID: 1224463164541339165L

类 java.util.SubList$1 继承 Object 实现 Serializable

类 java.util.TimeZone 继承 Object 实现 Serializable

serialVersionUID: 3581463369166924961L

序列化字段

ID

String ID

此 TimeZone 的字符串标识符。这是一个编程标识符，供内部用于从系统表中查询 TimeZone 对象，也用于把它们映射到它们的本地化显示名称。ID 值在系统表中是惟一的，但可能不是针对动态创建的区域。

类 java.util.TooManyListenersException 继承 Exception 实现 Serializable

类 java.util.TreeMap 继承 AbstractMap<K,V> 实现 Serializable

serialVersionUID: 919286545866124006L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

重新构造来自流的 TreeMap 实例（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将 TreeMap 实例的状态保存到流中（也就是将其序列化）。

序列数据：: 发出 TreeMap（键-值映射关系数）的大小 (int)，然后是 TreeMap 表示的每个键-值映射关系的键 (Object) 和值 (Object)。键-值映射关系按照键的顺序发出（由 TreeMap 的 Comparator 确定，或者如果 TreeMap 没有 Comparator，则由键的自然排序确定）。
抛出：: java.io.IOException

序列化字段

comparator

Comparator<T> comparator

用于保持此 TreeMap 中的顺序的 Comparator，或者如果此 TreeMap 使用它的元素自然排序，则为 null。

类 java.util.TreeMap$1 继承 Object 实现 Serializable

类 java.util.TreeMap$2 继承 Object 实现 Serializable

类 java.util.TreeMap$3 继承 Object 实现 Serializable

类 java.util.TreeSet 继承 AbstractSet<E> 实现 Serializable

serialVersionUID: -2479143000061671589L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

从流重构 TreeSet 实例（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将 TreeSet 实例的状态保存到流中（也就是将其序列化）

序列数据：: 发出用于对此 set 进行排序的比较器，或者如果其元素遵循自然顺序 (Object)，则发出 null，然后是集合的大小（其包含的元素数） (int)，再后面是其按顺序排列的所有元素（每个元素是一个 Object）（该顺序由 set 的 Comparator 确定，或者如果 set 没有 Comparator，则由元素的自然顺序确定）。
抛出：: java.io.IOException

类 java.util.UnknownFormatConversionException 继承 IllegalFormatException 实现 Serializable

serialVersionUID: 19060418L

序列化字段

s

String s

类 java.util.UnknownFormatFlagsException 继承 IllegalFormatException 实现 Serializable

serialVersionUID: 19370506L

序列化字段

flags

String flags

类 java.util.UUID 继承 Object 实现 Serializable

serialVersionUID: -4856846361193249489L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        ClassNotFoundException

从流重构 UUID 实例（也就是将其反序列化）。这对于将各个 transient 字段设置为其正确的未初始化的值以便按需重新计算很有必要。

抛出：: java.io.IOException; ClassNotFoundException

序列化字段

mostSigBits

long mostSigBits

leastSigBits

long leastSigBits

类 java.util.Vector 继承 AbstractList<E> 实现 Serializable

serialVersionUID: -2767605614048989439L

序列化方法

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将 Vector 实例的状态保存到流中（也就是将其序列化）。此方法只在同步时使用。它仅调用默认的 readObject 方法。

抛出：: java.io.IOException

序列化字段

elementData

Object[] elementData

存储向量组件的数组缓冲区。vector 的容量就是此数据缓冲区的长度，该长度至少要足以包含向量的所有元素。

Vector 中的最后一个元素后的任何数组元素都为 null。

elementCount

int elementCount

Vector 对象中的有效组件数。从 elementData[0] 到 elementData[elementCount-1] 的组件均为实际项。

capacityIncrement

int capacityIncrement

向量的大小大于其容量时，容量自动增加的量。如果容量的增量小于或等于零，则每次需要增大容量时，向量的容量将增大一倍。

类 java.util.Vector$1 继承 Object 实现 Serializable

软件包 java.util.concurrent

类 java.util.concurrent.ArrayBlockingQueue 继承 AbstractQueue<E> 实现 Serializable

serialVersionUID: -817911632652898426L

序列化字段

items

Object[] items

已加入队列的项

count

int count

队列中的项的数量

lock

ReentrantLock lock

保护所有访问的主锁

notEmpty

Condition notEmpty

等待取出的条件

notFull

Condition notFull

等待放入的条件

类 java.util.concurrent.BrokenBarrierException 继承 Exception 实现 Serializable

serialVersionUID: 7117394618823254244L

类 java.util.concurrent.CancellationException 继承 IllegalStateException 实现 Serializable

serialVersionUID: -9202173006928992231L

类 java.util.concurrent.ConcurrentHashMap 继承 AbstractMap<K,V> 实现 Serializable

serialVersionUID: 7249069246763182397L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

从流中重构 ConcurrentHashMap 实例（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将 ConcurrentHashMap 实例的状态保存到流中（也就是将其序列化）。

序列数据：: 每个键-值映射关系的键 (Object) 和值 (Object)，后跟一个 null 对。键-值映射关系的发出没有任何特定顺序。
抛出：: java.io.IOException

序列化字段

segmentMask

int segmentMask

用来对段进行索引的掩码值。哈希表的键的高位被用来选择段。

segmentShift

int segmentShift

用来在段中进行索引的移位值。

segments

java.util.concurrent.ConcurrentHashMap.Segment<K,V>[] segments

每个段都是一个专门的哈希表。

类 java.util.concurrent.ConcurrentLinkedQueue 继承 AbstractQueue<E> 实现 Serializable

serialVersionUID: 196745693267521676L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

从流中重构 Queue 实例（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将状态保存到流中（也就是将其序列化）。

序列数据：: 以正确顺序排列的所有元素（每个元素是一个 E），后跟一个 null
抛出：: java.io.IOException

类 java.util.concurrent.CopyOnWriteArrayList 继承 Object 实现 Serializable

serialVersionUID: 8673264195747942595L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

从流中重构列表（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将列表状态保存到流中（也就是将其序列化）。

序列数据：: 发出支持列表的数组的长度 (int)，后跟以适当顺序排列的所有数组元素（均为对象）。
抛出：: java.io.IOException

类 java.util.concurrent.CopyOnWriteArraySet 继承 AbstractSet<E> 实现 Serializable

serialVersionUID: 5457747651344034263L

序列化字段

al

CopyOnWriteArrayList<E> al

类 java.util.concurrent.ExecutionException 继承 Exception 实现 Serializable

serialVersionUID: 7830266012832686185L

类 java.util.concurrent.LinkedBlockingQueue 继承 AbstractQueue<E> 实现 Serializable

serialVersionUID: -6903933977591709194L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

从流重构此队列实例（也就是将其反序列化）。

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将状态保存到流中（也就是将其序列化）。

序列数据：: 发出容量 (int)，后跟以正确顺序排列的所有元素（每个都是顺序正确的 Object），后跟 null。
抛出：: java.io.IOException

序列化字段

capacity

int capacity

容量上限，如果没有则为 Integer.MAX_VALUE。

count

AtomicInteger count

当前的元素数。

takeLock

ReentrantLock takeLock

由 take、poll 等所保持的锁定。

notEmpty

Condition notEmpty

等待 take 的等待队列。

putLock

ReentrantLock putLock

由 put、offer 等所保持的锁定。

notFull

Condition notFull

等待 put 的等待队列。

类 java.util.concurrent.PriorityBlockingQueue 继承 AbstractQueue<E> 实现 Serializable

serialVersionUID: 5595510919245408276L

序列化方法

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

将状态保存到流中（也就是将其序列化）。这只包装锁定内的默认序列化内容。该内容的序列化策略留给基础的 Queue 负责。注意，不需要对反序列化进行锁定，所以并未定义 readObject，使用默认值即可。

抛出：: java.io.IOException

序列化字段

q

PriorityQueue<E> q

lock

ReentrantLock lock

notEmpty

Condition notEmpty

类 java.util.concurrent.RejectedExecutionException 继承 RuntimeException 实现 Serializable

serialVersionUID: -375805702767069545L

类 java.util.concurrent.Semaphore 继承 Object 实现 Serializable

serialVersionUID: -3222578661600680210L

序列化字段

sync

java.util.concurrent.Semaphore.Sync sync

通过 AbstractQueuedSynchronizer 子类实现的所有机制。

类 java.util.concurrent.SynchronousQueue 继承 AbstractQueue<E> 实现 Serializable

serialVersionUID: -3223113410248163686L

序列化字段

qlock

ReentrantLock qlock

锁定保护两个等待队列

waitingProducers

java.util.concurrent.SynchronousQueue.WaitQueue waitingProducers

保持等待放入内容的队列

waitingConsumers

java.util.concurrent.SynchronousQueue.WaitQueue waitingConsumers

保持等待取得内容的队列

类 java.util.concurrent.TimeoutException 继承 Exception 实现 Serializable

serialVersionUID: 1900926677490660714L

软件包 java.util.concurrent.atomic

类 java.util.concurrent.atomic.AtomicBoolean 继承 Object 实现 Serializable

serialVersionUID: 4654671469794556979L

序列化字段

value

int value

类 java.util.concurrent.atomic.AtomicInteger 继承 Number 实现 Serializable

serialVersionUID: 6214790243416807050L

序列化字段

value

int value

类 java.util.concurrent.atomic.AtomicIntegerArray 继承 Object 实现 Serializable

serialVersionUID: 2862133569453604235L

序列化字段

array

int[] array

类 java.util.concurrent.atomic.AtomicLong 继承 Number 实现 Serializable

serialVersionUID: 1927816293512124184L

序列化字段

value

long value

类 java.util.concurrent.atomic.AtomicLongArray 继承 Object 实现 Serializable

serialVersionUID: -2308431214976778248L

序列化字段

array

long[] array

类 java.util.concurrent.atomic.AtomicReference 继承 Object 实现 Serializable

serialVersionUID: -1848883965231344442L

序列化字段

value

Object value

类 java.util.concurrent.atomic.AtomicReferenceArray 继承 Object 实现 Serializable

serialVersionUID: -6209656149925076980L

序列化字段

array

Object[] array

软件包 java.util.concurrent.locks

类 java.util.concurrent.locks.AbstractQueuedSynchronizer 继承 Object 实现 Serializable

serialVersionUID: 7373984972572414691L

序列化字段

state

int state

同步状态。

类 java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject 继承 Object 实现 Serializable

serialVersionUID: 1173984872572414699L

类 java.util.concurrent.locks.ReentrantLock 继承 Object 实现 Serializable

serialVersionUID: 7373984872572414699L

序列化字段

sync

java.util.concurrent.locks.ReentrantLock.Sync sync

提供所有实现机制的同步器

类 java.util.concurrent.locks.ReentrantReadWriteLock 继承 Object 实现 Serializable

serialVersionUID: -6992448646407690164L

序列化字段

readerLock

ReentrantReadWriteLock.ReadLock readerLock

提供读取锁定的内部类

writerLock

ReentrantReadWriteLock.WriteLock writerLock

提供写入锁定的内部类

sync

java.util.concurrent.locks.ReentrantReadWriteLock.Sync sync

执行所有同步机制

类 java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock 继承 Object 实现 Serializable

serialVersionUID: -5992448646407690164L

序列化字段

sync

java.util.concurrent.locks.ReentrantReadWriteLock.Sync sync

类 java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock 继承 Object 实现 Serializable

serialVersionUID: -4992448646407690164L

序列化字段

sync

java.util.concurrent.locks.ReentrantReadWriteLock.Sync sync

软件包 java.util.jar

类 java.util.jar.JarException 继承 ZipException 实现 Serializable

软件包 java.util.logging

类 java.util.logging.Level 继承 Object 实现 Serializable

serialVersionUID: -8176160795706313070L

序列化方法

readResolve

private Object readResolve()

序列化字段

name

String name

级别的非本地化名称。

value

int value

级别的整数值。

resourceBundleName

String resourceBundleName

本地化级别名称时使用的资源包名称。

类 java.util.logging.LoggingPermission 继承 java.security.BasicPermission 实现 Serializable

serialVersionUID: 63564341580231582L

类 java.util.logging.LogRecord 继承 Object 实现 Serializable

serialVersionUID: 5372048053134512534L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        ClassNotFoundException

抛出：: java.io.IOException; ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream out)
                  throws java.io.IOException

序列数据：: 默认字段，后跟两个字节的版本号（前面是主字节，后面是次字节），后跟关于日志记录参数数组的信息。如果不存在参数数组，则写入 -1。如果存在参数数组（可能长度为零），则作为整数写入数组长度，后跟每个参数的 String 值。如果参数为 null，则写入 null String。否则，写入 Object.toString() 的输出。
抛出：: java.io.IOException

序列化字段

level

Level level

日志消息级别

sequenceNumber

long sequenceNumber

序列号

sourceClassName

String sourceClassName

发出日志调用的类

sourceMethodName

String sourceMethodName

发出日志调用的方法

message

String message

非本地化的原始消息文本

threadID

int threadID

发出日志调用的线程的线程 ID。

millis

long millis

自从 1970 年以毫秒为单位的事件时间

thrown

Throwable thrown

与日志消息相关联的 Throwable（如果有）

loggerName

String loggerName

源 Logger 的名称。

resourceBundleName

String resourceBundleName

本地化日志消息的资源包名称。

软件包 java.util.prefs

类 java.util.prefs.BackingStoreException 继承 Exception 实现 Serializable

serialVersionUID: 859796500401108469L

类 java.util.prefs.InvalidPreferencesFormatException 继承 Exception 实现 Serializable

serialVersionUID: -791715184232119669L

软件包 java.util.regex

类 java.util.regex.Pattern 继承 Object 实现 Serializable

serialVersionUID: 5073258162644648461L

序列化方法

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        ClassNotFoundException

从流中重新编译 Pattern 实例。读入初始模式字符串并从中重新编译对象树。

抛出：: java.io.IOException; ClassNotFoundException

序列化字段

pattern

String pattern

初始正则表达式模式字符串。

flags

int flags

初始模式标志。

类 java.util.regex.PatternSyntaxException 继承 IllegalArgumentException 实现 Serializable

序列化字段

desc

String desc

pattern

String pattern

index

int index

软件包 java.util.zip

类 java.util.zip.DataFormatException 继承 Exception 实现 Serializable

类 java.util.zip.ZipException 继承 java.io.IOException 实现 Serializable

概述

软件包

类

使用

树

已过时

索引

帮助

Java^TM 2 Platform
Standard Ed. 5.0

上一个下一个

框架 无框架

提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。