Java를 사용하여 문자열을 텍스트 파일로 저장하는 방법

Java에서는 "text"라는 String 변수에 텍스트 필드의 텍스트가 있습니다.

"text"변수의 내용을 파일로 저장하려면 어떻게해야합니까?

이진 데이터가 아닌 단순히 텍스트를 출력하는 경우 다음이 작동합니다.

PrintWriter out = new PrintWriter("filename.txt");

그런 다음 출력 스트림과 마찬가지로 문자열을 작성하십시오.

out.println(text);

언제나처럼 예외 처리가 필요합니다. out.close()쓰기가 끝나면 전화하십시오 .

Java 7 이상을 사용하는 경우 " try-with-resources 문 "을 사용 PrintStream하면 다음과 같이 완료했을 때 자동으로 닫힙니다 (예 : 블록 종료).

try (PrintWriter out = new PrintWriter("filename.txt")) {
    out.println(text);
}

여전히 java.io.FileNotFoundException이전 과 같이 명시 적으로 던져야합니다 .

Apache Commons IO 에는이를 수행하기위한 몇 가지 훌륭한 방법이 있으며 특히 FileUtils에는 다음과 같은 방법이 있습니다.

static void writeStringToFile(File file, String data) 

한 번의 메소드 호출로 파일에 텍스트를 쓸 수 있습니다.

FileUtils.writeStringToFile(new File("test.txt"), "Hello File");

파일 인코딩을 지정하는 것도 고려할 수 있습니다.

Java File API를 살펴보십시오

간단한 예 :

try (PrintStream out = new PrintStream(new FileOutputStream("filename.txt"))) {
    out.print(text);
}

Java 7에서는 다음을 수행 할 수 있습니다.

String content = "Hello File!";
String path = "C:/a.txt";
Files.write( Paths.get(path), content.getBytes());

여기에 더 많은 정보가 있습니다 : http://www.drdobbs.com/jvm/java-se-7-new-file-io/231600403

내 프로젝트에서 비슷한 것을했습니다. FileWriter 를 사용 하면 작업의 일부를 단순화 할 수 있습니다. 그리고 여기 당신은 좋은 튜토리얼을 찾을 수 있습니다 .

BufferedWriter writer = null;
try
{
    writer = new BufferedWriter( new FileWriter( yourfilename));
    writer.write( yourstring);

}
catch ( IOException e)
{
}
finally
{
    try
    {
        if ( writer != null)
        writer.close( );
    }
    catch ( IOException e)
    {
    }
}

Apache Commons IOFileUtils.writeStringToFile() 에서 사용합니다 . 이 특정 바퀴를 재발 명할 필요가 없습니다.

아래 코드 수정을 사용하여 텍스트를 처리하는 클래스 또는 함수에서 파일을 쓸 수 있습니다. 왜 세상에 새로운 텍스트 편집기가 필요한지 궁금합니다 ...

import java.io.*;

public class Main {

    public static void main(String[] args) {

        try {
            String str = "SomeMoreTextIsHere";
            File newTextFile = new File("C:/thetextfile.txt");

            FileWriter fw = new FileWriter(newTextFile);
            fw.write(str);
            fw.close();

        } catch (IOException iox) {
            //do stuff with exception
            iox.printStackTrace();
        }
    }
}

에서 자바 (11)java.nio.file.Files 클래스는 파일에 문자열을 작성하는 두 가지 새로운 유틸리티 방법으로 확장되었다. 첫 번째 방법 ( 여기 JavaDoc 참조 )은 문자셋 UTF-8 을 기본값으로 사용합니다.

Files.writeString(Path.of("my", "path"), "My String");

두 번째 방법 ( 여기서는 JavaDoc 참조 )을 통해 개별 문자 세트를 지정할 수 있습니다.

Files.writeString(Path.of("my", "path"), "My String", StandardCharset.ISO_8859_1);

두 가지 방법 모두 파일 처리 옵션을 설정하기위한 선택적 Varargs 매개 변수가 있습니다 (JavaDoc 여기 참조 ). 다음 예제는 존재하지 않는 파일을 작성하거나 기존 파일에 문자열을 추가합니다.

Files.writeString(Path.of("my", "path"), "String to append", StandardOpenOption.CREATE, StandardOpenOption.APPEND);

나는 이런 종류의 작업을 위해 가능할 때마다 라이브러리에 의존하는 것을 선호합니다. 이렇게하면 실수로 중요한 단계를 생략 할 가능성이 줄어 듭니다 (위의 wolfsnipes와 같은 실수). 일부 라이브러리는 위에서 제안되었지만 이러한 종류의 것들에 대해 내가 가장 좋아하는 것은 Google Guava 입니다. 구아바에는 이 작업에 잘 작동하는 파일 이라는 클래스가 있습니다 .

