Як створити файл і записати його на Java?

Який найпростіший спосіб створити та записати у (текстовий) файл на Java?

Зверніть увагу, що кожен з наведених нижче зразків коду може кидатись IOException. Спробуйте / ловити / нарешті блоки були опущені для стислості. Дивіться цей підручник для отримання інформації про обробку виключень.

Зауважте, що кожен із зразків коду нижче буде перезаписати файл, якщо він уже існує

Створення текстового файлу:

PrintWriter writer = new PrintWriter("the-file-name.txt", "UTF-8");
writer.println("The first line");
writer.println("The second line");
writer.close();

Створення двійкового файлу:

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

Користувачі Java 7+ можуть використовувати Filesклас для запису у файли:

Створення текстового файлу:

List<String> lines = Arrays.asList("The first line", "The second line");
Path file = Paths.get("the-file-name.txt");
Files.write(file, lines, StandardCharsets.UTF_8);
//Files.write(file, lines, StandardCharsets.UTF_8, StandardOpenOption.APPEND);

Створення двійкового файлу:

byte data[] = ...
Path file = Paths.get("the-file-name");
Files.write(file, data);
//Files.write(file, data, StandardOpenOption.APPEND);

На Java 7 і вище:

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

Для цього є корисні утиліти:

• FileUtils.writeStringtoFile (..) від commons-io
• Files.write (..) від гуави

Зауважте також, що ви можете використовувати FileWriterкодування, але воно використовує кодування за замовчуванням, що часто є поганою ідеєю - краще вказати кодування чітко.

Нижче наведена оригінальна відповідь, попередня до Java 7

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

Дивись також: Читання, запис та створення файлів (включає NIO2).

Якщо у вас вже є вміст, який ви хочете записати у файл (а не генеруватися під час польоту), java.nio.file.Files руху додавання в Java 7 як частина нативного вводу / виводу забезпечує найпростіший та найефективніший спосіб досягти ваших цілей.

В основному створення і запис у файл - це лише один рядок, а також один простий виклик методу !

Наступний приклад створює і записує в 6 різних файлів, щоб продемонструвати, як його можна використовувати:

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

Ось невеликий приклад програми для створення або перезапису файла. Це довга версія, тому її можна зрозуміти легше.

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

Дуже простий спосіб створити та записати у файл на Java:

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

Використання:

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

Використання try()закриє потік автоматично. Ця версія коротка, швидка (буферизована) і дозволяє вибрати кодування.

Ця функція була введена в Java 7.

Тут ми вводимо рядок у текстовий файл:

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

Ми можемо легко створити новий файл і додати до нього вміст.

Оскільки автор не вказав, чи потребують вони рішення для версій Java, які були EoL'd (як Sun, так і IBM, а це технічно найбільш поширені JVM), а також через те, що, здається, більшість людей відповіли на на запитання автора, перш ніж було визначено, що це текстовий (не двійковий) файл, я вирішив надати свою відповідь.

Перш за все, Java 6 загалом досягла кінця життя, і оскільки автор не вказав, що йому потрібна сумісна версія, я думаю, що це автоматично означає Java 7 або вище (Java 7 ще не EoL'd від IBM). Отже, ми можемо переглянути право підручник з вводу / виводу файлів: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

До випуску Java SE 7 клас java.io.File був механізмом, використовуваним для вводу / виводу файлів, але він мав кілька недоліків.

• Багато методів не кидали винятків, коли вони не вдавалися, тому неможливо було отримати корисне повідомлення про помилку. Наприклад, якщо видалення файлу не вдалося, програма отримає "помилку видалення", але не знає, чи не тому, що файл не існував, у користувача не було дозволів або виникла якась інша проблема.
• Метод перейменування не працював послідовно на всіх платформах.
• Не було реальної підтримки символічних посилань.
• Бажано отримати більшу підтримку метаданих, таких як дозволи файлів, власник файлу та інші атрибути безпеки. Доступ до метаданих файлів виявився неефективним.
• Багато методів File не масштабували. Запит великого списку каталогів на сервері може призвести до зависання. Великі каталоги також можуть спричинити проблеми з ресурсами пам'яті, що призведе до відмови в обслуговуванні.
• Не вдалося написати надійний код, який міг би рекурсивно переходити до файлового дерева та відповідати відповідним чином, якщо були кругові символічні посилання.

Ну добре, це виключає java.io.File. Якщо файл неможливо записати / додати, можливо, ви навіть не зможете знати, чому.

Ми можемо продовжити перегляд підручника: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

Якщо у вас є всі рядки, які ви будете записувати (додавати) до текстового файлу заздалегідь , рекомендований підхід 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 ...-

Ось приклад (спрощений):

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

Інший приклад (додавання):

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

Якщо ви хочете писати вміст файлів у процесі переходу : https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html#newBufferedWriter-java.nio.file.file.Path-java .nio.charset.Charset-java.nio.file.OpenOption ...-

Спрощений приклад (Java 8 або вище):

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

Інший приклад (додавання):

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

Ці методи вимагають мінімальних зусиль з боку автора, і їх слід віддавати перевагу всім іншим при написанні у [текстові] файли.

Якщо ви хочете мати відносно безболісний досвід, ви також можете ознайомитись з пакетом вводу-виводу Apache Commons , точніше FileUtilsкласом .

Ніколи не забудьте перевірити сторонні бібліотеки. Joda-Time для маніпулювання датою, Apache Commons LangStringUtils для загальних рядкових операцій, і таке може зробити ваш код більш читабельним.

Java - це чудова мова, але стандартна бібліотека іноді трохи низька. Потужний, але все-таки низький рівень.

Якщо ви з якоїсь причини хочете відокремити акт створення та написання, еквівалентом Java touchє

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()чи перевірка існування та створення атомів створює файл. Це може бути корисно, якщо ви хочете, наприклад, створити файл, перш ніж писати в нього.

Ось кілька можливих способів створення та запису файлу на Java:

Використання 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();
}

