Java ile nasıl dosya oluşturur ve ona nasıl yazarım?

Java'da bir (metin) dosyası oluşturmanın ve bu dosyaya yazmanın en basit yolu nedir?

Aşağıdaki kod örneklerinin her birinin atılabileceğini unutmayın IOException. Denemek / yakalamak / nihayet bloklar kısalık için atlanmıştır. İstisna yönetimi hakkında bilgi için bu eğiticiye bakın .

Aşağıdaki kod örneklerinin her birinin zaten varsa dosyanın üzerine yazacağını unutmayın

Metin dosyası oluşturma:

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

İkili dosya oluşturma:

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

Java 7+ kullanıcıları Filesdosyalara yazmak için sınıfı kullanabilir :

Metin dosyası oluşturma:

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

İkili dosya oluşturma:

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

Java 7 ve sonraki sürümlerde:

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

Bunun için yararlı araçlar var:

• Commons-io sitesinden FileUtils.writeStringtoFile (..)
• Files.write (..), guava dan

Ayrıca, a'yı kullanabileceğinizi FileWriter, ancak genellikle kötü bir fikir olan varsayılan kodlamayı kullandığını unutmayın - kodlamayı açıkça belirtmek en iyisidir.

Aşağıda, Java 7'den önceki orijinal yanıt yer almaktadır

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

Ayrıca bkz: Dosya Okuma, Yazma ve Oluşturma (NIO2'yi içerir).

Dosyaya yazmak istediğiniz içeriğe zaten sahipseniz (ve anında oluşturulmadıysa), java.nio.file.Files yerel I / O'nun bir parçası olarak Java 7'ye eklenmesi, hedeflerinize ulaşmak için en basit ve en etkili yolu sağlar.

Temelde bir dosya oluşturmak ve dosyaya yazmak yalnızca bir satırdır, ayrıca basit bir yöntem çağrısıdır !

Aşağıdaki örnek, nasıl kullanılabileceğini göstermek için 6 farklı dosya oluşturur ve bunlara yazar:

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

İşte bir dosya oluşturmak veya üzerine yazmak için küçük bir örnek program. Uzun versiyonu bu yüzden daha kolay anlaşılabilir.

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 ile bir dosya oluşturmanın ve yazmanın çok basit bir yolu:

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

kullanın:

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

Kullanıldığında try()akışı otomatik olarak kapatır. Bu sürüm kısa, hızlı (arabelleğe alınmış) ve kodlamanın seçilmesini sağlar.

Bu özellik Java 7'de tanıtıldı.

Burada bir metin dosyasına bir dize giriyoruz:

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

Kolayca yeni bir dosya oluşturabilir ve bu dosyaya içerik ekleyebiliriz.

Yazar, EoL'd olan Java sürümleri için bir çözüm gerekip gerekmediğini belirtmediğinden (hem Sun hem de IBM tarafından ve bunlar teknik olarak en yaygın JVM'lerdir) ve çoğu insanın Yazarın sorusuna bir metin (ikili olmayan) dosya olduğunu belirtmeden önce cevabımı vermeye karar verdim.

