Как создать файл и записать его на Java?

в Java 7 и выше:

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

есть полезные утилиты для этого, хотя:

• пакета fileutils.writeStringtoFile(..) из commons-io
• файлы.писать.(.) из гуавы

обратите внимание также, что вы can использовать 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 добавление в 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();
    }
}

использование:

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.

очень простой способ создания и записи в файл на 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

здесь мы вводим строку в текстовый файл:

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

мы можем легко создать новый файл и добавить содержимое в него.

Если вы хотите иметь относительно безболезненный опыт, вы также можете взглянуть на Apache Commons IO пакет, точнее FileUtils класс.

никогда не забывайте проверять сторонние библиотеки. Joda Времени на сегодняшний день манипуляций, Apache Commons Lang StringUtils для общих строковых операций и таких может сделать ваш код более читаемым.

Java-отличный язык, но стандартная библиотека иногда немного низкоуровневый. Мощный, но все же низкий уровень.

поскольку автор не указал, требуется ли им решение для версий Java, которые были Eold (как Sun, так и IBM, и это технически самые распространенные JVMs), и из-за того, что большинство людей, похоже, ответили на вопрос автора, Прежде чем было указано, что это текст (не бинарные) файл, я решил предоставить свой ответ.

прежде всего, Java 6, как правило, достиг конца жизни, и так как автор не сделал укажите, что ему нужна устаревшая совместимость, я думаю, это автоматически означает Java 7 или выше (Java 7 еще не Eol'D IBM). Итак, мы можем посмотреть прямо на файл I/O учебник:https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

до выпуска Java SE 7, java.Ио.Класс File был механизм, используемый для ввода-вывода файлов, имел несколько недостатков.

• многие методы не создавали исключений, когда они терпели неудачу, поэтому это было невозможно получить сообщение об ошибке. Например, если файл ошибка удаления, программа получит "удалить сбой", но не знал бы, если бы это было потому, что файл не существовал, пользователь не есть разрешения, или была какая-то другая проблема.
• метод rename не работал последовательно на разных платформах.
• не было никакой реальной поддержки для символических ссылок.
• больше поддержка метаданных, например, файл разрешения, владелец файла и другие атрибуты безопасности. Подключение метаданные файлов неэффективны.
• многие методы файлов не масштабируются. Запрос большого списка каталогов через сервер может привести к висеть. Большие каталоги также могут вызвать проблемы с ресурсами памяти , что приводит к отказу в обслуживании.
• невозможно было написать надежный код, который может рекурсивно ходить по дереву файлов и отвечать соответственно, если бы были круговые символы связи.

Ну, это исключает java.Ио.Файл. Если файл не может быть записан / добавлен, вы можете даже не знать, почему.

мы можем продолжить просмотр учебника: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);

если вы хотите записать содержимое файла, как вы go: 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("----------");
    [...]
}

эти методы требуют минимальных усилий со стороны автора и должны быть предпочтительнее всех других при записи в [текстовые] файлы.

Если вы по какой-то причине хотите отделить акт создания и записи, эквивалент Java touch is

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() проверяет существование и создает файл атомарно. Это может быть полезно, если вы хотите убедиться, что вы были создателем файла перед записью в него, например.

использование:

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

Я думаю, что это самый короткий путь:

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 и выше, а также знаем содержимое, которое будет добавлено (добавлено) в файл, мы можем использовать newBufferedWriter метод в пакете NIO.

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. это всегда хорошая привычка, чтобы указать кодировку кодировки и для этого у нас есть константа в классе StandardCharsets.
2. код использует try-with-resource инструкция, в которой ресурсы автоматически закрываются после пытаться.

хотя OP не спрашивал, но на всякий случай мы хотим искать строки с определенным ключевым словом, например confidential мы можем использовать API потока в Java:

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

чтение и запись файлов с помощью input и outputstream:

//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 7+:

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

выглядит многообещающе...

для нескольких файлов вы можете использовать:

static void out(String[] name, String[] content) {

    File path = new File(System.getProperty("user.dir") + File.separator + "OUT");

    for (File file : path.listFiles())
        if (!file.isDirectory())
            file.delete();
    path.mkdirs();

    File c;

    for (int i = 0; i != name.length; i++) {
        c = new File(path + File.separator + name[i] + ".txt");
        try {
            c.createNewFile();
            FileWriter fiWi = new FileWriter(c.getAbsoluteFile());
            BufferedWriter buWi = new BufferedWriter(fiWi);
            buWi.write(content[i]);
            buWi.close();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

он отлично работает.

вот некоторые из возможных способов создания и записи файла на 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 .

есть несколько простых способов, как:

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

вы даже можете создать временный файл с помощью системное свойство, который будет независимо от того, какую ОС вы используете.

File file = new File(System.*getProperty*("java.io.tmpdir") +
                     System.*getProperty*("file.separator") +
                     "YourFileName.txt");

используя библиотеку Guava Google, мы можем создавать и записывать в файл очень легко.

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

лучший способ - использовать 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 для записи двоичных данных в файл. Следующий код преобразует строку int bytes и записывает байты в файл с помощью 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();
}

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