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

程序包 com.jn.langx.asn1
- 类com.jn.langx.asn1.OID扩展Object实现可序列化
  
  serialVersionUID:
  
  -4542498394670806081L
  - 序列化字段
    - components
```
List<E> components
```
    - oidString
```
String oidString
```
程序包 com.jn.langx.asn1.bytestring
- 类com.jn.langx.asn1.bytestring.ByteStringBuffer扩展Object实现可序列化
  
  serialVersionUID:
  
  2899392249591230998L
  - 序列化字段
    - array
```
byte[] array
```
    - capacity
```
int capacity
```
    - endPos
```
int endPos
```
程序包 com.jn.langx.asn1.spec
- 类com.jn.langx.asn1.spec.ASN1BigInteger扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  2631806934961821260L
  - 序列化字段
    - value
```
BigInteger value
```
- 类com.jn.langx.asn1.spec.ASN1BitString扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  -5962171503831966571L
  - 序列化字段
    - bits
```
boolean[] bits
```
    - bytes
```
byte[] bytes
```
- 类com.jn.langx.asn1.spec.ASN1Boolean扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  7131700816847855524L
  - 序列化字段
    - booleanValue
```
boolean booleanValue
```
- 类com.jn.langx.asn1.spec.ASN1Buffer扩展Object实现可序列化
  
  serialVersionUID:
  
  -4898230771376551562L
  - 序列化字段
    - zeroBufferOnClear
```
AtomicBoolean zeroBufferOnClear
```
    - buffer
```
ByteStringBuffer buffer
```
    - maxBufferSize
```
int maxBufferSize
```
- 类com.jn.langx.asn1.spec.ASN1BufferSequence扩展Object实现可序列化
  
  serialVersionUID:
  
  7219098399193345629L
  - 序列化字段
    - buffer
```
ASN1Buffer buffer
```
    - valueStartPos
```
int valueStartPos
```
- 类com.jn.langx.asn1.spec.ASN1BufferSet扩展Object实现可序列化
  
  serialVersionUID:
  
  6686782295672518084L
  - 序列化字段
    - buffer
```
ASN1Buffer buffer
```
    - valueStartPos
```
int valueStartPos
```
- 类com.jn.langx.asn1.spec.ASN1Element扩展Object实现可序列化
  
  serialVersionUID:
  
  -1871166128693521335L
  - 序列化字段
    - type
```
byte type
```
    - value
```
byte[] value
```
    - hashCode
```
int hashCode
```
    - valueLength
```
int valueLength
```
    - valueOffset
```
int valueOffset
```
- 类com.jn.langx.asn1.spec.ASN1Enumerated扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  -5915912036130847725L
  - 序列化字段
    - intValue
```
int intValue
```
- 类com.jn.langx.asn1.spec.ASN1Exception扩展RuntimeException实现可序列化
  
  serialVersionUID:
  
  3234714599495723483L
- 类com.jn.langx.asn1.spec.ASN1GeneralizedTime扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  -7215431927354583052L
  - 序列化字段
    - time
```
long time
```
    - stringRepresentation
```
String stringRepresentation
```
- 类com.jn.langx.asn1.spec.ASN1IA5String扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  -9112411497688179053L
  - 序列化字段
    - stringValue
```
String stringValue
```
- 类com.jn.langx.asn1.spec.ASN1Integer扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  -733929804601994372L
  - 序列化字段
    - intValue
```
int intValue
```
- 类com.jn.langx.asn1.spec.ASN1Long扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  -3445506299288414013L
  - 序列化字段
    - longValue
```
long longValue
```
- 类com.jn.langx.asn1.spec.ASN1Null扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  -3264450066845549348L
- 类com.jn.langx.asn1.spec.ASN1NumericString扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  -3972798266250943461L
  - 序列化字段
    - stringValue
```
String stringValue
```
- 类com.jn.langx.asn1.spec.ASN1ObjectIdentifier扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  -777778295086222273L
  - 序列化字段
    - oid
```
OID oid
```
- 类com.jn.langx.asn1.spec.ASN1OctetString扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  -7857753188341295516L
  - 序列化字段
    - valueBytes
```
byte[] valueBytes
```
    - valueBytesGuard
```
byte[] valueBytesGuard
```
    - length
```
int length
```
    - offset
```
int offset
```
    - stringValue
```
String stringValue
```
- 类com.jn.langx.asn1.spec.ASN1PrintableString扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  7489436088285132189L
  - 序列化字段
    - stringValue
```
String stringValue
```
- 类com.jn.langx.asn1.spec.ASN1Sequence扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  7294248008273774906L
  - 序列化字段
    - elements
