devstory

Le Tutoriel de Java OutputStream

  1. OutputStream
  2. write(int)
  3. write(byte[])
  4. write(byte[], int, int)
  5. close()
  6. flush()

1. OutputStream

OutputStream est une classe dans le package java.io, qui est une classe de base représentant un flux des bytes (stream of bytes) pour écrire les bytes sur une cible, un fichier par exemple.
public abstract class OutputStream implements Closeable, Flushable
En règle générale, vous ne pouvez pas utiliser la classe OutputStream directement, car il s'agit d'une classe abstraite. Mais dans un cas particulier, vous pouvez utiliser l'une de ses sous-classes.
OutputStream methods
public static OutputStream nullOutputStream()   
 
public abstract void write(int b) throws IOException
public void write(byte b[]) throws IOException  
public void write(byte b[], int off, int len) throws IOException  

public void flush() throws IOException  
public void close() throws IOException

2. write(int)

public abstract void write(int b) throws IOException
Écrit un byte dans OutputStream. Le paramètre b est le code de byte non signé, qui est un entier compris entre 0 et 255. Si la valeur de b est situé à l'extérieur du champ susmentionné, elle sera ignorée.
OutputStream_write_ex1.java
package org.o7planning.outputstream.ex;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class OutputStream_write_ex1 {

    // Windows path: C:/Somedirectory/out-file.txt
    private static final String file_path = "/Volumes/Data/test/out-file.txt";

    public static void main(String[] args) throws IOException {
        File file = new File(file_path);
        // Create parent folder:
        file.getParentFile().mkdirs();

        // FileOutputStream  
        OutputStream os = new FileOutputStream(file);
       
        // 'J'
        os.write((int)'J'); // 74
        
        // 'P'
        os.write('P'); // 80 (Automatically converted to int)
        
        // '日' = 3 bytes UTF-8: [230, 151, 165]
        os.write(230);  
        os.write(151);  
        os.write(165);  
        
        // '本' = 3 bytes UTF-8: [230, 156, 172]
        os.write(230);    
        os.write(156);     
        os.write(172);     
        
        // '-'
        os.write('-');  // 45 (Automatically converted to int)
        
        // '八' = 3 bytes UTF-8: [229, 133, 171]
        os.write(229);    
        os.write(133);    
        os.write(171);    
        
        // '洲' = 3 bytes UTF-8: [230, 180, 178]
        os.write(230);  
        os.write(180);  
        os.write(178);   
        
        // Close
        os.close();
    }
}
Output:
out-file.txt
JP日本-八洲
Les fichiers UTF-8 utilisent 1, 2, 3 ou 4 bytes pour stocker un caractère. L'image ci-dessous démontrent les bytes sur le fichier nouvellement créé.

3. write(byte[])

public void write(byte[] b) throws IOException
Ecrire un tableau de byte dans OutputStream.
OutputStream_write_ex2.java
package org.o7planning.outputstream.ex;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class OutputStream_write_ex2 {

    // Windows path: C:/Somedirectory/out-file.txt
    private static final String file_path = "/Volumes/Data/test/out-file.txt";

    public static void main(String[] args) throws IOException {
        File file = new File(file_path);
        // Create parent folder:
        file.getParentFile().mkdirs();

        // FileOutputStream
        OutputStream writer = new FileOutputStream(file);  
        
        byte[] bytes = new byte[] { 'J', 'P', //
                         (byte)230, (byte)151, (byte)165, // '日' = 3 bytes UTF-8: [230, 151, 165]
                         (byte)230, (byte)156, (byte)172, // '本' = 3 bytes UTF-8: [230, 156, 172]
                         '-', //
                         (byte)229, (byte)133, (byte)171, // '八' = 3 bytes UTF-8: [229, 133, 171]
                         (byte)230, (byte)180, (byte)178, // '洲' = 3 bytes UTF-8: [230, 180, 178]
                         };  
        
        writer.write(bytes);  
        // Close
        writer.close();
    }
}
Output:
out-file.txt
JP日本-八洲

4. write(byte[], int, int)

public void write(byte b[], int offset, int len) throws IOException
Ecrire une partie d'un tableau de byte dans OutputStream. Ecrire les bytes de l'index offset vers l'index offset+len
OutputStream_write_ex3.java
package org.o7planning.outputstream.ex;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class OutputStream_write_ex3 {

    public static void main(String[] args) throws IOException {
        
        // ByteArrayOutputStream is a subclass of OutputStream.
        OutputStream outputStream = new ByteArrayOutputStream();  
        
        byte[] bytes = new byte[] {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
        
        outputStream.write(bytes, 2, 5); // '2', ...'6'
        
        String s = outputStream.toString();
        System.out.println(s);
        
        outputStream.close();
    }
}
Output:
23456

5. close()

public void close() throws IOException
La méthode close() est utilisée pour fermer ce flux, la méthode flush() sera convoquée en premier. Lorsque le flux est fermé, les autres appels write() ou flush() vont entraîner la levée d'une IOException. La fermeture d'un flux précédemment fermé n'a aucun effet.
public interface Closeable extends AutoCloseable
La classe Writer implémente une interface Closeable. Si vous écrivez le code selon les règles d'AutoCloseable, le système fermera automatiquement le flux sans avoir à appeler directement la méthode close().
OutputStream_close_ex1.java
package org.o7planning.outputstream.ex;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class OutputStream_close_ex1 {

    // Windows path: C:/Somedirectory/out-file.txt
    private static final String file_path = "/Volumes/Data/test/out-file.txt";

    public static void main(String[] args) throws IOException {
        File file = new File(file_path);
        // Create parent folder:
        file.getParentFile().mkdirs();

        try (OutputStream writer = new FileOutputStream(file)) {
            writer.write((int) '1');
            writer.write('2');
            writer.write((int) '3');
        }
    }
}
  • Le Tutoriel de Java Closeable

6. flush()

public void flush() throws IOException
Les données que vous écrivez dans OutputStream sont parfois temporairement stockées sur la mémoire tampon. flush() est utilisée pour vider les données dans la cible.
Vous pouvez lire l'article ci-dessous sur BufferedOutputStream pour en savoir plus sur la méthode flush().
Si la destination prévue de ce OutputStream est une abstraction fournie par le système d'exploitation sous-jacent, un fichier par exemple, le vidage du flux garantit uniquement que les bytes précédemment écrits dans le flux sont transférés au système d'exploitation pour l'écriture; cela ne garantit pas qu'ils sont réellement écrits dans un périphérique physique tel qu'un lecteur de disque.

Tutoriels Java IO

Show More

Tutoriels Java IO

Show More

Articles les plus récents

Show More