序列化表格 (com.github.fangjinuo.langx:langx-java:4.2.2 4.2.2 API)

程序包 com.jn.langx.classpath
- 类com.jn.langx.classpath.ClasspathScanException扩展RuntimeException实现可序列化
程序包 com.jn.langx.codec
- 类com.jn.langx.codec.CodecException扩展RuntimeException实现可序列化
程序包 com.jn.langx.commandline
- 类com.jn.langx.commandline.ExecuteException扩展IOException实现可序列化
  
  serialVersionUID:
  
  3256443620654331699L
  - 序列化字段
    - cause
```
Throwable cause
```
      The underlying cause of this exception.
    - exitValue
```
int exitValue
```
      The exit value returned by the failed process
程序包 com.jn.langx.configuration
- 类com.jn.langx.configuration.ConfigurationEvent扩展DomainEvent<T extends Configuration>实现可序列化
  - 序列化字段
    - eventType
```
ConfigurationEventType eventType
```
- 类com.jn.langx.configuration.ConfigurationException扩展RuntimeException实现可序列化
程序包 com.jn.langx.configuration.file
- 类com.jn.langx.configuration.file.InvalidConfigurationFileException扩展RuntimeException实现可序列化
程序包 com.jn.langx.distributed.session
- 类com.jn.langx.distributed.session.SessionEvent扩展DomainEvent<Session>实现可序列化
  - 序列化字段
    - eventType
```
SessionEvent.SessionEventType eventType
```
- 类com.jn.langx.distributed.session.SessionException扩展RuntimeException实现可序列化
程序包 com.jn.langx.event
- 类com.jn.langx.event.DomainEvent扩展EventObject实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - domain
```
String domain
```
    - source
```
Object source
```
程序包 com.jn.langx.exception
- 类com.jn.langx.exception.CompletionException扩展RuntimeException实现可序列化
  
  serialVersionUID:
  
  7830266012832686185L
- 类com.jn.langx.exception.ExpressionParseException扩展RuntimeException实现可序列化
- 类com.jn.langx.exception.FileExistsException扩展RuntimeException实现可序列化
  
  serialVersionUID:
  
  1L
- 类com.jn.langx.exception.IllegalParameterException扩展IllegalArgumentException实现可序列化
- 类com.jn.langx.exception.IllegalPropertyException扩展RuntimeException实现可序列化
- 类com.jn.langx.exception.IllegalValueException扩展RuntimeException实现可序列化
- 类com.jn.langx.exception.NoMappedFieldException扩展RuntimeException实现可序列化
- 类com.jn.langx.exception.NotDirectoryException扩展IOException实现可序列化
- 类com.jn.langx.exception.RuntimeIOException扩展RuntimeException实现可序列化
- 类com.jn.langx.exception.StreamExhaustedException扩展IOException实现可序列化
  
  serialVersionUID:
  
  -1L
- 类com.jn.langx.exception.SyntaxException扩展RuntimeException实现可序列化
- 类com.jn.langx.exception.UnsupportedEnvironmentException扩展RuntimeException实现可序列化
- 类com.jn.langx.exception.UnsupportedPlatformException扩展RuntimeException实现可序列化
- 类com.jn.langx.exception.ValueConvertException扩展RuntimeException实现可序列化
程序包 com.jn.langx.io.buffer.charseq
- 类com.jn.langx.io.buffer.charseq.ByteArrayBuffer扩展Object实现可序列化
  
  serialVersionUID:
  
  4359112959524048036L
  - 序列化字段
    - buffer
```
byte[] buffer
```
    - len
```
int len
```
- 类com.jn.langx.io.buffer.charseq.CharArrayBuffer扩展Object实现可序列化
  
  serialVersionUID:
  
  -6208952725094867135L
  - 序列化字段
    - buffer
```
char[] buffer
```
    - len
```
int len
```
程序包 com.jn.langx.io.resource
- 类com.jn.langx.io.resource.InvalidResourceException扩展RuntimeException实现可序列化
- 类com.jn.langx.io.resource.ResourceNotFoundException扩展RuntimeException实现可序列化
程序包 com.jn.langx.io.stream
- 类com.jn.langx.io.stream.StringBuilderWriter扩展Writer实现可序列化
  
  serialVersionUID:
  
  -146927496096066153L
  - 序列化字段
    - builder
