Java Language
Fichier I / O

Introduction

Lecture de tous les octets dans un octet []

Java 7 a introduit la classe Files très utile

import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.Path;

Path path = Paths.get("path/to/file");

try {
    byte[] data = Files.readAllBytes(path);
} catch(IOException e) {
    e.printStackTrace();
}

Lecture d'une image à partir d'un fichier

import java.awt.Image;
import javax.imageio.ImageIO;

...

try {
    Image img = ImageIO.read(new File("~/Desktop/cat.png"));
} catch (IOException e) {
    e.printStackTrace();
}

Ecrire un octet [] dans un fichier

byte[] bytes = { 0x48, 0x65, 0x6c, 0x6c, 0x6f };

try(FileOutputStream stream = new FileOutputStream("Hello world.txt")) {
    stream.write(bytes);
} catch (IOException ioe) {
    // Handle I/O Exception
    ioe.printStackTrace();
}

byte[] bytes = { 0x48, 0x65, 0x6c, 0x6c, 0x6f };

FileOutputStream stream = null;
try {
    stream = new FileOutputStream("Hello world.txt");
    stream.write(bytes);
} catch (IOException ioe) {
    // Handle I/O Exception
    ioe.printStackTrace();
} finally {
    if (stream != null) {
        try {
            stream.close();
        } catch (IOException ignored) {}
    }
}

La plupart des API de fichiers java.io acceptent à la fois les String et les File comme arguments, de sorte que vous pouvez aussi bien utiliser

File file = new File("Hello world.txt");
FileOutputStream stream = new FileOutputStream(file);

API Stream vs Writer / Reader

Cours d' eau fournissent l'accès le plus direct au contenu binaire, de sorte que toute InputStream / OutputStream implémentations fonctionnent toujours sur int s et byte s.

// Read a single byte from the stream
int b = inputStream.read();
if (b >= 0) { // A negative value represents the end of the stream, normal values are in the range 0 - 255
    // Write the byte to another stream
    outputStream.write(b);
}

// Read a chunk
byte[] data = new byte[1024];
int nBytesRead = inputStream.read(data);
if (nBytesRead >= 0) { // A negative value represents end of stream
    // Write the chunk to another stream
    outputStream.write(data, 0, nBytesRead);
}

Il y a quelques exceptions, notamment le PrintStream qui ajoute la "possibilité d'imprimer facilement des représentations de différentes valeurs de données". Cela permet d'utiliser System.out fois en tant que InputStream binaire et en tant que sortie textuelle en utilisant des méthodes telles que System.out.println() .

En outre, certaines implémentations de flux fonctionnent comme une interface avec des contenus de niveau supérieur tels que les objets Java (voir Sérialisation) ou les types natifs, par exemple DataOutputStream / DataInputStream .

Avec les classes Writer et Reader , Java fournit également une API pour les flux de caractères explicites. Bien que la plupart des applications basent ces implémentations sur des flux, l'API de flux de caractères n'expose aucune méthode pour le contenu binaire.

// This example uses the platform's default charset, see below
// for a better implementation.

Writer writer = new OutputStreamWriter(System.out);
writer.write("Hello world!");

Reader reader = new InputStreamReader(System.in);
char singleCharacter = reader.read();

