Forem: Jayashree

Wrapper Classes in Java – A Simple Guide

Jayashree — Wed, 22 Apr 2026 05:01:29 +0000

When we start learning Java, we mostly work with primitive data types like int, char, double, etc. These are fast and efficient. But at some point, we run into situations where primitives alone are not enough. That’s where wrapper classes come into the picture.

What is a Wrapper Class?

A wrapper class is used to convert a primitive data type into an object.

In simple terms, it “wraps” a primitive value inside an object.

For example:

int → Integer
char → Character
double → Double
boolean → Boolean

So instead of working with raw values, we can work with objects.

Why Do We Need Wrapper Classes?

You might wonder — why not just use primitives?

Good question. Here are the main reasons:

1. Collections work only with objects

Java collections like ArrayList cannot store primitive types.

ArrayList<int> list;   //  Not allowed
ArrayList<Integer> list; //  Allowed

So we use wrapper classes to store values in collections.

2. Utility Methods

Wrapper classes provide useful methods like:

Integer.parseInt("123");   // converts String to int
Double.valueOf("10.5");    // converts String to Double

These methods make data conversion easy.

3. Object-Oriented Features

Sometimes we need objects instead of primitives—for example, when working with APIs, frameworks, or generics.

Wrapper classes help us follow object-oriented programming concepts.

Autoboxing and Unboxing

Java automatically converts between primitives and wrapper classes.

Autoboxing (primitive → object)
Integer num = 10; // int → Integer

Unboxing (object → primitive)
Integer num = 10;
int value = num; // Integer → int

This makes coding easier and cleaner.

Where Are Wrapper Objects Stored?

Primitive values → stored in stack memory
Wrapper objects → stored in heap memory
Reference variables → stored in stack

Example:

Integer a = 10;

Here:

a is stored in stack
The actual object (10) is stored in heap
Special Case: Integer Caching

Java caches values between -128 to 127.

Integer x = 100;
Integer y = 100;

System.out.println(x == y); // true

Because Java reuses the same object from memory.

But:

Integer x = 200;
Integer y = 200;

System.out.println(x == y); // false

Here, new objects are created.

Final Thoughts

Wrapper classes play a very important role in Java. Even though primitives are faster, wrapper classes give flexibility, especially when working with collections, APIs, and object-based operations.

If you are preparing for interviews, understanding wrapper classes, autoboxing, and memory behavior is a must.

Comparable Interface in Java – Simple Explanation

Jayashree — Tue, 21 Apr 2026 04:58:30 +0000

When you work with objects in Java, sometimes you need to sort them. Sorting numbers or strings is easy because Java already knows how to compare them. But what if you create your own class, like Student, Employee, or Product?

That’s where the Comparable interface comes in.

What is Comparable?

The Comparable interface is used to define the natural ordering of objects.

In simple words, it tells Java:

This is how objects of my class should be compared.

Where is it used?

It is part of the Java Collections Framework, and it works with methods like:

Collections.sort()
Arrays.sort()

The Comparable interface has only one method:

int compareTo(Object obj)

How it works:

Returns 0 → both objects are equal
Returns positive number → current object is greater
Returns negative number → current object is smaller

Example 1:
Sorting Numbers (Default Behavior)

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(5, 2, 8, 1);

        Collections.sort(list);

        System.out.println(list);
    }
}

Output:

[1, 2, 5, 8]

Here, Integer already implements Comparable.

Example 2:

Custom Class (Student)

Now let’s create our own class and sort it.

Step 1: Create Class and Implement Comparable

class Student implements Comparable<Student> {
    int id;
    String name;

    Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int compareTo(Student s) {
        return this.id - s.id; // sorting by id
    }
}

Step 2: Use It

import java.util.*;

public class Main {
    public static void main(String[] args) {

        List<Student> list = new ArrayList<>();

        list.add(new Student(3, "Ram"));
        list.add(new Student(1, "John"));
        list.add(new Student(2, "Arun"));

        Collections.sort(list);

        for(Student s : list) {
            System.out.println(s.id + " " + s.name);
        }
    }
}