```
StringBuilder builder
```
程序包 com.jn.langx.lifecycle
- 类com.jn.langx.lifecycle.InitializationException扩展RuntimeException实现可序列化
程序包 com.jn.langx.management
- 类com.jn.langx.management.MBeanException扩展RuntimeException实现可序列化
  
  serialVersionUID:
  
  1L
程序包 com.jn.langx.management.connector.server.impl
- 类com.jn.langx.management.connector.server.impl.RMIJMXConnectorServerWrapper.RmiClientLocalhostSocketFactory扩展Object实现可序列化
  - 序列化字段
    - factory
```
RMIClientSocketFactory factory
```
程序包 com.jn.langx.security
- 类com.jn.langx.security.SecurityException扩展RuntimeException实现可序列化
程序包 com.jn.langx.security.crypto
- 类com.jn.langx.security.crypto.AlgorithmUnregisteredException扩展SecurityException实现可序列化
- 类com.jn.langx.security.crypto.CryptoException扩展SecurityException实现可序列化
程序包 com.jn.langx.security.crypto.key.spec
- 类com.jn.langx.security.crypto.key.spec.KeyFileFormatException扩展RuntimeException实现可序列化
程序包 com.jn.langx.security.crypto.provider
- 类com.jn.langx.security.crypto.provider.LangxSecurityProvider扩展Provider实现可序列化
  - 序列化字段
    - properties
```
Map<K,V> properties
```
    - propertiesBackup
```
Map<K,V> propertiesBackup
```
程序包 com.jn.langx.security.ssl
- 类com.jn.langx.security.ssl.SSLInitializationException扩展IllegalStateException实现可序列化
  
  serialVersionUID:
  
  -1L
程序包 com.jn.langx.text.csv
- 类com.jn.langx.text.csv.CsvFormat扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - allowDuplicateHeaderNames
```
boolean allowDuplicateHeaderNames
```
    - allowMissingColumnNames
```
boolean allowMissingColumnNames
```
    - autoFlush
```
boolean autoFlush
```
    - commentMarker
```
Character commentMarker
```
    - delimiter
```
char delimiter
```
    - escapeCharacter
```
Character escapeCharacter
```
    - header
```
String[] header
```
    - headerComments
```
String[] headerComments
```
    - ignoreEmptyLines
```
boolean ignoreEmptyLines
```
    - ignoreHeaderCase
```
boolean ignoreHeaderCase
```
    - ignoreSurroundingSpaces
```
boolean ignoreSurroundingSpaces
```
    - nullString
```
String nullString
```
    - quoteCharacter
```
Character quoteCharacter
```
    - quotedNullString
```
String quotedNullString
```
    - quoteMode
```
QuoteMode quoteMode
```
    - recordSeparator
```
String recordSeparator
```
    - skipHeaderRecord
```
boolean skipHeaderRecord
```
    - trailingDelimiter
```
boolean trailingDelimiter
```
    - trim
```
boolean trim
```
- 类com.jn.langx.text.csv.CsvRecord扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - characterPosition
```
long characterPosition
```
    - comment
```
String comment
```
      The accumulated comments (if any)
    - recordNumber
```
long recordNumber
```
      The record number.
    - values
```
String[] values
```
      The values of the record
    - parser
```
CsvParser parser
```
      The parser that originates this record.
程序包 com.jn.langx.text.xml
- 类com.jn.langx.text.xml.XmlElementNotFoundException扩展RuntimeException实现可序列化
程序包 com.jn.langx.util
- 类com.jn.langx.util.Equivalence.Wrapper扩展Object实现可序列化
  
  serialVersionUID:
  
  0L
  - 序列化字段
    - equivalence
```
Equivalence<T> equivalence
```
    - reference
```
Object reference
```
- 类com.jn.langx.util.MemoableResetException扩展ClassCastException实现可序列化
程序包 com.jn.langx.util.bit
- 类com.jn.langx.util.bit.MaskSet扩展LinkedHashSet<Integer>实现可序列化
  - 序列化字段
    - masks
