Java Language
Fil I / O

Introduktion

Läser alla byte till en byte []

Java 7 introducerade den mycket användbara Files- klassen

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

Läser en bild från en fil

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

...

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

Skriva en byte [] till en fil

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) {}
    }
}

De flesta API: er för java.io-fil accepterar både String och File som argument, så du kan också använda det

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

Stream vs Writer / Reader API

Strömmar ger den mest direkta åtkomsten till det binära innehållet, så alla InputStream / OutputStream implementationer fungerar alltid på int och byte .

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

Det finns några undantag, förmodligen framför allt PrintStream som lägger till "möjligheten att skriva ut representationer av olika datavärden bekvämt". Detta tillåter att använda System.out både som en binär InputStream och som en textutgång med metoder som System.out.println() .

Vissa strömimplementeringar fungerar också som ett gränssnitt till innehåll på högre nivå som Java-objekt (se Serialisering) eller inbyggda typer, t.ex. DataOutputStream / DataInputStream .

I klasserna Writer and Reader tillhandahåller Java också ett API för explicita teckenströmmar. Även om de flesta applikationer kommer att basera dessa implementationer på strömmar, avslöjar inte teckenström-API: n några metoder för binärt innehåll.

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

När det är nödvändigt att koda tecken i binär data (t.ex. när du använder InputStreamWriter / OutputStreamWriter ), bör du ange en charset om du inte vill vara beroende av plattformens standardcharset. Om du är osäker, använd en Unicode-kompatibel kodning, t.ex. UTF-8 som stöds på alla Java-plattformar. Därför bör du förmodligen hålla dig borta från klasser som FileWriter och FileReader eftersom de alltid använder standardplattformen. Ett bättre sätt att komma åt filer med teckenströmmar är detta:

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

En av de som oftast används Reader s är BufferedReader som tillhandahåller en metod för att läsa hela textrader från en annan läsare och är förmodligen det enklaste sättet att läsa en teckenström rad för rad:

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

Läser en hel fil på en gång

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

\ Z är symbolen EOF (End of File). När den är inställd som avgränsare läser skannern fyllningen tills EOF-flaggan nås.

Läser en fil med en skanner

Läsa en fil rad för rad

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

ord för ord

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

och du kan också ändra delometern med metoden scanner.useDelimeter ()

Iterera över en katalog och filter efter filändelse

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

Migrera från java.io.File till Java 7 NIO (java.nio.file.Path)

Dessa exempel antar att du redan vet vad Java 7: s NIO generellt är och att du är van vid att skriva kod med java.io.File . Använd dessa exempel som ett sätt att snabbt hitta mer NIO-centrerad dokumentation för migrering.

Det finns mycket mer till Java 7: s NIO, t.ex. minneskartade filer eller öppna en ZIP- eller JAR-fil med FileSystem . Dessa exempel kommer endast att täcka ett begränsat antal fall för grundläggande användning.

Som en grundregel, om du är van vid att utföra en filsystemläs / java.io.File med en java.io.File , hittar du den som en statisk metod inom java.nio.file.Files .

Peka på en väg

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

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

Vägar relativt en annan väg

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

Konvertera fil från / till sökväg för användning med bibliotek

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

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

Kontrollera om filen finns och ta bort den om den gör det

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

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

Skriv till en fil via en OutputStream

Det finns flera sätt att skriva och läsa från en fil med NIO för olika prestanda och minnesbegränsningar, läsbarhet och användningsfall, till exempel FileChannel , Files.write(Path path, byte\[\] bytes, OpenOption... options) . .. I det här exemplet OutputStream endast OutputStream , men du uppmanas starkt att lära dig om minneskartade filer och de olika statiska metoder som finns tillgängliga i 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));
    }
}

Iterera om varje fil i en mapp

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

Rekursiv mapp iteration

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

Fil läs / skriv med FileInputStream / FileOutputStream

Skriv till en fil 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();
}

Läs från filen 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();
}

Observera att sedan Java 1.7 introducerades try-with-resources- uttalandet, vilket gjorde implementeringen av läsning / skrivning mycket enklare:

Skriv till en fil 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();
}

Läs från filen 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();
}

Läser från en binär fil

Du kan läsa en binär fil med denna kodkod i alla nya versioner av 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();

Om du använder Java 7 eller senare finns det ett enklare sätt att använda nio API :

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

låsning

En fil kan låsas med FileChannel API som kan anskaffas från Input Output- streams och readers

Exempel med streams

// Öppna en filström FileInputStream ios = nytt FileInputStream (filnamn);

    // 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

Kopiera en fil med InputStream och OutputStream

Vi kan direkt kopiera data från en källa till ett datasänk med en slinga. I det här exemplet läser vi data från en InputStream och skriver samtidigt till en OutputStream. När vi är klar med att läsa och skriva måste vi stänga resursen.

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

Läser en fil med kanal och buffert

Channel använder en Buffer att läsa / skriva data. En buffert är en fast storlek behållare där vi kan skriva ett block med data på en gång. Channel är en ganska snabbare än strömbaserad I / O.

För att läsa data från en fil med Channel måste vi ha följande steg-