Використання 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();
}

Використання 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();
}

Використання 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();
}

Для подальшої перевірки цього підручника про те, як читати та писати файли на Java .

Використання:

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

Найкращим способом є використання Java7: Java 7 представляє новий спосіб роботи з файловою системою разом з новим класом утиліти - Файлами. Використовуючи клас Files, ми також можемо створювати, переміщувати, копіювати, видаляти файли та каталоги; він також може бути використаний для читання та запису у файл.

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

    Files.write(path, strToBytes);
}

Пишіть за допомогою FileChannel Якщо ви маєте справу з великими файлами, FileChannel може бути швидшим, ніж стандартний IO. Наступний код записує рядок у файл за допомогою 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();
}

Пишіть за допомогою 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();
}

Пишіть за допомогою FileOutputStream

Давайте тепер розберемося, як ми можемо використовувати FileOutputStream для запису бінарних даних у файл. Наступний код перетворює байт Stt int і записує байти у файл за допомогою FileOutputStream:

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

    outputStream.close();
}

Пишіть за допомогою PrintWriter, ми можемо використовувати PrintWriter для запису форматованого тексту у файл:

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

Пишіть за допомогою BufferedWriter: використовуйте BufferedWriter, щоб написати рядок до нового файлу:

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

    writer.close();
}

додати рядок до існуючого файлу:

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

    writer.close();
}

Я думаю, що це найкоротший шлях:

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

Щоб створити файл без перезапису існуючого файлу:

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

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

Тільки один рядок! pathі lineє струнними

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

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

Найпростіший спосіб, який я можу знайти:

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

Напевно, це буде працювати лише для 1.7+.

Варто спробувати для Java 7+:

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

Це виглядає перспективно ...

Якщо ми використовуємо Java 7 і вище, а також знаємо вміст, який потрібно додати (додавати) до файлу, ми можемо скористатися методом newBufferedWriter у пакеті 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();
    }
}

Є кілька моментів, які слід зазначити:

1. Завжди корисно вказувати кодування шаблонів, і для цього ми постійно в класі StandardCharsets.
2. У коді використовується try-with-resourceоператор, в якому ресурси автоматично закриваються після спроби.

Хоча OP не запитує, але на всякий випадок, якщо ми хочемо шукати рядки, які мають певне ключове слово, наприклад, confidentialми можемо використовувати API потоку на Java:

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

Читання та запис файлів за допомогою вводу та виходу потоку:

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

Просто включіть цей пакет:

java.nio.file

І тоді ви можете використовувати цей код для написання файлу:

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

У Java 8 використовуйте Файли та Шляхи та використовуйте спробу з ресурсами.

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

Є кілька простих способів, наприклад:

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

Ви навіть можете створити тимчасовий файл, використовуючи властивість системи , яка не залежатиме від ОС, яку ви використовуєте.

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

Використовуючи бібліотеку Google Guava, ми можемо створювати та записувати у файл дуже легко.

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

Приклад створює новий fruits.txtфайл у кореневому каталозі проекту.

Читання колекції з клієнтами та збереження у файлі за допомогою 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();
        }
    }
}

Існує щонайменше кілька способів створення файлу та запису до нього:

Невеликі файли (1.7)

Ви можете використовувати один із методів запису для написання байтів або рядків у файл.

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

Ці методи забезпечують більшу частину роботи, наприклад, відкриття та закриття потоку, але не призначені для обробки великих файлів.

Запис великого файлу за допомогою вбудованого потокового вводу / виводу (1.7)

У java.nio.fileпакет підтримує канал введення / виводу, який переміщує дані в буфер, минаючи деякі з шарів , які можуть вузьким місцем Потік введення / виведення.

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

Цей підхід є переважним через його ефективне виконання, особливо при виконанні великої кількості операцій запису. Буферизовані операції мають такий ефект, оскільки їм не потрібно викликати метод запису операційної системи для кожного байта, зменшуючи дорогі операції вводу / виводу.

Використання NIO API для копіювання (та створення нового) файлу з вихідного потоку (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);
}

Існують також додаткові методи, які дозволяють копіювати всі байти з вхідного потоку у файл.

FileWriter (текст) (<1.7)

Записується безпосередньо у файл (з меншою продуктивністю) і його слід використовувати лише тоді, коли кількість записів менша. Використовується для запису даних, орієнтованих на символи, у файл.

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

FileOutputStream (двійковий) (<1.7)

FileOutputStream призначений для запису потоків необроблених байтів, таких як дані зображення.

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

При такому підході слід подумати про те, щоб завжди писати масив байтів, а не писати один байт за один раз. Швидкість роботи може бути досить значною - до 10 х і більше. Тому рекомендується використовувати write(byte[])методи, коли це можливо.