@Beta @GwtIncompatible public final class LittleEndianDataOutputStream extends FilterOutputStream implements DataOutput
DataOutput
that uses little-endian byte ordering for writing char
, short
, int
, float
, double
, and long
values.
Note: This class intentionally violates the specification of its supertype DataOutput
, which explicitly requires big-endian byte order.
out
Constructor and Description |
---|
LittleEndianDataOutputStream(OutputStream out)
Creates a
LittleEndianDataOutputStream that wraps the given stream. |
Modifier and Type | Method and Description |
---|---|
void |
close()
Closes this output stream and releases any system resources
associated with the stream.
|
void |
write(byte[] b,
int off,
int len)
Writes
len bytes from the specified
byte array starting at offset off to
this output stream. |
void |
writeBoolean(boolean v)
Writes a
boolean value to this output stream. |
void |
writeByte(int v)
Writes to the output stream the eight low-
order bits of the argument
v . |
void |
writeBytes(String s)
Deprecated.
The semantics of
writeBytes(String s) are considered dangerous. Please use
writeUTF(String s) , writeChars(String s) or another write method instead. |
void |
writeChar(int v)
Writes a char as specified by
DataOutputStream.writeChar(int) , except using
little-endian byte order. |
void |
writeChars(String s)
Writes a
String as specified by DataOutputStream.writeChars(String) , except
each character is written using little-endian byte order. |
void |
writeDouble(double v)
Writes a
double as specified by DataOutputStream.writeDouble(double) , except
using little-endian byte order. |
void |
writeFloat(float v)
Writes a
float as specified by DataOutputStream.writeFloat(float) , except using
little-endian byte order. |
void |
writeInt(int v)
Writes an
int as specified by DataOutputStream.writeInt(int) , except using
little-endian byte order. |
void |
writeLong(long v)
Writes a
long as specified by DataOutputStream.writeLong(long) , except using
little-endian byte order. |
void |
writeShort(int v)
Writes a
short as specified by DataOutputStream.writeShort(int) , except using
little-endian byte order. |
void |
writeUTF(String str)
Writes two bytes of length information
to the output stream, followed
by the
modified UTF-8
representation
of every character in the string
s . |
flush, write, write
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
write, write
public LittleEndianDataOutputStream(OutputStream out)
LittleEndianDataOutputStream
that wraps the given stream.out
- the stream to delegate topublic void write(byte[] b, int off, int len) throws IOException
java.io.FilterOutputStream
len
bytes from the specified
byte
array starting at offset off
to
this output stream.
The write
method of FilterOutputStream
calls the write
method of one argument on each
byte
to output.
Note that this method does not call the write
method
of its underlying input stream with the same arguments. Subclasses
of FilterOutputStream
should provide a more efficient
implementation of this method.
write
in interface DataOutput
write
in class FilterOutputStream
b
- the data.off
- the start offset in the data.len
- the number of bytes to write.IOException
- if an I/O error occurs.FilterOutputStream.write(int)
public void writeBoolean(boolean v) throws IOException
java.io.DataOutput
boolean
value to this output stream.
If the argument v
is true
, the value (byte)1
is written; if v
is false
,
the value (byte)0
is written.
The byte written by this method may
be read by the readBoolean
method of interface DataInput
,
which will then return a boolean
equal to v
.writeBoolean
in interface DataOutput
v
- the boolean to be written.IOException
- if an I/O error occurs.public void writeByte(int v) throws IOException
java.io.DataOutput
v
.
The 24 high-order bits of v
are ignored. (This means that writeByte
does exactly the same thing as write
for an integer argument.) The byte written
by this method may be read by the readByte
method of interface DataInput
,
which will then return a byte
equal to (byte)v
.writeByte
in interface DataOutput
v
- the byte value to be written.IOException
- if an I/O error occurs.@Deprecated public void writeBytes(String s) throws IOException
writeBytes(String s)
are considered dangerous. Please use
writeUTF(String s)
, writeChars(String s)
or another write method instead.java.io.DataOutput
s
, taken in order, one byte
is written to the output stream. If
s
is null
, a NullPointerException
is thrown. If s.length
is zero, then no bytes are written. Otherwise,
the character s[0]
is written
first, then s[1]
, and so on;
the last character written is s[s.length-1]
.
For each character, one byte is written,
the low-order byte, in exactly the manner
of the writeByte
method . The
high-order eight bits of each character
in the string are ignored.
writeBytes
in interface DataOutput
s
- the string of bytes to be written.IOException
- if an I/O error occurs.public void writeChar(int v) throws IOException
DataOutputStream.writeChar(int)
, except using
little-endian byte order.writeChar
in interface DataOutput
v
- the char
value to be written.IOException
- if an I/O error occurspublic void writeChars(String s) throws IOException
String
as specified by DataOutputStream.writeChars(String)
, except
each character is written using little-endian byte order.writeChars
in interface DataOutput
s
- the string value to be written.IOException
- if an I/O error occurspublic void writeDouble(double v) throws IOException
double
as specified by DataOutputStream.writeDouble(double)
, except
using little-endian byte order.writeDouble
in interface DataOutput
v
- the double
value to be written.IOException
- if an I/O error occurspublic void writeFloat(float v) throws IOException
float
as specified by DataOutputStream.writeFloat(float)
, except using
little-endian byte order.writeFloat
in interface DataOutput
v
- the float
value to be written.IOException
- if an I/O error occurspublic void writeInt(int v) throws IOException
int
as specified by DataOutputStream.writeInt(int)
, except using
little-endian byte order.writeInt
in interface DataOutput
v
- the int
value to be written.IOException
- if an I/O error occurspublic void writeLong(long v) throws IOException
long
as specified by DataOutputStream.writeLong(long)
, except using
little-endian byte order.writeLong
in interface DataOutput
v
- the long
value to be written.IOException
- if an I/O error occurspublic void writeShort(int v) throws IOException
short
as specified by DataOutputStream.writeShort(int)
, except using
little-endian byte order.writeShort
in interface DataOutput
v
- the short
value to be written.IOException
- if an I/O error occurspublic void writeUTF(String str) throws IOException
java.io.DataOutput
s
.
If s
is null
,
a NullPointerException
is thrown.
Each character in the string s
is converted to a group of one, two, or
three bytes, depending on the value of the
character.
If a character c
is in the range \u0001
through
\u007f
, it is represented
by one byte:
(byte)c
If a character c
is \u0000
or is in the range \u0080
through \u07ff
, then it is
represented by two bytes, to be written
in the order shown:
(byte)(0xc0 | (0x1f & (c >> 6)))
(byte)(0x80 | (0x3f & c))
If a character
c
is in the range \u0800
through uffff
, then it is
represented by three bytes, to be written
in the order shown:
(byte)(0xe0 | (0x0f & (c >> 12)))
(byte)(0x80 | (0x3f & (c >> 6)))
(byte)(0x80 | (0x3f & c))
First,
the total number of bytes needed to represent
all the characters of s
is
calculated. If this number is larger than
65535
, then a UTFDataFormatException
is thrown. Otherwise, this length is written
to the output stream in exactly the manner
of the writeShort
method;
after this, the one-, two-, or three-byte
representation of each character in the
string s
is written.
The
bytes written by this method may be read
by the readUTF
method of interface
DataInput
, which will then
return a String
equal to s
.
writeUTF
in interface DataOutput
str
- the string value to be written.IOException
- if an I/O error occurs.public void close() throws IOException
java.io.FilterOutputStream
The close
method of FilterOutputStream
calls its flush
method, and then calls the
close
method of its underlying output stream.
close
in interface Closeable
close
in interface AutoCloseable
close
in class FilterOutputStream
IOException
- if an I/O error occurs.FilterOutputStream.flush()
,
FilterOutputStream.out
Copyright © 2010–2019. All rights reserved.