```
ASN1Element[] elements
```
    - encodedValue
```
byte[] encodedValue
```
    - encodedValueGuard
```
byte[] encodedValueGuard
```
- 类com.jn.langx.asn1.spec.ASN1Set扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  -523497075310394409L
  - 序列化字段
    - elements
```
ASN1Element[] elements
```
    - encodedValue
```
byte[] encodedValue
```
    - encodedValueGuard
```
byte[] encodedValueGuard
```
- 类com.jn.langx.asn1.spec.ASN1UTCTime扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  -3107099228691194285L
  - 序列化字段
    - time
```
long time
```
    - stringRepresentation
```
String stringRepresentation
```
- 类com.jn.langx.asn1.spec.ASN1UTF8String扩展ASN1Element实现可序列化
  
  serialVersionUID:
  
  -2147537370903003997L
  - 序列化字段
    - stringValue
```
String stringValue
```
程序包 com.jn.langx.beans
- 类com.jn.langx.beans.BeansException扩展RuntimeException实现可序列化
程序包 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.ParseException扩展RuntimeException实现可序列化
- 类com.jn.langx.exception.ResourceNotFoundException扩展RuntimeException实现可序列化
  - 序列化字段
    - resourceType
```
String resourceType
```
    - resourceId
```
String resourceId
```
- 类com.jn.langx.exception.RuntimeIOException扩展RuntimeException实现可序列化
- 类com.jn.langx.exception.StreamExhaustedException扩展RuntimeIOException实现可序列化
  
  serialVersionUID:
  
  -1L
- 类com.jn.langx.exception.SyntaxException扩展ParseException实现可序列化
- 类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.AbstractStatefulLifecycle.StopException扩展RuntimeException实现可序列化
- 类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.IllegalKeyException扩展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.grok
- 类com.jn.langx.text.grok.GrokException扩展RuntimeException实现可序列化
  
  serialVersionUID:
  
  1L
程序包 com.jn.langx.text.xml
- 类com.jn.langx.text.xml.XmlElementNotFoundException扩展RuntimeException实现可序列化
程序包 com.jn.langx.ui.image.jepg
- 类com.jn.langx.ui.image.jepg.ImageFormatException扩展RuntimeException实现可序列化
- 类com.jn.langx.ui.image.jepg.TruncatedFileException扩展RuntimeException实现可序列化
  - 序列化字段
    - ras
```
Raster ras
```
    - bi
```
BufferedImage bi
```
程序包 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.Money扩展Object实现可序列化
  
  serialVersionUID:
  
  -1004117971993390293L
  - 序列化字段
    - cent
```
long cent
```
      金额，以分为单位。
    - currency
```
Currency currency
```
      币种。
程序包 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.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.KeyComparatorHashMap扩展AbstractMap<K,V>实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream s)
                 throws IOException,
                        ClassNotFoundException
```
      Reconstitute the HashMap instance from a stream (i.e., deserialize it).
      
      抛出:
      
      IOException
      
      ClassNotFoundException
    - writeObject
```
private void writeObject(ObjectOutputStream s)
                  throws IOException
```
      Save the state of the HashMap instance to a stream (i.e., serialize it).
      
      序列数据:
      
      The capacity of the HashMap (the length of the bucket array) is emitted (int), followed by the ss of the HashMap (the number of key-value mappings), followed by the key (Object) and value (Object) for each key-value mapping represented by the HashMap The key-value mappings are emitted in the order that they are returned by entrySet().iterator().
      
      抛出:
      
      IOException
  - 序列化字段
    - threshold
```
int threshold
```
      The next ss value at which to resize (capacity * load factor).
    - loadFactor
```
float loadFactor
```
      The load factor for the hash table.
    - keyComparator
```
KeyComparator<K> keyComparator
```
- 类com.jn.langx.util.collection.KeyComparatorLinkedHashMap扩展KeyComparatorHashMap<K,V>实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - accessOrder
```
boolean accessOrder
```
      The iteration ordering method for this linked hash map: true for access-order, false for insertion-order.
- 类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.OneToOneMap扩展HashMap<K,V>实现可序列化
- 类com.jn.langx.util.collection.PrefixHashMap扩展HashMap<String,V>实现可序列化
  - 序列化字段
    - prefix
```
String prefix
```
    - readUsingPrefix
```
boolean readUsingPrefix
```
- 类com.jn.langx.util.collection.SortedLinkedHashSet扩展LinkedHashSet<E>实现可序列化
  - 序列化字段
    - comparator
```
OrderedComparator<T> comparator
```
    - rwl
```
ReentrantReadWriteLock rwl
```
    - readLock
```
ReentrantReadWriteLock.ReadLock readLock
```
    - writeLock
```
ReentrantReadWriteLock.WriteLock writeLock
```
- 类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.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.concurrent.BoundedConcurrentHashMap.Segment<K,V>[] segments
```
      The segments, each of which is a specialized hash table
