Jak utworzyć plik i do niego napisać?

W Javie 7 i w górę:

try (Writer writer = new BufferedWriter(new OutputStreamWriter(
              new FileOutputStream("filename.txt"), "utf-8"))) {
   writer.write("something");
}

Są do tego przydatne narzędzia:

• FileUtils.writeStringtoFile(..) z commons-io
• Pliki.napisz(..) z guawy

Zauważ również, że możesz użyć FileWriter, ale używa on domyślnego kodowania, co często jest złym pomysłem - najlepiej jest jawnie określić kodowanie.

Poniżej oryginalna, przed-Java 7 odpowiedź

Writer writer = null;

try {
    writer = new BufferedWriter(new OutputStreamWriter(
          new FileOutputStream("filename.txt"), "utf-8"));
    writer.write("Something");
} catch (IOException ex) {
    // Report
} finally {
   try {writer.close();} catch (Exception ex) {/*ignore*/}
}

Zobacz też: Czytanie, Zapisywanie i tworzenie plików (zawiera NIO2).

Jeśli masz już zawartość, którą chcesz zapisać do pliku (a nie generowaną w locie),java.nio.file.Files dodatek w Javie 7 jako część natywnych I/O zapewnia najprostszy i najbardziej efektywny sposób osiągnięcia celów.

Zasadniczo tworzenie i zapis do pliku to tylko jedna linia, ponadto jedno proste wywołanie metody !

Poniższy przykład tworzy i zapisuje do 6 różnych plików, aby pokazać, jak można go używać:

Charset utf8 = StandardCharsets.UTF_8;
List<String> lines = Arrays.asList("1st line", "2nd line");
byte[] data = {1, 2, 3, 4, 5};

try {
    Files.write(Paths.get("file1.bin"), data);
    Files.write(Paths.get("file2.bin"), data,
            StandardOpenOption.CREATE, StandardOpenOption.APPEND);
    Files.write(Paths.get("file3.txt"), "content".getBytes());
    Files.write(Paths.get("file4.txt"), "content".getBytes(utf8));
    Files.write(Paths.get("file5.txt"), lines, utf8);
    Files.write(Paths.get("file6.txt"), lines, utf8,
            StandardOpenOption.CREATE, StandardOpenOption.APPEND);
} catch (IOException e) {
    e.printStackTrace();
}

public class Program {
    public static void main(String[] args) {
        String text = "Hello world";
        BufferedWriter output = null;
        try {
            File file = new File("example.txt");
            output = new BufferedWriter(new FileWriter(file));
            output.write(text);
        } catch ( IOException e ) {
            e.printStackTrace();
        } finally {
          if ( output != null ) {
            output.close();
          }
        }
    }
}

Oto mały przykładowy program do tworzenia lub nadpisywania pliku. Jest to długa wersja, więc można ją łatwiej zrozumieć.

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class writer {
    public void writing() {
        try {
            //Whatever the file path is.
            File statText = new File("E:/Java/Reference/bin/images/statsTest.txt");
            FileOutputStream is = new FileOutputStream(statText);
            OutputStreamWriter osw = new OutputStreamWriter(is);    
            Writer w = new BufferedWriter(osw);
            w.write("POTATO!!!");
            w.close();
        } catch (IOException e) {
            System.err.println("Problem writing to the file statsTest.txt");
        }
    }

    public static void main(String[]args) {
        writer write = new writer();
        write.writing();
    }
}

Bardzo prosty sposób tworzenia i zapisu do pliku w Javie:

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;

public class CreateFiles {

    public static void main(String[] args) {
        try{
            // Create new file
            String content = "This is the content to write into create file";
            String path="D:\\a\\hi.txt";
            File file = new File(path);

            // If file doesn't exists, then create it
            if (!file.exists()) {
                file.createNewFile();
            }

            FileWriter fw = new FileWriter(file.getAbsoluteFile());
            BufferedWriter bw = new BufferedWriter(fw);

            // Write in file
            bw.write(content);

            // Close connection
            bw.close();
        }
        catch(Exception e){
            System.out.println(e);
        }
    }
}

