java - मैं जावा में फ़ाइल कैसे बना सकता हूं और इसे लिख सकता हूं?




file-io (20)

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

इनपुट और आउटपुटस्ट्रीम का उपयोग करके फ़ाइल पढ़ने और लिखना:

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

उपयोग:

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

एक नमूना फ़ाइल बनाना:

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

कई फाइलों के लिए आप इसका उपयोग कर सकते हैं:

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

यह बहुत अच्छा काम कर रहा है।


केवल एक पंक्ति! path और line स्ट्रिंग्स हैं

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

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

चूंकि लेखक ने यह निर्दिष्ट नहीं किया है कि उन्हें जावा संस्करणों के लिए समाधान की आवश्यकता है जो ईओएलएड (सूर्य और आईबीएम दोनों द्वारा, और ये तकनीकी रूप से सबसे व्यापक जेवीएम हैं), और इस तथ्य के कारण कि ज्यादातर लोगों ने जवाब दिया है लेखक के प्रश्न से पहले यह निर्दिष्ट किया गया था कि यह एक पाठ (गैर-बाइनरी) फ़ाइल है, मैंने अपना उत्तर देने का निर्णय लिया है।

सबसे पहले, जावा 6 आम तौर पर जीवन के अंत तक पहुंच गया है, और चूंकि लेखक ने निर्दिष्ट नहीं किया है कि उसे विरासत संगतता की आवश्यकता है, मुझे लगता है कि इसका स्वचालित रूप से जावा 7 या उससे ऊपर का मतलब है (जावा 7 अभी तक आईबीएम द्वारा नहीं किया गया है)। इसलिए, हम फ़ाइल I / O ट्यूटोरियल पर सही देख सकते हैं: https://docs.oracle.com/javase/tutorial/essential/io/legacy.html

जावा एसई 7 रिलीज से पहले, java.io.File क्लास फ़ाइल I / O के लिए उपयोग की गई तंत्र थी, लेकिन इसमें कई कमीएं थीं।

  • विफल होने पर कई विधियों ने अपवाद नहीं फेंक दिए, इसलिए उपयोगी त्रुटि संदेश प्राप्त करना असंभव था। उदाहरण के लिए, यदि कोई फ़ाइल हटाना विफल हो गया है, तो प्रोग्राम को "असफल डिलीट" प्राप्त होगा, लेकिन यह नहीं पता होगा कि यह क्यों था क्योंकि फ़ाइल मौजूद नहीं थी, उपयोगकर्ता को अनुमति नहीं थी, या कोई अन्य समस्या थी।
  • नामकरण विधि प्लेटफॉर्म पर लगातार काम नहीं करती है।
  • प्रतीकात्मक लिंक के लिए कोई वास्तविक समर्थन नहीं था।
  • मेटाडेटा के लिए अधिक समर्थन वांछित था, जैसे फ़ाइल अनुमतियां, फ़ाइल स्वामी, और अन्य सुरक्षा विशेषताओं। फ़ाइल मेटाडेटा एक्सेस करना अक्षम था।
  • फ़ाइल फ़ाइलों में से कई पैमाने पर नहीं थे। एक सर्वर पर एक बड़ी निर्देशिका सूची का अनुरोध करने के परिणामस्वरूप एक लटका हो सकता है। बड़ी निर्देशिका मेमोरी संसाधन समस्याओं का भी कारण बन सकती है, जिसके परिणामस्वरूप सेवा का इनकार होता है।
  • भरोसेमंद कोड लिखना संभव नहीं था जो सर्कुलर प्रतीकात्मक लिंक होने पर उचित रूप से फ़ाइल पेड़ पर चल सकता है और उचित प्रतिक्रिया दे सकता है।

ओह ठीक है, यह 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...-

सरलीकृत उदाहरण (जावा 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("----------");
    [...]
}

इन विधियों को लेखक के हिस्से पर न्यूनतम प्रयास की आवश्यकता होती है और [टेक्स्ट] फ़ाइलों को लिखते समय सभी को प्राथमिकता दी जानी चाहिए।


जावा 7+ के लिए प्रयास करने लायक है:

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

यह आशाजनक लग रहा है ...


जावा में फ़ाइल बनाने और लिखने का एक बहुत ही आसान तरीका:

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

संदर्भ: फ़ाइल जावा में उदाहरण बनाते हैं


फ़ाइल बनाने या ओवरराइट करने के लिए यहां एक छोटा उदाहरण प्रोग्राम दिया गया है। यह लंबा संस्करण है इसलिए इसे अधिक आसानी से समझा जा सकता है।

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

बस इस पैकेज को शामिल करें:

java.nio.file

और फिर आप फ़ाइल को लिखने के लिए इस कोड का उपयोग कर सकते हैं:

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

मौजूदा फ़ाइल को ओवरराइट किए बिना फ़ाइल बनाने के लिए:

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
}

यदि आप अपेक्षाकृत दर्द रहित अनुभव चाहते हैं तो आप अपाचे कॉमन्स आईओ पैकेज पर भी विशेष रूप से FileUtils क्लास देख सकते हैं

तीसरे पक्ष के पुस्तकालयों की जांच करना कभी न भूलें। Joda-Time डेट StringUtils लिए, अपाचे कॉमन्स लैंग स्ट्रिंग सामान्य स्ट्रिंग ऑपरेशंस के लिए उपयोग करता है और इस तरह आपका कोड अधिक पठनीय बना सकता है।

जावा एक महान भाषा है, लेकिन मानक पुस्तकालय कभी-कभी थोड़ा कम स्तर होता है। शक्तिशाली, लेकिन फिर भी निम्न स्तर।


यदि आपके पास पहले से ही सामग्री है जिसे आप फ़ाइल में लिखना चाहते हैं (और फ्लाई पर जेनरेट नहीं किया गया है), java.nio.file.Files . देशी I / O के हिस्से के रूप में जावा 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();
}

यदि हम जावा 7 और ऊपर का उपयोग कर रहे हैं और फ़ाइल में जोड़े जाने के लिए सामग्री को भी जोड़ते हैं तो हम एनआईओ पैकेज में newBufferedWriter विधि का उपयोग कर सकते हैं।

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 कथन का उपयोग करता है जिसमें प्रयास के बाद संसाधन स्वचालित रूप से बंद हो जाते हैं।

हालांकि ओपी ने नहीं पूछा है, लेकिन अगर हम कुछ विशिष्ट कीवर्ड वाले लाइनों की तलाश करना चाहते हैं जैसे confidential हम जावा में स्ट्रीम एपीआई का उपयोग कर सकते हैं:

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

सबसे आसान तरीका मैं पा सकता हूं:

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

यह शायद 1.7+ के लिए ही काम करेगा।


ध्यान दें कि नीचे दिए गए प्रत्येक कोड नमूने IOException फेंक IOException कोशिश / पकड़ / आखिरकार ब्लॉक को अल्पसंख्यक के लिए छोड़ दिया गया है। अपवाद हैंडलिंग के बारे में जानकारी के लिए इस ट्यूटोरियल को देखें।

एक टेक्स्ट फ़ाइल बनाना (ध्यान दें कि यह फ़ाइल को ओवरराइट कर देगा यदि यह पहले से मौजूद है):

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

जावा 7+ उपयोगकर्ता Files को लिखने के लिए फाइल क्लास का उपयोग कर सकते हैं:

एक पाठ फ़ाइल बनाना:

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

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

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






file-io