Output:

1 John
2 Arun
3 Ram
Sorting Based on Different Fields

If you want to sort by name instead of id:

public int compareTo(Student s) {
    return this.name.compareTo(s.name);
}

Key Points to Remember

Used for natural sorting
Class must implement Comparable
Override compareTo() method
Works with sorting methods like Collections.sort()

Comparable vs Comparator (Quick Idea)

Comparable → inside the class (default sorting)
Comparator → outside the class (custom sorting)

Final Thought

Use Comparable when your class has a clear default way of sorting.
For example:

Students → by ID
Products → by price
Employees → by salary

If sorting changes frequently, then Comparator is better.

Understanding Methods in Programming (Simple Explanation)

Jayashree — Mon, 20 Apr 2026 12:58:57 +0000

When we start learning programming, one word we keep hearing again and again is method. It might sound technical at first, but in reality, it’s a very simple concept.

Let’s break it down in a way that actually makes sense.

What is a Method?

A method is just a block of code that performs a specific task.

Think of it like this:

You don’t cook an entire meal in one step, right?
You break it into smaller tasks like cutting vegetables, boiling water, frying, etc.

In programming, a method is exactly that — a small task written once and reused whenever needed.

Why Do We Use Methods?

Without methods, your code would become long, messy, and hard to understand.

Methods help you:

Avoid repeating the same code again and again
Make your code clean and readable
Debug easily
Organize your logic better

Simple Real-Life Example

Imagine you want to greet a user.

Instead of writing this again and again:

System.out.println("Hello, welcome!");

You can create a method:

void greet() {
    System.out.println("Hello, welcome!");
}

Now, whenever you need it, just call:

greet();
That’s it. Cleaner and smarter.

Structure of a Method

In Java, a method usually looks like this:

returnType methodName(parameters) { // code }

Example:

int add(int a, int b) {
    return a + b;
}

Here:

int → return type
add → method name
a, b → parameters
return a + b; → result

Types of Methods

There are mainly two common types:

Method without return value

void showMessage() {
System.out.println("Hello!");
}

This method just prints something. It doesn’t return anything.

2.** Method with return value**

int multiply(int x, int y) {
return x * y;
}

This method returns a value that you can use later.

Why Methods Matter (Important Point)

If you understand methods well, you’ll find programming much easier.

Almost everything in modern programming — whether it’s building apps, websites, or APIs — depends heavily on methods.

They are like building blocks of your program.

Final Thoughts

Don’t think of methods as something complicated.

Just remember:

A method = a reusable piece of code that does one job.

Once you start using methods properly, your code will automatically become cleaner and more professional.

Upcasting and Downcasting in Java (Simple Explanation)

Jayashree — Sun, 19 Apr 2026 16:38:57 +0000

When working with inheritance in Java, you’ll often hear two terms:
Upcasting and Downcasting.

Don’t worry — it’s not as complicated as it sounds.

First, let’s understand the idea

In Java, a child class inherits from a parent class.

Example:

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog barks");
    }
}

Here:

Animal -> Parent class
Dog -> Child class

What is Upcasting?

Upcasting means:
Converting a child class object into a parent class reference

Example:

Animal a = new Dog(); // Upcasting
a.sound();

What’s happening here?

Dog object is created
But it is stored in Animal reference

Important point:

You can only access parent class methods

a.sound(); // Works
// a.bark(); // Error

Even though the object is Dog, Java only allows what Animal knows.

Why use Upcasting?

Helps in polymorphism
Makes code flexible and reusable

What is Downcasting?

Downcasting means:
Converting parent reference back to child type

Example:

Animal a = new Dog(); // Upcasting

Dog d = (Dog) a; // Downcasting
d.bark();

What’s happening?

We tell Java: “Hey, this Animal is actually a Dog”
So now we can use child methods
Important: Be careful

Downcasting can cause errors if done wrongly.