1. Vi behöver en instans av FileInputStream . FileInputStream har en metod som heter getChannel() som returnerar en kanal.
2. Ring getChannel() för FileInputStream och skaffa kanal.
3. Skapa en ByteBuffer. ByteBuffer är en fast storlek behållare med byte.
4. Channel har en läsmetod och vi måste tillhandahålla en ByteBuffer som ett argument till denna läsmetod. ByteBuffer har två lägen - skrivskyddad och skrivskyddad stämning. Vi kan ändra läget med hjälp av flip() -samtal. Buffert har en position, gräns och kapacitet. När en buffert skapas med en fast storlek, är dess gräns och kapacitet desamma som storleken och positionen börjar från noll. Medan en buffert skrivs med data ökar dess position gradvis. Att ändra läge betyder att ändra position. För att läsa data från början av en buffert måste vi ställa in positionen till noll. flip () -metod ändra position
5. När vi kallar Channel läsmetod fyller den bufferten med data.
6. Om vi behöver läsa data från ByteBuffer , måste vi vända bufferten för att ändra dess läge till skrivskyddsläge till skrivskyddsläge och sedan fortsätta läsa data från bufferten.
7. När det inte längre finns data att läsa returnerar metoden read() för kanal 0 eller -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();
  }
 }
}

Kopiera en fil med kanal

Vi kan använda Channel att kopiera filinnehåll snabbare. För att göra det kan vi använda transferTo() -metoden i 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();
        }
    }
}

Läser en fil med BufferedInputStream

Läser fil med en BufferedInputStream generellt snabbare än FileInputStream eftersom den har en intern buffert för att lagra byte som läses från den underliggande inmatningsströmmen.

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

    }
}

Skriva en fil med kanal och buffert

För att skriva data till en fil med Channel måste vi ha följande steg:

1. Först måste vi få ett objekt för FileOutputStream
2. FileChannel anropa getChannel() -metoden från FileOutputStream
3. Skapa en ByteBuffer och fyll den sedan med data
4. Då måste vi kalla flip() -metoden för ByteBuffer och skicka den som ett argument för att write() -metoden i FileChannel
5. När vi har skrivit, måste vi stänga resursen

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

Skriva en fil med PrintStream

Vi kan använda PrintStream klassen för att skriva en fil. Det har flera metoder som låter dig skriva ut alla datatypvärden. metoden println() lägger till en ny rad. När vi har PrintStream måste vi spola 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();
        }

    }
}

Iterera över en katalog som skriver ut underkataloger i den

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

Lägga till kataloger

För att skapa en ny katalog från en File måste du använda en av två metoder: mkdirs() eller mkdir() .

• mkdir() - Skapar katalogen med namnet på det abstrakta söknamnet. ( källa )
• mkdirs() - Skapar den katalog som heter med detta abstrakta söknamn, inklusive alla nödvändiga men ej befintliga överordnade kataloger. Observera att om den här åtgärden misslyckas kan det ha lyckats skapa några av de nödvändiga moderkatalogerna. ( källa )

Obs: createNewFile() skapar inte en ny katalog bara en fil.

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

Blockering eller omdirigering av standardutgång / fel

Ibland skriver ett dåligt utformat tredjepartsbibliotek oönskad diagnostik till System.out eller System.err . De rekommenderade lösningarna på detta skulle vara att antingen hitta ett bättre bibliotek eller (i fallet med open source) fixa problemet och bidra med en patch för utvecklarna.

Om ovanstående lösningar inte är möjliga bör du överväga att omdirigera strömmarna.

Omdirigering på kommandoraden

På ett UNIX, kan Linux eller MacOSX-system göras från skalet med > omdirigering. Till exempel:

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

Den första omdirigerar standardutdata och standardfel till "/ dev / null", som kastar bort allt skrivet till dessa strömmar. Den andra av omdirigerar standardutdata till "out.log" och standardfel till "error.log".

(Mer information om omdirigering hänvisas till dokumentationen för kommandoskalet du använder. Liknande råd gäller Windows.)

Alternativt kan du implementera omdirigeringen i ett wrappskript eller en batchfil som startar Java-applikationen.

Omdirigering inom en Java-applikation

Det är också möjligt att redired strömmarna inom ett Java-program med användning System.setOut() och System.setErr() . Till exempel omdirigerar följande utdrag standardutmatning och standardfel till två loggfiler:

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

Om du vill kasta bort utgången helt kan du skapa en utgångsström som "skriver" till en ogiltig filbeskrivning. Detta är funktionellt motsvarande att skriva till "/ dev / null" på UNIX.

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

Varning: var försiktig setOut du använder setOut och setErr :

1. Omdirigeringen påverkar hela JVM.
2. Genom att göra detta tar du bort användarens förmåga att omdirigera strömmarna från kommandoraden.

Få åtkomst till innehållet i en ZIP-fil

FileSystem API från Java 7 tillåter att läsa och lägga till poster från eller till en Zip-fil med Java NIO-fil API på samma sätt som att fungera på något annat filsystem.

FileSystemet är en resurs som bör stängas ordentligt efter användning, därför bör try-with-resource-blocket användas.

Läser från en befintlig fil

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

Skapa en ny fil

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