```
int masks
```
程序包 com.jn.langx.util.collection
- 类com.jn.langx.util.collection.BoundedConcurrentHashMap扩展AbstractMap<K,V>实现可序列化
  
  serialVersionUID:
  
  7249069246763182397L
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream s)
                 throws IOException,
                        ClassNotFoundException
```
      Reconstitute the ConcurrentHashMap instance from a stream (i.e., deserialize it).
      
      抛出:
      
      IOException
      
      ClassNotFoundException
    - writeObject
```
private void writeObject(ObjectOutputStream s)
                  throws IOException
```
      Save the state of the ConcurrentHashMap instance to a stream (i.e., serialize it).
      
      序列数据:
      
      the key (Object) and value (Object) for each key-value mapping, followed by a null pair. The key-value mappings are emitted in no particular order.
      
      抛出:
      
      IOException
  - 序列化字段
    - segmentMask
```
int segmentMask
```
      Mask value for indexing into segments. The upper bits of a key's hash code are used to choose the segment.
    - segmentShift
```
int segmentShift
```
      Shift value for indexing within segments.
    - segments
```
com.jn.langx.util.collection.BoundedConcurrentHashMap.Segment<K,V>[] segments
```
      The segments, each of which is a specialized hash table
- 类com.jn.langx.util.collection.CommonProps扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - props
```
Map<K,V> props
```
- 类com.jn.langx.util.collection.DistinctLinkedBlockingQueue扩展AbstractQueue<E>实现可序列化
  
  serialVersionUID:
  
  -1L
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream s)
                 throws IOException,
                        ClassNotFoundException
```
      Reconstitutes this queue from a stream (that is, deserializes it).
      
      抛出:
      
      ClassNotFoundException - if the class of a serialized object could not be found
      
      IOException - if an I/O error occurs
    - writeObject
```
private void writeObject(ObjectOutputStream s)
                  throws IOException
```
      Saves this queue to a stream (that is, serializes it).
      
      序列数据:
      
      The capacity is emitted (int), followed by all of its elements (each an Object) in the proper order, followed by a null
      
      抛出:
      
      IOException - if an I/O error occurs
  - 序列化字段
    - capacity
```
int capacity
```
      The capacity bound, or Integer.MAX_VALUE if none
    - count
```
AtomicInteger count
```
      Current number of elements
    - elementsHolder
```
ConcurrentHashSet<E> elementsHolder
```
    - takeLock
```
ReentrantLock takeLock
```
      Lock held by take, poll, etc
    - notEmpty
```
Condition notEmpty
```
      Wait the queue for waiting takes
    - putLock
```
ReentrantLock putLock
```
      Lock held by put, offer, etc
    - notFull
```
Condition notFull
```
      Wait the queue for waiting puts
- 类com.jn.langx.util.collection.IdentityMap.IdentityKey扩展Object实现可序列化
  - 序列化字段
    - key
```
Object key
```
    - hash
```
int hash
```
- 类com.jn.langx.util.collection.LinkedCaseInsensitiveMap扩展Object实现可序列化
  - 序列化字段
    - targetMap
```
LinkedHashMap<K,V> targetMap
```
    - locale
```
Locale locale
```
- 类com.jn.langx.util.collection.LinkedCaseInsensitiveSet扩展LinkedHashSet<String>实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - locale
```
Locale locale
```
    - cache
```
Map<K,V> cache
```
- 类com.jn.langx.util.collection.LinkedTreeMap扩展AbstractMap<K,V>实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化方法
    - writeReplace
```
private Object writeReplace()
                     throws ObjectStreamException
```
      If somebody is unlucky enough to have to serialize one of these, serialize it as a LinkedHashMap so that they won't need Gson on the other side to deserialize it. Using serialization defeats our DoS defence, so most apps shouldn't use it.
      
      抛出:
      
      ObjectStreamException
  - 序列化字段
    - comparator
```
Comparator<T> comparator
```
    - root
```
com.jn.langx.util.collection.LinkedTreeMap.Node<K,V> root
```
    - size
```
int size
```
    - modCount
```
int modCount
```
    - header