Animal a = new Animal();
Dog d = (Dog) a; // Runtime error

This will crash because:

a is NOT a Dog
Safe way to Downcast

Use instanceof:

if (a instanceof Dog) {
    Dog d = (Dog) a;
    d.bark();
}

instanceof is used to check whether an object belongs to a particular class or not.
It returns:

true → if object belongs to that class
false → if it doesn’t

Simple Real-Life Analogy

Think like this:

Animal = General category
Dog = Specific type

Upcasting:

Treating a Dog as an Animal
("This is an animal")

Downcasting:

Checking and saying
("This animal is actually a dog")

Final Summary
Upcasting = Child -> Parent (safe, automatic)
Downcasting = Parent -> Child (manual, risky)
Use instanceof before downcasting

Mastering Java ArrayList: Important Methods Explained Simply

Jayashree — Sat, 18 Apr 2026 18:14:55 +0000

When you start working with Java, one of the first useful classes you’ll come across is ArrayList. At first, it may look similar to an array, but it solves a major limitation size.

Unlike arrays, an ArrayList can grow and shrink dynamically. You don’t need to worry about defining a fixed size in advance, which makes it very practical in real-world applications.

Let’s go through the most important methods in a simple and relatable way.

Getting Started

Here’s a basic example of creating and using an ArrayList:

package project.com;
import java.util.*;

public class ArraylistMethods {

    public static void main(String[] args) {

        ArrayList<Object> container = new ArrayList<>();

        container.add(10);
        container.add(30.4);
        container.add(true);
        container.add("hiii");
        container.add(10);
        container.add("hello");

        System.out.println(container);
    }
}

In this example, the list stores different types of values. This works because we used Object as the type.

Adding Elements

Adding data is the most common operation. By default, elements are added to the end of the list.

container.add(100);

If needed, you can insert an element at a specific position:

container.add(2, "Java");

This shifts existing elements to the right.

Removing Elements

Removing elements can be done in two ways — using index or value.

container.remove(3);

This removes the element at index 3.

container.remove("hiii");

This removes the first occurrence of the given value.

Combining Lists

Sometimes you may need to combine two lists. That’s where addAll() comes in.

ArrayList<Object> container2 = new ArrayList<>();
container2.add(1);
container2.add(2);

container.addAll(container2);

Now all elements from container2 are added to container.

Clearing the List

If you want to remove everything from a list:

container2.clear();

After this, the list will be empty.

Checking for Values

To check whether a value exists in the list:

container.contains(10);

This returns either true or false, which is useful for validations.

Accessing Elements

To retrieve a value using its index:

container.get(1);

This gives the element at index 1.

Finding the Size

To know how many elements are present:

container.size();

This is commonly used in loops and conditions.

Finding Element Positions

If you want to know where a value appears:

container.indexOf(10); container.lastIndexOf(10);

The first method returns the first occurrence, while the second returns the last occurrence.

Checking if the List is Empty

Before performing operations, it’s sometimes useful to check if the list is empty:

container.isEmpty();

Updating Elements

To replace an existing value:

container.set(1, "Updated Value");

This updates the value at index 1.

Looping Through the List

There are multiple ways to iterate over an ArrayList.

Using an iterator:

Iterator<Object> it = container.iterator();

while(it.hasNext()) {
    System.out.println(it.next());
}

Sorting and Reversing

You can also manipulate the order of elements.

Collections.sort(container);
Collections.reverse(container);

Sorting works only when all elements are of the same type.

Comparing Two Lists

To check if two lists are equal:

container.equals(container2);

This compares both content and order.

A Small but Important Tip

Instead of using a raw ArrayList, it’s better to define a specific type.

ArrayList<Integer> list = new ArrayList<>();

This improves readability and prevents runtime errors.

Final Thoughts

ArrayList is one of the most commonly used data structures in Java. Once you understand these methods, working with collections becomes much easier.

Focus on practicing operations like adding, removing, accessing, and searching. These form the foundation for solving most real-world problems.

