파일을 작성하여 Java로 작성하는 방법

Java에서 (텍스트) 파일을 작성하고 쓰는 가장 간단한 방법은 무엇입니까?

아래의 각 코드 샘플은 throw 될 수 있습니다 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에 추가하면 목표를 달성하는 가장 간단하고 효율적인 방법을 제공합니다.

기본적으로 파일을 작성하고 쓰는 것은 한 줄로, 하나의 간단한 메소드 호출입니다 !

다음 예제는 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에 사용 된 메커니즘 이었지만 몇 가지 단점이있었습니다.

• 많은 메소드가 실패했을 때 예외를 발생시키지 않았으므로 유용한 오류 메시지를 얻는 것이 불가능했습니다. 예를 들어, 파일 삭제에 실패한 경우 프로그램은 "삭제 실패"를 수신하지만 파일이 존재하지 않거나 사용자에게 권한이 없거나 다른 문제가 있는지 여부를 알 수 없습니다.
• 여러 플랫폼에서 이름 바꾸기 방법이 일관되게 작동하지 않았습니다.
• 심볼릭 링크는 실제로 지원되지 않았습니다.
• 파일 권한, 파일 소유자 및 기타 보안 속성과 같은 메타 데이터에 대한 추가 지원이 필요했습니다. 파일 메타 데이터에 액세스하는 것이 비효율적이었습니다.
• 많은 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 동등 작성하는 행위를 구분합니다 touchIS를

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을 사용하여 이진 데이터를 파일에 쓰는 방법을 알아 보겠습니다. 다음 코드는 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");
    }
}

한 줄만! 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 인코딩을 지정하는 것은 항상 좋은 습관이며 class에 상수가 있습니다 StandardCharsets.
2. 코드는 try-with-resource시도 후 리소스가 자동으로 닫히는 문을 사용 합니다.

OP는 요청하지 않았지만 특정 키워드가있는 행을 검색하려는 경우를 대비 confidential하여 Java에서 스트림 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)

write 메소드 중 하나를 사용하여 파일에 바이트 또는 라인을 쓸 수 있습니다.

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

이 방법은 특히 많은 양의 쓰기 작업을 완료 할 때 효율적인 성능으로 인해 우선적입니다. 버퍼링 된 작업은 모든 단일 바이트에 대해 운영 체제의 쓰기 메소드를 호출 할 필요가 없으므로 비용이 많이 드는 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();

이 방법을 사용하면 한 번에 한 바이트를 쓰는 대신 항상 바이트 배열을 쓰는 것이 좋습니다. 속도는 최대 10 배 이상으로 상당히 중요합니다. 따라서 write(byte[])가능할 때마다 방법 을 사용하는 것이 좋습니다 .