Javaでファイルを作成して書き込む方法を教えてください。

Javaで（テキスト）ファイルを作成して書き込む最も簡単な方法は何ですか？

以下の各コードサンプルがスローする場合があることに注意してくださいIOException。簡潔にするため、try / catch / finallyブロックは省略されています。例外処理については、このチュートリアルを参照してください。

以下の各コードサンプルは、ファイルが既に存在する場合、ファイルを上書きすることに注意してください。

テキストファイルの作成：

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

ただし、そのための便利なユーティリティがあります。

• commons-ioのFileUtils.writeStringtoFile（..）
• グアバの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ネイティブI / Oの一部としてJava 7に追加すると、目標を達成するための最も単純で最も効率的な方法が提供されます。

基本的に、ファイルの作成とファイルへの書き込みは1行だけであり、さらに1つの単純なメソッド呼び出しです！

次の例では、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

新しいファイルを簡単に作成して、コンテンツを追加できます。

著者はEoLされたJavaバージョン（SunとIBMの両方によるものであり、これらは技術的に最も広く普及しているJVMです）のソリューションが必要かどうかを指定しなかったため、ほとんどの人が答えたようですそれがテキスト（非バイナリ）ファイルであると指定される前の作者の質問、私は私の答えを提供することにしました。

まず第一に、Java 6は一般に寿命に達しており、著者がレガシー互換性が必要であると指定しなかったので、それは自動的にJava 7以上を意味すると思います（Java 7はまだIBMによってEoLされていません）。したがって、ファイルI / Oチュートリアルを正しく見ることができます：https : //docs.oracle.com/javase/tutorial/essential/io/legacy.html

Java SE 7リリース以前は、java.io.FileクラスはファイルI / Oに使用されるメカニズムでしたが、いくつかの欠点がありました。

• 多くのメソッドは、失敗しても例外をスローしなかったため、有用なエラーメッセージを取得できませんでした。たとえば、ファイルの削除に失敗した場合、プログラムは「削除失敗」を受け取りますが、ファイルが存在しないか、ユーザーに権限がないか、またはその他の問題が原因であるかどうかはわかりません。
• renameメソッドは、プラットフォーム間で一貫して機能しませんでした。
• シンボリックリンクの実際のサポートはありませんでした。
• ファイルのアクセス許可、ファイルの所有者、その他のセキュリティ属性など、メタデータのサポートがさらに必要でした。ファイルのメタデータへのアクセスは非効率的でした。
• 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.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 IOパッケージ、より具体的には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を使用することです。Java7 では、ファイルシステムを操作する新しい方法と、新しいユーティリティクラスであるファイルを導入しています。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を使用してバイナリデータをファイルに書き込む方法を見てみましょう。次のコードは、String 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");
    }
}

1行のみ！ 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以降を使用していて、ファイルに追加（追加）されるコンテンツも知っている場合は、NIOパッケージのnewBufferedWriterメソッドを利用できます。

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. charsetエンコーディングを指定することは常に良い習慣であり、そのためにはクラスに定数がありStandardCharsetsます。
2. コードはtry-with-resource、試行後にリソースが自動的に閉じられるステートメントを使用します。

OPは尋ねていませんが、特定のキーワードを持つ行を検索する場合に備えて、たとえばconfidentialJavaでストリームAPIを利用できます。

//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では、ファイルとパスを使用し、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
    }
}

次のような簡単な方法があります。

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

使用しているOSに依存しないシステムプロパティを使用して一時ファイルを作成することもできます。

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）

書き込みメソッドの1つを使用して、バイトまたは行をファイルに書き込むことができます。

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

これらのメソッドは、ストリームの開閉など、ほとんどの作業を処理しますが、大きなファイルを処理するためのものではありません。

バッファストリームI / Oを使用した大きなファイルの書き込み（1.7）

このjava.nio.fileパッケージは、ストリームI / Oをボトルネックにする可能性があるいくつかのレイヤーをバイパスして、バッファー内のデータを移動するチャネル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());
}

このアプローチは、特に大量の書き込み操作を完了する場合の効率的なパフォーマンスのために優先されます。バッファリングされた操作は、1バイトごとにオペレーティングシステムの書き込みメソッドを呼び出す必要がないため、この効果があり、コストのかかるI / O操作を削減します。

NIO APIを使用して、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);
}

入力ストリームからファイルにすべてのバイトをコピーできるようにする追加のメソッドもあります。

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

このアプローチでは、一度に1バイトを書き込むのではなく、常にバイトの配列を書き込むことを検討する必要があります。スピードアップは非常に重要です-最大で10倍以上。したがって、write(byte[])可能な限りメソッドを使用することをお勧めします。