Użycie:

try (Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8))) {
    writer.write("text to write");
} 
catch (IOException ex) {
    // Handle me
}  

Użycie {[1] } spowoduje automatyczne Zamknięcie strumienia. Wersja ta jest krótka, szybka (buforowana) i umożliwia wybór kodowania.

Ta funkcja została wprowadzona w Javie 7.

Tutaj wpisujemy łańcuch znaków do pliku tekstowego:

String content = "This is the content to write into a file";
File file = new File("filename.txt");
FileWriter fw = new FileWriter(file.getAbsoluteFile());
BufferedWriter bw = new BufferedWriter(fw);
bw.write(content);
bw.close(); // Be sure to close BufferedWriter

Możemy łatwo utworzyć nowy plik i dodać do niego zawartość.

Jeśli chcesz mieć relatywnie bezbolesne doświadczenie, możesz również rzucić okiem na Apache Commons IO package, a dokładniej na FileUtils klasa .

Nigdy nie zapomnij sprawdzić bibliotek innych firm. Joda-czas do manipulacji datą, Apache Commons Lang StringUtils w przypadku typowych operacji ciągów i takich może uczynić Twój kod bardziej czytelnym.

Java jest świetnym językiem, ale biblioteka standardowa jest czasami nieco niskopoziomowa. Potężny, ale mimo wszystko na niskim poziomie.

Ponieważ autor nie sprecyzował, czy wymagają one rozwiązania dla wersji Javy, które zostały EoL ' d (zarówno przez Sun, jak i IBM, a są to technicznie najbardziej rozpowszechnione JVM), i ze względu na fakt, że większość ludzi zdaje się odpowiadać na pytanie autora, zanim zostało określone, że jest to plik tekstowy (niebinarny) , postanowiłem udzielić odpowiedzi.

Po pierwsze, Java 6 na ogół osiągnęła koniec życia, a ponieważ autor nie sprecyzował, że potrzebuje legacy kompatybilność, myślę, że automatycznie oznacza Java 7 lub powyżej (Java 7 nie jest jeszcze EoL ' D przez IBM). Tak więc, możemy spojrzeć prosto na plik i/o tutorial: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

Przed wydaniem Java SE 7, Klasa java. io. File była mechanizm używany do we/wy plików, ale miał kilka wad.

• wiele metod nie wyrzuca WYJĄTKÓW, gdy zawiodły, więc było to niemożliwe uzyskanie użytecznego błędu wiadomość. Na przykład, jeśli plik usunięcie nie powiodło się, program otrzyma "delete fail", ale nie wiedziałby, czy to dlatego, że plik nie istnieje, użytkownik nie mieć uprawnienia, albo był jakiś inny problem.
• metoda rename nie działał konsekwentnie na różnych platformach.
• nie było realnego wsparcia dla dowiązań symbolicznych.
• pożądano większego wsparcia dla metadanych, takich jak uprawnienia do plików, właściciel pliku i inne atrybuty zabezpieczeń. Dostęp metadane plików były nieefektywne.
• wiele metod plików nie skalowało się. Żądanie dużej listy katalogów na serwerze może skutkować czekaj. Duże katalogi mogą również powodować problemy z zasobami pamięci, skutkuje odmową świadczenia usług.
• nie można było napisać niezawodny kod, który mógłby rekurencyjnie poruszać się po drzewie plików i odpowiadać odpowiednio, gdyby istniały okrągłe dowiązania symboliczne.

No cóż, to wyklucza plik java. io. jeśli plik nie może być zapisany/dołączony, możesz nie być w stanie nawet wiedzieć dlaczego.

Możemy kontynuować przeglądanie tutoriala: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

Jeśli masz wszystkie linie, to z góry napiszesz (dopiszesz) do pliku tekstowego , zalecane podejście na https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#write-java.nio.file.Path-java.lang.Iterable-java.nio.charset.Charset-java.nio.file.OpenOption...-

Oto przykład (uproszczony):

Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, StandardCharsets.UTF_8);

