Jak utworzyć plik i napisać do niego w Javie?

Jaki jest najprostszy sposób na utworzenie i zapisanie pliku (tekstowego) w Javie?

Pamiętaj, że każda z poniższych próbek kodu może wyrzucać IOException. Dla zwięzłości pominięto try / catch / wreszcie bloki. Zobacz ten samouczek, aby uzyskać informacje na temat obsługi wyjątków.

Zauważ, że każdy z poniższych przykładów kodu zastąpi plik, jeśli już istnieje

Tworzenie pliku tekstowego:

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

Tworzenie pliku binarnego:

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

Użytkownicy Java 7+ mogą używać tej Filesklasy do zapisywania plików:

Tworzenie pliku tekstowego:

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

Tworzenie pliku binarnego:

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

W Javie 7 i nowszych:

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

Istnieją jednak przydatne narzędzia:

• FileUtils.writeStringtoFile (..) from commons-io
• Files.write (..) z guawy

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

Poniżej znajduje się oryginalna odpowiedź wcześniejsza niż 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*/}
}

Zobacz także: Odczytywanie, zapisywanie i tworzenie plików (obejmuje NIO2).

Jeśli masz już treść, którą chcesz zapisać do pliku (i nie jest generowana w locie), java.nio.file.Filesdodanie do Java 7 jako części natywnego We / Wy zapewnia najprostszy i najbardziej wydajny sposób na osiągnięcie twoich celów.

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

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

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 zastępowania pliku. Jest to długa wersja, dzięki czemu 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 zapisywania plików 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);
        }
    }
}

Posługiwać się:

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

Za pomocą try() spowoduje automatyczne zamknięcie strumienia. Ta wersja jest krótka, szybka (buforowana) i umożliwia wybór kodowania.

Ta funkcja została wprowadzona w Javie 7.

Tutaj wprowadzamy ciąg 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 stworzyć nowy plik i dodać do niego zawartość.

Ponieważ autor nie określił, czy wymagają rozwiązania dla wersji Java, które zostały poddane EoL (zarówno przez firmę Sun, jak i IBM, a są to technicznie najbardziej rozpowszechnione maszyny JVM), a także dlatego, że wydaje się, że większość ludzi odpowiedziała na pytanie autora zanim określono, że jest to plik tekstowy (niebinarny) , postanowiłem udzielić odpowiedzi.

Po pierwsze, Java 6 ogólnie osiągnęła koniec życia, a ponieważ autor nie określił, że potrzebuje starszej kompatybilności, domyślam się, że automatycznie oznacza Javę 7 lub nowszą (Java 7 nie jest jeszcze EoL'd przez IBM). Możemy więc spojrzeć bezpośrednio na samouczek we / wy pliku: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

Przed wydaniem Java SE 7 klasa java.io.File była mechanizmem używanym do operacji we / wy plików, ale miała kilka wad.

• Wiele metod nie zgłaszało wyjątków, gdy zawiodły, dlatego niemożliwe było uzyskanie przydatnego komunikatu o błędzie. Na przykład, jeśli usunięcie pliku nie powiedzie się, program otrzyma komunikat „niepowodzenie usunięcia”, ale nie będzie wiedział, czy to dlatego, że plik nie istnieje, użytkownik nie miał uprawnień lub wystąpił inny problem.
• Metoda zmiany nazwy nie działała konsekwentnie na różnych platformach.
• Nie było rzeczywistego wsparcia dla dowiązań symbolicznych.
• Potrzebna była większa obsługa metadanych, takich jak uprawnienia do pliku, właściciel pliku i inne atrybuty bezpieczeństwa. Dostęp do metadanych pliku był nieefektywny.
• Wiele metod File nie skalowało się. Żądanie dużej listy katalogów przez serwer może spowodować zawieszenie się. Duże katalogi mogą również powodować problemy z zasobami pamięci, powodując odmowę usługi.
• Nie było możliwe napisanie niezawodnego kodu, który mógłby rekurencyjnie chodzić po drzewie plików i odpowiednio reagować, jeśli były okrągłe dowiązania symboliczne.

No cóż, to wyklucza plik java.io.File. Jeśli pliku nie można zapisać / dołączyć, możesz nawet nie wiedzieć, dlaczego.

Możemy nadal patrzeć na samouczek: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

Jeśli masz wszystkie wiersze, które wcześniej napiszesz (dołączasz) do pliku tekstowego , zalecanym podejściem jest 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 (dołącz):

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

Jeśli chcesz pisać zawartość pliku na bieżąco : 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 nowszy):

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

Kolejny przykład (dołącz):

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 podczas pisania do plików [tekstowych].