Why Do We Use Collections Instead of Arrays?

Jayashree — Fri, 17 Apr 2026 12:04:10 +0000

If you notice while working with arrays, the size is always fixed. Once you create an array, you can’t directly increase or decrease its size.

Because of that, even for a small change like adding or removing an element, we end up creating a new array and copying all the values. It works, but it feels a bit unnecessary when the data keeps changing.

Let’s see a simple example.

Using Array

int[] arr = {10, 20, 30};

// creating a new array with extra space
int[] newArr = new int[arr.length + 1];

// copying old values
for(int i = 0; i < arr.length; i++) {
    newArr[i] = arr[i];
}

// adding new value
newArr[arr.length] = 40;

Here, just to add one element, we had to create a new array and copy everything manually.

Using Collection (ArrayList)

Now look at the same thing using ArrayList:

import java.util.*;

ArrayList<Integer> list = new ArrayList<>();

list.add(10);
list.add(20);
list.add(30);

// adding new value
list.add(40);

That’s it. No extra steps, no copying needed.

Removing Element

With arrays:

int[] arr = {10, 20, 30, 40};

int[] newArr = new int[arr.length - 1];
int j = 0;

for(int i = 0; i < arr.length; i++) {
    if(arr[i] != 30) {
        newArr[j++] = arr[i];
    }
}

With ArrayList:

list.remove(Integer.valueOf(30));

Much simpler and cleaner.

Since When Is This Available?

Collections were introduced in Java 1.2, and since then they’ve been widely used in real-world applications.

Final Thought

Arrays are still useful when the size is fixed and known.

But if your data changes often, collections make things easier. Less code, fewer steps, and more flexibility.

Autoboxing and unboxing in java

Jayashree — Fri, 17 Apr 2026 11:20:06 +0000

In Java, we usually work with two types of data primitive values like int, double and objects (Non-primitive). At some point, we may need to convert between these two. Java makes this easier with something called autoboxing and unboxing.

Primitive vs Object

Primitive types are simple and store values directly.

int a = 10;

Here, a just holds the value 10.

Objects are a bit different. They don’t store the value directly, instead they refer to a location where the value is stored.

String name = "Java";

Wrapper classes like Integer, Double are also objects. They are mainly used when we need primitives in object form.

Autoboxing

Autoboxing means converting a primitive value into its corresponding object automatically.

int a = 10;
Integer obj = a;

We are not doing any conversion manually here, Java handles it in the background.

Unboxing

Unboxing is just the reverse of that. It converts an object back into a primitive value.

Integer obj = 20;
int b = obj;

Again, no manual work needed.

Why do we even need this?

One common place where this is useful is collections.

For example, ArrayList cannot store primitive values. It only works with objects. So when we add an int, it gets converted automatically.

import java.util.*;

public class Example {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();

        list.add(50);
        int value = list.get(0);

        System.out.println(value);
    }
}

Without autoboxing, we would have to write extra code every time to convert values.

Small thing to watch out for

If you try to unbox a null value, it will cause an error.

Integer obj = null;
int x = obj;

This will throw a NullPointerException. So it’s better to check before using it.

Final note

Autoboxing and unboxing might look like small features, but they actually make coding much easier. Especially when working with collections, this becomes really helpful.

Once you understand this, a lot of things in Java start to make more sense.

Understanding Java Collection Framework in Simple Words

Jayashree — Thu, 16 Apr 2026 13:57:29 +0000

Introduction

In Java, a Collection is a framework that provides architecture to store and manipulate groups of objects. It is part of the Java Collections Framework (JCF) in the package java.util.

What is a Collection?

A Collection is an interface that represents a group of objects (elements). It is the root interface of the collection hierarchy.

What do you understand by Collection Framework in Java?

The Java Collection framework provides an architecture to store and manage a group of objects. It permits the developers to access prepackaged data structures as well as algorithms to manipulate data. The collection framework includes the following:

Interfaces
Classes
Algorithm

All these classes and interfaces support various operations such as Searching, Sorting, Insertion, Manipulation, and Deletion which makes the data manipulation really easy and quick.

Structure of Collection Framework

The Collection Framework is mainly divided into:

Interfaces

They define what operations can be performed.

Examples:

Collection
List
Set
Queue

Classes

They provide implementation of interfaces.

Examples:

ArrayList
LinkedList
HashSet
TreeSet

Algorithms

These are predefined methods used to perform operations.

Example:

Sorting (Collections.sort())
Searching
Shuffling

Why Collection Framework in Java?

Before Collection Framework, Java used arrays.

Arrays had limitations:

Fixed size
Difficult manipulation
No built-in methods

To overcome these issues, Java introduced the Collection Framework.

Advantages:

Dynamic size (grow/shrink easily)
Built-in methods for operations
Easy searching and sorting
Better performance
Code reusability
Standard structure for data handling

Why Collection Uses Interfaces in Java?

Java uses interfaces like Collection, List, and Set to make the framework flexible and powerful.

Interfaces define rules, while classes provide implementation.

Key Reasons:

Flexibility to change implementations easily
Loose coupling (code not dependent on one class)
Multiple implementations for same interface
Common methods across all collections

Supports polymorphism
Real Example

List<String> list = new ArrayList<>();
list = new LinkedList<>();

Same interface, different implementations
No major code changes required

Real-Life Analogy for Understand

Think of Collection interface like a remote control

Remote → Interface
TV / AC / Fan → Different classes

Same control, different behavior

Simple Example

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        list.add("Java");
        list.add("Python");
        list.add("C++");

        System.out.println(list);
    }
}

Advantages of Collection Framework

Dynamic data handling
Easy manipulation
Built-in algorithms
Better performance
Code reusability
Standard architecture

Conclusion

The Java Collection Framework is a powerful system that helps developers store and manage data efficiently. It provides a standard structure with interfaces, classes, and algorithms.

Interfaces make it flexible, reusable, and loosely coupled, making Java programming easier and scalable.

Operators in Java – Complete Guide

Jayashree — Thu, 16 Apr 2026 13:13:36 +0000

In Java, operators are used to perform different kinds of operations on variables and values. Instead of writing long logic, operators help us do things quickly like calculations, comparisons, and decision-making.

For example:

int a = 10;
int b = 5;
int result = a + b;

Here, + is an operator that adds two values.

Types of Operators in Java

Java has several types of operators, each used for a specific purpose.

1. Arithmetic Operators

These are used for basic mathematical operations.

+ → Addition
- → Subtraction
* → Multiplication
/ → Division
% → Remainder

Example:

int a = 10, b = 3;
System.out.println(a + b); // 13
System.out.println(a % b); // 1

2. Relational Operators

Used to compare two values. The result will always be true or false.

==, !=, >, <, >=, <=

Example:

int a = 10, b = 5;
System.out.println(a > b); // true

3. Logical Operators

Used when working with multiple conditions.

&& → AND
|| → OR
! → NOT

Example:

int age = 20;
System.out.println(age > 18 && age < 30);

4. Assignment Operators

Used to assign and update values.

=, +=, -=, *=, /=

Example:

int x = 5;
x += 3; // x = x + 3

5. Increment and Decrement

Used to increase or decrease value by 1.

++, --

Example:

int x = 5;
x++;
x--;

6. Ternary Operator

Shortcut for if-else.

int a = 10, b = 20;
int max = (a > b) ? a : b;

Bitwise Operators

Bitwise operators work on binary values (0s and 1s). They are mostly used in advanced or performance-based programs.

& → AND
| → OR
^ → XOR
~ → NOT
<< → Left Shift
>> → Right Shift

Example:

int a = 5;  // 0101
int b = 3;  // 0011

System.out.println(a & b); // 1
System.out.println(a | b); // 7

Shift Example:

int x = 4;
System.out.println(x << 1); // 8
System.out.println(x >> 1); // 2