```
com.jn.langx.util.collection.LinkedTreeMap.Node<K,V> header
```
    - entrySet
```
com.jn.langx.util.collection.LinkedTreeMap.EntrySet entrySet
```
    - keySet
```
com.jn.langx.util.collection.LinkedTreeMap.KeySet keySet
```
- 类com.jn.langx.util.collection.NonAbsentHashMap扩展HashMap<K,V>实现可序列化
  - 序列化字段
    - supplier
```
Supplier<I,O> supplier
```
- 类com.jn.langx.util.collection.NonAbsentTreeMap扩展TreeMap<K,V>实现可序列化
  - 序列化字段
    - supplier
```
Supplier<I,O> supplier
```
- 类com.jn.langx.util.collection.NonDistinctTreeMap扩展TreeMap<K,V>实现可序列化
- 类com.jn.langx.util.collection.NonDistinctTreeSet扩展TreeSet<E>实现可序列化
- 类com.jn.langx.util.collection.PrefixHashMap扩展HashMap<String,V>实现可序列化
  - 序列化字段
    - prefix
```
String prefix
```
    - readUsingPrefix
```
boolean readUsingPrefix
```
- 类com.jn.langx.util.collection.StringMap扩展HashMap<String,String>实现可序列化
- 类com.jn.langx.util.collection.Tuple扩展BasedStringAccessor<Integer,Collection>实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - elements
```
List<E> elements
```
    - maxSize
```
int maxSize
```
程序包 com.jn.langx.util.collection.buffer.exception
- 类com.jn.langx.util.collection.buffer.exception.BufferOverflowException扩展RuntimeException实现可序列化
- 类com.jn.langx.util.collection.buffer.exception.BufferUnderflowException扩展RuntimeException实现可序列化
- 类com.jn.langx.util.collection.buffer.exception.InvalidMarkException扩展IllegalStateException实现可序列化
- 类com.jn.langx.util.collection.buffer.exception.ReadOnlyBufferException扩展RuntimeException实现可序列化
程序包 com.jn.langx.util.collection.graph
- 类com.jn.langx.util.collection.graph.CycleDetectedException扩展RuntimeException实现可序列化
  - 序列化字段
    - cycle
```
List<E> cycle
```
程序包 com.jn.langx.util.collection.multivalue
- 类com.jn.langx.util.collection.multivalue.LinkedMultiValueMap扩展CommonMultiValueMap<K,V>实现可序列化
  
  serialVersionUID:
  
  3801124242820219131L
- 类com.jn.langx.util.collection.multivalue.MultiValueMapAdapter扩展CommonMultiValueMap<K,V>实现可序列化
程序包 com.jn.langx.util.collection.tree
- 类com.jn.langx.util.collection.tree.CommonTree扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - nodes
```
List<E> nodes
```
- 类com.jn.langx.util.collection.tree.SimpleTree扩展Object实现可序列化
  
  serialVersionUID:
  
  -9051148743662948065L
  - 序列化字段
    - nodes
```
List<E> nodes
```
- 类com.jn.langx.util.collection.tree.TreeNode扩展BasedStringAccessor<String,Map<String,Object>>实现可序列化
  
  serialVersionUID:
  
  3465696230080207245L
  - 序列化字段
    - id
```
String id
```
    - pid
```
String pid
```
    - name
```
String name
```
    - isParent
```
boolean isParent
```
    - children
```
Collection<E> children
```
- 类com.jn.langx.util.collection.tree.TreeNodeNotFoundException扩展RuntimeException实现可序列化
程序包 com.jn.langx.util.collection.trie
- 类com.jn.langx.util.collection.trie.TrieMap扩展AbstractMap<CharSequence,V>实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - root
```
com.jn.langx.util.collection.trie.TrieMap.TrieNode<V> root
```
    - size
