www.infkoffler.com - Site de cours d'informatique

Accueil

Java Standard Edition

Java EE 5

Visual Basic .Net 2005

Cours Javascript - DOM - DHTML

Nouveautés sur le site

Contacts

Accueil > Java Standard Edition > E/S(6):Les filtres d'octets: DataInputStream et DataOutputStream

____________________________________________________________________________________________________

Connexion

Les entrées-sorties(6) - Les classes héritant de FilterInputStream et FilerOutputStream: DataInputStream et DataOutputStream

Sommaire :

I) Généralités
II) La classe DataOutputStream(java.io)
II-1) Les méthodes d'écriture
III) La classe DataInputStream(java.io)
III-1) Les méthodes de lecture

I) Généralités

Poursuivons l'étude des filtres d'octets, avec les classes DataInputStream et DataOutputStream du package java.io.
Elles héritent respectivement de java.io.FilterInputStream et java.io.FilterOutputStream.
DataOutputStream permet d'écrire des types primitifs dans un flux d'octets sous-jacent(c'est donc un filtre), d'une façon indépendante de la machine, c'est à dire portable. N'importe quelle application java, tournant sur n'importe quelle machine, sera capable de lire ces données, avec DataInputStream. Et rappelons qu'un flux d'octets peut être autre chose qu'un fichier, par exemple une socket.

II) La classe DataOutputStream(java.io)

Elle permet d'écrire des données d'un type primitif java, dans le flux d'octets, et d'une façon portable. Ces données pourront être lues avec DataOutputStream.

II-1) Les méthodes d'écriture

Regardons les méthodes caractéristiques de la classe:

Aurapavant, attardons-nous une minute sur ceci:

/**
     * The number of bytes written to the data output stream so far. 
     * If this counter overflows, it will be wrapped to Integer.MAX_VALUE.
     */
    protected int written;

(...)
/**
 * Creates a new data output stream to write data to the specified 
 * underlying output stream. The counter <code>written</code> is 
 * set to zero.
 *
 * @param out the underlying output stream, to be saved for later 
 * use.
 * @see java.io.FilterOutputStream#out
 */
 public DataOutputStream(OutputStream out) {
	super(out);
 }
(...)
/**
 * Increases the written counter by the specified value
 * until it reaches Integer.MAX_VALUE.
 */
 private void incCount(int value) {
 int temp = written + value;
 if (temp < 0) {
 temp = Integer.MAX_VALUE;
 }
 written = temp;
 }
(...)
/**
 * Returns the current value of the counter <code>written</code>, 
 * the number of bytes written to this data output stream so far.
 * If the counter overflows, it will be wrapped to Integer.MAX_VALUE.
 *
 * @return the value of the <code>written</code> field.
 * @see java.io.DataOutputStream#written
 */
 public final int size() {
	return written;
 }

written est une propriété protected de type int, qui sera incrémentée du nombre correspondant au nombre d'octets écrits, à chaque appel à une méthode write. L'incrémentation se fait grâce à la méthode privée incCount. La méthode publique size() retourne la valeur de written, qui est d'ailleurs = Integer.MAX_VALUE en cas de dépassement de capacité. Remarquons que le seul constructeur de la classe, qui est DataOutputStream(OutputStream out), ne met pas written à zéro, car en java une propriété int est initialisée automatiquement à zéro à l'instanciation de l'objet. written vaut donc zéro à l'instantiation du DataOutputStream, et comptera tous les octets écrits depuis ce moment.

Ce point éclairci, nous pouvons regarder les méthodes de lecture les plus importantes:
Le codage choisi pour les booléens est un octet 1 pour true, et 0 pour false.
Pour écrire un seul octet, pas de problème de codage!
Un short java est sur 16 bits. Le codage "machine-indépendant" choisi pour les short est d'écrire l'octet de poids fort en premier, puis l'octet de poids faible.

/**
 * Writes a <code>char</code> to the underlying output stream as a 
 * 2-byte value, high byte first. If no exception is thrown, the 
 * counter <code>written</code> is incremented by <code>2</code>.
 *
 * @param v a <code>char</code> value to be written.
 * @exception IOException if an I/O error occurs.
 * @see java.io.FilterOutputStream#out
 */
 public final void writeChar(int v) throws IOException {
 out.write((v >>> 8) & 0xFF);
 out.write((v >>> 0) & 0xFF);
 incCount(2);
 }