Special Operators

These are slightly different but important in Java.

1. instanceof

Checks object type.

String name = "Java";
System.out.println(name instanceof String);

2. Dot Operator (.)

Used to access methods or properties.

System.out.println("Hello".length());

3. Type Casting

Used to convert one datatype to another.

double d = 10.5;
int i = (int) d;

Final Thoughts

Operators are the core part of Java programming. Whether it is calculation, comparison, or decision-making, operators make coding easier and faster.

Once you practice using them in small programs, you will naturally understand where to use each type.

Understanding Datatypes in Java

Jayashree — Fri, 10 Apr 2026 07:21:40 +0000

When you start learning Java, one of the first things you come across is datatypes. At first, it may seem like just syntax, but it actually plays a very important role in how your program works.

What is a Datatype?

A datatype in Java defines what kind of value a variable can store.
In simple terms, it tells the computer whether the data is a number, a character, or something else.

For example:

int age = 25;

Here, int is the datatype, and it tells Java that the variable age will store a number.

Types of Datatypes in Java

Java datatypes are mainly divided into two categories:

1. Primitive Datatypes

Primitive datatypes are the most basic types in Java. They store simple values directly.

There are 8 primitive datatypes:

Integer Types

These are used to store whole numbers.

byte – for small numbers
short – for slightly larger values
int – most commonly used
long – for very large numbers

Example:

int marks = 90;
long distance = 100000L;

Decimal Types

Used for numbers with decimal points.

float – less precision
double – more precision (commonly used)

Example:

float price = 99.5f;
double pi = 3.14159;

Character Type

Used to store a single character.

char grade = 'A';

Boolean Type

Used to store true or false values.

boolean isPassed = true;

2. Non-Primitive Datatypes

Non-primitive datatypes are more complex. Instead of storing the actual value, they store a reference to the value.

String

Used to store text.

String name = "John";

Array

Used to store multiple values in a single variable.

int[] marks = {85, 90, 78};

Class and Object

These are used to create real-world models like Student, Car, etc.

Key Differences

Primitive Datatypes	Non-Primitive Datatypes
Store actual values	Store references
Fixed size	Flexible size
Faster performance	Slightly slower

Easy Way to Understand

Think of it like this:

Primitive datatype → stores the actual value
Non-primitive datatype → stores the address of the value

Conclusion

Datatypes are the foundation of Java programming.
They help define what kind of data you are working with and ensure your program runs correctly.

Choosing the right datatype makes your code more efficient and easier to understand.

Java File Handling Examples – Logging, File Copy, and Finding Maximum Marks

Jayashree — Wed, 08 Apr 2026 13:14:50 +0000

In this blog, we’ll look at three simple and useful Java programs related to file handling:

Writing logs into separate files (error & log)
Copying content from one file to another
Finding the student with the maximum mark and storing it in a file

These examples are beginner-friendly and help understand how Java works with files.

1. Writing Logs into Separate Files

This program demonstrates how to store messages in different files based on their type.
For example:

Error messages go into error.txt
Normal logs go into log.txt

Key Idea:

We check the message type and decide the file path accordingly.

Code:

public static void logExample(String type, String message) {
    String filename = "";

    if (type.equalsIgnoreCase("error")) {
        filename = "error.txt";
    } else if (type.equalsIgnoreCase("log")) {
        filename = "log.txt";
    }

    try (BufferedWriter br = new BufferedWriter(new FileWriter(filename, true))) {
        br.write(message);
        br.newLine();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Output:

error.txt → stores error messages
log.txt → stores normal logs

2. Copying Data from One File to Another

This program reads content from one file and writes it into another file.

Key Idea:

Use BufferedReader to read
Use BufferedWriter to write

Code:

File inputfile = new File("file1.txt");
File outputfile = new File("file2.txt");

try {
    BufferedReader br = new BufferedReader(new FileReader(inputfile));
    BufferedWriter bw = new BufferedWriter(new FileWriter(outputfile));

    String line;

    while ((line = br.readLine()) != null) {
        bw.write(line);
        bw.newLine();
    }

    br.close();
    bw.close();

    System.out.println("File copied successfully...");
} catch (IOException ioe) {
    ioe.printStackTrace();
}

Output:

Content from file1.txt will be copied into file2.txt.

3. Finding Maximum Mark and Writing to File

This program takes student details (id, name, mark), finds the student with the highest mark, and stores the result in a file.

Key Idea:

Store student data in an array
Compare marks to find the maximum
Write result to file

Code:

Student maxStudent = students[0];

for (Student s : students) {
    if (s.mark > maxStudent.mark) {
        maxStudent = s;
    }
}

try (BufferedWriter writer = new BufferedWriter(new FileWriter("max.txt"))) {
    writer.write("Topper Details:\n");
    writer.write("ID: " + maxStudent.id + "\n");
    writer.write("Name: " + maxStudent.name + "\n");
    writer.write("Mark: " + maxStudent.mark + "\n");
} catch (IOException e) {
    e.printStackTrace();
}

Output:

The file max.txt will contain the details of the student with the highest mark.

Conclusion

These three programs cover important concepts in Java:

File writing and appending
File reading and copying
Basic data processing and storing results

Understanding these basics will help you build more advanced applications like logging systems, report generators, and data processing tools.

Understanding File Handling in Java (FileReader, FileWriter, BufferedReader & More)

Jayashree — Tue, 07 Apr 2026 10:50:22 +0000

Working with files is a basic but important part of Java programming. Whether you're storing data, reading logs, or processing text, Java provides several classes to make file handling simple and efficient.

In this post, let’s walk through some commonly used classes:

File
FileReader
FileWriter
BufferedReader
BufferedWriter

1. File Class

The File class is used to represent a file or directory path. It doesn’t actually read or write data — it just gives information about the file.

Example:

import java.io.File;
public class FileExample {
    public static void main(String[] args) {
        File file = new File("example.txt");

        if (file.exists()) {
            System.out.println("File exists");
            System.out.println("File name: " + file.getName());
            System.out.println("Path: " + file.getAbsolutePath());
        } else {
            System.out.println("File does not exist");
        }
    }
}

2. FileReader

FileReader is used to read data from a file character by character. It’s simple but not the most efficient for large files.

Example:

import java.io.FileReader;
import java.io.IOException;

public class FileReaderExample {
    public static void main(String[] args) throws IOException {
        FileReader reader = new FileReader("example.txt");
        int ch;

        while ((ch = reader.read()) != -1) {
            System.out.print((char) ch);
        }

        reader.close();
    }
}

3. FileWriter

FileWriter is used to write text into a file. If the file doesn’t exist, it will be created automatically.

Example:

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterExample {
    public static void main(String[] args) throws IOException {
        FileWriter writer = new FileWriter("example.txt");

        writer.write("Hello, this is a file writing example.");
        writer.close();
    }
}

4. BufferedReader

BufferedReader is used along with FileReader to read text efficiently. It reads larger chunks(a group of characters) instead of one character at a time.

Example:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderExample {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("example.txt"));
        String line;

        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

        br.close();
    }
}

5. BufferedWriter

BufferedWriter is used with FileWriter to write data efficiently. It reduces the number of write operations.

Example:

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterExample {
    public static void main(String[] args) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter("example.txt"));

        bw.write("Hello, this is written using BufferedWriter.");
        bw.newLine();
        bw.write("Writing another line.");

        bw.close();
    }
}

Why Use Buffered Classes?

Without buffering:

Data is read/written one character at a time → slow

With buffering:

Data is handled in chunks(A fixed-size block of data) → faster and more efficient

Final Thoughts

Use File to manage file paths and properties
Use FileReader and FileWriter for basic operations
Use BufferedReader and BufferedWriter for better performance

In real-world applications, buffered classes are preferred because they improve speed and reduce system load.