- 类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.concurrent.forkjoin
- 类com.jn.langx.util.concurrent.forkjoin.ForkJoinTask扩展Object实现可序列化
  
  serialVersionUID:
  
  -7721805057305804111L
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream s)
                 throws IOException,
                        ClassNotFoundException
```
      Reconstitutes the instance from a stream (that is, deserializes it).
      
      抛出:
      
      IOException
      
      ClassNotFoundException
    - writeObject
```
private void writeObject(ObjectOutputStream s)
                  throws IOException
```
      Saves the state to a stream (that is, serializes it).
      
      序列数据:
      
      the current run status and the exception thrown during execution, or null if none
      
      抛出:
      
      IOException
  - 序列化字段
    - status
```
int status
```
      The run status of this task
- 类com.jn.langx.util.concurrent.forkjoin.RecursiveAction扩展ForkJoinTask<Void>实现可序列化
  
  serialVersionUID:
  
  5232453952276485070L
- 类com.jn.langx.util.concurrent.forkjoin.RecursiveTask扩展ForkJoinTask<V>实现可序列化
  
  serialVersionUID:
  
  5232453952276485270L
  - 序列化字段
    - result
```
Object result
```
      The result of the computation.
程序包 com.jn.langx.util.concurrent.lock
- 类com.jn.langx.util.concurrent.lock.AutoLock扩展Object实现可序列化
  
  serialVersionUID:
  
  3300696774541816341L
  - 序列化字段
    - _lock
```
ReentrantLock _lock
```
- 类com.jn.langx.util.concurrent.lock.AutoLock.WithCondition扩展AutoLock实现可序列化
  - 序列化字段
    - _condition
```
Condition _condition
```
程序包 com.jn.langx.util.datetime
- 类com.jn.langx.util.datetime.NotFoundDateTimeFormatterException扩展RuntimeException实现可序列化
程序包 com.jn.langx.util.hash
- 类com.jn.langx.util.hash.UnsupportedHashAlgorithmException扩展RuntimeException实现可序列化
程序包 com.jn.langx.util.id
- 类com.jn.langx.util.id.Ulid.Value扩展Object实现可序列化
  
  serialVersionUID:
  
  -3563159514112487717L
  - 序列化字段
    - mostSignificantBits
```
long mostSignificantBits
```
    - leastSignificantBits
```
long leastSignificantBits
```
程序包 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.progress
- 类com.jn.langx.util.progress.ProgressEvent扩展DomainEvent<ProgressSource>实现可序列化
  - 序列化字段
    - eventType
```
ProgressEventType eventType
```
程序包 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.reflect.type.ResolvableType扩展Object实现可序列化
  - 序列化方法
    - readResolve
```
private Object readResolve()
```
      Custom serialization support for ResolvableType.NONE.
  - 序列化字段
    - type
```
Type type
```
      The underlying Java type being managed (only ever null for ResolvableType.NONE).
    - typeProvider
```
SerializableTypeWrapper.TypeProvider typeProvider
```
      Optional provider for the type.
    - variableResolver
```
com.jn.langx.util.reflect.type.ResolvableType.VariableResolver variableResolver
```
      The VariableResolver to use or null if no resolver is available.
    - componentType
```
ResolvableType componentType
```
      The component type for an array or null if the type should be deduced.
    - resolved
```
Class<T> resolved
```
      Copy of the resolved value.
    - hash
```
Integer hash
```
    - superType
```
ResolvableType superType
```
    - interfaces
```
ResolvableType[] interfaces
```
    - generics
```
ResolvableType[] generics
```
- 类com.jn.langx.util.reflect.type.SerializableTypeWrapper.FieldTypeProvider扩展Object实现可序列化
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream inputStream)
                 throws IOException,
                        ClassNotFoundException
```
      抛出:
      
      IOException
      
      ClassNotFoundException
  - 序列化字段
    - fieldName
```
String fieldName
```
    - declaringClass
```
Class<T> declaringClass
```
- 类com.jn.langx.util.reflect.type.SerializableTypeWrapper.MethodInvokeTypeProvider扩展Object实现可序列化
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream inputStream)
                 throws IOException,
                        ClassNotFoundException
