Java Language
File I / O

introduzione

Lettura di tutti i byte su un byte []

Java 7 ha introdotto la classe Files molto 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();
}

Leggere un'immagine da un file

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

...

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

Scrivere un byte [] in un file

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 maggior parte delle API di file java.io accetta sia String s che File s come argomenti, quindi si potrebbe anche usare

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

Stream vs Writer / Reader API

Gli stream forniscono l'accesso più diretto al contenuto binario, quindi qualsiasi implementazione InputStream / OutputStream funziona sempre su int s e 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);
}

Ci sono alcune eccezioni, probabilmente in particolare PrintStream che aggiunge la "capacità di stampare le rappresentazioni di vari valori di dati convenientemente". Ciò consente di utilizzare System.out sia come InputStream binario sia come output testuale utilizzando metodi come System.out.println() .

Inoltre, alcune implementazioni di stream funzionano come interfaccia per contenuti di livello superiore come oggetti Java (vedi Serializzazione) o tipi nativi, ad esempio DataOutputStream / DataInputStream .

Con le classi Writer e Reader , Java fornisce anche un'API per i flussi di caratteri espliciti. Sebbene la maggior parte delle applicazioni baserà queste implementazioni sui flussi, l'API del flusso di caratteri non espone alcun metodo per il contenuto binario.

// 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();

Ogni volta che è necessario codificare i caratteri in dati binari (ad esempio quando si utilizzano le classi InputStreamWriter / OutputStreamWriter ), è necessario specificare un set di caratteri se non si desidera dipendere dal set di caratteri predefinito della piattaforma. In caso di dubbi, utilizzare una codifica compatibile con Unicode, ad esempio UTF-8, supportata su tutte le piattaforme Java. Pertanto, si dovrebbe probabilmente stare lontano da classi come FileWriter e FileReader poiché utilizzano sempre il set di caratteri della piattaforma predefinito. Un modo migliore per accedere ai file utilizzando i flussi di caratteri è questo:

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();

Uno dei Reader più comunemente usati è BufferedReader che fornisce un metodo per leggere intere righe di testo da un altro lettore ed è presumibilmente il modo più semplice per leggere un flusso di caratteri riga per riga:

// 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);
}

Lettura di un intero file in una sola volta

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

\ Z è il simbolo EOF (Fine del file). Se impostato come delimitatore, lo scanner leggerà il riempimento fino al raggiungimento del flag EOF.

Lettura di un file con uno scanner

Leggere un file riga per riga

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();
        }
    }
}

parola per parola

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();
        }
    }
}

e puoi anche cambiare il delimitatore usando il metodo scanner.useDelimeter ()

Iterazione su una directory e filtro per estensione di file

    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());
            }
        }
    }

Migrazione da java.io.File a Java 7 NIO (java.nio.file.Path)

Questi esempi presumono che tu sappia già che cos'è NIO di Java 7 in generale e che sei abituato a scrivere codice usando java.io.File . Utilizzare questi esempi come mezzo per trovare rapidamente più documentazione NIO-centrica per la migrazione.

C'è molto di più nell'NIO di Java 7 come i file mappati in memoria o l' apertura di un file ZIP o JAR usando FileSystem . Questi esempi copriranno solo un numero limitato di casi d'uso di base.

Come regola di base, se si è abituati a eseguire un'operazione di lettura / scrittura di file system utilizzando un metodo di istanza java.io.File , lo si troverà come metodo statico all'interno di java.nio.file.Files .

Indica un percorso

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

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

Percorsi relativi ad un altro percorso

// 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");

Conversione di file da / a Path per l'uso con le librerie

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

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

Controlla se il file esiste ed eliminalo se lo fa

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

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

Scrivi su un file tramite un OutputStream