```
int size
```
程序包 com.jn.langx.util.comparator
- 类com.jn.langx.util.comparator.CalendarComparator扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
- 类com.jn.langx.util.comparator.CharComparator扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
- 类com.jn.langx.util.comparator.ComparableComparator扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
- 类com.jn.langx.util.comparator.EqualsComparator扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
- 类com.jn.langx.util.comparator.HashCodeComparator扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
- 类com.jn.langx.util.comparator.IntegerComparator扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - asc
```
boolean asc
```
- 类com.jn.langx.util.comparator.NonZeroComparator扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - delegate
```
Comparator<T> delegate
```
- 类com.jn.langx.util.comparator.ParallelingComparator扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - delegates
```
List<E> delegates
```
- 类com.jn.langx.util.comparator.ReverseComparator扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - delegate
```
Comparator<T> delegate
```
- 类com.jn.langx.util.comparator.StringComparator扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - ignoreCase
```
boolean ignoreCase
```
- 类com.jn.langx.util.comparator.StringLengthComparator扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
程序包 com.jn.langx.util.concurrent
- 类com.jn.langx.util.concurrent.BlockingMode扩展Object实现可序列化
  
  serialVersionUID:
  
  -1L
  - 序列化方法
    - readResolve
```
Object readResolve()
            throws ObjectStreamException
```
      Overriden to return the indentity instance of BlockingMode based on the stream type int value. This ensures that BlockingMode enums can be compared using ==.
      
      抛出:
      
      ObjectStreamException
  - 序列化字段
    - type
```
int type
```
      The enum manifest constant
- 类com.jn.langx.util.concurrent.MpscQueue扩展AbstractQueue<E>实现可序列化
  
  serialVersionUID:
  
  -6903933977591709194L
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream s)
                 throws IOException,
                        ClassNotFoundException
```
      Reconstitute this queue instance from a stream (that is, deserialize it).
      
      抛出:
      
      IOException
      
      ClassNotFoundException
    - writeObject
```
private void writeObject(ObjectOutputStream s)
                  throws IOException
```
      Save the state to a stream (that is, serialize it).
      
      序列数据:
      
      The capacity is emitted (int), followed by all of its elements (each an Object) in the proper order, followed by a null
      
      抛出:
      
      IOException
  - 序列化字段
    - capacity
```
int capacity
```
      The capacity bound, or Integer.MAX_VALUE if none
    - count
```
AtomicInteger count
```
      Current number of elements
    - takeLock
```
ReentrantLock takeLock
```
      Lock held by take, poll, etc
    - notEmpty
```
Condition notEmpty
```
      Wait queue for waiting takes
    - putLock
```
ReentrantLock putLock
```
      Lock held by put, offer, etc
    - notFull
```
Condition notFull
```
      Wait queue for waiting puts
程序包 com.jn.langx.util.concurrent.clhm
- 类com.jn.langx.util.concurrent.clhm.ConcurrentHashMapV8.KeySetView扩展com.jn.langx.util.concurrent.clhm.ConcurrentHashMapV8.CollectionView<K,V,K>实现可序列化
  
  serialVersionUID:
  
  7249069246763182397L
  - 序列化字段
    - value
```
Object value
```
- 类com.jn.langx.util.concurrent.clhm.ConcurrentLinkedHashMap扩展AbstractMap<K,V>实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream stream)
                 throws InvalidObjectException
```
      抛出:
      
      InvalidObjectException
    - writeReplace
```
Object writeReplace()
```
  - 序列化字段
    - data
```
ConcurrentMap<K,V> data
```
    - concurrencyLevel
```
int concurrencyLevel
```
    - readBufferReadCount
```
long[] readBufferReadCount
```
    - evictionDeque
```
com.jn.langx.util.concurrent.clhm.LinkedDeque<E extends com.jn.langx.util.concurrent.clhm.Linked<E>> evictionDeque
```
    - weightedSize
```
AtomicLong weightedSize
```
    - capacity
```
AtomicLong capacity
```
    - evictionLock
```
Lock evictionLock
```
    - writeBuffer
```
Queue<E> writeBuffer
```
    - readBufferWriteCount
```
AtomicLong[] readBufferWriteCount
```
    - readBufferDrainAtWriteCount
```
AtomicLong[] readBufferDrainAtWriteCount
```
    - readBuffers
```
AtomicReference<V>[][] readBuffers
```
    - drainStatus
```
AtomicReference<V> drainStatus
```
    - weigher
```
EntryWeigher<K,V> weigher
```
    - pendingNotifications