/**
 * Writes an <code>int</code> to the underlying output stream as four
 * bytes, high byte first. If no exception is thrown, the counter 
 * <code>written</code> is incremented by <code>4</code>.
 *
 * @param v an <code>int</code> to be written.
 * @exception IOException if an I/O error occurs.
 * @see java.io.FilterOutputStream#out
 */
 public final void writeInt(int v) throws IOException {
 out.write((v >>> 24) & 0xFF);
 out.write((v >>> 16) & 0xFF);
 out.write((v >>> 8) & 0xFF);
 out.write((v >>> 0) & 0xFF);
 incCount(4);
 }

Un int java est sur 32 bits. Le codage "machine-indépendant" choisi pour les int est d'écrire les octets de poids le plus forts aux octets de poids le plus faible.
Un long java est sur 8 octets. Comme pour les int et les short, on écrit les 8 octets, en commençant par celui de poids le plus fort, jusqu'à celui de poids le plus faible.
Le float est d'abord converti en int selon le standard IEEE 754, puis les 4 octets de l'int sont écrits dans le flux avec la méthode writeInt.
Le double est d'abord converti en long, d'après le standard IEEE 754. Le long obtenu est ensuite écrit dans le flux, avec la méthode writeLong.

III) La classe DataInputStream(java.io)

Elle permet de lire des données d'un type primitif, à partir d'un flux d'octets sous-jacent. Les données doivent avoir été écrites par DataOutputStream, et sont donc machine-indépendantes.

III-1) Les méthodes de lecture

Regardons les méthodes caractéristiques:

/**
 * See the general contract of the <code>readBoolean</code>
 * method of <code>DataInput</code>.
 * 
 * Bytes for this operation are read from the contained
 * input stream.
 *
 * @return the <code>boolean</code> value read.
 * @exception EOFException if this input stream has reached the end.
 * @exception IOException the stream has been closed and the contained
 * 		 input stream does not support reading after close, or
 * 		 another I/O error occurs.
 * @see java.io.FilterInputStream#in
 */
 public final boolean readBoolean() throws IOException {
	int ch = in.read();
	if (ch < 0)
	 throw new EOFException();
	return (ch != 0);
 }

/**
 * See the general contract of the <code>readByte</code>
 * method of <code>DataInput</code>.
 * 
 * Bytes
 * for this operation are read from the contained
 * input stream.
 *
 * @return the next byte of this input stream as a signed 8-bit
 * <code>byte</code>.
 * @exception EOFException if this input stream has reached the end.
 * @exception IOException the stream has been closed and the contained
 * 		 input stream does not support reading after close, or
 * 		 another I/O error occurs.
 * @see java.io.FilterInputStream#in
 */
 public final byte readByte() throws IOException {
	int ch = in.read();
	if (ch < 0)
	 throw new EOFException();
	return (byte)(ch);
 }

/**
 * See the general contract of the <code>readUnsignedByte</code>
 * method of <code>DataInput</code>.
 * 
 * Bytes
 * for this operation are read from the contained
 * input stream.
 *
 * @return the next byte of this input stream, interpreted as an
 * unsigned 8-bit number.
 * @exception EOFException if this input stream has reached the end.
 * @exception IOException the stream has been closed and the contained
 * 		 input stream does not support reading after close, or
 * 		 another I/O error occurs.
 * @see java.io.FilterInputStream#in
 */
 public final int readUnsignedByte() throws IOException {
	int ch = in.read();
	if (ch < 0)
	 throw new EOFException();
	return ch;
 }

/**
 * See the general contract of the <code>readShort</code>
 * method of <code>DataInput</code>.
 * 
 * Bytes
 * for this operation are read from the contained
 * input stream.
 *
 * @return the next two bytes of this input stream, interpreted as a
 * signed 16-bit number.
 * @exception EOFException if this input stream reaches the end before
 * reading two bytes.
 * @exception IOException the stream has been closed and the contained
 * 		 input stream does not support reading after close, or
 * 		 another I/O error occurs.
 * @see java.io.FilterInputStream#in
 */
 public final short readShort() throws IOException {
 int ch1 = in.read();
 int ch2 = in.read();
 if ((ch1 | ch2) < 0)
 throw new EOFException();
 return (short)((ch1 << 8) + (ch2 << 0));
 }

La méthode retourne un short. On lit le premier octet dans ch1, puis le deuxième octet dans ch2. Puis on retourne un short dont l'octet de poids fort et le premier octet lu, et dont l'octet de poids faible est le second octet lu. C'est donc l'opération inverse du codage réalisé par writeShort de DataOutputStream.

