cn.sliew.milky.common.io.stream

类 StreamOutput

java.lang.Object

java.io.OutputStream

cn.sliew.milky.common.io.stream.StreamOutput

所有已实现的接口:

Closeable, Flushable, AutoCloseable

直接已知子类:

OutputStreamStreamOutput

public abstract class StreamOutput
extends OutputStream

A stream from another node to this node. Technically, it can also be streamed from a byte array but that is mostly for testing.

This class's methods are optimized so you can put the methods that read and write a class next to each other and you can scan them visually for differences. That means that most variables should be read and written in a single line so even large objects fit both reading and writing on the screen. It also means that the methods on this class are named very similarly to StreamInput. Finally it means that the "barrier to entry" for adding new methods to this class is relatively low even though it is a shared class with code everywhere. That being said, this class deals primarily with Lists rather than Arrays. For the most part calls should adapt to lists, either by storing Lists internally or just converting to and from a List when calling. This comment is repeated on StreamInput.

构造器概要

构造器

构造器和说明
StreamOutput()

方法概要

限定符和类型	方法和说明
abstract void	close() Closes this stream to further operations.
abstract void	flush() Forces any buffered output to be written.
abstract void	reset()
void	write(byte[] b, int off, int len)
void	write(int b)
void	writeBoolean(boolean b)
abstract void	writeByte(byte b) Writes a single byte.
void	writeBytes(byte[] b) Writes an array of bytes.
void	writeBytes(byte[] b, int length) Writes an array of bytes.
abstract void	writeBytes(byte[] b, int offset, int length) Writes an array of bytes.
void	writeDouble(double v)
void	writeFloat(float v)
void	writeGenericValue(Object value) Notice: when serialization a map, the stream out map with the stream in map maybe have the different key-value orders, they will maybe have different stream order.
void	writeInt(int i) Writes an int as four bytes.
void	writeLong(long i) Writes a long as eight bytes.
void	writeOptionalBoolean(Boolean b)
void	writeOptionalDouble(Double v)
void	writeOptionalFloat(Float floatValue)
void	writeOptionalInt(Integer integer) Writes an optional Integer.
void	writeOptionalLong(Long l)
void	writeOptionalVInt(Integer integer)
void	writeOptionalVLong(Long l)
void	writeShort(short v)
void	writeVInt(int i) Writes an int in a variable-length format.
void	writeVLong(long i) Writes a non-negative long in a variable-length format.
void	writeZLong(long i) Writes a long in a variable-length format.

从类继承的方法 java.io.OutputStream

write

从类继承的方法 java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

构造器详细资料

StreamOutput

public StreamOutput()

方法详细资料

close

public abstract void close()
                    throws IOException

Closes this stream to further operations.

指定者:

close 在接口中 Closeable

指定者:

close 在接口中 AutoCloseable

覆盖:

close 在类中 OutputStream

抛出:

IOException

flush

public abstract void flush()
                    throws IOException

Forces any buffered output to be written.

指定者:

flush 在接口中 Flushable

覆盖:

flush 在类中 OutputStream

抛出:

IOException

reset

public abstract void reset()
                    throws IOException

抛出:

IOException

writeByte

public abstract void writeByte(byte b)
                        throws IOException

Writes a single byte.

抛出:

IOException

writeBytes

public void writeBytes(byte[] b)
                throws IOException

Writes an array of bytes.

参数:

b - the bytes to write

抛出:

IOException

writeBytes

public void writeBytes(byte[] b,
                       int length)
                throws IOException

Writes an array of bytes.

参数:

b - the bytes to write

length - the number of bytes to write

抛出:

IOException

writeBytes

public abstract void writeBytes(byte[] b,
                                int offset,
                                int length)
                         throws IOException

Writes an array of bytes.

参数:

b - the bytes to write

offset - the offset in the byte array

length - the number of bytes to write

抛出:

IOException

writeShort

public final void writeShort(short v)
                      throws IOException

抛出:

IOException

writeInt

public void writeInt(int i)
              throws IOException

Writes an int as four bytes.

抛出:

IOException

writeOptionalInt

public void writeOptionalInt(Integer integer)
                      throws IOException

Writes an optional Integer.

抛出:

IOException

writeVInt

public void writeVInt(int i)
               throws IOException

Writes an int in a variable-length format. Writes between one and five bytes. Smaller values take fewer bytes. Negative numbers will always use all 5 bytes and are therefore better serialized using writeInt(int)

抛出:

IOException

writeOptionalVInt

public void writeOptionalVInt(Integer integer)
                       throws IOException

抛出:

IOException

writeLong

public void writeLong(long i)
               throws IOException

Writes a long as eight bytes.

抛出:

IOException

writeOptionalLong

public void writeOptionalLong(Long l)
                       throws IOException

抛出:

IOException

writeVLong

public void writeVLong(long i)
                throws IOException

Writes a non-negative long in a variable-length format. Writes between one and ten bytes. Smaller values take fewer bytes. Negative numbers use ten bytes and trip assertions (if running in tests) so prefer writeLong(long) or writeZLong(long) for negative numbers.

抛出:

IOException

writeOptionalVLong

public void writeOptionalVLong(Long l)
                        throws IOException

抛出:

IOException

writeZLong

public void writeZLong(long i)
                throws IOException

Writes a long in a variable-length format. Writes between one and ten bytes. Values are remapped by sliding the sign bit into the lsb and then encoded as an unsigned number e.g., 0 -;> 0, -1 -;> 1, 1 -;> 2, ..., Long.MIN_VALUE -;> -1, Long.MAX_VALUE -;> -2 Numbers with small absolute value will have a small encoding If the numbers are known to be non-negative, use writeVLong(long)

抛出:

IOException

writeFloat

public void writeFloat(float v)
                throws IOException

抛出:

IOException

writeOptionalFloat

public void writeOptionalFloat(Float floatValue)
                        throws IOException

抛出:

IOException

writeDouble

public void writeDouble(double v)
                 throws IOException

抛出:

IOException

writeOptionalDouble

public void writeOptionalDouble(Double v)
                         throws IOException

抛出:

IOException

writeBoolean

public void writeBoolean(boolean b)
                  throws IOException

抛出:

IOException

writeOptionalBoolean

public void writeOptionalBoolean(Boolean b)
                          throws IOException

抛出:

IOException

write

public void write(int b)
           throws IOException

指定者:

write 在类中 OutputStream

抛出:

IOException

write

public void write(byte[] b,
                  int off,
                  int len)
           throws IOException

覆盖:

write 在类中 OutputStream

抛出:

IOException

writeGenericValue

public void writeGenericValue(Object value)
                       throws IOException

Notice: when serialization a map, the stream out map with the stream in map maybe have the different key-value orders, they will maybe have different stream order. If want to keep stream out map and stream in map have the same stream order when stream, can use writeMapWithConsistentOrder

抛出:

IOException