```
Queue<E> pendingNotifications
```
    - listener
```
EvictionListener<K,V> listener
```
程序包 com.jn.langx.util.concurrent.completion
- 类com.jn.langx.util.concurrent.completion.CompletionException扩展RuntimeException实现可序列化
  
  serialVersionUID:
  
  7830266012832686185L
程序包 com.jn.langx.util.id.vm
- 类com.jn.langx.util.id.vm.GUID扩展Object实现可序列化
  
  serialVersionUID:
  
  3289509836244263718L
  - 序列化字段
    - vmid
```
VMID vmid
```
      The virtual machine identifier
    - uid
```
UID uid
```
      The unique identifier
    - hashCode
```
int hashCode
```
      The hash code of this GUID
- 类com.jn.langx.util.id.vm.UID扩展Object实现可序列化
  
  serialVersionUID:
  
  -8093336932569424512L
  - 序列化字段
    - time
```
long time
```
      The time portion of the UID
    - id
```
long id
```
      The identity portion of the UID
- 类com.jn.langx.util.id.vm.VMID扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - address
```
byte[] address
```
      The address of the current virtual machine
    - pid
```
String pid
```
      The process identifier of the current virtual machine
    - uid
```
UID uid
```
      A unique identifier to ensure uniqueness across the host machine
    - hashCode
```
int hashCode
```
      The hash code of this VMID
程序包 com.jn.langx.util.io.file.comparator
- 类com.jn.langx.util.io.file.comparator.LastModifiedFileComparator扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
- 类com.jn.langx.util.io.file.comparator.SizeFileComparator扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - sumDirectoryContents
```
boolean sumDirectoryContents
```
      Whether the sum of the directory's contents should be calculated.
程序包 com.jn.langx.util.jar
- 类com.jn.langx.util.jar.JarNotFoundException扩展RuntimeException实现可序列化
- 类com.jn.langx.util.jar.JarVersionMismatchedException扩展RuntimeException实现可序列化
程序包 com.jn.langx.util.net.cidr
- 类com.jn.langx.util.net.cidr.CidrAddress扩展Object实现可序列化
  
  serialVersionUID:
  
  -1L
  - 序列化方法
    - writeReplace
```
Object writeReplace()
```
  - 序列化字段
    - networkAddress
```
InetAddress networkAddress
```
    - cachedBytes
```
byte[] cachedBytes
```
    - netmaskBits
```
int netmaskBits
```
    - broadcast
```
Inet4Address broadcast
```
    - toString
```
String toString
```
    - hashCode
```
int hashCode
```
程序包 com.jn.langx.util.net.http
- 类com.jn.langx.util.net.http.HttpHeaders扩展Object实现可序列化
  
  serialVersionUID:
  
  -8578554704772377436L
  - 序列化字段
    - headers
```
MultiValueMap<K,V> headers
```
    - dateFormatter
```
SimpleDateFormat dateFormatter
```
      Date formats with time zone as specified in the HTTP RFC to use for formatting.
      
      另请参阅:
      
      Section 7.1.1.1 of RFC 7231
    - dateParsers
```
SimpleDateFormat[] dateParsers
```
      Date formats with time zone as specified in the HTTP RFC to use for parsing.
      
      另请参阅:
      
      Section 7.1.1.1 of RFC 7231
程序包 com.jn.langx.util.net.ipv6
- 类com.jn.langx.util.net.ipv6.IPv6Address扩展Object实现可序列化
  - 序列化字段
    - highBits
```
long highBits
```
    - lowBits
```
long lowBits
```
- 类com.jn.langx.util.net.ipv6.IPv6AddressPool扩展Object实现可序列化
  - 序列化字段
    - underlyingRange
```
IPv6AddressRange underlyingRange
```
    - freeRanges
```
SortedSet<E> freeRanges
```
    - allocationSubnetSize
```
IPv6NetworkMask allocationSubnetSize
```
    - lastAllocated
```
IPv6Network lastAllocated
```
- 类com.jn.langx.util.net.ipv6.IPv6AddressRange扩展Object实现可序列化
  - 序列化字段
    - first
```
IPv6Address first
```
    - last
