Java Language => फ़ाइल I / O

परिचय

जावा I / O (इनपुट और आउटपुट) का उपयोग इनपुट को प्रोसेस करने और आउटपुट के उत्पादन के लिए किया जाता है। जावा I / O ऑपरेशन को तेज करने के लिए स्ट्रीम की अवधारणा का उपयोग करता है। Java.io पैकेज में इनपुट और आउटपुट संचालन के लिए आवश्यक सभी वर्ग शामिल हैं। जावा I / O API द्वारा हैंडलिंग फाइलें जावा में भी की जाती हैं।

एक बाइट के लिए सभी बाइट्स पढ़ना []

जावा 7 ने बहुत उपयोगी फाइल क्लास की शुरुआत की

जावा एसई 7

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

Path path = Paths.get("path/to/file");

try {
    byte[] data = Files.readAllBytes(path);
} catch(IOException e) {
    e.printStackTrace();
}

एक फ़ाइल से एक छवि पढ़ना

import java.awt.Image;
import javax.imageio.ImageIO;

...

try {
    Image img = ImageIO.read(new File("~/Desktop/cat.png"));
} catch (IOException e) {
    e.printStackTrace();
}

एक फाइल को बाइट [] लिखना

जावा एसई 7

byte[] bytes = { 0x48, 0x65, 0x6c, 0x6c, 0x6f };

try(FileOutputStream stream = new FileOutputStream("Hello world.txt")) {
    stream.write(bytes);
} catch (IOException ioe) {
    // Handle I/O Exception
    ioe.printStackTrace();
}

जावा एसई 7

byte[] bytes = { 0x48, 0x65, 0x6c, 0x6c, 0x6f };

FileOutputStream stream = null;
try {
    stream = new FileOutputStream("Hello world.txt");
    stream.write(bytes);
} catch (IOException ioe) {
    // Handle I/O Exception
    ioe.printStackTrace();
} finally {
    if (stream != null) {
        try {
            stream.close();
        } catch (IOException ignored) {}
    }
}

अधिकांश java.io फ़ाइल API दोनों String S और File s दोनों को तर्क के रूप में स्वीकार करते हैं, इसलिए आप भी उपयोग कर सकते हैं

File file = new File("Hello world.txt");
FileOutputStream stream = new FileOutputStream(file);

स्ट्रीम बनाम राइटर / रीडर एपीआई

धाराएँ द्विआधारी सामग्री तक सबसे अधिक सीधी पहुंच प्रदान करती हैं, इसलिए कोई भी InputStream / OutputStream कार्यान्वयन हमेशा int एस और byte एस पर संचालित होता है।

// Read a single byte from the stream
int b = inputStream.read();
if (b >= 0) { // A negative value represents the end of the stream, normal values are in the range 0 - 255
    // Write the byte to another stream
    outputStream.write(b);
}

// Read a chunk
byte[] data = new byte[1024];
int nBytesRead = inputStream.read(data);
if (nBytesRead >= 0) { // A negative value represents end of stream
    // Write the chunk to another stream
    outputStream.write(data, 0, nBytesRead);
}

कुछ अपवाद हैं, शायद विशेष रूप से PrintStream जो "विभिन्न डेटा मूल्यों के प्रतिनिधित्व को आसानी से प्रिंट करने की क्षमता" जोड़ता है। यह System.out को बाइनरी InputStream रूप में और System.out.println() जैसे तरीकों का उपयोग करके एक पाठ आउटपुट के रूप में उपयोग करने की अनुमति देता है।

इसके अलावा, कुछ स्ट्रीम कार्यान्वयन उच्च-स्तरीय सामग्रियों जैसे कि जावा ऑब्जेक्ट्स (सीरियलाइज़ेशन देखें) या देशी प्रकार, जैसे DataOutputStream / DataInputStream इंटरफ़ेस के रूप में काम करते हैं।

Writer और Reader कक्षाओं के साथ, जावा स्पष्ट चरित्र धाराओं के लिए एक एपीआई भी प्रदान करता है। हालांकि अधिकांश एप्लिकेशन इन कार्यान्वयनों को धाराओं पर आधारित करेंगे, लेकिन चरित्र स्ट्रीम API द्विआधारी सामग्री के लिए किसी भी तरीके को उजागर नहीं करता है।

