it-swarm.dev

어떻게 파일을 생성하고 Java로 파일을 만들었습니까?

자바로 (텍스트) 파일을 만들고 쓰는 가장 간단한 방법은 무엇입니까?

1266
Drew Johnson

아래의 각 코드 샘플은 IOException을 throw 할 수 있습니다. 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+ users는 Files class를 사용하여 파일에 쓸 수 있습니다.

텍스트 파일 만들기 :

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

이진 파일 만들기 :

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

자바 7 이상 :

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

유용한 유틸리티가 있습니다.

You can FileWriter을 사용하지만, 종종 나쁜 생각 인 기본 인코딩을 사용합니다. 인코딩을 명시 적으로 지정하는 것이 가장 좋습니다.

아래는 자바 이전의 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 포함).

390
Bozho

파일에 쓰고 싶은 컨텐트가 이미있는 경우 (즉석에서 생성되지는 않음) 원시 I/O의 일부로 Java 7에서 Java.nio.file.Files 를 추가하면 가장 간단하고 효율적인 방법으로 목표를 달성 할 수 있습니다 .

기본적으로 파일을 만들고 쓰는 것은 한 줄로, 더 나아가 하나의 간단한 메서드 호출 !

다음 예제는 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();
}
123
icza
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();
          }
        }
    }
}
71
Eric Petroelje

다음은 파일을 작성하거나 겹쳐 쓰는 예제 프로그램입니다. 긴 버전이므로 더 쉽게 이해할 수 있습니다.

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

용도:

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에서 도입되었습니다.

32
icl7126

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

참조 : Java에서 파일 작성 예제

31
Anuj Dhiman

텍스트 파일에 문자열을 입력합니다.

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

우리는 쉽게 새 파일을 만들고 그 안에 내용을 추가 할 수 있습니다.

18
iKing

저자는 EoL이 된 Java 버전에 대한 솔루션이 필요한지 여부를 지정하지 않았기 때문에 (Sun과 IBM 모두에서 기술적으로 가장 널리 사용되는 JVM 임) 사람들은 파일이 text (non-binary) 파일임을 지정하기 전에 저자의 질문에 대답 한 것 같습니다. 나는 대답을 제공하기로 결정했습니다.


우선, Java 6은 일반적으로 수명이 다했으며 저자가 레거시 호환성이 필요하다고 지정하지 않았기 때문에 자동으로 Java 7 이상을 의미한다고 생각합니다 (Java 7은 아직 EoL이 아닙니다) IBM). 따라서 파일 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("----------");
    [...]
}

이러한 방법은 저자가 최소한의 노력을 기울여야하며 [텍스트] 파일에 쓸 때 다른 모든 방법보다 선호해야합니다.

15
afk5min

비교적 통증이없는 경험을 원한다면 Apache Commons IO package , 좀 더 구체적으로 FileUtils class 를 살펴볼 수도 있습니다.

타사 라이브러리를 확인하는 것을 잊지 마십시오. Joda-Time 날짜 조작을 위해, Apache Commons Lang StringUtils 일반적인 문자열 연산 등으로 코드를 읽기 쉽게 만들 수 있습니다.

Java는 훌륭한 언어이지만 표준 라이브러리는 때로는 약간 낮은 수준입니다. 그럼에도 불구하고 강력하지만 낮은 수준.

15
extraneon

어떤 이유로 든 작성 및 작성 작업을 분리하려는 경우 touch과 동일한 Java가

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()은 존재 체크와 파일을 원자 적으로 만듭니다. 예를 들어, 파일을 작성하기 전에 파일을 작성했는지 확인하려는 경우에 유용 할 수 있습니다.

10
Mark Peters

용도:

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);
}
9
Rohit ZP

나는 이것이 가장 짧은 방법이라고 생각한다.

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

기존 파일을 덮어 쓰지 않고 파일을 만들려면 :

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

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

자세한 내용은이 튜토리얼의 How to Java에서 파일 읽기 및 쓰기 를 참조하십시오.

7
Mehdi
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();
        }
    }
}
6
Anurag Goel
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");
    }
}
6

한 줄만! pathline은 문자열입니다.

import Java.nio.file.Files;
import Java.nio.file.Paths;

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

내가 찾을 수있는 가장 간단한 방법은 다음과 같습니다.

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

아마도 1.7 이상에서만 작동합니다.

5
qed

가장 좋은 방법은 Java7을 사용하는 것입니다 : Java 7은 새로운 유틸리티 클래스 인 Files를 사용하여 파일 시스템 작업의 새로운 방식을 소개합니다. 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을 사용하여 String을 파일에 씁니다.

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

입력 및 출력 스트림을 사용한 파일 읽기 및 쓰기 :

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

이 패키지를 포함하기 만하면됩니다.

Java.nio.file

그런 다음이 코드를 사용하여 파일을 쓸 수 있습니다.

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

Java 7 이상을 사용해 볼 가치가 있습니다.

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

그것은 유망 해 보인다 ...

4
Olu Smith

Java 7 이상을 사용하고 파일에 추가 (추가) 할 내용을 알고 있으면 NIO 패키지에서 newBufferedWriter method를 사용할 수 있습니다.

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가 질문하지는 않았지만, 특정 키워드를 갖는 라인을 검색하고자하는 경우에 대비하여. confidential 자바에서 스트림 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();
}
4
i_am_zero

시스템 속성 을 사용하여 임시 파일을 만들 수도 있습니다.이 옵션은 사용중인 OS와 독립적입니다.

File file = new File(System.*getProperty*("Java.io.tmpdir") +
                     System.*getProperty*("file.separator") +
                     "YourFileName.txt");
3
Muhammed Sayeed

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

다음과 같은 간단한 방법이 있습니다.

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

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

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 파일을 만듭니다.

2
Jan Bodnar

샘플 파일 만들기 :

try {
    File file = new File ("c:/new-file.txt");
    if(file.createNewFile()) {
        System.out.println("Successful created!");
    }
    else {
        System.out.println("Failed to create!");
    }
}
catch (IOException e) {
    e.printStackTrace();
}
0
sultan