DataOutputView (milky-io 1.0.6

All Superinterfaces:

AutoCloseable, Closeable, DataOutput, Flushable, Serializable

All Known Implementing Classes:

OutputStreamDataOutputView
```
public interface DataOutputView
extends DataOutput, Closeable, Flushable, Serializable
```

Field Summary

Fields
Modifier and Type Field and Description

static byte ONE

static byte TWO

static byte ZERO

Fields
Modifier and Type	Field and Description
`static byte`	`ONE`
`static byte`	`TWO`
`static byte`	`ZERO`

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`void`	`close()`
`void`	`flush()`
`byte[]`	`getBuffer()`
`default void`	`write(byte[] b)`
`default void`	`write(byte[] b, int off, int len)`
`default void`	`writeBoolean(boolean v)` Writes a 1 byte boolean.
`void`	`writeBytes(byte[] b)`
`void`	`writeBytes(byte[] b, int off, int len)`
`default void`	`writeChar(int v)` Writes a 2 byte char.
`default void`	`writeDouble(double v)` Writes a 8 byte double.
`default void`	`writeFloat(float v)` Writes a 4 byte float.
`default void`	`writeInt(int v)` Writes a 4 byte int.
`default void`	`writeLong(long i)` Writes an 8 byte long.
`default void`	`writeOptionalBoolean(Boolean b)` Writes an optional `Boolean`.
`default void`	`writeOptionalDouble(Double v)` Writes an optional `Double`.
`default void`	`writeOptionalFloat(Float v)` Writes an optional `Float`.
`default void`	`writeOptionalInt(Integer integer)` Writes an optional `Integer`.
`default void`	`writeOptionalLong(Long l)` Writes an optional `Long`.
`default void`	`writeOptionalVInt(Integer integer)`
`default void`	`writeOptionalVLong(Long l)`
`default void`	`writeOptionalZLong(Long l)`
`default void`	`writeShort(int v)` Writes a 2 byte short.
`default void`	`writeVDouble(double value, double precision, boolean optimizePositive)` Writes a 1-9 byte double with reduced precision.
`default void`	`writeVFloat(float value, float precision)` Writes a 1-5 byte float with reduced precision.
`default void`	`writeVInt(int v)` Writes an int in a variable-length format.
`default void`	`writeVLong(long i)` Writes a long in a variable-length format.
`default void`	`writeZInt(int v)` Writes a `zig-zag`-encoded `variable-length` integer.
`default void`	`writeZLong(long i)` Writes a long in a variable-length format.

Methods inherited from interface java.io.DataOutput
write, writeByte, writeBytes, writeChars, writeUTF

- Field Detail
  - ZERO
```
static final byte ZERO
```
    See Also:
    
    Constant Field Values
  - ONE
```
static final byte ONE
```
    See Also:
    
    Constant Field Values
  - TWO
```
static final byte TWO
```
    See Also:
    
    Constant Field Values
- Method Detail
  - writeBytes
```
void writeBytes(byte[] b)
         throws IOException
```
    Throws:
    
    IOException
  - writeBytes
```
void writeBytes(byte[] b,
                int off,
                int len)
         throws IOException
```
    Throws:
    
    IOException
  - write
```
default void write(byte[] b)
            throws IOException
```
    Specified by:
    
    write in interface DataOutput
    
    Throws:
    
    IOException
  - write
```
default void write(byte[] b,
                   int off,
                   int len)
            throws IOException
```
    Specified by:
    
    write in interface DataOutput
    
    Throws:
    
    IOException
  - writeBoolean
```
default void writeBoolean(boolean v)
                   throws IOException
```
    Writes a 1 byte boolean.
    
    Specified by:
    
    writeBoolean in interface DataOutput
    
    Throws:
    
    IOException
  - writeOptionalBoolean
```
default void writeOptionalBoolean(Boolean b)
                           throws IOException
```
    Writes an optional Boolean.
    
    Throws:
    
    IOException
  - writeShort
```
default void writeShort(int v)
                 throws IOException
```
    Writes a 2 byte short.
    
    Specified by:
    
    writeShort in interface DataOutput
    
    Throws:
    
    IOException
  - writeChar
```
default void writeChar(int v)
                throws IOException
```
    Writes a 2 byte char.
    
    Specified by:
    
    writeChar in interface DataOutput
    
    Throws:
    
    IOException
  - writeInt
```
default void writeInt(int v)
               throws IOException
```
    Writes a 4 byte int.
    
    Specified by:
    
    writeInt in interface DataOutput
    
    Throws:
    
    IOException
  - writeVInt
```
default void writeVInt(int v)
                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) or writeZInt(int)
    
    Throws:
    
    IOException
  - writeZInt
```
default void writeZInt(int v)
                throws IOException
```
    Writes a zig-zag-encoded variable-length integer. This is typically useful to write small signed ints and is equivalent to calling writeVInt(BitUtil.zigZagEncode(i)).
    
    Throws:
    
    IOException
    
    See Also:
    
    DataInputView.readZInt()
  - writeOptionalInt
```
default void writeOptionalInt(Integer integer)
                       throws IOException
```
    Writes an optional Integer.
    
    Throws:
    
    IOException
  - writeOptionalVInt
```
default void writeOptionalVInt(Integer integer)
                        throws IOException
```
    Throws:
    
    IOException
  - writeLong
```
default void writeLong(long i)
                throws IOException
```
    Writes an 8 byte long.
    
    Specified by:
    
    writeLong in interface DataOutput
    
    Throws:
    
    IOException
  - writeVLong
```
default void writeVLong(long i)
                 throws IOException
```
    Writes a long in a variable-length format. Writes between one and ten bytes. Smaller values take fewer bytes. Negative numbers use ten bytes so prefer writeLong(long) or writeZLong(long) for negative numbers.
    
    Throws:
    
    IOException
  - writeZLong
```
default 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)
    
    Throws:
    
    IOException
  - writeOptionalLong
