Wat is de eenvoudigste manier om een (tekst)bestand te maken en naar een (tekst)bestand te schrijven op Java?
Antwoord 1, autoriteit 100%
Houd er rekening mee dat elk van de onderstaande codevoorbeelden IOExceptionkan veroorzaken. Try/catch/finally-blokken zijn voor de beknoptheid weggelaten. Zie deze tutorialvoor informatie over het afhandelen van uitzonderingen.
Houd er rekening mee dat elk van de onderstaande codevoorbeelden het bestand zal overschrijven als het al bestaat
Een tekstbestand maken:
PrintWriter writer = new PrintWriter("the-file-name.txt", "UTF-8");
writer.println("The first line");
writer.println("The second line");
writer.close();
Een binair bestand maken:
byte data[] = ...
FileOutputStream out = new FileOutputStream("the-file-name");
out.write(data);
out.close();
Java 7+gebruikers kunnen de Filesklasse om naar bestanden te schrijven:
Een tekstbestand maken:
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);
Een binair bestand maken:
byte data[] = ...
Path file = Paths.get("the-file-name");
Files.write(file, data);
//Files.write(file, data, StandardOpenOption.APPEND);
Antwoord 2, autoriteit 24%
In Java 7 en hoger:
try (Writer writer = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream("filename.txt"), "utf-8"))) {
writer.write("something");
}
Daar zijn echter handige hulpprogramma’s voor:
- FileUtils.writeStringtoFile(..)van commons-io
- Files.write(..)van guave
Houd er ook rekening mee dat u kaneen FileWritergebruiken, maar deze gebruikt de standaardcodering, wat vaak een slecht idee is – u kunt de codering het beste expliciet specificeren.
p>
Hieronder staat het originele antwoord vóór 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*/}
}
Zie ook: Bestanden lezen, schrijven en maken(inclusief NIO2).
Antwoord 3, autoriteit 8%
Als je de inhoud die je naar het bestand wilt schrijven al hebt (en niet direct gegenereerd), de java.nio.file.Filestoevoeging in Java 7 als onderdeel van native I/O biedt de eenvoudigste en meest efficiënte manier om uw doelen te bereiken .
Het maken van en schrijven naar een bestand is slechts één regel, bovendien één eenvoudige methodeaanroep!
Het volgende voorbeeld maakt en schrijft naar 6 verschillende bestanden om te laten zien hoe het kan worden gebruikt:
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();
}
Antwoord 4, autoriteit 4%
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();
}
}
}
}
5, Autoriteit 3%
Een zeer eenvoudige manier om een bestand in Java te maken en te schrijven:
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);
}
}
}
6, Autoriteit 2%
Hier is een klein voorbeeldsprogramma om een bestand te maken of te overschrijven. Het is de lange versie, zodat het gemakkelijker kan worden begrepen.
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();
}
}
Antwoord 7, autoriteit 2%
Gebruik:
try (Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("myFile.txt"), StandardCharsets.UTF_8))) {
writer.write("text to write");
}
catch (IOException ex) {
// Handle me
}
Als je try()gebruikt, wordt de stream automatisch gesloten. Deze versie is kort, snel (gebufferd) en maakt het mogelijk om codering te kiezen.
Deze functie is geïntroduceerd in Java 7.
Antwoord 8
Hier voeren we een string in een tekstbestand in:
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
We kunnen eenvoudig een nieuw bestand maken en er inhoud aan toevoegen.
Antwoord 9
Als je een relatief pijnloze ervaring wilt hebben, kun je ook het Apache Commons IO-pakket bekijken , meer specifiek de FileUtilsklasse.
Vergeet nooit bibliotheken van derden te controleren. Joda-Timevoor datummanipulatie, Apache Commons Lang StringUtilsvoor algemene tekenreeksbewerkingen en dergelijke kunnen uw code leesbaarder maken.
Java is een geweldige taal, maar de standaardbibliotheek is soms een beetje laagdrempelig. Krachtig, maar toch laagdrempelig.
Antwoord 10
Omdat de auteur niet heeft aangegeven of ze een oplossing nodig hebben voor Java-versies die EoL’d zijn (zowel door Sun als IBM, en dit zijn technisch gezien de meest voorkomende JVM’s), en vanwege het feit dat de meeste mensen de vraag van de auteur heb beantwoord voordat werd gespecificeerd dat het een tekst (niet-binair)bestand is, heb ik besloten mijn antwoord te geven.
Allereerst heeft Java 6 over het algemeen het einde van zijn levensduur bereikt, en aangezien de auteur niet heeft aangegeven dat hij legacy-compatibiliteit nodig heeft, denk ik dat dit automatisch Java7 of hoger betekent (Java7 is nog niet ge-eoL’d door IBM ). We kunnen dus direct naar de I/O-zelfstudie voor bestanden kijken: https:/ /docs.oracle.com/javase/tutorial/essential/io/legacy.html
Voor de release van Java SE 7 was de klasse java.io.File de
mechanisme gebruikt voor bestands-I/O, maar het had verschillende nadelen.
- Veel methoden leverden geen uitzonderingen op als ze faalden, dus dat was het wel
onmogelijk om een bruikbare foutmelding te krijgen. Als bijvoorbeeld een bestand
verwijderen mislukt, zou het programma een “delete fail” ontvangen, maar
zou niet weten of het was omdat het bestand niet bestond, de gebruiker niet
machtigingen hebben, of er was een ander probleem.- De methode voor hernoemen
werkte niet consistent op alle platforms.- Er was geen echte steun
voor symbolische links.- Meer ondersteuning voor metadata was gewenst, zoals:
bestandsmachtigingen, bestandseigenaar en andere beveiligingskenmerken. Toegang tot
bestandsmetadata was inefficiënt.- Veel van de bestandsmethoden zijn niet geschaald.
Het aanvragen van een grote directoryvermelding via een server kan resulteren in een:
hangen. Grote mappen kunnen ook problemen met geheugenbronnen veroorzaken,
resulterend in een denial of service.- Het was niet mogelijk om te schrijven
betrouwbare code die recursief een bestandsboom kan doorlopen en kan reageren
gepast als er cirkelvormige symbolische links waren.
Ach, dat sluit java.io.File uit. Als een bestand niet kan worden geschreven/toegevoegd, weet je misschien niet eens waarom.
We kunnen verder kijken naar de tutorial: https:// docs.oracle.com/javase/tutorial/essential/io/file.html#common
Als u alle regels heeft die u van tevoren aan het tekstbestand zult schrijven (toevoegen), is de aanbevolen aanpak
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…-
Hier is een voorbeeld (vereenvoudigd):
Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, StandardCharsets.UTF_8);
Nog een voorbeeld (toevoegen):
Path file = ...;
List<String> linesInMemory = ...;
Files.write(file, linesInMemory, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE);
Als je bestandsinhoud onderweg wilt schrijven:
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…-
Vereenvoudigd voorbeeld (Java 8 of hoger):
Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file)) {
writer.append("Zero header: ").append('0').write("\r\n");
[...]
}
Nog een voorbeeld (toevoegen):
Path file = ...;
try (BufferedWriter writer = Files.newBufferedWriter(file, Charset.forName("desired charset"), StandardOpenOption.CREATE, StandardOpenOption.APPEND, StandardOpenOption.WRITE)) {
writer.write("----------");
[...]
}
Deze methoden vergen minimale inspanning van de auteur en zouden de voorkeur moeten hebben boven alle andere bij het schrijven naar [tekst]-bestanden.
Antwoord 11
Hier zijn enkele van de mogelijke manieren om een bestand in Java te maken en te schrijven:
FileOutputStream gebruiken
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 gebruiken
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 gebruiken
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 gebruiken
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();
}
Raadpleeg voor meer informatie deze tutorial over het lezen en schrijf bestanden in Java.
Antwoord 12
Als u om een of andere reden de handeling van het maken en schrijven wilt scheiden, is het Java-equivalent van touch
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()Creëer een bestaande controle en bestand atomisch. Dit kan handig zijn als u ervoor wilt zorgen dat u de maker van het bestand was voordat u ertoe aanschrijft, bijvoorbeeld.
13
Gebruik:
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);
}
14
beste manier is om Java7 te gebruiken:
Java 7 introduceert een nieuwe manier van werken met het bestandssysteem, samen met een nieuwe hulpprogramma’s – bestanden. Met behulp van de klasse Bestanden kunnen we ook kunnen maken, verplaatsen, kopiëren, verwijderen, verwijderen en mappen; Het kan ook worden gebruikt om een bestand te lezen en te schrijven.
public void saveDataInFile(String data) throws IOException {
Path path = Paths.get(fileName);
byte[] strToBytes = data.getBytes();
Files.write(path, strToBytes);
}
Schrijf met Filechannel
Als u te maken hebt met grote bestanden, kan Filechannel sneller zijn dan standaard io. De volgende code Schrijf string naar een bestand met behulp van 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();
}
Schrijven met 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();
}
schrijven met bestandoutputstream
Laten we nu zien hoe we FileoutPutStream kunnen gebruiken om binaire gegevens naar een bestand te schrijven. De volgende code converteert een tekenreeks en schrijft de bytes om te besturen met behulp van een bestandoutputstream:
public void saveDataInFile(String data) throws IOException {
FileOutputStream outputStream = new FileOutputStream(fileName);
byte[] strToBytes = data.getBytes();
outputStream.write(strToBytes);
outputStream.close();
}
schrijven met printwriter
We kunnen een printwriter gebruiken om opgemaakte tekst naar een bestand te schrijven:
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();
}
Schrijf met BufferedWriter:
gebruik BufferedWriter om een string naar een nieuw bestand te schrijven:
public void saveDataInFile(String data) throws IOException {
BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));
writer.write(data);
writer.close();
}
voeg een string toe aan het bestaande bestand:
public void saveDataInFile(String data) throws IOException {
BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true));
writer.append(' ');
writer.append(data);
writer.close();
}
Antwoord 15
Ik denk dat dit de kortste weg is:
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();
Antwoord 16
Om een bestand aan te maken zonder het bestaande bestand te overschrijven:
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
}
Antwoord 17
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();
}
}
}
Antwoord 18
Het is het proberen waard voor Java 7+:
Files.write(Paths.get("./output.txt"), "Information string herer".getBytes());
Het ziet er veelbelovend uit…
Antwoord 19
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");
}
}
20
De eenvoudigste manier die ik kan vinden:
Path sampleOutputPath = Paths.get("/tmp/testfile")
try (BufferedWriter writer = Files.newBufferedWriter(sampleOutputPath)) {
writer.write("Hello, world!");
}
Het werkt waarschijnlijk alleen voor 1,7 +.
21
Gebruik in Java 8 bestanden en paden en gebruik het gebruik van 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
}
}
22
Alleen één regel!
pathen lineZIJN STRINGEN
import java.nio.file.Files;
import java.nio.file.Paths;
Files.write(Paths.get(path), lines.getBytes());
Antwoord 23
Bestand lezen en schrijven met input en 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");
}
}
}
Antwoord 24
Voeg dit pakket gewoon toe:
java.nio.file
En dan kun je deze code gebruiken om het bestand te schrijven:
Path file = ...;
byte[] buf = ...;
Files.write(file, buf);
Antwoord 25
Als we Java 7 en hoger gebruiken en ook weten welke inhoud aan het bestand moet worden toegevoegd (bijgevoegd), kunnen we gebruik maken van newBufferedWritermethode in NIO-pakket.
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();
}
}
Er zijn enkele aandachtspunten:
- Het is altijd een goede gewoonte om tekensetcodering te specificeren en daarvoor hebben we constante
StandardCharsetsin de klas. - De code gebruikt de instructie
try-with-resourcewaarin bronnen automatisch worden gesloten na de try.
Hoewel OP niet heeft gevraagd, maar voor het geval we willen zoeken naar regels met een specifiek trefwoord, b.v. confidentialwe kunnen gebruik maken van stream-API’s in 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();
}
Antwoord 26
Er zijn enkele eenvoudige manieren, zoals:
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();
Antwoord 27
Je kunt zelfs een tijdelijk bestand maken met een systeemeigenschap, die onafhankelijk is van het besturingssysteem dat je gebruikt.
File file = new File(System.*getProperty*("java.io.tmpdir") +
System.*getProperty*("file.separator") +
"YourFileName.txt");
28
Met Google’s Guava-bibliotheek kunnen we een bestand maken en schrijven
gemakkelijk.
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);
}
}
Het voorbeeld maakt een nieuwe fruits.txtbestand in de hoofddirectory van het project.
29
Verzameling lezen met klanten en opslaan in het bestand, met 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();
}
}
}