Showing posts with label FileInputStream. Show all posts
Showing posts with label FileInputStream. Show all posts

Monday, August 4, 2025

Byte Stream in Java जावा में बाइट स्ट्रीम

Byte Stream in Java is used to read and write 8-bit binary data like files, images, audio, and video.

जावा में बाइट स्ट्रीम का उपयोग 8-बिट बाइनरी डेटा को पढ़ने और लिखने के लिए किया जाता है, जैसे फाइल, इमेज, ऑडियो और वीडियो। बाइट स्ट्रीम दो प्रकार की होती हैं:-

  1. InputStream (इनपुट स्ट्रीम)

  2. OutputStream (आउटपुट स्ट्रीम)


1️⃣ InputStream (इनपुट स्ट्रीम)

InputStream is a superclass that reads data from a source like file, device, or socket.
InputStream एक सुपरक्लास है जो डेटा को किसी स्त्रोत (फाइल, डिवाइस, या सॉकेट) से पढ़ती है।

🔹 Common Methods of InputStream

Method Description (English) विवरण (Hindi)
int read()          Reads next byte of data                       अगली बाइट को पढ़ता है
int available() Returns number of available bytes उपलब्ध बाइट्स की संख्या लौटाता है
void close() Closes the stream स्ट्रीम को बंद करता है

2️⃣ OutputStream (आउटपुट स्ट्रीम)

OutputStream is a superclass that writes data to a destination like file, device, or socket.
OutputStream एक सुपरक्लास है जो डेटा को किसी गंतव्य (फाइल, डिवाइस, या सॉकेट) में लिखती है।

🔹 Common Methods of OutputStream

Method      Description (English) विवरण (Hindi)
void write(int)           Writes a byte                       एक बाइट लिखता है
void write(byte[]) Writes byte array बाइट ऐरे लिखता है
void flush() Flushes the stream स्ट्रीम को रिफ्रेश करता है
void close() Closes the stream स्ट्रीम को बंद करता है

3️⃣ Important Byte Stream Classes

Class Name Description (English) विवरण (Hindi)
FileInputStream Reads byte data from file फाइल से बाइट डेटा पढ़ता है
FileOutputStream Writes byte data to file फाइल में बाइट डेटा लिखता है
BufferedInputStream Reads data using buffer बफर के साथ पढ़ता है
BufferedOutputStream Writes data using buffer बफर के साथ लिखता है
DataInputStream Reads primitive data types प्रिमिटिव डेटा पढ़ता है
DataOutputStream Writes primitive data types प्रिमिटिव डेटा लिखता है
PrintStream Writes formatted output फॉर्मेटेड आउटपुट लिखता है

4️⃣ Byte Stream Examples

📝 Example 1: Read File using BufferedInputStream

import java.io.*;

public class Sample {
    public static void main(String args[]) {
        try {
            FileInputStream fis = new FileInputStream("file.txt");
            BufferedInputStream bis = new BufferedInputStream(fis);
            int i;
            while((i = bis.read()) != -1) {
                System.out.print((char)i);
            }
            bis.close();
            fis.close();
        } catch(FileNotFoundException e1) {
            System.out.println("File not found");
        } catch(Exception e2) {
            System.out.println("Reading file error");
        }
    }
}

Output:

Example for BufferedInputStream.

📝 Example 2: Write File using BufferedOutputStream

import java.io.*;

public class Sample {
    public static void main(String args[]) {
        try {
            FileOutputStream fos = new FileOutputStream("file1.txt");
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            String str = "Example for BufferedOutputStream.";
            bos.write(str.getBytes());
            bos.close();
            fos.close();
            System.out.println("File is created successfully");
        } catch(Exception e) {
            System.out.println("File is not created");
        }
    }
}

📝 Example 3: Write Primitive Data using DataOutputStream

import java.io.*;