Her şeyden önce, Java 6 genellikle ömrünün sonuna ulaşmıştır ve yazar eski uyumluluğa ihtiyaç duyduğunu belirtmediğinden, otomatik olarak Java 7 veya üstü anlamına gelir (Java 7 henüz IBM tarafından EoL'd değildir). Dolayısıyla, doğrudan dosya G / Ç eğitimine bakabiliriz: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

Java SE 7 sürümünden önce java.io.File sınıfı, dosya G / Ç için kullanılan mekanizmadır, ancak birkaç dezavantajı vardı.

• Birçok yöntem başarısız olduklarında istisna atmadı, bu nedenle yararlı bir hata mesajı almak imkansızdı. Örneğin, bir dosya silme başarısız olursa, program "silme hatası" alır, ancak dosyanın bulunmadığından, kullanıcının izinleri olmadığından veya başka bir sorundan kaynaklanıp kaynaklanmadığını bilmez.
• Yeniden adlandırma yöntemi, platformlar arasında tutarlı bir şekilde çalışmadı.
• Sembolik bağlantılar için gerçek bir destek yoktu.
• Dosya izinleri, dosya sahibi ve diğer güvenlik öznitelikleri gibi meta veriler için daha fazla destek istendi. Dosya meta verilerine erişim yetersizdi.
• Dosya yöntemlerinin çoğu ölçeklendirilmedi. Bir sunucu üzerinden büyük bir dizin listesinin istenmesi askıda kalmaya neden olabilir. Büyük dizinler de bellek kaynağı sorunlarına neden olarak hizmet reddine neden olabilir.
• Dairesel sembolik bağlantılar varsa, bir dosya ağacında özyinelemeli olarak yürüyebilen ve uygun şekilde yanıt verebilecek güvenilir bir kod yazmak mümkün değildi.

Oh, bu java.io dosyasını geçersiz kılar. Bir dosya yazılamaz / eklenemezse, nedenini bile bilemeyebilirsiniz.

Eğiticiye bakmaya devam edebiliriz: https://docs.oracle.com/javase/tutorial/essential/io/file.html#common

Metin dosyasına önceden yazacağınız (ekleyeceğiniz) tüm satırlarınız varsa , önerilen yaklaşım https://docs.oracle.com/javase/8/docs/api/java/nio/file/Files.html# yazmaya karşı java.nio.file.Path-java.lang.Iterable-java.nio.charset.Charset-java.nio.file.OpenOption ...-

İşte bir örnek (basitleştirilmiş):

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

Başka bir örnek (ekle):

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

Dosya içeriğini istediğiniz gibi yazmak istiyorsanız : 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 ...-

Basitleştirilmiş örnek (Java 8 veya üstü):

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

Başka bir örnek (ekle):

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

Bu yöntemler yazar adına çok az çaba gerektirir ve [text] dosyalarına yazarken diğerlerine tercih edilmelidir.

Nispeten acısız bir deneyim yaşamak istiyorsanız, Apache Commons IO paketine , daha özel olarak FileUtilssınıfa da göz atabilirsiniz .

Üçüncü taraf kütüphanelerini asla kontrol etmeyi unutmayın. Tarih manipülasyonu için Joda-Time , yaygın dize işlemleri için Apache Commons LangStringUtils ve benzeri kodunuzu daha okunabilir hale getirebilir.

Java harika bir dildir, ancak standart kütüphane bazen biraz düşük seviyededir. Yine de güçlü, ancak düşük seviyeli.

Nedense oluşturma ve, Java eşdeğer yazma eylemini ayırmak istiyorsanız touch, IS

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()bir varlık denetimi yapar ve dosya atomik olarak oluşturur. Örneğin, dosyaya yazmadan önce dosyanın yaratıcısı olduğunuzdan emin olmak istiyorsanız bu yararlı olabilir.

Java'da dosya oluşturmanın ve yazmanın olası yollarından bazıları şunlardır:

FileOutputStream öğesini kullanma

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'ı kullanma

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'ı kullanma

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 Kullanımı

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

Daha fazla bilgi için Java'da dosya okuma ve yazma hakkında bu eğiticiye bakın .

kullanın:

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

En iyi yol Java7'yi kullanmaktır: Java 7, yeni bir yardımcı program sınıfı olan Files (Dosya) ile birlikte yeni bir çalışma sistemi sunar. Files sınıfını kullanarak dosya ve dizinler de oluşturabilir, taşıyabilir, kopyalayabilir, silebiliriz; ayrıca bir dosyayı okumak ve yazmak için de kullanılabilir.

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

    Files.write(path, strToBytes);
}

FileChannel ile yazma Büyük dosyalarla ilgileniyorsanız, FileChannel standart G / Ç'den daha hızlı olabilir. Aşağıdaki kod FileChannel kullanarak bir dosyaya String yazın:

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 ile yazma

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 ile yazma

Şimdi bir dosyaya ikili veri yazmak için FileOutputStream'i nasıl kullanabileceğimizi görelim. Aşağıdaki kod bir String int baytını dönüştürür ve bir FileOutputStream kullanarak baytları dosyaya yazar:

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

    outputStream.close();
}

PrintWriter ile yaz biz bir dosyaya biçimlendirilmiş metni yazmak için PrintWriter kullanabilirsiniz:

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 ile Yaz: kullanım BufferedWriter yeni bir dosya için bir Dize yazmak için:

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

    writer.close();
}