Kolejny przykład (append):

Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE);

Jeśli chcesz zapisać zawartość pliku jak go : https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#newBufferedWriter-java.nio.file.Path-java.nio.charset.Charset-java.nio.file.OpenOption...-

Uproszczony przykład (Java 8 lub up):

Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file)) {
    writer.append("Zero header: ").append('0').write("\r\n");
    [...]
}

Kolejny przykład (append):

Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE)) {
    writer.write("----------");
    [...]
}

Metody te wymagają minimalnego wysiłku ze strony autora i powinny być preferowane dla wszystkich innych podczas pisania do plików [tekstowych].

Oto niektóre z możliwych sposobów tworzenia i zapisu pliku w Javie:

Using FileOutputStream

try {
  File fout = new File("myOutFile.txt");
  FileOutputStream fos = new FileOutputStream(fout);
  BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos));
  bw.write("Write somthing to the file ...");
  bw.newLine();
  bw.close();
} catch (FileNotFoundException e){
  // File was not found
  e.printStackTrace();
} catch (IOException e) {
  // Problem when writing to the file
  e.printStackTrace();
}

Używanie FileWriter

try {
  FileWriter fw = new FileWriter("myOutFile.txt");
  fw.write("Example of content");
  fw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

Korzystanie Z PrintWriter

try {
  PrintWriter pw = new PrintWriter("myOutFile.txt");
  pw.write("Example of content");
  pw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

Korzystanie Z OutputStreamWriter

try {
  File fout = new File("myOutFile.txt");
  FileOutputStream fos = new FileOutputStream(fout);
  OutputStreamWriter osw = new OutputStreamWriter(fos);
  osw.write("Soe content ...");
  osw.close();
} catch (FileNotFoundException e) {
  // File not found
  e.printStackTrace();
} catch (IOException e) {
  // Error when writing to the file
  e.printStackTrace();
}

Aby dowiedzieć się więcej, sprawdź ten samouczek o tym, jak odczytywać i zapisywać pliki w Javie .

Jeśli z jakiegoś powodu chcesz oddzielić akt tworzenia i pisania, odpowiednikiem touch w Javie jest

try {
   //create a file named "testfile.txt" in the current working directory
   File myFile = new File("testfile.txt");
   if ( myFile.createNewFile() ) {
      System.out.println("Success!");
   } else {
      System.out.println("Failure!");
   }
} catch ( IOException ioe ) { ioe.printStackTrace(); }

createNewFile() czy sprawdzanie istnienia i tworzenie pliku atomicznie. Może to być przydatne, jeśli chcesz się upewnić, że jesteś twórcą pliku, na przykład przed zapisaniem do niego.

Użycie:

JFileChooser c = new JFileChooser();
c.showOpenDialog(c);
File writeFile = c.getSelectedFile();
String content = "Input the data here to be written to your file";

try {
    FileWriter fw = new FileWriter(writeFile);
    BufferedWriter bw = new BufferedWriter(fw);
    bw.append(content);
    bw.append("hiiiii");
    bw.close();
    fw.close();
}
catch (Exception exc) {
   System.out.println(exc);
}

Najlepszym sposobem jest użycie Java7: Java 7 wprowadza nowy sposób pracy z systemem plików wraz z nowymi klasami narzędziowymi-plikami. Korzystając z klasy Files, możemy tworzyć, przenosić, kopiować, usuwać pliki i katalogi, a także może być używana do odczytu i zapisu do pliku.

public void saveDataInFile(String data) throws IOException {
    Path path = Paths.get(fileName);
    byte[] strToBytes = data.getBytes();

    Files.write(path, strToBytes);
}

Napisz za pomocą FileChannel Jeśli masz do czynienia z dużymi plikami, FileChannel może być szybszy niż standardowe IO. Poniższy kod zapisuje ciąg znaków do pliku za pomocą FileChannel:

public void saveDataInFile(String data) 
  throws IOException {
    RandomAccessFile stream = new RandomAccessFile(fileName, "rw");
    FileChannel channel = stream.getChannel();
    byte[] strBytes = data.getBytes();
    ByteBuffer buffer = ByteBuffer.allocate(strBytes.length);
    buffer.put(strBytes);
    buffer.flip();
    channel.write(buffer);
    stream.close();
    channel.close();
}

Zapis z DataOutputStream

public void saveDataInFile(String data) throws IOException {
    FileOutputStream fos = new FileOutputStream(fileName);
    DataOutputStream outStream = new DataOutputStream(new BufferedOutputStream(fos));
    outStream.writeUTF(data);
    outStream.close();
}

Zapis z FileOutputStream

Zobaczmy teraz, jak możemy użyć FileOutputStream do zapisu danych binarnych do pliku. Poniższy kod konwertuje łańcuch int bajtów i zapisuje bajty do pliku za pomocą strumienia FileOutputStream:

public void saveDataInFile(String data) throws IOException {
    FileOutputStream outputStream = new FileOutputStream(fileName);
    byte[] strToBytes = data.getBytes();
    outputStream.write(strToBytes);

    outputStream.close();
}

Napisz za pomocą Printwritera możemy użyć drukarki do zapisu sformatowanego tekstu do pliku:

public void saveDataInFile() throws IOException {
    FileWriter fileWriter = new FileWriter(fileName);
    PrintWriter printWriter = new PrintWriter(fileWriter);
    printWriter.print("Some String");
    printWriter.printf("Product name is %s and its price is %d $", "iPhone", 1000);
    printWriter.close();
}

Zapis z BufferedWriter: użycie BufferedWriter zapisuje Łańcuch znaków do nowego pliku:

public void saveDataInFile(String data) throws IOException {
    BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));
    writer.write(data);

    writer.close();
}