public class Sample {
    public static void main(String args[]) {
        int id = 1;
        String name = "Ajay Tiwari";
        float salary = 25000.50f;
        try {
            FileOutputStream fos = new FileOutputStream("file.txt");
            DataOutputStream dos = new DataOutputStream(fos);
            dos.writeInt(id);
            dos.writeUTF(name);
            dos.writeFloat(salary);
            dos.close();
            System.out.println("Data written successfully.");
        } catch(IOException e) {
            System.out.println(e);
        }
    }
}

📝 Example 4: Read Primitive Data using DataInputStream

import java.io.*;

class Sample1 {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("file.txt");
            DataInputStream dis = new DataInputStream(fis);
            System.out.println("ID : " + dis.readInt());
            System.out.println("Name : " + dis.readUTF());
            System.out.println("Salary : " + dis.readFloat());
        } catch(IOException e) {
            System.out.println(e);
        }
    }
}

Output:

ID : 1
Name : Ajay Tiwari
Salary : 25000.50

📝 Example 5: Simple File Write using FileOutputStream

import java.io.*;

public class Sample {
    public static void main(String args[]) {
        try {
            FileOutputStream fos = new FileOutputStream("file.txt");
            String str = "Hello World!";
            fos.write(str.getBytes());
            fos.close();
            System.out.println("File written successfully");
        } catch(Exception e) {
            System.out.println(e);
        }
    }
}

📝 Example 6: Simple File Read using FileInputStream

import java.io.*;

public class Sample {
    public static void main(String args[]) {
        try {
            FileInputStream fis = new FileInputStream("file.txt");
            int i;
            while((i = fis.read()) != -1) {
                System.out.print((char)i);
            }
            fis.close();
        } catch(Exception e) {
            System.out.println(e);
        }
    }
}

📝 Example 7: Write File using PrintStream

import java.io.*;

public class Sample {
    public static void main(String args[]) {
        try {
            FileOutputStream fos = new FileOutputStream("file.txt");
            PrintStream ps = new PrintStream(fos);
            ps.println("Hello World!");
            ps.close();
            fos.close();
            System.out.println("Data Written Successfully");
        } catch(Exception e) {
            System.out.println(e);
        }
    }
}

Output:

Hello World!

जावा में फ़ाइल हैंडलिंग (Java File Handling in Hindi & English)

File handling in Java allows us to read and write data permanently in files. Using Java I/O (Input/Output) streams, we can store data, read it, and even process it efficiently.

जावा में फ़ाइल हैंडलिंग हमें डेटा को स्थायी रूप से सेव और पढ़ने की सुविधा देती है। जावा I/O (इनपुट/आउटपुट) स्ट्रीम्स की मदद से हम डेटा को स्टोर, पढ़ और प्रोसेस कर सकते हैं।


1️⃣ जावा में स्ट्रीम (Java Streams)

stream is a sequence of data. In Java, streams are used to read and write data from one location to another (like file, memory, or network).
स्ट्रीम डेटा का एक क्रम होता है। जावा में, स्ट्रीम का उपयोग डेटा पढ़ने और लिखने के लिए किया जाता है, जैसे फ़ाइल, मेमोरी या नेटवर्क।

Java I/O streams are mainly divided into two types:
जावा I/O स्ट्रीम मुख्यतः दो प्रकार की होती हैं:

1️⃣ Character Stream – कैरेक्टर (2 बाइट यूनिकोड) डेटा के लिए

  • Character Stream → Reader और Writer क्लासेस


2️⃣ Byte Stream – बाइट (8-बिट) डेटा के लिए

  • Byte Stream → InputStream और OutputStream क्लासेस

  • Buffering के लिए → BufferedReaderBufferedWriterBufferedInputStreamBufferedOutputStream

  • Printing और Formatting के लिए → PrintWriterPrintStream

  • फ़ाइल में डेटा को स्थायी रूप से सेव कर सकते हैं। बड़ी फाइल्स को पढ़ना और लिखना आसान। स्ट्रीम्स और बफरिंग से परफॉर्मेंस बेहतर। नेटवर्किंग और डेटाबेस ऑपरेशन में डाटा स्ट्रीमिंग आसान।