// This is where the file goes.
File destination = new File("file.txt");
// This line isn't needed, but is really useful 
// if you're a beginner and don't know where your file is going to end up.
System.out.println(destination.getAbsolutePath());
try {
    Files.write(text, destination, Charset.forName("UTF-8"));
} catch (IOException e) {
    // Useful error handling here
}

Apache Commons IO API를 사용하십시오. 간단 해

API를

 FileUtils.writeStringToFile(new File("FileNameToWrite.txt"), "stringToWrite");

메이븐 의존성

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
</dependency>

하나의 단일 문자열을 기반으로 텍스트 파일을 작성해야하는 경우 :

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

public class StringWriteSample {
    public static void main(String[] args) {
        String text = "This is text to be saved in file";

        try {
            Files.write(Paths.get("my-file.txt"), text.getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

이것을 사용하면 읽을 수 있습니다.

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

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

import java.io.*;

private void stringToFile( String text, String fileName )
 {
 try
 {
    File file = new File( fileName );

    // if file doesnt exists, then create it 
    if ( ! file.exists( ) )
    {
        file.createNewFile( );
    }

    FileWriter fw = new FileWriter( file.getAbsoluteFile( ) );
    BufferedWriter bw = new BufferedWriter( fw );
    bw.write( text );
    bw.close( );
    //System.out.println("Done writing to " + fileName); //For testing 
 }
 catch( IOException e )
 {
 System.out.println("Error: " + e);
 e.printStackTrace( );
 }
} //End method stringToFile

이 메소드를 클래스에 삽입 할 수 있습니다. 기본 메소드가있는 클래스에서이 메소드를 사용하는 경우 정적 키워드를 추가하여이 클래스를 정적으로 변경하십시오. 어느 쪽이든 java.io. *를 가져 와서 작동 시키려면 File, FileWriter 및 BufferedWriter가 인식되지 않습니다.

당신은 이것을 할 수 있습니다 :

import java.io.*;
import java.util.*;

class WriteText
{
    public static void main(String[] args)
    {   
        try {
            String text = "Your sample content to save in a text file.";
            BufferedWriter out = new BufferedWriter(new FileWriter("sample.txt"));
            out.write(text);
            out.close();
        }
        catch (IOException e)
        {
            System.out.println("Exception ");       
        }

        return ;
    }
};

사용 Java 7:

public static void writeToFile(String text, String targetFilePath) throws IOException
{
    Path targetPath = Paths.get(targetFilePath);
    byte[] bytes = text.getBytes(StandardCharsets.UTF_8);
    Files.write(targetPath, bytes, StandardOpenOption.CREATE);
}

org.apache.commons.io.FileUtils 사용 :

FileUtils.writeStringToFile(new File("log.txt"), "my string", Charset.defaultCharset());

한 블록의 텍스트를 파일로 푸시하는 것만 신경 쓰면 매번 덮어 씁니다.

JFileChooser chooser = new JFileChooser();
int returnVal = chooser.showSaveDialog(this);
if (returnVal == JFileChooser.APPROVE_OPTION) {
    FileOutputStream stream = null;
    PrintStream out = null;
    try {
        File file = chooser.getSelectedFile();
        stream = new FileOutputStream(file); 
        String text = "Your String goes here";
        out = new PrintStream(stream);
        out.print(text);                  //This will overwrite existing contents

    } catch (Exception ex) {
        //do something
    } finally {
        try {
            if(stream!=null) stream.close();
            if(out!=null) out.close();
        } catch (Exception ex) {
            //do something
        }
    }
}

이 예제에서는 사용자가 파일 선택기를 사용하여 파일을 선택할 수 있습니다.

무언가가 발생하는 경우를 대비하여 finally 블록에서 작성기 / 출력 스트림을 닫는 것이 좋습니다.

finally{
   if(writer != null){
     try{
        writer.flush();
        writer.close();
     }
     catch(IOException ioe){
         ioe.printStackTrace();
     }
   }
}

private static void generateFile(String stringToWrite, String outputFile) {
try {       
    FileWriter writer = new FileWriter(outputFile);
    writer.append(stringToWrite);
    writer.flush();
    writer.close();
    log.debug("New File is generated ==>"+outputFile);
} catch (Exception exp) {
    log.error("Exception in generateFile ", exp);
}

}

가장 좋은 방법은 다음을 사용하는 것 Files.write(Path path, Iterable<? extends CharSequence> lines, OpenOption... options)같습니다.

String text = "content";
Path path = Paths.get("path", "to", "file");
Files.write(path, Arrays.asList(text));

javadoc 참조 :

파일에 텍스트 줄을 씁니다. 각 줄은 문자 순서이며 시스템 속성 line.separator에 의해 정의 된대로 각 줄은 플랫폼의 줄 구분 기호로 끝나는 순서대로 파일에 기록됩니다. 지정된 문자 세트를 사용하여 문자가 바이트로 인코딩됩니다.

options 매개 변수는 파일을 작성하거나 여는 방법을 지정합니다. 옵션이 없으면이 메소드는 CREATE, TRUNCATE_EXISTING 및 WRITE 옵션이있는 것처럼 작동합니다. 즉, 파일을 작성하기 위해 파일을 열거 나 존재하지 않는 경우 파일을 만들거나 기존 일반 파일을 0 크기로 자릅니다.이 방법을 사용하면 모든 줄을 쓸 때 파일이 닫힙니다 ( 또는 I / O 오류 또는 기타 런타임 예외가 발생 함). I / O 오류가 발생하면 파일이 작성되거나 잘린 후 또는 일부 바이트가 파일에 기록 된 후에 오류가 발생할 수 있습니다.

양해 바랍니다. 사람들이 이미 Java의 내장 기능으로 Files.write응답 한 것을 보았지만 아무도 언급하지 않은 내 대답에서 특별한 것은 byte[]배열 대신 CharSequence의 Iterable (예 : String)을 취하는 메소드의 오버로드 된 버전 이므로 text.getBytes()필요하지 않습니다. 생각합니다.

문자열에서 파일로 캐리지 리턴 문자를 유지하려면 다음 코드 예제가 있습니다.

    jLabel1 = new JLabel("Enter SQL Statements or SQL Commands:");
    orderButton = new JButton("Execute");
    textArea = new JTextArea();
    ...


    // String captured from JTextArea()
    orderButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent ae) {
            // When Execute button is pressed
            String tempQuery = textArea.getText();
            tempQuery = tempQuery.replaceAll("\n", "\r\n");
            try (PrintStream out = new PrintStream(new FileOutputStream("C:/Temp/tempQuery.sql"))) {
                out.print(tempQuery);
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(tempQuery);
        }

    });

내 방식은 모든 Android 버전에서 실행되고 URL / URI와 같은 fecthing 리소스가 필요하기 때문에 스트림을 기반으로합니다. 제안은 환영합니다.

스트림 (InputStream 및 OutputStream)은 개발자가 스트림에 문자열을 쓰려고 할 때 먼저 이진 데이터를 바이트로 변환하거나 다른 말로 인코딩해야합니다.

public boolean writeStringToFile(File file, String string, Charset charset) {
    if (file == null) return false;
    if (string == null) return false;
    return writeBytesToFile(file, string.getBytes((charset == null) ? DEFAULT_CHARSET:charset));
}

public boolean writeBytesToFile(File file, byte[] data) {
    if (file == null) return false;
    if (data == null) return false;
    FileOutputStream fos;
    BufferedOutputStream bos;
    try {
        fos = new FileOutputStream(file);
        bos = new BufferedOutputStream(fos);
        bos.write(data, 0, data.length);
        bos.flush();
        bos.close();
        fos.close();
    } catch (IOException e) {
        e.printStackTrace();
        Logger.e("!!! IOException");
        return false;
    }
    return true;
}

ArrayList를 사용하여 예를 들어 TextArea의 모든 내용을 입력하고 저장기를 호출하여 매개 변수로 보낼 수 있습니다. 라이터는 방금 문자열 행을 쓴 다음 줄마다 "for"를 사용하여 끝에 ArrayList를 씁니다. 우리는 txt 파일의 내용 TextArea가 될 것입니다. 말이 안된다면 Google 번역가와 영어를 못하는 사람이 유감입니다.

Windows 메모장을보십시오. 항상 줄을 넘기는 것은 아니며 한 줄에 모두 표시되는 경우에는 Wordpad를 사용하십시오.

private void SaveActionPerformed(java.awt.event.ActionEvent evt) {

    String NameFile = Name.getText();
    ArrayList< String > Text = new ArrayList< String >();

    Text.add(TextArea.getText());

    SaveFile(NameFile, Text);
}

public void SaveFile(String name, ArrayList< String> message) {

    path = "C:\\Users\\Paulo Brito\\Desktop\\" + name + ".txt";

    File file1 = new File(path);

    try {

        if (!file1.exists()) {

            file1.createNewFile();
        }


        File[] files = file1.listFiles();


        FileWriter fw = new FileWriter(file1, true);

        BufferedWriter bw = new BufferedWriter(fw);

        for (int i = 0; i < message.size(); i++) {

            bw.write(message.get(i));
            bw.newLine();
        }

        bw.close();
        fw.close();

        FileReader fr = new FileReader(file1);

        BufferedReader br = new BufferedReader(fr);

        fw = new FileWriter(file1, true);

        bw = new BufferedWriter(fw);

        while (br.ready()) {

            String line = br.readLine();

            System.out.println(line);

            bw.write(line);
            bw.newLine();

        }
        br.close();
        fr.close();

    } catch (IOException ex) {
        ex.printStackTrace();
        JOptionPane.showMessageDialog(null, "Error in" + ex);     
    }   
}