Varolan dosyaya bir Dize ekleyin:

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

    writer.close();
}

Bence bu en kısa yol:

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

Mevcut dosyanın üzerine yazmadan dosya oluşturmak için:

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

Sadece bir satır! pathve lineDizeler

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

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

Bulabildiğim en basit yol:

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

Muhtemelen sadece 1.7+ için çalışacaktır.

Java 7+ için denemeye değer:

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

Umut verici görünüyor ...

Java 7 ve üstünü kullanıyorsanız ve dosyaya eklenecek (eklenmiş) içeriği de biliyorsanız, NIO paketinde newBufferedWriter yöntemini kullanabiliriz .

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

Unutulmaması gereken birkaç nokta vardır:

1. Karakter kodlamasını belirtmek her zaman iyi bir alışkanlıktır ve bunun için sınıfta sabit kalıyoruz StandardCharsets .
2. Kod try-with-resource, denemeden sonra kaynakların otomatik olarak kapatıldığı ifadeyi kullanır .

OP sormasa da, belirli bir anahtar kelimeye sahip satırları aramak istediğimizde, örneğin confidentialJava'da akış API'lerini kullanabiliriz:

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

Giriş ve çıkış akışını kullanarak dosya okuma ve yazma:

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

Sadece bu paketi dahil et:

java.nio.file

Ve sonra dosyayı yazmak için bu kodu kullanabilirsiniz:

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

Java 8'de Dosyalar ve Yollar'ı ve kaynaklarla deneme yapısını kullanın.

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

Bazı basit yollar vardır, örneğin:

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

Kullandığınız işletim sisteminden bağımsız olacak bir sistem özelliğini kullanarak geçici bir dosya bile oluşturabilirsiniz .

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

Google'ın Guava kütüphanesini kullanarak, kolayca bir dosya oluşturabilir ve bu dosyaya yazabiliriz.

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

Örnek fruits.txt, proje kök dizininde yeni bir dosya oluşturur .

JFilechooser ile müşterilerle koleksiyon okuma ve dosyaya kaydetme.

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

Bir dosya oluşturmanın ve ona yazmanın en az birkaç yolu vardır:

Küçük dosyalar (1.7)

Bir dosyaya bayt veya satır yazmak için yazma yöntemlerinden birini kullanabilirsiniz.

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

Bu yöntemler, akışı açma ve kapatma gibi işinizin çoğunu halleder, ancak büyük dosyaları işlemek için tasarlanmamıştır.

Arabellek Akışı G / Ç Kullanarak Daha Büyük Dosya Yazma (1.7)

java.nio.filePaket destekler / I akış O tıkanıklık ki, tabakaların atlayarak I / O, tamponlar içinde hareket veri kanalı.

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

Bu yaklaşım, özellikle büyük miktarda yazma işlemini tamamlarken verimli performansı nedeniyle tercih edilir. Arabelleğe alınan işlemlerin, her bir bayt için işletim sisteminin yazma yöntemini çağırmaları gerekmediğinden, maliyetli G / Ç işlemlerini azaltarak bu etkiye sahiptir.

Outputstream (1.7) ile bir dosyayı kopyalamak (ve yeni bir tane oluşturmak) için NIO API'sini kullanma

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

Tüm baytların bir girdi akışından bir dosyaya kopyalanmasına izin veren ek yöntemler de vardır.

FileWriter (metin) (<1.7)

Doğrudan dosyaya yazar (daha az performans) ve yalnızca yazma sayısı daha az olduğunda kullanılmalıdır. Bir dosyaya karakter odaklı veri yazmak için kullanılır.

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

FileOutputStream (ikili) (<1,7)

FileOutputStream, görüntü verileri gibi ham bayt akışları yazmak içindir.

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

Bu yaklaşımla, bir seferde bir bayt yazmak yerine her zaman bir bayt dizisi yazmayı düşünmeliyiz. Hızlandırma oldukça önemli olabilir - 10 kat daha fazla veya daha fazla. Bu nedenle, write(byte[])mümkün olduğunda yöntemlerin kullanılması önerilir .