Esistono diversi modi per scrivere e leggere da un file utilizzando NIO per diverse prestazioni e vincoli di memoria, leggibilità e casi d'uso, come FileChannel , Files.write(Path path, byte\[\] bytes, OpenOption... options) . .. In questo esempio, viene coperto solo OutputStream , ma sei fortemente incoraggiato a conoscere i file mappati in memoria e i vari metodi statici disponibili in 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));
    }
}

Iterazione su ogni file all'interno di una cartella

// -> 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;
    }
});

Iterazione della cartella ricorsiva

// -> 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);
        }
    }
}

File lettura / scrittura utilizzando FileInputStream / FileOutputStream

Scrivi in ​​un file 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();
}

Leggi dal file 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();
}

Si noti che da Java 1.7 è stata introdotta la dichiarazione try-with-resources che ha reso molto più semplice l'implementazione dell'operazione reading \ writing:

Scrivi in ​​un file 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();
}

Leggi dal file 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();
}

Lettura da un file binario

Puoi leggere un file binario usando questo pezzo di codice in tutte le versioni recenti di 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();

Se si utilizza Java 7 o versioni successive, esiste un modo più semplice di utilizzare l' nio API :

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

Blocco

Un file può essere bloccato utilizzando l'API FileChannel che può essere acquisita dai streams e dai readers Input Output

Esempio con streams

// Apre un flusso di file 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

Copia di un file usando InputStream e OutputStream

Possiamo copiare direttamente i dati da un'origine a un data sink usando un loop. In questo esempio, stiamo leggendo i dati da un InputStream e, allo stesso tempo, scrivendo su un OutputStream. Una volta che abbiamo finito di leggere e scrivere, dobbiamo chiudere la risorsa.

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();
        }
    }
}

Leggere un file usando Channel e Buffer

Channel utilizza un Buffer per leggere / scrivere dati. Un buffer è un contenitore di dimensioni fisse in cui è possibile scrivere un blocco di dati contemporaneamente. Channel è molto più veloce di I / O basato sul flusso.

Per leggere i dati da un file utilizzando il Channel è necessario avere i seguenti passaggi:

1. Abbiamo bisogno di un'istanza di FileInputStream . FileInputStream ha un metodo chiamato getChannel() che restituisce un canale.
2. Chiama il metodo getChannel() di FileInputStream e acquisisci Canale.
3. Crea un ByteBuffer. ByteBuffer è un contenitore di byte di dimensioni fisse.
4. Il canale ha un metodo di lettura e dobbiamo fornire un ByteBuffer come argomento per questo metodo di lettura. ByteBuffer ha due modalità: umore di sola lettura e umore di sola scrittura. Possiamo cambiare la modalità usando la chiamata al metodo flip() . Il buffer ha una posizione, un limite e una capacità. Una volta creato un buffer con una dimensione fissa, il suo limite e la sua capacità sono uguali a quelli della dimensione e la posizione inizia da zero. Mentre un buffer è scritto con dati, la sua posizione aumenta gradualmente. Cambiare modalità significa, cambiare la posizione. Per leggere i dati dall'inizio di un buffer, dobbiamo impostare la posizione a zero. flip () metodo cambia la posizione
5. Quando chiamiamo il metodo di lettura del Channel , riempie il buffer usando i dati.
6. Se abbiamo bisogno di leggere i dati dal ByteBuffer , dobbiamo capovolgere il buffer per cambiarne la modalità in sola scrittura in modalità di sola lettura e quindi continuare a leggere i dati dal buffer.
7. Quando non ci sono più dati da leggere, il metodo read() del canale restituisce 0 o -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();
  }
 }
}

Copia di un file utilizzando il canale

Possiamo usare Channel per copiare il contenuto del file più velocemente. Per fare ciò, possiamo usare il metodo transferTo() di 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();
        }
    }
}

Lettura di un file utilizzando BufferedInputStream

Leggendo il file usando BufferedInputStream generalmente più velocemente di FileInputStream perché mantiene un buffer interno per memorizzare i byte letti dal flusso di input sottostante.

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();
        }

    }
}

Scrivere un file usando Channel e Buffer

