Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to Byte Streams in Java — FileInputStream, FileOutputStream, reading and writing binary data, copying files, and understanding byte-level I/O operations.
What are Byte Streams?
Byte streams handle I/O of raw binary data — one byte (8 bits) at a time. They can read/write ANY type of data: text files, images, audio, video, PDFs, etc.
Byte Stream Hierarchy:
InputStream (abstract) OutputStream (abstract)
│ │
┌─────────┼──────────┐ ┌───────────┼───────────┐
│ │ │ │ │ │
FileInput ByteArray Filter FileOutput ByteArray Filter
Stream InputStream InputStream Stream OutputStream OutputStream
│ │
Buffered Buffered
InputStream OutputStream
InputStream and OutputStream
These are the abstract parent classes for all byte streams:
| Class | Purpose | Key Methods |
|---|---|---|
InputStream | Read bytes | read(), read(byte[]), close() |
OutputStream | Write bytes | write(int), write(byte[]), flush(), close() |
FileOutputStream — Writing Bytes
java example
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteWriteExample {
public static void main(String[] args) {
System.out.println("=== Writing Bytes to File ===\n");
// Method 1: Write one byte at a time
try (FileOutputStream fos = new FileOutputStream("output1.txt")) {
fos.write(72); // H (ASCII 72)
fos.write(101); // e (ASCII 101)
fos.write(108); // l
fos.write(108); // l
fos.write(111); // o
System.out.println("✓ Written 'Hello' byte by byte");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
// Method 2: Write byte array
try (FileOutputStream fos = new FileOutputStream("output2.txt")) {
String message = "Hello, Java Byte Streams!";
byte[] data = message.getBytes(); // Convert String to bytes
fos.write(data);
System.out.println("✓ Written entire string as byte array");
System.out.println(" Bytes written: " + data.length);
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
// Method 3: Append mode (true = append, don't overwrite)
try (FileOutputStream fos = new FileOutputStream("output2.txt", true)) {
fos.write("\nAppended line!".getBytes());
System.out.println("✓ Appended to existing file");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
// Method 4: Write partial array
try (FileOutputStream fos = new FileOutputStream("output3.txt")) {
byte[] data = "Hello World".getBytes();
fos.write(data, 0, 5); // Write only "Hello" (offset=0, length=5)
System.out.println("✓ Written partial array: first 5 bytes");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
}
}Output:
Example
=== Writing Bytes to File ===
✓ Written 'Hello' byte by byte
✓ Written entire string as byte array
Bytes written: 25
✓ Appended to existing file
✓ Written partial array: first 5 bytes
FileInputStream — Reading Bytes
Example
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteReadExample {
public static void main(String[] args) throws IOException {
// First, create a file to read
try (FileOutputStream fos = new FileOutputStream("sample.txt")) {
fos.write("Hello, Java I/O! Welcome to byte streams.".getBytes());
}
System.out.println("=== Reading Bytes from File ===\n");
// Method 1: Read one byte at a time
System.out.println("--- Read byte by byte ---");
try (FileInputStream fis = new FileInputStream("sample.txt")) {
int byteData;
StringBuilder content = new StringBuilder();
while ((byteData = fis.read()) != -1) { // -1 means end of file
content.append((char) byteData);
}
System.out.println("Content: " + content);
}
// Method 2: Read into byte array (more efficient)
System.out.println("\n--- Read into byte array ---");
try (FileInputStream fis = new FileInputStream("sample.txt")) {
byte[] buffer = new byte[10]; // Read 10 bytes at a time
int bytesRead;
int totalBytes = 0;
System.out.println("Reading in chunks of 10 bytes:");
while ((bytesRead = fis.read(buffer)) != -1) {
String chunk = new String(buffer, 0, bytesRead);
System.out.printf(" Chunk (%d bytes): '%s'%n", bytesRead, chunk);
totalBytes += bytesRead;
}
System.out.println("Total bytes read: " + totalBytes);
}
// Method 3: Read all bytes at once (Java 9+)
System.out.println("\n--- Read all at once ---");
try (FileInputStream fis = new FileInputStream("sample.txt")) {
byte[] allBytes = fis.readAllBytes();
System.out.println("All bytes (" + allBytes.length + "): " + new String(allBytes));
}
// Method 4: available() and skip()
System.out.println("\n--- available() and skip() ---");
try (FileInputStream fis = new FileInputStream("sample.txt")) {
System.out.println("Available bytes: " + fis.available());
fis.skip(7); // Skip first 7 bytes ("Hello, ")
System.out.println("After skipping 7 bytes:");
byte[] rest = fis.readAllBytes();
System.out.println(" Remaining: " + new String(rest));
}
// Cleanup
new java.io.File("sample.txt").delete();
}
}
Output:
| Content | Hello, Java I/O! Welcome to byte streams. |
| Chunk (10 bytes) | 'Hello, Jav' |
| Chunk (10 bytes) | 'a I/O! Wel' |
| Chunk (10 bytes) | 'come to by' |
| Chunk (10 bytes) | 'te streams' |
| Chunk (1 bytes) | '.' |
| Total bytes read | 41 |
| All bytes (41) | Hello, Java I/O! Welcome to byte streams. |
| Available bytes | 41 |
| Remaining | Java I/O! Welcome to byte streams. |
Understanding read() Return Value
The read() method returns an int (not byte). Here's why:
java example
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class ReadReturnValue {
public static void main(String[] args) throws IOException {
// Write bytes including values 0-255
try (FileOutputStream fos = new FileOutputStream("bytes.dat")) {
fos.write(0); // Zero byte (valid data)
fos.write(127); // Max positive byte
fos.write(128); // Would be -128 as signed byte
fos.write(255); // Would be -1 as signed byte
}
// Read and show int values
try (FileInputStream fis = new FileInputStream("bytes.dat")) {
int value;
while ((value = fis.read()) != -1) {
System.out.printf("int: %3d | byte: %4d | binary: %8s%n",
value, (byte) value, Integer.toBinaryString(value & 0xFF));
}
}
System.out.println("\nWhy int and not byte?");
System.out.println("- byte range: -128 to 127");
System.out.println("- But we need values 0-255 for raw bytes");
System.out.println("- AND we need -1 to signal end-of-file");
System.out.println("- int solves this: 0-255 for data, -1 for EOF");
new java.io.File("bytes.dat").delete();
}
}Output:
| int | 0 | byte: 0 | binary: 0 |
| int | 127 | byte: 127 | binary: 1111111 |
| int | 128 | byte: -128 | binary: 10000000 |
| int | 255 | byte: -1 | binary: 11111111 |
| - byte range | -128 to 127 |
| - int solves this | 0-255 for data, -1 for EOF |
File Copy Using Byte Streams
Example
import java.io.*;
public class FileCopy {
// Method 1: Byte by byte (SLOW for large files)
static long copyByteByByte(String source, String dest) throws IOException {
long bytesCopied = 0;
try (FileInputStream fis = new FileInputStream(source);
FileOutputStream fos = new FileOutputStream(dest)) {
int b;
while ((b = fis.read()) != -1) {
fos.write(b);
bytesCopied++;
}
}
return bytesCopied;
}
// Method 2: Using buffer (FAST — recommended)
static long copyWithBuffer(String source, String dest, int bufferSize) throws IOException {
long bytesCopied = 0;
byte[] buffer = new byte[bufferSize];
try (FileInputStream fis = new FileInputStream(source);
FileOutputStream fos = new FileOutputStream(dest)) {
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1) {
fos.write(buffer, 0, bytesRead);
bytesCopied += bytesRead;
}
}
return bytesCopied;
}
public static void main(String[] args) throws IOException {
// Create a test file (about 1MB)
String sourceFile = "test_source.dat";
try (FileOutputStream fos = new FileOutputStream(sourceFile)) {
byte[] data = new byte[1024];
java.util.Arrays.fill(data, (byte) 'A');
for (int i = 0; i < 1000; i++) {
fos.write(data); // Write 1KB × 1000 = ~1MB
}
}
System.out.println("Source file size: 1,024,000 bytes\n");
// Method 1: Byte by byte
long start = System.currentTimeMillis();
copyByteByByte(sourceFile, "copy1.dat");
long time1 = System.currentTimeMillis() - start;
System.out.printf("Byte-by-byte: %d ms%n", time1);
// Method 2: 1KB buffer
start = System.currentTimeMillis();
copyWithBuffer(sourceFile, "copy2.dat", 1024);
long time2 = System.currentTimeMillis() - start;
System.out.printf("1KB buffer: %d ms%n", time2);
// Method 3: 8KB buffer
start = System.currentTimeMillis();
copyWithBuffer(sourceFile, "copy3.dat", 8192);
long time3 = System.currentTimeMillis() - start;
System.out.printf("8KB buffer: %d ms%n", time3);
// Method 4: 64KB buffer
start = System.currentTimeMillis();
copyWithBuffer(sourceFile, "copy4.dat", 65536);
long time4 = System.currentTimeMillis() - start;
System.out.printf("64KB buffer: %d ms%n", time4);
System.out.printf("%nSpeedup (byte vs 8KB): ~%dx faster%n",
time1 > 0 ? time1 / Math.max(time3, 1) : 0);
// Cleanup
new File(sourceFile).delete();
new File("copy1.dat").delete();
new File("copy2.dat").delete();
new File("copy3.dat").delete();
new File("copy4.dat").delete();
}
}
Output (approximate):
| Source file size | 1,024,000 bytes |
| Byte-by-byte | 1856 ms |
| 1KB buffer | 12 ms |
| 8KB buffer | 4 ms |
| 64KB buffer | 3 ms |
| Speedup (byte vs 8KB) | ~464x faster |
Key Lesson: Always use a buffer when doing I/O! Reading byte-by-byte requires a system call for each byte, which is extremely slow.
Writing Binary Data (Non-Text)
java example
import java.io.*;
public class BinaryData {
public static void main(String[] args) throws IOException {
System.out.println("=== Writing/Reading Binary Data ===\n");
// Write various data types as bytes
try (FileOutputStream fos = new FileOutputStream("data.bin")) {
// Write an integer (4 bytes)
int number = 12345;
fos.write((number >> 24) & 0xFF);
fos.write((number >> 16) & 0xFF);
fos.write((number >> 8) & 0xFF);
fos.write(number & 0xFF);
// Write raw bytes
fos.write(new byte[]{10, 20, 30, 40, 50});
System.out.println("Written: int 12345 + 5 raw bytes");
}
// Read back
try (FileInputStream fis = new FileInputStream("data.bin")) {
// Read the integer back
int num = (fis.read() << 24) | (fis.read() << 16) |
(fis.read() << 8) | fis.read();
System.out.println("Read integer: " + num);
// Read remaining bytes
byte[] remaining = fis.readAllBytes();
System.out.print("Read bytes: ");
for (byte b : remaining) {
System.out.print(b + " ");
}
System.out.println();
}
new File("data.bin").delete();
// Better approach: Use DataOutputStream/DataInputStream
System.out.println("\n--- Using DataOutputStream (Better!) ---");
try (DataOutputStream dos = new DataOutputStream(
new FileOutputStream("data2.bin"))) {
dos.writeInt(12345);
dos.writeDouble(3.14159);
dos.writeBoolean(true);
dos.writeUTF("Hello!");
System.out.println("Written: int, double, boolean, String");
}
try (DataInputStream dis = new DataInputStream(
new FileInputStream("data2.bin"))) {
System.out.println("Read int: " + dis.readInt());
System.out.println("Read double: " + dis.readDouble());
System.out.println("Read boolean: " + dis.readBoolean());
System.out.println("Read String: " + dis.readUTF());
}
new File("data2.bin").delete();
}
}Output:
| Written | int 12345 + 5 raw bytes |
| Read integer | 12345 |
| Read bytes | 10 20 30 40 50 |
| Written | int, double, boolean, String |
| Read int | 12345 |
| Read double | 3.14159 |
| Read boolean | true |
| Read String | Hello! |
Common Mistakes
1. Not closing streams
java example
// ❌ BAD: Resource leak if exception occurs
FileInputStream fis = new FileInputStream("file.txt");
int data = fis.read();
fis.close(); // Won't execute if read() throws!
// ✅ GOOD: Try-with-resources
try (FileInputStream fis = new FileInputStream("file.txt")) {
int data = fis.read();
} // Automatically closed even on exception2. Reading byte-by-byte for large files
Example
// ❌ SLOW: One system call per byte
while ((b = fis.read()) != -1) { ... }
// ✅ FAST: Use buffer
byte[] buffer = new byte[8192];
while ((bytesRead = fis.read(buffer)) != -1) { ... }
3. Using byte streams for text (encoding issues)
java example
// ❌ BAD: Byte streams don't handle Unicode properly
FileOutputStream fos = new FileOutputStream("text.txt");
fos.write("Hello 日本語".getBytes()); // Encoding depends on platform!
// ✅ GOOD: Use character streams for text
FileWriter writer = new FileWriter("text.txt", java.nio.charset.StandardCharsets.UTF_8);
writer.write("Hello 日本語");Interview Questions
Q1: What is the difference between byte stream and character stream?
Answer: Byte streams (InputStream/OutputStream) handle raw binary data 8 bits at a time — suitable for images, audio, any file type. Character streams (Reader/Writer) handle Unicode text 16 bits at a time — suitable for text with proper encoding handling.
Q2: Why does read() return int instead of byte?
Answer: Because byte values range from 0-255 for raw data, and we need a special value (-1) to indicate end-of-file. A byte type (-128 to 127) can't distinguish between data byte -1 (which is actually 255 unsigned) and the EOF signal. Using int solves this: 0-255 = valid data, -1 = EOF.
Q3: What happens if you don't close a FileOutputStream?
Answer: (1) Data in internal buffers may not be written to disk (data loss), (2) the file handle leaks (OS limits the number of open files), (3) other programs may not be able to access the file. Always close streams, preferably with try-with-resources.
Q4: What is the difference between flush() and close()?
Answer: flush() forces buffered data to be written to the destination but keeps the stream open for more writes. close() flushes the buffer AND releases the resource (file handle). After close(), you cannot write anymore.
Q5: How would you efficiently copy a large file (e.g., 2GB)?
Answer: Use a buffered read/write loop with an 8KB-64KB buffer. For the best performance in modern Java, use Files.copy(source, destination) from java.nio which uses OS-level optimizations. Never read byte-by-byte for large files.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Byte Streams in Java.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, file, handling, byte
Related Java Master Course Topics
Continue learning this concept
File HandlingCharacter Streams in JavaComplete guide to Character Streams in Java — FileReader, FileWriter, handling Unicode text, character encoding, reading/writing text files with proper internationalization support.File HandlingBuffered Streams in JavaComplete guide to Buffered Streams in Java — BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter, performance benefits, line-by-line reading, and real-world file processing.File HandlingDeserialization in JavaComplete guide to Deserialization in Java — ObjectInputStream, reading objects from files, type safety, version compatibility, security risks, and best practices for safe deserialization.File HandlingFile Class in JavaComplete guide to the java.io.File class — creating File objects, checking file properties, creating/deleting files and directories, listing contents, and file path operations.File HandlingJava NIO PackageComplete guide to Java NIO (New I/O) — Path, Files, Channels, Buffers, non-blocking I/O, WatchService, and modern file operations that replace traditional java.io approaches.File HandlingSerialization in JavaComplete guide to Serialization in Java — converting objects to byte streams, Serializable interface, ObjectOutputStream, transient keyword, serialVersionUID, and custom serialization.