```
IPv6Address last
```
- 类com.jn.langx.util.net.ipv6.IPv6Network扩展IPv6AddressRange实现可序列化
  - 序列化字段
    - address
```
IPv6Address address
```
    - networkMask
```
IPv6NetworkMask networkMask
```
- 类com.jn.langx.util.net.ipv6.IPv6NetworkMask扩展Object实现可序列化
  - 序列化字段
    - prefixLength
```
int prefixLength
```
程序包 com.jn.langx.util.net.mime
- 类com.jn.langx.util.net.mime.InvalidMediaTypeException扩展IllegalArgumentException实现可序列化
  - 序列化字段
    - mediaType
```
String mediaType
```
- 类com.jn.langx.util.net.mime.InvalidMimeTypeException扩展IllegalArgumentException实现可序列化
  - 序列化字段
    - mimeType
```
String mimeType
```
- 类com.jn.langx.util.net.mime.MediaType扩展MimeType实现可序列化
  
  serialVersionUID:
  
  2069937152339670231L
- 类com.jn.langx.util.net.mime.MimeType扩展Object实现可序列化
  
  serialVersionUID:
  
  4085923477777865903L
  - 序列化字段
    - type
```
String type
```
    - subtype
```
String subtype
```
    - parameters
```
Map<K,V> parameters
```
    - toStringValue
```
String toStringValue
```
- 类com.jn.langx.util.net.mime.MimeType.SpecificityComparator扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
程序包 com.jn.langx.util.random
- 类com.jn.langx.util.random.ThreadLocalRandom扩展Random实现可序列化
  
  serialVersionUID:
  
  -5851777807851030925L
  - 序列化字段
    - rnd
```
long rnd
```
      The random seed. We can't use super.seed.
    - initialized
```
boolean initialized
```
      Initialization flag to permit calls to setSeed to succeed only while executing the Random constructor. We can't allow others since it would cause setting seed in one part of a program to unintentionally impact other usages by the thread.
    - pad0
```
long pad0
```
    - pad1
```
long pad1
```
    - pad2
```
long pad2
```
    - pad3
```
long pad3
```
    - pad4
```
long pad4
```
    - pad5
```
long pad5
```
    - pad6
```
long pad6
```
    - pad7
```
long pad7
```
程序包 com.jn.langx.util.ranges
- 类com.jn.langx.util.ranges.IllegalRangeException扩展RuntimeException实现可序列化
程序包 com.jn.langx.util.reflect.type
- 类com.jn.langx.util.reflect.type.ParameterizedTypeImpl.GenericArrayTypeImpl扩展Object实现可序列化
  
  serialVersionUID:
  
  0L
  - 序列化字段
    - componentType
```
Type componentType
```
- 类com.jn.langx.util.reflect.type.ParameterizedTypeImpl.WildcardTypeImpl扩展Object实现可序列化
  
  serialVersionUID:
  
  0L
  - 序列化字段
    - upperBound
```
Type upperBound
```
    - lowerBound
```
Type lowerBound
```
程序包 com.jn.langx.util.script.javascript.regexp
- 类com.jn.langx.util.script.javascript.regexp.RegexpPatternException扩展RuntimeException实现可序列化
  
  serialVersionUID:
  
  3078609769667671693L
程序包 com.jn.langx.util.timing.cron
- 类com.jn.langx.util.timing.cron.CronExpression扩展Object实现可序列化
  
  serialVersionUID:
  
  12423409423L
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream stream)
                 throws IOException,
                        ClassNotFoundException