Per scrivere i dati su un file utilizzando Channel è necessario avere i seguenti passaggi:

1. Per prima cosa, dobbiamo ottenere un oggetto di FileOutputStream
2. Acquisisci FileChannel chiamando il metodo getChannel() da FileOutputStream
3. Creare un ByteBuffer e quindi riempirlo con i dati
4. Quindi dobbiamo chiamare il metodo flip() del ByteBuffer e passarlo come argomento del metodo write() del FileChannel
5. Una volta che abbiamo finito di scrivere, dobbiamo chiudere la risorsa

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();
  }
 }
}  

Scrivere un file usando PrintStream

Possiamo usare la classe PrintStream per scrivere un file. Ha diversi metodi che ti permettono di stampare qualsiasi valore di tipo di dati. println() metodo println() aggiunge una nuova riga. Una volta terminata la stampa, dobbiamo svuotare 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();
        }

    }
}

Passare sopra una directory che stampa sottodirectory in esso

  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());
      }
    }
  }

Aggiunta di directory

Per creare una nuova directory da un'istanza di File è necessario utilizzare uno dei seguenti due metodi: mkdirs() o mkdir() .

• mkdir() - Crea la directory chiamata da questo percorso astratto. ( fonte )
• mkdirs() - Crea la directory nominata da questo percorso astratto, includendo tutte le directory padre necessarie ma inesistenti. Notare che se questa operazione fallisce, potrebbe essere riuscita a creare alcune delle directory madri necessarie. ( fonte )

Nota: createNewFile() non creerà una nuova directory solo un file.

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

Blocco o reindirizzamento dell'output / errore standard

A volte una libreria di terze parti progettata in modo inadeguato scriverà una diagnostica indesiderata sui flussi System.out o System.err . Le soluzioni consigliate per questo sarebbe trovare una libreria migliore o (nel caso di open source) risolvere il problema e contribuire con una patch agli sviluppatori.

Se le soluzioni di cui sopra non sono fattibili, dovresti considerare di reindirizzare i flussi.

Reindirizzamento sulla riga di comando

Su un sistema UNIX, Linux o MacOSX può essere fatto dalla shell usando > redirection. Per esempio:

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

Il primo reindirizza lo standard output e l'errore standard a "/ dev / null", che getta via qualsiasi cosa scritta su quei flussi. Il secondo reindirizza l'output standard a "out.log" e l'errore standard a "error.log".

(Per ulteriori informazioni sul reindirizzamento, consultare la documentazione della shell dei comandi che si sta utilizzando. Un consiglio simile si applica a Windows.)

In alternativa, è possibile implementare il reindirizzamento in uno script wrapper o in un file batch che avvia l'applicazione Java.

Reindirizzamento all'interno di un'applicazione Java

È anche possibile ridirigere i flussi all'interno di un'applicazione Java utilizzando System.setOut() e System.setErr() . Ad esempio, il seguente snippet reindirizza l'output standard e l'errore standard in 2 file di registro:

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

Se si desidera eliminare completamente l'output, è possibile creare un flusso di output che "scrive" su un descrittore di file non valido. Questo è funzionalmente equivalente alla scrittura su "/ dev / null" su UNIX.

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

Attenzione: fai attenzione a come usi setOut e setErr :

1. Il reindirizzamento interesserà l'intera JVM.
2. In questo modo, stai rimuovendo la possibilità dell'utente di reindirizzare gli stream dalla riga di comando.

Accedere ai contenuti di un file ZIP

L'API FileSystem di Java 7 consente di leggere e aggiungere voci da o ad un file Zip utilizzando l'API del file NIO Java allo stesso modo di operare su qualsiasi altro file system.

Il FileSystem è una risorsa che dovrebbe essere chiusa correttamente dopo l'uso, quindi dovrebbe essere usato il blocco try-with-resources.

Lettura da un file esistente

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();
}

Creare un nuovo file

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();
}