Chaque fois qu'il est nécessaire d'encoder des caractères en données binaires (par exemple, lors de l'utilisation des classes InputStreamWriter / OutputStreamWriter ), vous devez spécifier un jeu de caractères si vous ne souhaitez pas dépendre du jeu de caractères par défaut de la plate-forme. En cas de doute, utilisez un encodage compatible Unicode, par exemple UTF-8, pris en charge sur toutes les plates-formes Java. Par conséquent, vous devriez probablement rester à l'écart des classes telles que FileWriter et FileReader car celles-ci utilisent toujours le charset de plate-forme par défaut. Une meilleure façon d’accéder aux fichiers en utilisant des flux de caractères est la suivante:

Charset myCharset = StandardCharsets.UTF_8;

Writer writer = new OutputStreamWriter( new FileOutputStream("test.txt"), myCharset );
writer.write('Ä');
writer.flush();
writer.close();

Reader reader = new InputStreamReader( new FileInputStream("test.txt"), myCharset );
char someUnicodeCharacter = reader.read();
reader.close();

L'un des Reader les plus couramment utilisés est BufferedReader qui fournit une méthode permettant de lire des lignes entières de texte à partir d'un autre lecteur. C'est probablement le moyen le plus simple de lire un flux de caractères ligne par ligne:

// Read from baseReader, one line at a time
BufferedReader reader = new BufferedReader( baseReader );
String line;
while((line = reader.readLine()) != null) {
  // Remember: System.out is a stream, not a writer!
  System.out.println(line);
}

Lire un fichier entier à la fois

File f = new File(path);
String content = new Scanner(f).useDelimiter("\\Z").next();

\ Z est le symbole EOF (End of File). Lorsqu'il est défini comme délimiteur, le scanner lit le remplissage jusqu'à ce que l'indicateur EOF soit atteint.

Lecture d'un fichier avec un scanner

Lecture d'un fichier ligne par ligne

public class Main {

    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner(new File("example.txt"));
            while(scanner.hasNextLine())
            {
                String line = scanner.nextLine();
                //do stuff
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

mot par mot

public class Main {

    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner(new File("example.txt"));
            while(scanner.hasNext())
            {
                String line = scanner.next();
                //do stuff
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

et vous pouvez également modifier le séparateur à l'aide de la méthode scanner.useDelimeter ()

Itérer sur un répertoire et filtrer par extension de fichier

    public void iterateAndFilter() throws IOException {
        Path dir = Paths.get("C:/foo/bar");
        PathMatcher imageFileMatcher =
            FileSystems.getDefault().getPathMatcher(
                "regex:.*(?i:jpg|jpeg|png|gif|bmp|jpe|jfif)");

        try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir,
                entry -> imageFileMatcher.matches(entry.getFileName()))) {

            for (Path path : stream) {
                System.out.println(path.getFileName());
            }
        }
    }

Migration de java.io.File vers Java 7 NIO (java.nio.file.Path)

Ces exemples supposent que vous connaissez déjà le NIO de Java 7 en général et que vous avez l'habitude d'écrire du code en utilisant java.io.File . Utilisez ces exemples pour trouver rapidement une documentation plus centrée sur NIO pour la migration.

Il y a beaucoup plus à NIO de Java 7, comme les fichiers mappés en mémoire ou l' ouverture d'un fichier ZIP ou JAR à l'aide de FileSystem . Ces exemples ne couvriront qu'un nombre limité de cas d'utilisation de base.

En règle générale, si vous avez l'habitude d'effectuer une opération de lecture / écriture du système de fichiers à l'aide d'une méthode d'instance java.io.File , vous la trouverez en tant que méthode statique dans java.nio.file.Files .

Pointez sur un chemin

// -> IO
File file = new File("io.txt");

// -> NIO
Path path = Paths.get("nio.txt");

Chemins relatifs à un autre chemin

// Forward slashes can be used in place of backslashes even on a Windows operating system
// -> IO
File folder = new File("C:/");
File fileInFolder = new File(folder, "io.txt");

// -> NIO
Path directory = Paths.get("C:/");
Path pathInDirectory = directory.resolve("nio.txt");

Conversion de fichier depuis / vers un chemin pour une utilisation avec des bibliothèques

// -> IO to NIO
Path pathFromFile = new File("io.txt").toPath();

// -> NIO to IO
File fileFromPath = Paths.get("nio.txt").toFile();

Vérifiez si le fichier existe et supprimez-le s'il le fait

// -> IO
if (file.exists()) {
    boolean deleted = file.delete();
    if (!deleted) {
        throw new IOException("Unable to delete file");
    }
}

// -> NIO
Files.deleteIfExists(path);

Ecrire dans un fichier via un OutputStream

Il existe plusieurs manières d'écrire et de lire un fichier à l'aide de NIO pour différentes contraintes de performances et de mémoire, de lisibilité et de cas d'utilisation, tels que FileChannel , Files.write(Path path, byte\[\] bytes, OpenOption... options) . .. Dans cet exemple, seul OutputStream est couvert, mais vous êtes fortement encouragé à en apprendre davantage sur les fichiers mappés en mémoire et les différentes méthodes statiques disponibles dans java.nio.file.Files .

List<String> lines = Arrays.asList(
        String.valueOf(Calendar.getInstance().getTimeInMillis()),
        "line one",
        "line two");

// -> IO
if (file.exists()) {
    // Note: Not atomic
    throw new IOException("File already exists");
}
try (FileOutputStream outputStream = new FileOutputStream(file)) {
    for (String line : lines) {
        outputStream.write((line + System.lineSeparator()).getBytes(StandardCharsets.UTF_8));
    }
}

// -> NIO
try (OutputStream outputStream = Files.newOutputStream(path, StandardOpenOption.CREATE_NEW)) {
    for (String line : lines) {
        outputStream.write((line + System.lineSeparator()).getBytes(StandardCharsets.UTF_8));
    }
}

Itération sur chaque fichier dans un dossier

// -> IO
for (File selectedFile : folder.listFiles()) {
    // Note: Depending on the number of files in the directory folder.listFiles() may take a long time to return
    System.out.println((selectedFile.isDirectory() ? "d" : "f") + " " + selectedFile.getAbsolutePath());
}

// -> NIO
Files.walkFileTree(directory, EnumSet.noneOf(FileVisitOption.class), 1, new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult preVisitDirectory(Path selectedPath, BasicFileAttributes attrs) throws IOException {
        System.out.println("d " + selectedPath.toAbsolutePath());
        return FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult visitFile(Path selectedPath, BasicFileAttributes attrs) throws IOException {
        System.out.println("f " + selectedPath.toAbsolutePath());
        return FileVisitResult.CONTINUE;
    }
});

Itération du dossier récursif

// -> IO
recurseFolder(folder);

// -> NIO
// Note: Symbolic links are NOT followed unless explicitly passed as an argument to Files.walkFileTree
Files.walkFileTree(directory, new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
        System.out.println("d " + selectedPath.toAbsolutePath());
        return FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult visitFile(Path selectedPath, BasicFileAttributes attrs) throws IOException {
        System.out.println("f " + selectedPath.toAbsolutePath());
        return FileVisitResult.CONTINUE;
    }
});


private static void recurseFolder(File folder) {
    for (File selectedFile : folder.listFiles()) {
        System.out.println((selectedFile.isDirectory() ? "d" : "f") + " " + selectedFile.getAbsolutePath());
        if (selectedFile.isDirectory()) {
            // Note: Symbolic links are followed
            recurseFolder(selectedFile);
        }
    }
}

Lecture / écriture de fichier à l'aide de FileInputStream / FileOutputStream

Ecrivez dans un fichier test.txt:

String filepath ="C:\\test.txt";
FileOutputStream fos = null;
try {
      fos = new FileOutputStream(filepath);
      byte[] buffer = "This will be written in test.txt".getBytes();
      fos.write(buffer, 0, buffer.length);
      fos.close();
} catch (FileNotFoundException e) {
      e.printStackTrace();
} catch (IOException e) {
      e.printStackTrace();
} finally{
      if(fos != null)
        fos.close();
}

Lire depuis le fichier test.txt:

String filepath ="C:\\test.txt";        
FileInputStream fis = null;
try {
   fis = new FileInputStream(filepath);
   int length = (int) new File(filepath).length();
   byte[] buffer = new byte[length];
   fis.read(buffer, 0, length);
} catch (FileNotFoundException e) {
     e.printStackTrace();
} catch (IOException e) {
     e.printStackTrace();
} finally{
   if(fis != null)
     fis.close();
}

Notez que depuis Java 1.7, l’instruction try-with-resources a été introduite, ce qui a simplifié la mise en œuvre des opérations de lecture / écriture:

Ecrivez dans un fichier test.txt:

String filepath ="C:\\test.txt";
try (FileOutputStream fos = new FileOutputStream(filepath)){
    byte[] buffer = "This will be written in test.txt".getBytes();
    fos.write(buffer, 0, buffer.length);
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

Lire depuis le fichier test.txt:

String filepath ="C:\\test.txt";
try (FileInputStream fis = new FileInputStream(filepath)){
    int length = (int) new File(filepath).length();
    byte[] buffer = new byte[length];
    fis.read(buffer, 0, length);
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

Lecture d'un fichier binaire

Vous pouvez lire un fichier binaire en utilisant ce morceau de code dans toutes les versions récentes de Java:

File file = new File("path_to_the_file");
byte[] data = new byte[(int) file.length()];
DataInputStream stream = new DataInputStream(new FileInputStream(file));
stream.readFully(data);
stream.close();

Si vous utilisez Java 7 ou une version ultérieure, il existe un moyen plus simple d'utiliser l' nio API :

Path path = Paths.get("path_to_the_file");
byte [] data = Files.readAllBytes(path);

Verrouillage

Un fichier peut être verrouillé à l'aide de l'API FileChannel pouvant être FileChannel partir de streams et de readers d'entrée / sortie

Exemple avec des streams

// Ouvrir un flux de fichiers FileInputStream ios = new FileInputStream (filename);

    // get underlying channel
    FileChannel channel = ios.getChannel();

    /*
     * try to lock the file. true means whether the lock is shared or not i.e. multiple processes can acquire a
     * shared lock (for reading only) Using false with readable channel only will generate an exception. You should
     * use a writable channel (taken from FileOutputStream) when using false. tryLock will always return immediately
     */
    FileLock lock = channel.tryLock(0, Long.MAX_VALUE, true);

    if (lock == null) {
        System.out.println("Unable to acquire lock");
    } else {
        System.out.println("Lock acquired successfully");
    }

    // you can also use blocking call which will block until a lock is acquired.
    channel.lock();

    // Once you have completed desired operations of file. release the lock
    if (lock != null) {
        lock.release();
    }

    // close the file stream afterwards
    // Example with reader
    RandomAccessFile randomAccessFile = new RandomAccessFile(filename,  "rw");
    FileChannel channel = randomAccessFile.getChannel();
    //repeat the same steps as above but now you can use shared as true or false as the channel is in read write mode

Copier un fichier en utilisant InputStream et OutputStream

Nous pouvons directement copier les données d'une source vers un récepteur de données en utilisant une boucle. Dans cet exemple, nous lisons des données depuis un InputStream et en même temps, nous écrivons dans un OutputStream. Une fois que nous avons fini de lire et d'écrire, nous devons fermer la ressource.

public void copy(InputStream source, OutputStream destination) throws IOException {
    try {
        int c;
        while ((c = source.read()) != -1) {
            destination.write(c);
        }
    } finally {
        if (source != null) {
            source.close();
        }
        if (destination != null) {
            destination.close();
        }
    }
}

Lecture d'un fichier à l'aide du canal et du tampon

Channel utilise un Buffer pour lire / écrire des données. Un tampon est un conteneur de taille fixe où nous pouvons écrire un bloc de données à la fois. Channel est plus rapide que les E / S basées sur le flux.

Pour lire les données d'un fichier en utilisant Channel nous devons suivre les étapes suivantes:

1. Nous avons besoin d'une instance de FileInputStream . FileInputStream a une méthode nommée getChannel() qui renvoie un canal.
2. Appelez la méthode getChannel() de FileInputStream et acquérez Channel.
3. Créez un ByteBuffer. ByteBuffer est un conteneur de taille fixe d'octets.
4. Channel a une méthode de lecture et nous devons fournir un ByteBuffer comme argument à cette méthode de lecture. ByteBuffer a deux modes - humeur en lecture seule et humeur en écriture seule. Nous pouvons changer le mode en utilisant l'appel de la méthode flip() . La mémoire tampon a une position, une limite et une capacité. Une fois qu'un tampon est créé avec une taille fixe, sa limite et sa capacité sont identiques à la taille et la position commence à zéro. Alors qu'un tampon est écrit avec des données, sa position augmente progressivement. Changer de mode signifie changer la position. Pour lire des données depuis le début d'un tampon, il faut mettre la position à zéro. La méthode flip () modifie la position
5. Lorsque nous appelons la méthode de lecture du Channel , elle remplit le tampon en utilisant des données.
6. Si nous avons besoin de lire les données du ByteBuffer , nous devons retourner le tampon pour changer son mode en écriture seule en mode lecture seule, puis continuer à lire les données du tampon.
7. Lorsqu'il n'y a plus de données à lire, la méthode read() du canal renvoie 0 ou -1.

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class FileChannelRead {
 
public static void main(String[] args) {
  
   File inputFile = new File("hello.txt");
  
   if (!inputFile.exists()) {
    System.out.println("The input file doesn't exit.");
    return;
   }

  try {
   FileInputStream fis = new FileInputStream(inputFile);
   FileChannel fileChannel = fis.getChannel();
   ByteBuffer buffer = ByteBuffer.allocate(1024);

   while (fileChannel.read(buffer) > 0) {
    buffer.flip();
    while (buffer.hasRemaining()) {
     byte b = buffer.get();
     System.out.print((char) b);
    }
    buffer.clear();
   }

   fileChannel.close();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
}

Copier un fichier avec Channel

Nous pouvons utiliser Channel pour copier le contenu du fichier plus rapidement. Pour ce faire, nous pouvons utiliser la méthode transferTo() de FileChannel .

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;

public class FileCopier {
    
    public static void main(String[] args) {
        File sourceFile = new File("hello.txt");
        File sinkFile = new File("hello2.txt");
        copy(sourceFile, sinkFile);
    }

    public static void copy(File sourceFile, File destFile) {
        if (!sourceFile.exists() || !destFile.exists()) {
            System.out.println("Source or destination file doesn't exist");
            return;
        }


        try (FileChannel srcChannel = new FileInputStream(sourceFile).getChannel();
             FileChannel sinkChanel = new FileOutputStream(destFile).getChannel()) {

            srcChannel.transferTo(0, srcChannel.size(), sinkChanel);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Lecture d'un fichier à l'aide de BufferedInputStream

Lire un fichier en utilisant un BufferedInputStream généralement plus rapide que FileInputStream car il maintient un tampon interne pour stocker les octets lus à partir du flux d'entrée sous-jacent.

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;


public class FileReadingDemo {

    public static void main(String[] args) {
        String source = "hello.txt";
        
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(source))) {
            byte data;
            while ((data = (byte) bis.read()) != -1) {
                System.out.println((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

Ecrire un fichier en utilisant Channel and Buffer

Pour écrire des données dans un fichier à l'aide de Channel vous devez suivre les étapes suivantes:

1. Tout d'abord, nous devons obtenir un objet de FileOutputStream
2. Acquérir FileChannel appelant la méthode getChannel() depuis FileOutputStream
3. Créez un ByteBuffer puis remplissez-le avec des données
4. Ensuite, nous devons appeler la méthode flip() du ByteBuffer et la passer en argument de la méthode write() du FileChannel
5. Une fois que nous avons fini d'écrire, nous devons fermer la ressource

import java.io.*;
import java.nio.*;
public class FileChannelWrite {

 public static void main(String[] args) {

  File outputFile = new File("hello.txt");
  String text = "I love Bangladesh.";

  try {
   FileOutputStream fos = new FileOutputStream(outputFile);
   FileChannel fileChannel = fos.getChannel();
   byte[] bytes = text.getBytes();
   ByteBuffer buffer = ByteBuffer.wrap(bytes);
   fileChannel.write(buffer);
   fileChannel.close();
  } catch (java.io.IOException e) {
   e.printStackTrace();
  }
 }
}  

Ecrire un fichier en utilisant PrintStream

Nous pouvons utiliser la classe PrintStream pour écrire un fichier. Il existe plusieurs méthodes qui vous permettent d’imprimer des valeurs de type de données. println() méthode println() ajoute une nouvelle ligne. Une fois l'impression terminée, nous devons vider le PrintStream .

import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.time.LocalDate;

public class FileWritingDemo {
    public static void main(String[] args) {
        String destination = "file1.txt";

        try(PrintStream ps = new PrintStream(destination)){
            ps.println("Stackoverflow documentation seems fun.");
            ps.println();
            ps.println("I love Java!");
            ps.printf("Today is: %1$tm/%1$td/%1$tY", LocalDate.now());

            ps.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

    }
}

Itérer sur un sous répertoire répertoires d'impression

  public void iterate(final String dirPath) throws IOException {
    final DirectoryStream<Path> paths = Files.newDirectoryStream(Paths.get(dirPath));
    for (final Path path : paths) {
      if (Files.isDirectory(path)) {
        System.out.println(path.getFileName());
      }
    }
  }

Ajouter des répertoires

Pour créer un nouveau répertoire à partir d'une instance de File , vous devez utiliser l'une des deux méthodes suivantes: mkdirs() ou mkdir() .

• mkdir() - Crée le répertoire nommé par ce nom de chemin abstrait. ( source )
• mkdirs() - Crée le répertoire nommé par ce nom de chemin abstrait, y compris les répertoires parents nécessaires mais inexistants. Notez que si cette opération échoue, elle a peut-être réussi à créer certains des répertoires parents nécessaires. ( source )

Remarque: createNewFile() ne créera pas de nouveau répertoire uniquement un fichier.

File singleDir = new File("C:/Users/SomeUser/Desktop/A New Folder/");
    
File multiDir = new File("C:/Users/SomeUser/Desktop/A New Folder 2/Another Folder/");

// assume that neither "A New Folder" or "A New Folder 2" exist

singleDir.createNewFile(); // will make a new file called "A New Folder.file"
singleDir.mkdir(); // will make the directory
singleDir.mkdirs(); // will make the directory

multiDir.createNewFile(); // will throw a IOException
multiDir.mkdir(); // will not work
multiDir.mkdirs(); // will make the directory

Blocage ou redirection de la sortie / erreur standard

Parfois, une bibliothèque tierce mal conçue écrit des diagnostics indésirables dans les flux System.out ou System.err . Les solutions recommandées seraient soit de trouver une meilleure bibliothèque, soit (dans le cas de l’Open Source) de résoudre le problème et de fournir un correctif aux développeurs.

Si les solutions ci-dessus ne sont pas réalisables, vous devriez alors envisager de rediriger les flux.

Redirection sur la ligne de commande

Sur un UNIX, Linux ou MacOSX peut être fait à partir du shell en utilisant > redirection. Par exemple:

$ java -jar app.jar arg1 arg2 > /dev/null 2>&1
$ java -jar app.jar arg1 arg2 > out.log 2> error.log

Le premier redirige la sortie standard et l'erreur standard vers "/ dev / null", ce qui rejette tout ce qui est écrit dans ces flux. La seconde redirige la sortie standard vers "out.log" et l'erreur standard vers "error.log".

(Pour plus d'informations sur la redirection, reportez-vous à la documentation du shell de commandes que vous utilisez. Des conseils similaires s'appliquent à Windows.)

Vous pouvez également implémenter la redirection dans un script d'encapsuleur ou un fichier de commandes qui lance l'application Java.

Redirection dans une application Java

Il est également possible de rediriger les flux dans une application Java en utilisant System.setOut() et System.setErr() . Par exemple, l'extrait de code suivant redirige la sortie standard et l'erreur standard vers 2 fichiers journaux:

System.setOut(new PrintStream(new FileOutputStream(new File("out.log"))));
System.setErr(new PrintStream(new FileOutputStream(new File("err.log"))));

Si vous voulez supprimer complètement la sortie, vous pouvez créer un flux de sortie qui "écrit" dans un descripteur de fichier non valide. C'est fonctionnellement équivalent à écrire dans "/ dev / null" sous UNIX.

System.setOut(new PrintStream(new FileOutputStream(new FileDescriptor())));
System.setErr(new PrintStream(new FileOutputStream(new FileDescriptor())));

Attention: soyez prudent avec setOut et setErr :

1. La redirection affectera l'ensemble de la machine virtuelle Java.
2. Ce faisant, vous supprimez la capacité de l'utilisateur à rediriger les flux à partir de la ligne de commande.

Accéder au contenu d'un fichier ZIP

L'API FileSystem de Java 7 permet de lire et d'ajouter des entrées depuis ou vers un fichier Zip à l'aide de l'API de fichier Java NIO, de la même manière que pour tout autre système de fichiers.

Le FileSystem est une ressource qui doit être correctement fermée après utilisation. Par conséquent, le bloc try-with-resources doit être utilisé.

Lecture d'un fichier existant

Path pathToZip = Paths.get("path/to/file.zip");
try(FileSystem zipFs = FileSystems.newFileSystem(pathToZip, null)) {
  Path root = zipFs.getPath("/");
  ... //access the content of the zip file same as ordinary files
} catch(IOException ex) {
  ex.printStackTrace();
}

Créer un nouveau fichier

Map<String, String> env = new HashMap<>();  
env.put("create", "true"); //required for creating a new zip file
env.put("encoding", "UTF-8"); //optional: default is UTF-8
URI uri = URI.create("jar:file:/path/to/file.zip");
try (FileSystem zipfs = FileSystems.newFileSystem(uri, env)) {
  Path newFile = zipFs.getPath("/newFile.txt");
  //writing to file
  Files.write(newFile, "Hello world".getBytes());
} catch(IOException ex) {
  ex.printStackTrace();
}