// This example uses the platform's default charset, see below
// for a better implementation.

Writer writer = new OutputStreamWriter(System.out);
writer.write("Hello world!");

Reader reader = new InputStreamReader(System.in);
char singleCharacter = reader.read();

जब भी द्विआधारी डेटा में वर्णों को एनकोड करना आवश्यक होता है (जैसे कि InputStreamWriter / OutputStreamWriter क्लासेस का उपयोग करते हुए), तो आपको एक चार्ट निर्दिष्ट करना चाहिए यदि आप प्लेटफ़ॉर्म के डिफ़ॉल्ट चारसेट पर निर्भर नहीं होना चाहते हैं। जब संदेह हो, तो यूनिकोड-संगत एन्कोडिंग का उपयोग करें, उदाहरण के लिए यूटीएफ -8 जो सभी जावा प्लेटफार्मों पर समर्थित है। इसलिए, आपको शायद FileWriter और FileReader जैसी कक्षाओं से दूर रहना चाहिए क्योंकि वे हमेशा डिफ़ॉल्ट प्लेटफ़ॉर्म FileReader उपयोग करते हैं। चरित्र धाराओं का उपयोग करके फ़ाइलों तक पहुंचने का एक बेहतर तरीका यह है:

Charset myCharset = StandardCharsets.UTF_8;

Writer writer = new OutputStreamWriter( new FileOutputStream("test.txt"), myCharset );
writer.write('Ä');
writer.flush();
writer.close();

Reader reader = new InputStreamReader( new FileInputStream("test.txt"), myCharset );
char someUnicodeCharacter = reader.read();
reader.close();

सबसे अधिक इस्तेमाल किया जाने वाला Reader एस BufferedReader जो किसी अन्य रीडर से टेक्स्ट की पूरी लाइन पढ़ने की विधि प्रदान करता है और संभवत: लाइन द्वारा कैरेक्टर स्ट्रीम लाइन पढ़ने का सबसे सरल तरीका है:

// Read from baseReader, one line at a time
BufferedReader reader = new BufferedReader( baseReader );
String line;
while((line = reader.readLine()) != null) {
  // Remember: System.out is a stream, not a writer!
  System.out.println(line);
}

एक बार में पूरी फाइल पढ़ना

File f = new File(path);
String content = new Scanner(f).useDelimiter("\\Z").next();

\ Z ईओएफ (फ़ाइल का अंत) प्रतीक है। जब सीमांकक के रूप में सेट किया जाता है तो स्कैनर EOF फ्लैग तक पहुंचने तक फिल को पढ़ेगा।

एक स्कैनर के साथ एक फ़ाइल पढ़ना

एक फ़ाइल लाइन लाइन द्वारा पढ़ना