```
      抛出:
      
      IOException
      
      ClassNotFoundException
  - 序列化字段
    - cronExpression
```
String cronExpression
```
    - timeZone
```
TimeZone timeZone
```

序列化表格

程序包 com.jn.langx.classpath

类com.jn.langx.classpath.ClasspathScanException扩展RuntimeException实现可序列化

程序包 com.jn.langx.codec

类com.jn.langx.codec.CodecException扩展RuntimeException实现可序列化

程序包 com.jn.langx.commandline

类com.jn.langx.commandline.ExecuteException扩展IOException实现可序列化

序列化字段

cause

exitValue

程序包 com.jn.langx.configuration

类com.jn.langx.configuration.ConfigurationEvent扩展DomainEvent<T extends Configuration>实现可序列化

序列化字段

eventType

类com.jn.langx.configuration.ConfigurationException扩展RuntimeException实现可序列化

程序包 com.jn.langx.configuration.file

类com.jn.langx.configuration.file.InvalidConfigurationFileException扩展RuntimeException实现可序列化

程序包 com.jn.langx.distributed.session

类com.jn.langx.distributed.session.SessionEvent扩展DomainEvent<Session>实现可序列化

序列化字段

eventType

类com.jn.langx.distributed.session.SessionException扩展RuntimeException实现可序列化

程序包 com.jn.langx.event

类com.jn.langx.event.DomainEvent扩展EventObject实现可序列化

序列化字段

domain

source

程序包 com.jn.langx.exception

类com.jn.langx.exception.CompletionException扩展RuntimeException实现可序列化

类com.jn.langx.exception.ExpressionParseException扩展RuntimeException实现可序列化

类com.jn.langx.exception.FileExistsException扩展RuntimeException实现可序列化

类com.jn.langx.exception.IllegalParameterException扩展IllegalArgumentException实现可序列化

类com.jn.langx.exception.IllegalPropertyException扩展RuntimeException实现可序列化

类com.jn.langx.exception.IllegalValueException扩展RuntimeException实现可序列化

类com.jn.langx.exception.NoMappedFieldException扩展RuntimeException实现可序列化

类com.jn.langx.exception.NotDirectoryException扩展IOException实现可序列化

类com.jn.langx.exception.RuntimeIOException扩展RuntimeException实现可序列化

类com.jn.langx.exception.StreamExhaustedException扩展IOException实现可序列化

类com.jn.langx.exception.SyntaxException扩展RuntimeException实现可序列化

类com.jn.langx.exception.UnsupportedEnvironmentException扩展RuntimeException实现可序列化

类com.jn.langx.exception.UnsupportedPlatformException扩展RuntimeException实现可序列化

类com.jn.langx.exception.ValueConvertException扩展RuntimeException实现可序列化

程序包 com.jn.langx.io.buffer.charseq

类com.jn.langx.io.buffer.charseq.ByteArrayBuffer扩展Object实现可序列化

序列化字段

buffer

len

类com.jn.langx.io.buffer.charseq.CharArrayBuffer扩展Object实现可序列化

序列化字段

buffer

len

程序包 com.jn.langx.io.resource

类com.jn.langx.io.resource.InvalidResourceException扩展RuntimeException实现可序列化

类com.jn.langx.io.resource.ResourceNotFoundException扩展RuntimeException实现可序列化

程序包 com.jn.langx.io.stream

类com.jn.langx.io.stream.StringBuilderWriter扩展Writer实现可序列化

序列化字段

builder

程序包 com.jn.langx.lifecycle

类com.jn.langx.lifecycle.InitializationException扩展RuntimeException实现可序列化

程序包 com.jn.langx.management

类com.jn.langx.management.MBeanException扩展RuntimeException实现可序列化

程序包 com.jn.langx.management.connector.server.impl

类com.jn.langx.management.connector.server.impl.RMIJMXConnectorServerWrapper.RmiClientLocalhostSocketFactory扩展Object实现可序列化

序列化字段

factory

程序包 com.jn.langx.security

类com.jn.langx.security.SecurityException扩展RuntimeException实现可序列化

程序包 com.jn.langx.security.crypto

类com.jn.langx.security.crypto.AlgorithmUnregisteredException扩展SecurityException实现可序列化

类com.jn.langx.security.crypto.CryptoException扩展SecurityException实现可序列化

程序包 com.jn.langx.security.crypto.key.spec

类com.jn.langx.security.crypto.key.spec.KeyFileFormatException扩展RuntimeException实现可序列化

程序包 com.jn.langx.security.crypto.provider

类com.jn.langx.security.crypto.provider.LangxSecurityProvider扩展Provider实现可序列化

序列化字段

properties

propertiesBackup

程序包 com.jn.langx.security.ssl

类com.jn.langx.security.ssl.SSLInitializationException扩展IllegalStateException实现可序列化