```
      抛出:
      
      IOException
      
      ClassNotFoundException
  - 序列化字段
    - provider
```
SerializableTypeWrapper.TypeProvider provider
```
    - methodName
```
String methodName
```
    - declaringClass
```
Class<T> declaringClass
```
    - index
```
int index
```
- 类com.jn.langx.util.reflect.type.SerializableTypeWrapper.MethodParameterTypeProvider扩展Object实现可序列化
  - 序列化方法
    - readObject
```
private void readObject(ObjectInputStream inputStream)
                 throws IOException,
                        ClassNotFoundException
```
      抛出:
      
      IOException
      
      ClassNotFoundException
  - 序列化字段
    - methodName
```
String methodName
```
    - parameterTypes
```
Class<T>[] parameterTypes
```
    - declaringClass
```
Class<T> declaringClass
```
    - parameterIndex
```
int parameterIndex
```
程序包 com.jn.langx.util.regexp
- 类com.jn.langx.util.regexp.NamedGroupConflictedException扩展SyntaxException实现可序列化
程序包 com.jn.langx.util.regexp.named
- 类com.jn.langx.util.regexp.named.Groups.GroupCoordinate扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - pos
```
int pos
```
    - groupIndex
```
int groupIndex
```
- 类com.jn.langx.util.regexp.named.NamedRegexp扩展Object实现可序列化
  
  serialVersionUID:
  
  1L
  - 序列化字段
    - pattern
```
Pattern pattern
```
    - namedPattern
```
String namedPattern
```
    - groupNames
```
List<E> groupNames
```
    - groupInfo
```
Map<K,V> groupInfo
```
    - option
```
Option option
```
程序包 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.asn1

类com.jn.langx.asn1.OID扩展Object实现可序列化

序列化字段

components

oidString

程序包 com.jn.langx.asn1.bytestring

类com.jn.langx.asn1.bytestring.ByteStringBuffer扩展Object实现可序列化

序列化字段

array

capacity

endPos

程序包 com.jn.langx.asn1.spec

类com.jn.langx.asn1.spec.ASN1BigInteger扩展ASN1Element实现可序列化

序列化字段

value

类com.jn.langx.asn1.spec.ASN1BitString扩展ASN1Element实现可序列化

序列化字段

bits

bytes

类com.jn.langx.asn1.spec.ASN1Boolean扩展ASN1Element实现可序列化

序列化字段

booleanValue

类com.jn.langx.asn1.spec.ASN1Buffer扩展Object实现可序列化

序列化字段

zeroBufferOnClear

buffer

maxBufferSize

类com.jn.langx.asn1.spec.ASN1BufferSequence扩展Object实现可序列化

序列化字段

buffer

valueStartPos

类com.jn.langx.asn1.spec.ASN1BufferSet扩展Object实现可序列化

序列化字段

buffer

valueStartPos

类com.jn.langx.asn1.spec.ASN1Element扩展Object实现可序列化

序列化字段

type

value

hashCode

valueLength

valueOffset

类com.jn.langx.asn1.spec.ASN1Enumerated扩展ASN1Element实现可序列化

序列化字段

intValue

类com.jn.langx.asn1.spec.ASN1Exception扩展RuntimeException实现可序列化

类com.jn.langx.asn1.spec.ASN1GeneralizedTime扩展ASN1Element实现可序列化

序列化字段

time

stringRepresentation

类com.jn.langx.asn1.spec.ASN1IA5String扩展ASN1Element实现可序列化

序列化字段

stringValue

类com.jn.langx.asn1.spec.ASN1Integer扩展ASN1Element实现可序列化

序列化字段

intValue

类com.jn.langx.asn1.spec.ASN1Long扩展ASN1Element实现可序列化

序列化字段

longValue

类com.jn.langx.asn1.spec.ASN1Null扩展ASN1Element实现可序列化

类com.jn.langx.asn1.spec.ASN1NumericString扩展ASN1Element实现可序列化

序列化字段

stringValue

类com.jn.langx.asn1.spec.ASN1ObjectIdentifier扩展ASN1Element实现可序列化

序列化字段

oid

类com.jn.langx.asn1.spec.ASN1OctetString扩展ASN1Element实现可序列化

序列化字段

valueBytes

valueBytesGuard

length

offset

stringValue

类com.jn.langx.asn1.spec.ASN1PrintableString扩展ASN1Element实现可序列化

序列化字段

stringValue

类com.jn.langx.asn1.spec.ASN1Sequence扩展ASN1Element实现可序列化

序列化字段

elements