2️⃣ Character Stream (कैरेक्टर स्ट्रीम)

Character streams are used to read and write character data.
कैरेक्टर स्ट्रीम का प्रयोग कैरेक्टर डेटा को पढ़ने और लिखने के लिए किया जाता है।

✨ Common Character Stream Classes

Class NameDescription (English)विवरण (Hindi)
FileReaderReads data from a file (character by character)फाइल से कैरेक्टर डेटा पढ़ता है
FileWriterWrites data to a fileफाइल में कैरेक्टर डेटा लिखता है
BufferedReaderReads text from an input stream efficientlyबफर के साथ कैरेक्टर पढ़ता है
BufferedWriterWrites text to an output stream efficientlyबफर के साथ कैरेक्टर लिखता है
PrintWriterAllows printing formatted textफॉर्मेटेड टेक्स्ट प्रिंट करने की सुविधा

📝 Example 1: Reading File using BufferedReader

import java.io.*;

class ReadFileExample {
    public static void main(String[] args) {
        try {
            FileReader fr = new FileReader("file.txt");
            BufferedReader br = new BufferedReader(fr);
            String line;
            while((line = br.readLine()) != null) {
                System.out.println(line);
            }
            br.close();
            fr.close();
        } catch(Exception e) {
            System.out.println(e);
        }
    }
}

Output:

Hello World!

📝 Example 2: Writing File using FileWriter

import java.io.*;

class WriteFileExample {
    public static void main(String[] args) {
        try {
            FileWriter fw = new FileWriter("file.txt");
            fw.write("Hello World!");
            fw.close();
            System.out.println("Data written successfully.");
        } catch(Exception e) {
            System.out.println(e);
        }
    }
}

3️⃣ Byte Stream (बाइट स्ट्रीम)

Byte streams are used to handle binary data like images, videos, or audio files.
बाइट स्ट्रीम का प्रयोग बाइनरी डेटा जैसे इमेज, वीडियो या ऑडियो को पढ़ने-लिखने में किया जाता है।

✨ Common Byte Stream Classes

Class NameDescription (English)विवरण (Hindi)
FileInputStreamReads bytes from a fileफाइल से बाइट पढ़ता है
FileOutputStreamWrites bytes to a fileफाइल में बाइट लिखता है
BufferedInputStreamReads data with bufferingबफर के साथ बाइट पढ़ता है
BufferedOutputStreamWrites data with bufferingबफर के साथ बाइट लिखता है
DataInputStreamReads primitive data typesप्रिमिटिव डेटा पढ़ता है
DataOutputStreamWrites primitive data typesप्रिमिटिव डेटा लिखता है
PrintStreamPrints formatted outputफॉर्मेटेड आउटपुट लिखता है

📝 Example 3: Reading File using FileInputStream

import java.io.*;

class FileInputExample {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("file.txt");
            int i;
            while((i = fis.read()) != -1) {
                System.out.print((char)i);
            }
            fis.close();
        } catch(Exception e) {
            System.out.println(e);
        }
    }
}

📝 Example 4: Writing File using FileOutputStream

import java.io.*;

class FileOutputExample {
    public static void main(String[] args) {
        try {
            FileOutputStream fos = new FileOutputStream("file.txt");
            String str = "Hello Java!";
            fos.write(str.getBytes());
            fos.close();
            System.out.println("File written successfully.");
        } catch(Exception e) {
            System.out.println(e);
        }
    }
}

Output:

File written successfully.

4️⃣ फ़ाइल हैंडलिंग के फायदे (Advantages)

  • Permanent data storage (स्थायी स्टोरेज)

  • Easy reading/writing of large files (बड़ी फ़ाइल पढ़ना/लिखना आसान)

  • Supports both text and binary data

  • Useful in database, networking and real-time applications

📚 Other Stream Classes in Java जावा में अन्य स्ट्रीम क्लासेस

In Java, apart from basic byte and character streams, there are several specialized stream classes that provide advanced input-output operat...