public class Main {

    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner(new File("example.txt"));
            while(scanner.hasNextLine())
            {
                String line = scanner.nextLine();
                //do stuff
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

शब्द दर शब्द

public class Main {

    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner(new File("example.txt"));
            while(scanner.hasNext())
            {
                String line = scanner.next();
                //do stuff
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

और आप Scan.useDelimeter () पद्धति का उपयोग करके भी परिधि को बदल सकते हैं

एक निर्देशिका से अधिक और फ़ाइल एक्सटेंशन द्वारा फ़िल्टर करना

    public void iterateAndFilter() throws IOException {
        Path dir = Paths.get("C:/foo/bar");
        PathMatcher imageFileMatcher =
            FileSystems.getDefault().getPathMatcher(
                "regex:.*(?i:jpg|jpeg|png|gif|bmp|jpe|jfif)");

        try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir,
                entry -> imageFileMatcher.matches(entry.getFileName()))) {

            for (Path path : stream) {
                System.out.println(path.getFileName());
            }
        }
    }

Java.io.File से Java 7 NIO (java.nio.file.Path) पर माइग्रेट करना

ये उदाहरण मानते हैं कि आप पहले से ही जानते हैं कि जावा 7 का NIO सामान्य रूप से क्या है, और आपको java.io.File का उपयोग करके कोड लिखने के लिए उपयोग किया जाता है। माइग्रेट करने के लिए जल्दी से अधिक NIO- केंद्रित प्रलेखन खोजने के लिए इन उदाहरणों का उपयोग करें।

Java 7 के NIO में बहुत कुछ है जैसे कि मेमोरी-मैप्ड फाइलें या FileSystem का उपयोग करके एक ZIP या JAR फ़ाइल खोलना । ये उदाहरण केवल सीमित संख्या में उपयोग के मामलों को कवर करेंगे।

एक बुनियादी नियम के रूप में, यदि आप java.io.File उदाहरण विधि का उपयोग करके फाइल सिस्टम रीड / राइट ऑपरेशन करने के लिए उपयोग किए जाते हैं, तो आप इसे java.nio.file.Files भीतर एक स्थिर विधि के रूप में पाएंगे।

एक रास्ते की ओर इशारा

// -> IO
File file = new File("io.txt");

// -> NIO
Path path = Paths.get("nio.txt");

दूसरे रास्ते के सापेक्ष पथ

// Forward slashes can be used in place of backslashes even on a Windows operating system
// -> IO
File folder = new File("C:/");
File fileInFolder = new File(folder, "io.txt");

// -> NIO
Path directory = Paths.get("C:/");
Path pathInDirectory = directory.resolve("nio.txt");

पुस्तकालयों के साथ उपयोग के लिए / पथ से फ़ाइल परिवर्तित करना

// -> IO to NIO
Path pathFromFile = new File("io.txt").toPath();

// -> NIO to IO
File fileFromPath = Paths.get("nio.txt").toFile();

जाँच करें कि क्या फ़ाइल मौजूद है और यदि ऐसा है तो उसे हटा दें

// -> IO
if (file.exists()) {
    boolean deleted = file.delete();
    if (!deleted) {
        throw new IOException("Unable to delete file");
    }
}

// -> NIO
Files.deleteIfExists(path);

एक आउटपुट के माध्यम से एक फ़ाइल में लिखें

विभिन्न प्रदर्शन और मेमोरी बाधाओं, पठनीयता और उपयोग के मामलों के लिए NIO का उपयोग करके किसी फ़ाइल से लिखने और पढ़ने के कई तरीके हैं, जैसे कि FileChannel , Files.write(Path path, byte\[\] bytes, OpenOption... options) । .. इस उदाहरण में, केवल OutputStream को कवर किया गया है, लेकिन आपको मेमोरी-मैप की गई फ़ाइलों और java.nio.file.Files में उपलब्ध विभिन्न स्थैतिक तरीकों के बारे में जानने के लिए प्रोत्साहित किया जाता है।

List<String> lines = Arrays.asList(
        String.valueOf(Calendar.getInstance().getTimeInMillis()),
        "line one",
        "line two");

// -> IO
if (file.exists()) {
    // Note: Not atomic
    throw new IOException("File already exists");
}
try (FileOutputStream outputStream = new FileOutputStream(file)) {
    for (String line : lines) {
        outputStream.write((line + System.lineSeparator()).getBytes(StandardCharsets.UTF_8));
    }
}

// -> NIO
try (OutputStream outputStream = Files.newOutputStream(path, StandardOpenOption.CREATE_NEW)) {
    for (String line : lines) {
        outputStream.write((line + System.lineSeparator()).getBytes(StandardCharsets.UTF_8));
    }
}

एक फ़ोल्डर के भीतर प्रत्येक फ़ाइल पर Iterating

// -> IO
for (File selectedFile : folder.listFiles()) {
    // Note: Depending on the number of files in the directory folder.listFiles() may take a long time to return
    System.out.println((selectedFile.isDirectory() ? "d" : "f") + " " + selectedFile.getAbsolutePath());
}

// -> NIO
Files.walkFileTree(directory, EnumSet.noneOf(FileVisitOption.class), 1, new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult preVisitDirectory(Path selectedPath, BasicFileAttributes attrs) throws IOException {
        System.out.println("d " + selectedPath.toAbsolutePath());
        return FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult visitFile(Path selectedPath, BasicFileAttributes attrs) throws IOException {
        System.out.println("f " + selectedPath.toAbsolutePath());
        return FileVisitResult.CONTINUE;
    }
});

पुनरावर्ती फ़ोल्डर पुनरावृत्ति

// -> IO
recurseFolder(folder);

// -> NIO
// Note: Symbolic links are NOT followed unless explicitly passed as an argument to Files.walkFileTree
Files.walkFileTree(directory, new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
        System.out.println("d " + selectedPath.toAbsolutePath());
        return FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult visitFile(Path selectedPath, BasicFileAttributes attrs) throws IOException {
        System.out.println("f " + selectedPath.toAbsolutePath());
        return FileVisitResult.CONTINUE;
    }
});


private static void recurseFolder(File folder) {
    for (File selectedFile : folder.listFiles()) {
        System.out.println((selectedFile.isDirectory() ? "d" : "f") + " " + selectedFile.getAbsolutePath());
        if (selectedFile.isDirectory()) {
            // Note: Symbolic links are followed
            recurseFolder(selectedFile);
        }
    }
}

FileInputStream / FileOutputStream का उपयोग करके फ़ाइल पढ़ें / लिखें

फ़ाइल test.txt पर लिखें:

String filepath ="C:\\test.txt";
FileOutputStream fos = null;
try {
      fos = new FileOutputStream(filepath);
      byte[] buffer = "This will be written in test.txt".getBytes();
      fos.write(buffer, 0, buffer.length);
      fos.close();
} catch (FileNotFoundException e) {
      e.printStackTrace();
} catch (IOException e) {
      e.printStackTrace();
} finally{
      if(fos != null)
        fos.close();
}

फ़ाइल test.txt से पढ़ें:

String filepath ="C:\\test.txt";        
FileInputStream fis = null;
try {
   fis = new FileInputStream(filepath);
   int length = (int) new File(filepath).length();
   byte[] buffer = new byte[length];
   fis.read(buffer, 0, length);
} catch (FileNotFoundException e) {
     e.printStackTrace();
} catch (IOException e) {
     e.printStackTrace();
} finally{
   if(fis != null)
     fis.close();
}

ध्यान दें, कि जावा 1.7 के बाद से संसाधनों के साथ-साथ कथन को पेश किया गया था जिसने रीडिंग / राइटिंग ऑपरेशन के कार्यान्वयन को बहुत सरल बना दिया था:

फ़ाइल test.txt पर लिखें:

String filepath ="C:\\test.txt";
try (FileOutputStream fos = new FileOutputStream(filepath)){
    byte[] buffer = "This will be written in test.txt".getBytes();
    fos.write(buffer, 0, buffer.length);
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

फ़ाइल test.txt से पढ़ें:

String filepath ="C:\\test.txt";
try (FileInputStream fis = new FileInputStream(filepath)){
    int length = (int) new File(filepath).length();
    byte[] buffer = new byte[length];
    fis.read(buffer, 0, length);
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

एक बाइनरी फ़ाइल से पढ़ना

आप जावा के सभी हाल के संस्करणों में कोड के इस टुकड़े का उपयोग करके एक बाइनरी फ़ाइल पढ़ सकते हैं:

जावा एसई १.४

File file = new File("path_to_the_file");
byte[] data = new byte[(int) file.length()];
DataInputStream stream = new DataInputStream(new FileInputStream(file));
stream.readFully(data);
stream.close();

यदि आप जावा 7 या उसके बाद का उपयोग कर रहे हैं, तो nio API का उपयोग करने का एक सरल तरीका nio API :

जावा एसई 7

Path path = Paths.get("path_to_the_file");
byte [] data = Files.readAllBytes(path);

ताला

FileChannel API का उपयोग करके एक फ़ाइल को लॉक किया जा सकता है जिसे इनपुट आउटपुट streams और readers से प्राप्त किया जा सकता readers

streams साथ उदाहरण

// एक फ़ाइल स्ट्रीम खोलें FileInputStream ios = new FileInputStream (फ़ाइल नाम);

    // get underlying channel
    FileChannel channel = ios.getChannel();

    /*
     * try to lock the file. true means whether the lock is shared or not i.e. multiple processes can acquire a
     * shared lock (for reading only) Using false with readable channel only will generate an exception. You should
     * use a writable channel (taken from FileOutputStream) when using false. tryLock will always return immediately
     */
    FileLock lock = channel.tryLock(0, Long.MAX_VALUE, true);

    if (lock == null) {
        System.out.println("Unable to acquire lock");
    } else {
        System.out.println("Lock acquired successfully");
    }

    // you can also use blocking call which will block until a lock is acquired.
    channel.lock();

    // Once you have completed desired operations of file. release the lock
    if (lock != null) {
        lock.release();
    }

    // close the file stream afterwards
    // Example with reader
    RandomAccessFile randomAccessFile = new RandomAccessFile(filename,  "rw");
    FileChannel channel = randomAccessFile.getChannel();
    //repeat the same steps as above but now you can use shared as true or false as the channel is in read write mode

InputStream और OutputStream का उपयोग करके किसी फ़ाइल को कॉपी करना

हम किसी स्रोत से डेटा को लूप का उपयोग करके सीधे डेटा सिंक में कॉपी कर सकते हैं। इस उदाहरण में, हम एक इनपुटस्ट्रीम से डेटा पढ़ रहे हैं और एक ही समय में, आउटपुटस्ट्रीम पर लिख रहे हैं। एक बार पढ़ने और लिखने के बाद हमें संसाधन बंद करना होगा।

public void copy(InputStream source, OutputStream destination) throws IOException {
    try {
        int c;
        while ((c = source.read()) != -1) {
            destination.write(c);
        }
    } finally {
        if (source != null) {
            source.close();
        }
        if (destination != null) {
            destination.close();
        }
    }
}

चैनल और बफर का उपयोग करके एक फ़ाइल पढ़ना

Channel डेटा पढ़ने / लिखने के लिए एक Buffer का उपयोग करता है। एक बफर एक निश्चित आकार का कंटेनर है जहां हम एक बार में डेटा का एक ब्लॉक लिख सकते हैं। Channel स्ट्रीम-आधारित I / O से काफी तेज है।

Channel का उपयोग करते हुए फ़ाइल से डेटा पढ़ने के लिए हमें निम्नलिखित चरणों की आवश्यकता है-

हमें FileInputStream का एक उदाहरण चाहिए। FileInputStream में एक विधि है जिसका नाम getChannel() जो एक चैनल देता है।
FileInputStream की getChannel() विधि को कॉल करें और चैनल का अधिग्रहण करें।
एक बाइटबफ़र बनाएँ। बाइटबफ़र बाइट्स का एक निश्चित आकार का कंटेनर है।
चैनल के पास एक पठन विधि है और हमें इस पठन विधि के लिए एक तर्क के रूप में एक बाइटबफ़र प्रदान करना होगा। बाइटबफ़र के दो तरीके हैं - केवल-पढ़ने का मूड और लिखने का केवल मूड। हम flip() विधि कॉल का उपयोग करके मोड बदल सकते हैं। बफर की एक स्थिति, सीमा और क्षमता है। एक बार जब एक निश्चित आकार के साथ बफर बनाया जाता है, तो इसकी सीमा और क्षमता आकार के समान होती है और स्थिति शून्य से शुरू होती है। जबकि एक बफर डेटा के साथ लिखा जाता है, इसकी स्थिति धीरे-धीरे बढ़ जाती है। मोड बदलने का मतलब है, स्थिति बदलना। बफर की शुरुआत से डेटा पढ़ने के लिए, हमें स्थिति को शून्य पर सेट करना होगा। फ्लिप () विधि स्थिति को बदलते हैं
जब हम Channel के रीड मेथड को कॉल करते हैं, तो यह डेटा का उपयोग करके बफर को भरता है।
यदि हमें ByteBuffer से डेटा पढ़ने की आवश्यकता है, तो हमें अपने मोड को केवल-पढ़ने के लिए केवल मोड में बदलने के लिए बफर को फ्लिप करना होगा और फिर बफर से डेटा पढ़ना जारी रखना चाहिए।
जब पढ़ने के लिए डेटा नहीं रह जाता है, तो चैनल read() 0 read() का रिटर्न read() विधि read() ।

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class FileChannelRead {
 
public static void main(String[] args) {
  
   File inputFile = new File("hello.txt");
  
   if (!inputFile.exists()) {
    System.out.println("The input file doesn't exit.");
    return;
   }

  try {
   FileInputStream fis = new FileInputStream(inputFile);
   FileChannel fileChannel = fis.getChannel();
   ByteBuffer buffer = ByteBuffer.allocate(1024);

   while (fileChannel.read(buffer) > 0) {
    buffer.flip();
    while (buffer.hasRemaining()) {
     byte b = buffer.get();
     System.out.print((char) b);
    }
    buffer.clear();
   }

   fileChannel.close();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
}

चैनल का उपयोग करके एक फ़ाइल की प्रतिलिपि बनाई जा रही है

हम फ़ाइल सामग्री को तेज़ी से कॉपी करने के लिए Channel का उपयोग कर सकते हैं। ऐसा करने के लिए, हम FileChannel transferTo() पद्धति का उपयोग कर सकते हैं।

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;

public class FileCopier {
    
    public static void main(String[] args) {
        File sourceFile = new File("hello.txt");
        File sinkFile = new File("hello2.txt");
        copy(sourceFile, sinkFile);
    }

    public static void copy(File sourceFile, File destFile) {
        if (!sourceFile.exists() || !destFile.exists()) {
            System.out.println("Source or destination file doesn't exist");
            return;
        }


        try (FileChannel srcChannel = new FileInputStream(sourceFile).getChannel();
             FileChannel sinkChanel = new FileOutputStream(destFile).getChannel()) {

            srcChannel.transferTo(0, srcChannel.size(), sinkChanel);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

BufferedInputStream का उपयोग करके एक फ़ाइल पढ़ना

एक का उपयोग कर फ़ाइल पढ़ना BufferedInputStream आम तौर पर तेजी से FileInputStream क्योंकि यह एक आंतरिक बफर दुकान करने के लिए अंतर्निहित इनपुट धारा से पढ़े गए बाइट बनाए रखता है।

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;


public class FileReadingDemo {

    public static void main(String[] args) {
        String source = "hello.txt";
        
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(source))) {
            byte data;
            while ((data = (byte) bis.read()) != -1) {
                System.out.println((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

चैनल और बफर का उपयोग करके एक फ़ाइल लिखना

Channel का उपयोग करके किसी फ़ाइल में डेटा लिखने के लिए हमें निम्नलिखित कदम उठाने होंगे:

सबसे पहले, हमें FileOutputStream की एक वस्तु प्राप्त करने की आवश्यकता है
अधिग्रहण FileChannel बुला getChannel() से विधि FileOutputStream
एक ByteBuffer बनाएं और फिर इसे डेटा से भरें
फिर हम कॉल करनी होगी flip() की विधि ByteBuffer और का एक तर्क के रूप में यह पारित write() की विधि FileChannel
एक बार जब हम लेखन कर लेते हैं, तो हमें संसाधन बंद करना होगा

import java.io.*;
import java.nio.*;
public class FileChannelWrite {

 public static void main(String[] args) {

  File outputFile = new File("hello.txt");
  String text = "I love Bangladesh.";

  try {
   FileOutputStream fos = new FileOutputStream(outputFile);
   FileChannel fileChannel = fos.getChannel();
   byte[] bytes = text.getBytes();
   ByteBuffer buffer = ByteBuffer.wrap(bytes);
   fileChannel.write(buffer);
   fileChannel.close();
  } catch (java.io.IOException e) {
   e.printStackTrace();
  }
 }
}

PrintStream का उपयोग करके एक फ़ाइल लिखना

हम फाइल लिखने के लिए PrintStream क्लास का उपयोग कर सकते हैं। इसकी कई विधियाँ हैं जो आपको किसी भी डेटा प्रकार के मान को प्रिंट करने देती हैं। println() विधि एक नई लाइन को जोड़ती है। एक बार जब हम प्रिंटिंग कर लेते हैं, तो हमें PrintStream को फ्लश करना PrintStream ।

import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.time.LocalDate;

public class FileWritingDemo {
    public static void main(String[] args) {
        String destination = "file1.txt";

        try(PrintStream ps = new PrintStream(destination)){
            ps.println("Stackoverflow documentation seems fun.");
            ps.println();
            ps.println("I love Java!");
            ps.printf("Today is: %1$tm/%1$td/%1$tY", LocalDate.now());

            ps.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

    }
}

इसमें एक निर्देशिका मुद्रण उपनिर्देशिका पर Iterate

  public void iterate(final String dirPath) throws IOException {
    final DirectoryStream<Path> paths = Files.newDirectoryStream(Paths.get(dirPath));
    for (final Path path : paths) {
      if (Files.isDirectory(path)) {
        System.out.println(path.getFileName());
      }
    }
  }

निर्देशिकाएँ जोड़ना

File उदाहरण से एक नई निर्देशिका बनाने के लिए आपको दो विधियों में से एक का उपयोग करना होगा: mkdirs() या mkdir() ।

mkdir() - इस अमूर्त पथनामे द्वारा नामित निर्देशिका बनाता है। ( स्रोत )
mkdirs() - इस अमूर्त पथनाम नाम की निर्देशिका को बनाता है, जिसमें कोई भी आवश्यक लेकिन कोई नहीं, मूल निर्देशिका शामिल है। ध्यान दें कि यदि यह ऑपरेशन विफल हो जाता है तो यह कुछ आवश्यक मूल निर्देशिका बनाने में सफल हो सकता है। ( स्रोत )

नोट: createNewFile() केवल एक नई निर्देशिका नहीं बनाएगा।

File singleDir = new File("C:/Users/SomeUser/Desktop/A New Folder/");
    
File multiDir = new File("C:/Users/SomeUser/Desktop/A New Folder 2/Another Folder/");

// assume that neither "A New Folder" or "A New Folder 2" exist

singleDir.createNewFile(); // will make a new file called "A New Folder.file"
singleDir.mkdir(); // will make the directory
singleDir.mkdirs(); // will make the directory

multiDir.createNewFile(); // will throw a IOException
multiDir.mkdir(); // will not work
multiDir.mkdirs(); // will make the directory

मानक आउटपुट / त्रुटि को ब्लॉक या पुनर्निर्देशित करना

कभी-कभी खराब तरीके से डिजाइन की गई 3-पार्टी लाइब्रेरी System.out या System.err धाराओं के लिए अवांछित डायग्नोस्टिक्स लिख देगी। इसके लिए अनुशंसित समाधान या तो एक बेहतर पुस्तकालय खोजने के लिए होगा (या खुले स्रोत के मामले में) समस्या को ठीक करेगा और डेवलपर्स को एक पैच योगदान देगा।

यदि उपरोक्त समाधान संभव नहीं हैं, तो आपको धाराओं को पुनर्निर्देशित करने पर विचार करना चाहिए।

कमांड लाइन पर पुनर्निर्देशन

एक UNIX पर, लिनक्स या MacOSX प्रणाली का उपयोग कर खोल से किया जा सकता > पुनर्निर्देशन। उदाहरण के लिए:

$ java -jar app.jar arg1 arg2 > /dev/null 2>&1
$ java -jar app.jar arg1 arg2 > out.log 2> error.log

पहले एक मानक आउटपुट और मानक त्रुटि को "/ dev / null" पर पुनर्निर्देशित करता है, जो उन धाराओं में लिखे गए कुछ भी को फेंक देता है। दूसरा मानक आउटपुट को "out.log" और मानक त्रुटि "error.log" को रीडायरेक्ट करता है।

(पुनर्निर्देशन के बारे में अधिक जानकारी के लिए, जिस कमांड शेल का आप उपयोग कर रहे हैं, उसके प्रलेखन को देखें। विंडोज पर भी यही सलाह लागू होती है।)

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

जावा एप्लिकेशन के भीतर पुनर्निर्देशन

System.setOut System.setOut() और System.setErr() का उपयोग करके जावा एप्लिकेशन के भीतर धाराओं को रिडीम करना भी संभव है। उदाहरण के लिए, निम्नलिखित स्निपेट 2 लॉग फ़ाइलों में मानक आउटपुट और मानक त्रुटि को पुनर्निर्देशित करता है:

System.setOut(new PrintStream(new FileOutputStream(new File("out.log"))));
System.setErr(new PrintStream(new FileOutputStream(new File("err.log"))));

यदि आप आउटपुट को पूरी तरह से फेंकना चाहते हैं, तो आप एक आउटपुट स्ट्रीम बना सकते हैं जो अमान्य फाइल डिस्क्रिप्टर को "लिखता है"। यह कार्यात्मक रूप से UNIX पर "/ dev / null" लिखने के बराबर है।

System.setOut(new PrintStream(new FileOutputStream(new FileDescriptor())));
System.setErr(new PrintStream(new FileOutputStream(new FileDescriptor())));

सावधानी: सावधान रहें कि आप कैसे setOut और setErr उपयोग करें:

पुनर्निर्देशन पूरे JVM को प्रभावित करेगा।
ऐसा करने से, आप कमांड लाइन से स्ट्रीम को पुनर्निर्देशित करने की उपयोगकर्ता की क्षमता को हटा रहे हैं।

एक ज़िप फ़ाइल की सामग्री तक पहुँचना

जावा 7 का फाइलसिस्टम एपीआई किसी अन्य फाइलसिस्टम पर काम करते हुए उसी तरह से जावा एनआईओ फ़ाइल एपीआई का उपयोग करके किसी जिप फाइल से या जिप फाइल को पढ़ने या जोड़ने की अनुमति देता है।

FileSystem एक संसाधन है जिसे उपयोग के बाद ठीक से बंद किया जाना चाहिए, इसलिए कोशिश-के-संसाधन ब्लॉक का उपयोग किया जाना चाहिए।

मौजूदा फ़ाइल से पढ़ना

Path pathToZip = Paths.get("path/to/file.zip");
try(FileSystem zipFs = FileSystems.newFileSystem(pathToZip, null)) {
  Path root = zipFs.getPath("/");
  ... //access the content of the zip file same as ordinary files
} catch(IOException ex) {
  ex.printStackTrace();
}

एक नई फ़ाइल बनाना

Map<String, String> env = new HashMap<>();  
env.put("create", "true"); //required for creating a new zip file
env.put("encoding", "UTF-8"); //optional: default is UTF-8
URI uri = URI.create("jar:file:/path/to/file.zip");
try (FileSystem zipfs = FileSystems.newFileSystem(uri, env)) {
  Path newFile = zipFs.getPath("/newFile.txt");
  //writing to file
  Files.write(newFile, "Hello world".getBytes());
} catch(IOException ex) {
  ex.printStackTrace();
}

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow

Java Language
फ़ाइल I / O

खोज…

परिचय

एक बाइट के लिए सभी बाइट्स पढ़ना []

एक फ़ाइल से एक छवि पढ़ना

एक फाइल को बाइट [] लिखना

स्ट्रीम बनाम राइटर / रीडर एपीआई

एक बार में पूरी फाइल पढ़ना

एक स्कैनर के साथ एक फ़ाइल पढ़ना

एक निर्देशिका से अधिक और फ़ाइल एक्सटेंशन द्वारा फ़िल्टर करना

Java.io.File से Java 7 NIO (java.nio.file.Path) पर माइग्रेट करना

एक रास्ते की ओर इशारा

दूसरे रास्ते के सापेक्ष पथ

पुस्तकालयों के साथ उपयोग के लिए / पथ से फ़ाइल परिवर्तित करना

जाँच करें कि क्या फ़ाइल मौजूद है और यदि ऐसा है तो उसे हटा दें

एक आउटपुट के माध्यम से एक फ़ाइल में लिखें

एक फ़ोल्डर के भीतर प्रत्येक फ़ाइल पर Iterating

पुनरावर्ती फ़ोल्डर पुनरावृत्ति

FileInputStream / FileOutputStream का उपयोग करके फ़ाइल पढ़ें / लिखें

एक बाइनरी फ़ाइल से पढ़ना

ताला

InputStream और OutputStream का उपयोग करके किसी फ़ाइल को कॉपी करना

चैनल और बफर का उपयोग करके एक फ़ाइल पढ़ना

चैनल का उपयोग करके एक फ़ाइल की प्रतिलिपि बनाई जा रही है

BufferedInputStream का उपयोग करके एक फ़ाइल पढ़ना

चैनल और बफर का उपयोग करके एक फ़ाइल लिखना

PrintStream का उपयोग करके एक फ़ाइल लिखना

इसमें एक निर्देशिका मुद्रण उपनिर्देशिका पर Iterate

निर्देशिकाएँ जोड़ना

मानक आउटपुट / त्रुटि को ब्लॉक या पुनर्निर्देशित करना

एक ज़िप फ़ाइल की सामग्री तक पहुँचना

मौजूदा फ़ाइल से पढ़ना

एक नई फ़ाइल बनाना