Bir dizeyi Java kullanarak bir metin dosyasına nasıl kaydedebilirim?

Java, "metin" adlı bir String değişkeni bir metin alanından metin var.

"Metin" değişkeninin içeriğini bir dosyaya nasıl kaydedebilirim?

Herhangi bir ikili veri yerine metin çıktısı alıyorsanız, aşağıdakiler işe yarar:

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

Ardından, herhangi bir çıktı akışında yaptığınız gibi Dizenizi ona yazın:

out.println(text);

Her zamanki gibi istisna işlemeye ihtiyacınız olacak. out.close()Yazmayı bitirdiğinizde aradığınızdan emin olun .

Java 7 veya üstünü kullanıyorsanız, işiniz bittiğinde (yani bloktan çıktığınızda) otomatik olarak kapanacak olan " kaynaklarla dene " ifadesini kullanabilirsiniz PrintStream:

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

Yine de java.io.FileNotFoundExceptiondaha önce olduğu gibi açıkça atmanız gerekir .

Apache Commons IO bunu yapmak için bazı harika yöntemler içerir, özellikle FileUtils aşağıdaki yöntemi içerir:

static void writeStringToFile(File file, String data) 

bir yöntem çağrısında dosyaya metin yazmanıza olanak tanır:

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

Ayrıca, dosyanın kodlamasını da belirlemeyi düşünebilirsiniz.

Java Dosya API'sına bir göz atın

hızlı bir örnek:

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

Java 7'de şunları yapabilirsiniz:

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

Burada daha fazla bilgi var: http://www.drdobbs.com/jvm/java-se-7-new-file-io/231600403

Projemde benzer bir şey yaptım. Kullanım FileWriter işinizin parça basitleştirecek. Ve burada güzel bir öğretici bulabilirsiniz .

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

Kullanım FileUtils.writeStringToFile()gelen Apache Commons IO . Bu tekerleği yeniden icat etmeye gerek yok.

Dosyanızı herhangi bir sınıf veya işlev metnin işlediği herhangi bir sınıftan yazmak için aşağıdaki kodu değiştirin. Biri dünyanın neden yeni bir metin editörüne ihtiyacı olduğunu merak ediyor ...

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

In Java 11java.nio.file.Files sınıf bir dosyaya bir dize yazmak için iki yeni yardımcı program yöntemleri ile uzatıldı. İlk yöntem ( buradaki JavaDoc'a bakın ) varsayılan olarak UTF-8 karakter kümesini kullanır :

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

Ve ikinci yöntem ( buradaki JavaDoc'a bakın ) ayrı bir karakter seti belirtmeye izin verir:

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

Her iki yöntem de (JavaDoc'u bkz seçenekleri ele dosyayı ayarı için isteğe bağlı varargs parametresine sahip burada ). Aşağıdaki örnek, var olmayan bir dosya oluşturur veya dizeyi var olan bir dosyaya ekler:

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

Bu tür bir işlem için mümkün olduğunda kütüphanelere güvenmeyi tercih ederim. Bu, yanlışlıkla önemli bir adımı atlamamı daha az olası hale getirir (yukarıda yapılan hatalar gibi). Yukarıda bazı kütüphaneler önerilmektedir, ancak bu tür şeyler için en sevdiğim Google Guava . Guava'nın bu görev için güzel çalışan Dosyalar adlı bir sınıfı var :

// 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 kullanın. Basit

API'yı şu şekilde kullanın:

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

Maven Bağımlılığı

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

Tek bir dizeye dayalı olarak metin dosyası oluşturmanız gerekirse:

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

Bunu kullanın, çok okunabilir:

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

Bu yöntemi sınıflarınıza ekleyebilirsiniz. Bu yöntemi ana yöntemle bir sınıfta kullanıyorsanız, statik anahtar kelimesini ekleyerek bu sınıfı statik olarak değiştirin. Her iki durumda da java.io. * dosyasını içe aktarmanız gerekir, aksi takdirde File, FileWriter ve BufferedWriter tanınmaz.

Bunu yapabilirsin:

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

Kullanma 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 kullanma:

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

Yalnızca bir metin bloğunu dosyaya aktarmayı önemsiyorsanız, her seferinde metnin üzerine yazılacaktır.

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

Bu örnek, kullanıcının bir dosya seçici kullanarak bir dosya seçmesine izin verir.

Bir şey olması durumunda, yazarı / çıktı akışını nihayet bir blokta kapatmak daha iyidir

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

}

Bence en iyi yolu kullanıyor 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));

Bkz. Javadoc :

Bir dosyaya metin satırları yazın. Her satır bir karakter dizisidir ve sistem özelliği line.separator tarafından tanımlandığı şekilde platformun satır ayırıcısı tarafından sonlandırılan her satırla dosyaya sırayla yazılır. Karakterler, belirtilen karakter seti kullanılarak baytlara kodlanır.

Options parametresi dosyanın nasıl oluşturulacağını veya açılacağını belirtir. Hiçbir seçenek yoksa, bu yöntem CREATE, TRUNCATE_EXISTING ve WRITE seçenekleri varmış gibi çalışır. Başka bir deyişle, dosyayı yazmak, açmak durumunda oluşturmak veya başlangıçta varolan bir normal dosyayı 0 boyutuna kısaltmak için açar. Yöntem, tüm satırlar yazıldığında dosyanın kapatılmasını sağlar ( veya bir G / Ç hatası veya başka bir çalışma zamanı istisnası atılır). Bir G / Ç hatası oluşursa, dosya oluşturulduktan veya kesildikten veya dosyaya bazı baytlar yazıldıktan sonra bunu yapabilir.

Lütfen aklınızda bulundurun. İnsanların Java'nın yerleşik Files.writekodlarıyla zaten yanıt verdiğini görüyorum, ancak cevabımda kimsenin bahsetmediği özel olan şey, bir byte[]dizi yerine CharSequence (yani Dize) Yinelenebilir alan yöntemin aşırı yüklenmiş sürümüdür , bu nedenle text.getBytes()gerekli değildir Sanırım biraz daha temiz.

Satır başı karakterlerini dizeden bir dosyaya tutmak istiyorsanız, burada bir kod örneğidir:

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

    });

Yolum, tüm Android sürümlerinde ve URL / URI gibi fecthing kaynaklarının ihtiyaçları nedeniyle akışa dayanıyor, herhangi bir öneri kabul edilir.

İlgili olarak, akışlar (InputStream ve OutputStream), geliştirici bir akışa bir dize yazmaya gittiğinde, önce bayt'a dönüştürmeli veya başka bir deyişle onu kodlamalıdır.

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

Örnek için TextArea öğesinin tüm içeriğini koymak için ArrayList'i kullanabilir ve yazar dize satırları yazdığı için save komutunu kullanarak parametre olarak gönderebilirsiniz. txt dosyasında TextArea içeriği olacağız. bir şey mantıklı değilse, üzgünüm google çevirmen ve ben İngilizce konuşmayan.

Windows Not Defteri'ni izleyin, her zaman satır atlamaz ve tümünü tek bir satırda gösterir, Wordpad'i kullanın.

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