```
default void writeOptionalLong(Long l)
                        throws IOException
```
    Writes an optional Long.
    
    Throws:
    
    IOException
  - writeOptionalVLong
```
default void writeOptionalVLong(Long l)
                         throws IOException
```
    Throws:
    
    IOException
  - writeOptionalZLong
```
default void writeOptionalZLong(Long l)
                         throws IOException
```
    Throws:
    
    IOException
  - writeFloat
```
default void writeFloat(float v)
                 throws IOException
```
    Writes a 4 byte float.
    
    Specified by:
    
    writeFloat in interface DataOutput
    
    Throws:
    
    IOException
  - writeVFloat
```
default void writeVFloat(float value,
                         float precision)
                  throws IOException
```
    Writes a 1-5 byte float with reduced precision. Small positive numbers will be more efficient (1 byte) and small negative numbers will be inefficient (5 bytes).
    
    Throws:
    
    IOException
  - writeVDouble
```
default void writeVDouble(double value,
                          double precision,
                          boolean optimizePositive)
                   throws IOException
```
    Writes a 1-9 byte double with reduced precision. Small positive numbers will be more efficient (1 byte) and small negative numbers will be inefficient (9 bytes).
    
    Throws:
    
    IOException
  - writeOptionalFloat
```
default void writeOptionalFloat(Float v)
                         throws IOException
```
    Writes an optional Float.
    
    Throws:
    
    IOException
  - writeDouble
```
default void writeDouble(double v)
                  throws IOException
```
    Writes a 8 byte double.
    
    Specified by:
    
    writeDouble in interface DataOutput
    
    Throws:
    
    IOException
  - writeOptionalDouble
```
default void writeOptionalDouble(Double v)
                          throws IOException
```
    Writes an optional Double.
    
    Throws:
    
    IOException
  - getBuffer
```
byte[] getBuffer()
```
  - flush
```
void flush()
    throws IOException
```
    Specified by:
    
    flush in interface Flushable
    
    Throws:
    
    IOException
  - close
```
void close()
    throws IOException
```
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface Closeable
    
    Throws:
    
    IOException

Interface DataOutputView

Field Summary

Method Summary

Methods inherited from interface java.io.DataOutput

Field Detail

ZERO

ONE

TWO

Method Detail

writeBytes

writeBytes

write

write

writeBoolean

writeOptionalBoolean

writeShort

writeChar

writeInt

writeVInt

writeZInt

writeOptionalInt

writeOptionalVInt

writeLong

writeVLong

writeZLong

writeOptionalLong

writeOptionalVLong

writeOptionalZLong

writeFloat

writeVFloat

writeVDouble

writeOptionalFloat

writeDouble

writeOptionalDouble

getBuffer

flush

close