/**
 * See the general contract of the <code>readUnsignedShort</code>
 * method of <code>DataInput</code>.
 * 
 * Bytes
 * for this operation are read from the contained
 * input stream.
 *
 * @return the next two bytes of this input stream, interpreted as an
 * unsigned 16-bit integer.
 * @exception EOFException if this input stream reaches the end before
 * reading two bytes.
 * @exception IOException the stream has been closed and the contained
 * 		 input stream does not support reading after close, or
 * 		 another I/O error occurs.
 * @see java.io.FilterInputStream#in
 */
 public final int readUnsignedShort() throws IOException {
 int ch1 = in.read();
 int ch2 = in.read();
 if ((ch1 | ch2) < 0)
 throw new EOFException();
 return (ch1 << 8) + (ch2 << 0);
 }

/**
 * See the general contract of the <code>readChar</code>
 * method of <code>DataInput</code>.
 * 
 * Bytes
 * for this operation are read from the contained
 * input stream.
 *
 * @return the next two bytes of this input stream, interpreted as a
 *		 <code>char</code>.
 * @exception EOFException if this input stream reaches the end before
 * reading two bytes.
 * @exception IOException the stream has been closed and the contained
 * 		 input stream does not support reading after close, or
 * 		 another I/O error occurs.
 * @see java.io.FilterInputStream#in
 */
 public final char readChar() throws IOException {
 int ch1 = in.read();
 int ch2 = in.read();
 if ((ch1 | ch2) < 0)
 throw new EOFException();
 return (char)((ch1 << 8) + (ch2 << 0));
 }

/**
 * See the general contract of the <code>readInt</code>
 * method of <code>DataInput</code>.
 * 
 * Bytes
 * for this operation are read from the contained
 * input stream.
 *
 * @return the next four bytes of this input stream, interpreted as an
 * <code>int</code>.
 * @exception EOFException if this input stream reaches the end before
 * reading four bytes.
 * @exception IOException the stream has been closed and the contained
 * 		 input stream does not support reading after close, or
 * 		 another I/O error occurs.
 * @see java.io.FilterInputStream#in
 */
 public final int readInt() throws IOException {
 int ch1 = in.read();
 int ch2 = in.read();
 int ch3 = in.read();
 int ch4 = in.read();
 if ((ch1 | ch2 | ch3 | ch4) < 0)
 throw new EOFException();
 return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
 }

Même principe que pour le readShort. On lit 4 octets. Puis on renvoie l'int composé avec les 4 octets lus, les premiers lus étant les octets de poids le plus fort, jusqu'au plus poids le plus faible.

private byte readBuffer[] = new byte[8];

/**
 * See the general contract of the <code>readLong</code>
 * method of <code>DataInput</code>.
 * 
 * Bytes
 * for this operation are read from the contained
 * input stream.
 *
 * @return the next eight bytes of this input stream, interpreted as a
 * <code>long</code>.
 * @exception EOFException if this input stream reaches the end before
 * reading eight bytes.
 * @exception IOException the stream has been closed and the contained
 * 		 input stream does not support reading after close, or
 * 		 another I/O error occurs.
 * @see java.io.FilterInputStream#in
 */
 public final long readLong() throws IOException {
 readFully(readBuffer, 0, 8);
 return (((long)readBuffer[0] << 56) +
 ((long)(readBuffer[1] & 255) << 48) +
		((long)(readBuffer[2] & 255) << 40) +
 ((long)(readBuffer[3] & 255) << 32) +
 ((long)(readBuffer[4] & 255) << 24) +
 ((readBuffer[5] & 255) << 16) +
 ((readBuffer[6] & 255) << 8) +
 ((readBuffer[7] & 255) << 0));
 }

/**
 * See the general contract of the <code>readFloat</code>
 * method of <code>DataInput</code>.
 * 
 * Bytes
 * for this operation are read from the contained
 * input stream.
 *
 * @return the next four bytes of this input stream, interpreted as a
 * <code>float</code>.
 * @exception EOFException if this input stream reaches the end before
 * reading four bytes.
 * @exception IOException the stream has been closed and the contained
 * 		 input stream does not support reading after close, or
 * 		 another I/O error occurs.
 * @see java.io.DataInputStream#readInt()
 * @see java.lang.Float#intBitsToFloat(int)
 */
 public final float readFloat() throws IOException {
	return Float.intBitsToFloat(readInt());
 }

On lit un int. Puis on retourne le float résultant de l'appel à Float.intBitsToFloat, qui est à la norme IEEE 754.
On lit un long. Ensuite on retourne le double résultant de l'appel à Double.longBitsToDouble, qui est à la norme IEEE 754.

RETOUR HAUT