Dołączenie ciągu znaków do istniejącego pliku:

public void saveDataInFile(String data) throws IOException {
    BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true));
    writer.append(' ');
    writer.append(data);

    writer.close();
}

Myślę, że to najkrótsza droga:

FileWriter fr = new FileWriter("your_file_name.txt"); // After '.' write
// your file extention (".txt" in this case)
fr.write("Things you want to write into the file"); // Warning: this will REPLACE your old file content!
fr.close();

Aby utworzyć plik bez nadpisywania istniejącego pliku:

System.out.println("Choose folder to create file");
JFileChooser c = new JFileChooser();
c.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
c.showOpenDialog(c);
c.getSelectedFile();
f = c.getSelectedFile(); // File f - global variable
String newfile = f + "\\hi.doc";//.txt or .doc or .html
File file = new File(newfile);

try {
    //System.out.println(f);
    boolean flag = file.createNewFile();

    if(flag == true) {
        JOptionPane.showMessageDialog(rootPane, "File created successfully");
    }
    else {
        JOptionPane.showMessageDialog(rootPane, "File already exists");
    }
    /* Or use exists() function as follows:
        if(file.exists() == true) {
            JOptionPane.showMessageDialog(rootPane, "File already exists");
        }
        else {
            JOptionPane.showMessageDialog(rootPane, "File created successfully");
        }
    */
}
catch(Exception e) {
    // Any exception handling method of your choice
}

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterExample {
    public static void main(String [] args) {
        FileWriter fw= null;
        File file =null;
        try {
            file=new File("WriteFile.txt");
            if(!file.exists()) {
                file.createNewFile();
            }
            fw = new FileWriter(file);
            fw.write("This is an string written to a file");
            fw.flush();
            fw.close();
            System.out.println("File written Succesfully");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Warto spróbować dla Javy 7+:

 Files.write(Paths.get("./output.txt"), "Information string herer".getBytes());

package fileoperations;
import java.io.File;
import java.io.IOException;

public class SimpleFile {
    public static void main(String[] args) throws IOException {
        File file =new File("text.txt");
        file.createNewFile();
        System.out.println("File is created");
        FileWriter writer = new FileWriter(file);

        // Writes the content to the file
        writer.write("Enter the text that you want to write"); 
        writer.flush();
        writer.close();
        System.out.println("Data is entered into file");
    }
}

Najprostszy sposób, jaki mogę znaleźć:

Path sampleOutputPath = Paths.get("/tmp/testfile")
try (BufferedWriter writer = Files.newBufferedWriter(sampleOutputPath)) {
    writer.write("Hello, world!");
}

Prawdopodobnie będzie działać tylko dla 1.7+.

W Javie 8 używaj plików i ścieżek oraz używaj try-with-resources construct.

import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class WriteFile{
    public static void main(String[] args) throws IOException {
        String file = "text.txt";
        System.out.println("Writing to file: " + file);
        // Files.newBufferedWriter() uses UTF-8 encoding by default
        try (BufferedWriter writer = Files.newBufferedWriter(Paths.get(file))) {
            writer.write("Java\n");
            writer.write("Python\n");
            writer.write("Clojure\n");
            writer.write("Scala\n");
            writer.write("JavaScript\n");
        } // the file will be automatically closed
    }
}

Tylko jedna linijka ! path i line są ciągami

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

Files.write(Paths.get(path), lines.getBytes());

Odczyt i zapis plików za pomocą strumienia wejściowego i wyjściowego:

//Coded By Anurag Goel
//Reading And Writing Files
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;


public class WriteAFile {
    public static void main(String args[]) {
        try {
            byte array [] = {'1','a','2','b','5'};
            OutputStream os = new FileOutputStream("test.txt");
            for(int x=0; x < array.length ; x++) {
                os.write( array[x] ); // Writes the bytes
            }
            os.close();

            InputStream is = new FileInputStream("test.txt");
            int size = is.available();

            for(int i=0; i< size; i++) {
                System.out.print((char)is.read() + " ");
            }
            is.close();
        } catch(IOException e) {
            System.out.print("Exception");
        }
    }
}

Po prostu dołącz ten pakiet:

java.nio.file

A następnie możesz użyć tego kodu do napisania pliku:

Path file = ...;
byte[] buf = ...;
Files.write(file, buf);

Jeśli korzystamy z Javy 7 i nowszej oraz znamy zawartość dodaną (dołączoną) do pliku, możemy skorzystać z metody newBufferedWriter w pakiecie NIO.

public static void main(String[] args) {
    Path FILE_PATH = Paths.get("C:/temp", "temp.txt");
    String text = "\n Welcome to Java 8";

    //Writing to the file temp.txt
    try (BufferedWriter writer = Files.newBufferedWriter(FILE_PATH, StandardCharsets.UTF_8, StandardOpenOption.APPEND)) {
        writer.write(text);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Jest kilka punktów do odnotowania:

1. dobrym nawykiem jest zawsze określanie kodowania znaków i do tego mamy stałą w klasie StandardCharsets.
2. kod używa instrukcji try-with-resource, w której zasoby są automatycznie zamykane po próbie.

Choć OP nie zapytał, ale na wszelki wypadek chcemy wyszukać linie posiadające jakieś konkretne słowo kluczowe np. confidential możemy skorzystać z API stream w Javie:

//Reading from the file the first line which contains word "confidential"
try {
    Stream<String> lines = Files.lines(FILE_PATH);
    Optional<String> containsJava = lines.filter(l->l.contains("confidential")).findFirst();
    if(containsJava.isPresent()){
        System.out.println(containsJava.get());
    }
} catch (IOException e) {
    e.printStackTrace();
}

Jest kilka prostych sposobów, jak:

File file = new File("filename.txt");
PrintWriter pw = new PrintWriter(file);

pw.write("The world I'm coming");
pw.close();

String write = "Hello World!";

FileWriter fw = new FileWriter(file);
BufferedWriter bw = new BufferedWriter(fw);

fw.write(write);

fw.close();

Możesz nawet utworzyć plik tymczasowy używając właściwości systemowej , która będzie niezależna od używanego systemu operacyjnego.

File file = new File(System.*getProperty*("java.io.tmpdir") +
                     System.*getProperty*("file.separator") +
                     "YourFileName.txt");

Za pomocą biblioteki Google Guava możemy tworzyć i zapisywać do Pliku bardzo łatwo.

package com.zetcode.writetofileex;

import com.google.common.io.Files;
import java.io.File;
import java.io.IOException;

public class WriteToFileEx {

    public static void main(String[] args) throws IOException {

        String fileName = "fruits.txt";
        File file = new File(fileName);

        String content = "banana, orange, lemon, apple, plum";

        Files.write(content.getBytes(), file);
    }
}

Przykład tworzy nowy plik fruits.txt w katalogu głównym projektu.

Odczytywanie kolekcji z klientami i zapisywanie do pliku za pomocą JFilechooser.

private void writeFile(){

    JFileChooser fileChooser = new JFileChooser(this.PATH);
    int retValue = fileChooser.showDialog(this, "Save File");

    if (retValue == JFileChooser.APPROVE_OPTION){

        try (Writer fileWrite = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileChooser.getSelectedFile())))){

            this.customers.forEach((c) ->{
                try{
                    fileWrite.append(c.toString()).append("\n");
                }
                catch (IOException ex){
                    ex.printStackTrace();
                }
            });
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }
}

Istnieje co najmniej kilka sposobów tworzenia pliku i zapisu do niego:

Małe pliki (1.7)

Możesz użyć jednej z metod zapisu, aby zapisać bajty lub linie do pliku.

Path file = Paths.get("path-to-file");
byte[] buf = "text-to-write-to-file".getBytes();
Files.write(file, buf);

Te metody zajmują się większością prac, takich jak otwieranie i zamykanie strumienia, ale nie są przeznaczone do obsługi dużych plików.

Zapisanie większego pliku za pomocą buforowanego strumienia We / Wy (1.7)

Pakiet java.nio.file obsługuje kanały I / O, które poruszają dane w buforach, omijając niektóre warstwy, które mogą wąskiego gardła we/wy strumienia.]}

String s = "much-larger-text-to-write-to-file";
try (BufferedWriter writer = Files.newBufferedWriter(file, StandardCharsets.UTF_8)) {
    writer.write(s, 0, s.length());
}

To podejście jest preferencyjne ze względu na jego wydajną wydajność, szczególnie podczas wykonywania dużej ilości operacji zapisu. Operacje buforowane mają ten efekt, ponieważ nie są wymagane do wywoływania metody zapisu systemu operacyjnego dla każdego bajtu, co zmniejsza kosztowne operacje We / Wy.

Korzystanie z NIO API do kopiowania (i tworzenia nowego) pliku ze strumieniem wyjściowym (1.7)

Path oldFile = Paths.get("existing-file-path");
Path newFile = Paths.get("new-file-path");
try (OutputStream os = new FileOutputStream(newFile.toFile())) {
    Files.copy(oldFile, os);
}

Istnieją również dodatkowe metody, które pozwalają skopiować wszystkie bajty ze strumienia wejściowego do pliku.

FileWriter (tekst) (

Zapisuje bezpośrednio do pliku (mniejsza wydajność) i powinien być używany tylko wtedy, gdy liczba zapisów jest mniejsza. Służy do zapisu danych zorientowanych na znaki do pliku.

String s= "some-text";
FileWriter fileWriter = new FileWriter("C:\\path\\to\\file\\file.txt");
fileWriter.write(fileContent);
fileWriter.close();

FileOutputStream (binary) (

FileOutputStream jest przeznaczony do zapisu strumieni surowych bajtów, takich jak dane obrazu.

byte data[] = "binary-to-write-to-file".getBytes();
FileOutputStream out = new FileOutputStream("file-name");
out.write(data);
out.close();

Z takie podejście należy rozważyć, aby zawsze zapisywać tablicę bajtów zamiast zapisywać jeden bajt na raz. Przyspieszenie może być dość znaczące - do 10 x wyższe lub więcej. Dlatego zaleca się stosowanie metod write(byte[]) w miarę możliwości.