Jeśli chcesz mieć względnie bezbolesne doświadczenie, możesz również spojrzeć na pakiet IO Apache Commons , a dokładniej FileUtilsklasę .

Nigdy nie zapomnij sprawdzić bibliotek innych firm. Joda-Time do manipulacji datami, Apache Commons LangStringUtils do typowych operacji na łańcuchach znaków i takie mogą sprawić, że twój kod będzie bardziej czytelny.

Java jest świetnym językiem, ale standardowa biblioteka jest czasem nieco niskiego poziomu. Mocny, ale mimo to na niskim poziomie.

Jeśli z jakiegoś powodu chcesz oddzielić tworzenie i pisanie, odpowiednikiem Java touchjest

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()sprawdza istnienie i plik tworzy atomowo. Może to być przydatne, jeśli na przykład chcesz się upewnić, że jesteś twórcą pliku przed jego zapisaniem.

Oto niektóre z możliwych sposobów utworzenia i napisania pliku w Javie:

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

Korzystanie z 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 uzyskać więcej informacji, zapoznaj się z tym samouczkiem na temat odczytywania i zapisywania plików w Javie .

Posługiwać się:

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 nową klasą narzędzi - Pliki. Za pomocą klasy Files możemy również tworzyć, przenosić, kopiować, usuwać pliki i katalogi; Można go również używać 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);
}

Pisz w FileChannel Jeśli masz do czynienia z dużymi plikami, FileChannel może być szybszy niż standardowe IO. Poniższy kod zapisuje ciąg 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();
}

Napisz za pomocą 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();
}

Napisz za pomocą FileOutputStream

Zobaczmy teraz, jak możemy wykorzystać FileOutputStream do zapisywania danych binarnych do pliku. Poniższy kod konwertuje String int bajtów i zapisuje bajty do pliku za pomocą FileOutputStream:

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

    outputStream.close();
}

Pisz za pomocą PrintWriter możemy użyć PrintWriter do zapisania sformatowanego tekstu w 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();
}

Napisz za pomocą BufferedWriter: użyj BufferedWriter, aby napisać ciąg znaków do nowego pliku:

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

    writer.close();
}

dodaj ciąg 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 zastępowania 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();
        }
    }
}

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

Tylko jedna linia! pathi linesą ciągami znaków

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

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

Najprostszy sposób, w 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 wersji 1.7+.

Warto wypróbować Javę 7+:

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

Wygląda obiecująco ...

Jeśli korzystamy z Javy 7 i nowszych, a także znamy zawartość do dodania (dołączenia) 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();
    }
}

Warto zwrócić uwagę na kilka punktów:

1. Zawsze dobrym nawykiem jest kodowanie zestawu znaków i do tego mamy stałą w klasie StandardCharsets.
2. Kod używa try-with-resourceinstrukcji, w której zasoby są automatycznie zamykane po próbie.

Chociaż OP nie zapytał, ale na wszelki wypadek chcemy wyszukać wiersze zawierające określone słowo kluczowe, np. confidentialMożemy użyć interfejsów API strumieni 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();
}

Odczytywanie i zapisywanie plików przy użyciu 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");
        }
    }
}

Wystarczy dołączyć 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);

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

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

Istnieje kilka prostych sposobów, takich 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 za pomocą 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");

Korzystając z biblioteki Guava Google, możemy bardzo łatwo tworzyć i zapisywać pliki.

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 fruits.txtplik w katalogu głównym projektu.

Czytanie kolekcji klientom 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 zapisywania w nim:

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".;
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.

Pisanie większego pliku przy użyciu buforowanego strumienia we / wy (1.7)

Te java.nio.filenośniki pakietów kanału I / O, która porusza się dane w buforach, z pominięciem niektórych warstw, które może stanowić wąskie gardło strumienia I / O.

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

Takie podejście jest preferencyjne ze względu na jego wydajną wydajność, szczególnie przy wykonywaniu dużej liczby operacji zapisu. Operacje buforowane mają ten efekt, ponieważ nie są wymagane do wywoływania metody zapisu systemu operacyjnego dla każdego pojedynczego bajtu, co zmniejsza kosztowne operacje we / wy.

Używanie NIO API do kopiowania (i tworzenia nowego) pliku za pomocą Outputstream (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) (<1.7)

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

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

FileOutputStream (binarny) (<1.7)

FileOutputStream jest przeznaczony do zapisywania 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();

Przy takim podejściu należy rozważyć zapisanie tablicy bajtów zamiast pojedynczego bajtu. Przyspieszenie może być dość znaczące - do 10 x więcej lub więcej. Dlatego zaleca się stosowanie tych write(byte[])metod, gdy tylko jest to możliwe.