下面列出了java.io.ObjectOutputStream#write ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
/**
* Save the state of this object to a stream (i.e., serialize it).
*
* @serialData We write out two formats, a JDK 1.1 compatible format, using
* {@code DOW_IN_MONTH_MODE} rules, in the required section, followed
* by the full rules, in packed format, in the optional section. The
* optional section will be ignored by JDK 1.1 code upon stream in.
* <p> Contents of the optional section: The length of a byte array is
* emitted (int); this is 4 as of this release. The byte array of the given
* length is emitted. The contents of the byte array are the true values of
* the fields {@code startDay}, {@code startDayOfWeek},
* {@code endDay}, and {@code endDayOfWeek}. The values of these
* fields in the required section are approximate values suited to the rule
* mode {@code DOW_IN_MONTH_MODE}, which is the only mode recognized by
* JDK 1.1.
*/
@java.io.Serial
private void writeObject(ObjectOutputStream stream)
throws IOException
{
// Construct a binary rule
byte[] rules = packRules();
int[] times = packTimes();
// Convert to 1.1 FCS rules. This step may cause us to lose information.
makeRulesCompatible();
// Write out the 1.1 FCS rules
stream.defaultWriteObject();
// Write out the binary rules in the optional data area of the stream.
stream.writeInt(rules.length);
stream.write(rules);
stream.writeObject(times);
// Recover the original rules. This recovers the information lost
// by makeRulesCompatible.
unpackRules(rules);
unpackTimes(times);
}
void writeObject(ObjectOutputStream out) throws IOException {
out.writeInt(bufSize);
out.writeBoolean(buffer != null);
if (buffer != null) {
Deflater compressor = new Deflater();
// for small buffers, the compressed size can be somewhat larger than the original
byte[] compressedBytes = new byte[bufSize + 32];
int compressedSize;
compressor.setInput(buffer,startPos,bufSize);
compressor.finish();
compressedSize = compressor.deflate(compressedBytes);
out.writeInt(compressedSize);
out.write(compressedBytes,0,compressedSize);
} else {
out.writeUTF(eventBufferFileName);
}
}
/**
* Save the state of this object to a stream (i.e., serialize it).
*
* @serialData We write out two formats, a JDK 1.1 compatible format, using
* <code>DOW_IN_MONTH_MODE</code> rules, in the required section, followed
* by the full rules, in packed format, in the optional section. The
* optional section will be ignored by JDK 1.1 code upon stream in.
* <p> Contents of the optional section: The length of a byte array is
* emitted (int); this is 4 as of this release. The byte array of the given
* length is emitted. The contents of the byte array are the true values of
* the fields <code>startDay</code>, <code>startDayOfWeek</code>,
* <code>endDay</code>, and <code>endDayOfWeek</code>. The values of these
* fields in the required section are approximate values suited to the rule
* mode <code>DOW_IN_MONTH_MODE</code>, which is the only mode recognized by
* JDK 1.1.
*/
private void writeObject(ObjectOutputStream stream)
throws IOException
{
// Construct a binary rule
byte[] rules = packRules();
int[] times = packTimes();
// Convert to 1.1 FCS rules. This step may cause us to lose information.
makeRulesCompatible();
// Write out the 1.1 FCS rules
stream.defaultWriteObject();
// Write out the binary rules in the optional data area of the stream.
stream.writeInt(rules.length);
stream.write(rules);
stream.writeObject(times);
// Recover the original rules. This recovers the information lost
// by makeRulesCompatible.
unpackRules(rules);
unpackTimes(times);
}
/**
* Save the state of this object to a stream (i.e., serialize it).
*
* @serialData We write out two formats, a JDK 1.1 compatible format, using
* <code>DOW_IN_MONTH_MODE</code> rules, in the required section, followed
* by the full rules, in packed format, in the optional section. The
* optional section will be ignored by JDK 1.1 code upon stream in.
* <p> Contents of the optional section: The length of a byte array is
* emitted (int); this is 4 as of this release. The byte array of the given
* length is emitted. The contents of the byte array are the true values of
* the fields <code>startDay</code>, <code>startDayOfWeek</code>,
* <code>endDay</code>, and <code>endDayOfWeek</code>. The values of these
* fields in the required section are approximate values suited to the rule
* mode <code>DOW_IN_MONTH_MODE</code>, which is the only mode recognized by
* JDK 1.1.
*/
private void writeObject(ObjectOutputStream stream)
throws IOException
{
// Construct a binary rule
byte[] rules = packRules();
int[] times = packTimes();
// Convert to 1.1 FCS rules. This step may cause us to lose information.
makeRulesCompatible();
// Write out the 1.1 FCS rules
stream.defaultWriteObject();
// Write out the binary rules in the optional data area of the stream.
stream.writeInt(rules.length);
stream.write(rules);
stream.writeObject(times);
// Recover the original rules. This recovers the information lost
// by makeRulesCompatible.
unpackRules(rules);
unpackTimes(times);
}
/**
* Save the state of this object to a stream (i.e., serialize it).
*
* @serialData We write out two formats, a JDK 1.1 compatible format, using
* <code>DOW_IN_MONTH_MODE</code> rules, in the required section, followed
* by the full rules, in packed format, in the optional section. The
* optional section will be ignored by JDK 1.1 code upon stream in.
* <p> Contents of the optional section: The length of a byte array is
* emitted (int); this is 4 as of this release. The byte array of the given
* length is emitted. The contents of the byte array are the true values of
* the fields <code>startDay</code>, <code>startDayOfWeek</code>,
* <code>endDay</code>, and <code>endDayOfWeek</code>. The values of these
* fields in the required section are approximate values suited to the rule
* mode <code>DOW_IN_MONTH_MODE</code>, which is the only mode recognized by
* JDK 1.1.
*/
private void writeObject(ObjectOutputStream stream)
throws IOException
{
// Construct a binary rule
byte[] rules = packRules();
int[] times = packTimes();
// Convert to 1.1 FCS rules. This step may cause us to lose information.
makeRulesCompatible();
// Write out the 1.1 FCS rules
stream.defaultWriteObject();
// Write out the binary rules in the optional data area of the stream.
stream.writeInt(rules.length);
stream.write(rules);
stream.writeObject(times);
// Recover the original rules. This recovers the information lost
// by makeRulesCompatible.
unpackRules(rules);
unpackTimes(times);
}
/**
* Serialize this {@code CertificateRevokedException} instance.
*
* @serialData the size of the extensions map (int), followed by all of
* the extensions in the map, in no particular order. For each extension,
* the following data is emitted: the OID String (Object), the criticality
* flag (boolean), the length of the encoded extension value byte array
* (int), and the encoded extension value bytes.
*/
private void writeObject(ObjectOutputStream oos) throws IOException {
// Write out the non-transient fields
// (revocationDate, reason, authority)
oos.defaultWriteObject();
// Write out the size (number of mappings) of the extensions map
oos.writeInt(extensions.size());
// For each extension in the map, the following are emitted (in order):
// the OID String (Object), the criticality flag (boolean), the length
// of the encoded extension value byte array (int), and the encoded
// extension value byte array. The extensions themselves are emitted
// in no particular order.
for (Map.Entry<String, Extension> entry : extensions.entrySet()) {
Extension ext = entry.getValue();
oos.writeObject(ext.getId());
oos.writeBoolean(ext.isCritical());
byte[] extVal = ext.getValue();
oos.writeInt(extVal.length);
oos.write(extVal);
}
}
/**
* Serialize this {@code CertificateRevokedException} instance.
*
* @serialData the size of the extensions map (int), followed by all of
* the extensions in the map, in no particular order. For each extension,
* the following data is emitted: the OID String (Object), the criticality
* flag (boolean), the length of the encoded extension value byte array
* (int), and the encoded extension value bytes.
*/
private void writeObject(ObjectOutputStream oos) throws IOException {
// Write out the non-transient fields
// (revocationDate, reason, authority)
oos.defaultWriteObject();
// Write out the size (number of mappings) of the extensions map
oos.writeInt(extensions.size());
// For each extension in the map, the following are emitted (in order):
// the OID String (Object), the criticality flag (boolean), the length
// of the encoded extension value byte array (int), and the encoded
// extension value byte array. The extensions themselves are emitted
// in no particular order.
for (Map.Entry<String, Extension> entry : extensions.entrySet()) {
Extension ext = entry.getValue();
oos.writeObject(ext.getId());
oos.writeBoolean(ext.isCritical());
byte[] extVal = ext.getValue();
oos.writeInt(extVal.length);
oos.write(extVal);
}
}
/**
* Save the state of this object to a stream (i.e., serialize it).
*
* @serialData We write out two formats, a JDK 1.1 compatible format, using
* <code>DOW_IN_MONTH_MODE</code> rules, in the required section, followed
* by the full rules, in packed format, in the optional section. The
* optional section will be ignored by JDK 1.1 code upon stream in.
* <p> Contents of the optional section: The length of a byte array is
* emitted (int); this is 4 as of this release. The byte array of the given
* length is emitted. The contents of the byte array are the true values of
* the fields <code>startDay</code>, <code>startDayOfWeek</code>,
* <code>endDay</code>, and <code>endDayOfWeek</code>. The values of these
* fields in the required section are approximate values suited to the rule
* mode <code>DOW_IN_MONTH_MODE</code>, which is the only mode recognized by
* JDK 1.1.
*/
private void writeObject(ObjectOutputStream stream)
throws IOException
{
// Construct a binary rule
byte[] rules = packRules();
int[] times = packTimes();
// Convert to 1.1 FCS rules. This step may cause us to lose information.
makeRulesCompatible();
// Write out the 1.1 FCS rules
stream.defaultWriteObject();
// Write out the binary rules in the optional data area of the stream.
stream.writeInt(rules.length);
stream.write(rules);
stream.writeObject(times);
// Recover the original rules. This recovers the information lost
// by makeRulesCompatible.
unpackRules(rules);
unpackTimes(times);
}
/**
* Save the state of this object to a stream (i.e., serialize it).
*
* @serialData We write out two formats, a JDK 1.1 compatible format, using
* <code>DOW_IN_MONTH_MODE</code> rules, in the required section, followed
* by the full rules, in packed format, in the optional section. The
* optional section will be ignored by JDK 1.1 code upon stream in.
* <p> Contents of the optional section: The length of a byte array is
* emitted (int); this is 4 as of this release. The byte array of the given
* length is emitted. The contents of the byte array are the true values of
* the fields <code>startDay</code>, <code>startDayOfWeek</code>,
* <code>endDay</code>, and <code>endDayOfWeek</code>. The values of these
* fields in the required section are approximate values suited to the rule
* mode <code>DOW_IN_MONTH_MODE</code>, which is the only mode recognized by
* JDK 1.1.
*/
private void writeObject(ObjectOutputStream stream)
throws IOException
{
// Construct a binary rule
byte[] rules = packRules();
int[] times = packTimes();
// Convert to 1.1 FCS rules. This step may cause us to lose information.
makeRulesCompatible();
// Write out the 1.1 FCS rules
stream.defaultWriteObject();
// Write out the binary rules in the optional data area of the stream.
stream.writeInt(rules.length);
stream.write(rules);
stream.writeObject(times);
// Recover the original rules. This recovers the information lost
// by makeRulesCompatible.
unpackRules(rules);
unpackTimes(times);
}
void writeObject(ObjectOutputStream out) throws IOException {
out.writeInt(packedData.length);
out.write(packedData);
out.writeInt(packedArrayOffsets.length);
for (int i = 0; i < packedArrayOffsets.length; i++) {
out.writeInt(packedArrayOffsets[i]);
}
packedData = null;
packedArrayOffsets = null;
}
private void writeObject(ObjectOutputStream out) throws IOException
{
byte[] bytes = this.contents.getBytes("ISO8859_1");
out.writeInt(bytes.length);
if (this.exceptionThrown)
{
out.write(bytes);
}
else
{
out.write(bytes, 0, bytes.length / 2);
this.exceptionThrown = true;
throw new IOException();
}
}
public void doWrite( ObjectOutputStream stream )
throws IOException
{
// write the IOR to the ObjectOutputStream
stream.writeInt(typeData.length);
stream.write(typeData);
stream.writeInt(profileTags.length);
for (int i = 0; i < profileTags.length; i++) {
stream.writeInt(profileTags[i]);
stream.writeInt(profileData[i].length);
stream.write(profileData[i]);
}
}
/**
* Serializes an {@link MBeanFeatureInfo} to an {@link ObjectOutputStream}.
* @serialData
* For compatibility reasons, an object of this class is serialized as follows.
* <p>
* The method {@link ObjectOutputStream#defaultWriteObject defaultWriteObject()}
* is called first to serialize the object except the field {@code descriptor}
* which is declared as transient. The field {@code descriptor} is serialized
* as follows:
* <ul>
* <li>If {@code descriptor} is an instance of the class
* {@link ImmutableDescriptor}, the method {@link ObjectOutputStream#write
* write(int val)} is called to write a byte with the value {@code 1},
* then the method {@link ObjectOutputStream#writeObject writeObject(Object obj)}
* is called twice to serialize the field names and the field values of the
* {@code descriptor}, respectively as a {@code String[]} and an
* {@code Object[]};</li>
* <li>Otherwise, the method {@link ObjectOutputStream#write write(int val)}
* is called to write a byte with the value {@code 0}, then the method
* {@link ObjectOutputStream#writeObject writeObject(Object obj)} is called
* to serialize directly the field {@code descriptor}.
* </ul>
*
* @since 1.6
*/
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
if (descriptor != null &&
descriptor.getClass() == ImmutableDescriptor.class) {
out.write(1);
final String[] names = descriptor.getFieldNames();
out.writeObject(names);
out.writeObject(descriptor.getFieldValues(names));
} else {
out.write(0);
out.writeObject(descriptor);
}
}
/**
* Serializes an {@link MBeanInfo} to an {@link ObjectOutputStream}.
* @serialData
* For compatibility reasons, an object of this class is serialized as follows.
* <p>
* The method {@link ObjectOutputStream#defaultWriteObject defaultWriteObject()}
* is called first to serialize the object except the field {@code descriptor}
* which is declared as transient. The field {@code descriptor} is serialized
* as follows:
* <ul>
* <li> If {@code descriptor} is an instance of the class
* {@link ImmutableDescriptor}, the method {@link ObjectOutputStream#write
* write(int val)} is called to write a byte with the value {@code 1},
* then the method {@link ObjectOutputStream#writeObject writeObject(Object obj)}
* is called twice to serialize the field names and the field values of the
* {@code descriptor}, respectively as a {@code String[]} and an
* {@code Object[]};</li>
* <li> Otherwise, the method {@link ObjectOutputStream#write write(int val)}
* is called to write a byte with the value {@code 0}, then the method
* {@link ObjectOutputStream#writeObject writeObject(Object obj)} is called
* to serialize the field {@code descriptor} directly.
* </ul>
*
* @since 1.6
*/
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
if (descriptor.getClass() == ImmutableDescriptor.class) {
out.write(1);
final String[] names = descriptor.getFieldNames();
out.writeObject(names);
out.writeObject(descriptor.getFieldValues(names));
} else {
out.write(0);
out.writeObject(descriptor);
}
}
/**
* Serializes an {@link MBeanFeatureInfo} to an {@link ObjectOutputStream}.
* @serialData
* For compatibility reasons, an object of this class is serialized as follows.
* <p>
* The method {@link ObjectOutputStream#defaultWriteObject defaultWriteObject()}
* is called first to serialize the object except the field {@code descriptor}
* which is declared as transient. The field {@code descriptor} is serialized
* as follows:
* <ul>
* <li>If {@code descriptor} is an instance of the class
* {@link ImmutableDescriptor}, the method {@link ObjectOutputStream#write
* write(int val)} is called to write a byte with the value {@code 1},
* then the method {@link ObjectOutputStream#writeObject writeObject(Object obj)}
* is called twice to serialize the field names and the field values of the
* {@code descriptor}, respectively as a {@code String[]} and an
* {@code Object[]};</li>
* <li>Otherwise, the method {@link ObjectOutputStream#write write(int val)}
* is called to write a byte with the value {@code 0}, then the method
* {@link ObjectOutputStream#writeObject writeObject(Object obj)} is called
* to serialize directly the field {@code descriptor}.
* </ul>
*
* @since 1.6
*/
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
if (descriptor != null &&
descriptor.getClass() == ImmutableDescriptor.class) {
out.write(1);
final String[] names = descriptor.getFieldNames();
out.writeObject(names);
out.writeObject(descriptor.getFieldValues(names));
} else {
out.write(0);
out.writeObject(descriptor);
}
}
/**
* Serializes an {@link MBeanInfo} to an {@link ObjectOutputStream}.
* @serialData
* For compatibility reasons, an object of this class is serialized as follows.
* <p>
* The method {@link ObjectOutputStream#defaultWriteObject defaultWriteObject()}
* is called first to serialize the object except the field {@code descriptor}
* which is declared as transient. The field {@code descriptor} is serialized
* as follows:
* <ul>
* <li> If {@code descriptor} is an instance of the class
* {@link ImmutableDescriptor}, the method {@link ObjectOutputStream#write
* write(int val)} is called to write a byte with the value {@code 1},
* then the method {@link ObjectOutputStream#writeObject writeObject(Object obj)}
* is called twice to serialize the field names and the field values of the
* {@code descriptor}, respectively as a {@code String[]} and an
* {@code Object[]};</li>
* <li> Otherwise, the method {@link ObjectOutputStream#write write(int val)}
* is called to write a byte with the value {@code 0}, then the method
* {@link ObjectOutputStream#writeObject writeObject(Object obj)} is called
* to serialize the field {@code descriptor} directly.
* </ul>
*
* @since 1.6
*/
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
if (descriptor.getClass() == ImmutableDescriptor.class) {
out.write(1);
final String[] names = descriptor.getFieldNames();
out.writeObject(names);
out.writeObject(descriptor.getFieldValues(names));
} else {
out.write(0);
out.writeObject(descriptor);
}
}
private void writeObject( final ObjectOutputStream out ) throws IOException{
out.write( length );
out.write( value , start , length );
}
/**
* Serializes an {@link MBeanInfo} to an {@link ObjectOutputStream}.
* @serialData
* For compatibility reasons, an object of this class is serialized as follows.
* <p>
* The method {@link ObjectOutputStream#defaultWriteObject defaultWriteObject()}
* is called first to serialize the object except the field {@code descriptor}
* which is declared as transient. The field {@code descriptor} is serialized
* as follows:
* <ul>
* <li> If {@code descriptor} is an instance of the class
* {@link ImmutableDescriptor}, the method {@link ObjectOutputStream#write
* write(int val)} is called to write a byte with the value {@code 1},
* then the method {@link ObjectOutputStream#writeObject writeObject(Object obj)}
* is called twice to serialize the field names and the field values of the
* {@code descriptor}, respectively as a {@code String[]} and an
* {@code Object[]};</li>
* <li> Otherwise, the method {@link ObjectOutputStream#write write(int val)}
* is called to write a byte with the value {@code 0}, then the method
* {@link ObjectOutputStream#writeObject writeObject(Object obj)} is called
* to serialize the field {@code descriptor} directly.
* </ul>
*
* @since 1.6
*/
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
if (descriptor.getClass() == ImmutableDescriptor.class) {
out.write(1);
final String[] names = descriptor.getFieldNames();
out.writeObject(names);
out.writeObject(descriptor.getFieldValues(names));
} else {
out.write(0);
out.writeObject(descriptor);
}
}
/**
* Serializes an {@link MBeanFeatureInfo} to an {@link ObjectOutputStream}.
* @serialData
* For compatibility reasons, an object of this class is serialized as follows.
* <p>
* The method {@link ObjectOutputStream#defaultWriteObject defaultWriteObject()}
* is called first to serialize the object except the field {@code descriptor}
* which is declared as transient. The field {@code descriptor} is serialized
* as follows:
* <ul>
* <li>If {@code descriptor} is an instance of the class
* {@link ImmutableDescriptor}, the method {@link ObjectOutputStream#write
* write(int val)} is called to write a byte with the value {@code 1},
* then the method {@link ObjectOutputStream#writeObject writeObject(Object obj)}
* is called twice to serialize the field names and the field values of the
* {@code descriptor}, respectively as a {@code String[]} and an
* {@code Object[]};</li>
* <li>Otherwise, the method {@link ObjectOutputStream#write write(int val)}
* is called to write a byte with the value {@code 0}, then the method
* {@link ObjectOutputStream#writeObject writeObject(Object obj)} is called
* to serialize directly the field {@code descriptor}.
* </ul>
*
* @since 1.6
*/
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
if (descriptor != null &&
descriptor.getClass() == ImmutableDescriptor.class) {
out.write(1);
final String[] names = descriptor.getFieldNames();
out.writeObject(names);
out.writeObject(descriptor.getFieldValues(names));
} else {
out.write(0);
out.writeObject(descriptor);
}
}
/**
* Serializes an {@link MBeanFeatureInfo} to an {@link ObjectOutputStream}.
* @serialData
* For compatibility reasons, an object of this class is serialized as follows.
* <p>
* The method {@link ObjectOutputStream#defaultWriteObject defaultWriteObject()}
* is called first to serialize the object except the field {@code descriptor}
* which is declared as transient. The field {@code descriptor} is serialized
* as follows:
* <ul>
* <li>If {@code descriptor} is an instance of the class
* {@link ImmutableDescriptor}, the method {@link ObjectOutputStream#write
* write(int val)} is called to write a byte with the value {@code 1},
* then the method {@link ObjectOutputStream#writeObject writeObject(Object obj)}
* is called twice to serialize the field names and the field values of the
* {@code descriptor}, respectively as a {@code String[]} and an
* {@code Object[]};</li>
* <li>Otherwise, the method {@link ObjectOutputStream#write write(int val)}
* is called to write a byte with the value {@code 0}, then the method
* {@link ObjectOutputStream#writeObject writeObject(Object obj)} is called
* to serialize directly the field {@code descriptor}.
* </ul>
*
* @since 1.6
*/
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
if (descriptor != null &&
descriptor.getClass() == ImmutableDescriptor.class) {
out.write(1);
final String[] names = descriptor.getFieldNames();
out.writeObject(names);
out.writeObject(descriptor.getFieldValues(names));
} else {
out.write(0);
out.writeObject(descriptor);
}
}