DEV Community: Divya Divya

List and Set in Java

Divya Divya — Thu, 11 Jun 2026 15:15:33 +0000

Why do we use List and Set in Java?

Normal Arrays some limitations:

Array size is fixed and can not be changed dynamically.
There is no built-in control for handling duplicate elements.
Managing and manipulating data can be difficult.

So,we use List and Set in the Java collection Framework to manage data easily.

List in Java:

List is an interface in the Java collection Framework.

Features of List:

Maintain insertion order.
Allows duplicate elements.
Supports index-based access.
Dynamically resizes as needed.

List implementation classes:

ArrayList
LinkedList
Vector
Stack

ArrayList: Stores data using a dynamic array.
ArrayList<String> list = new ArrayList<>();
LinkedList: Stores data using a linked list structure.
LinkedList<String> list = new LinkedList<>();

Example:

Apple
Mango
Apple
Orange

Apple is repeated, so we can use a List.

Set in Java:

Set is an interface in the Java collection Framework.
Features of Set:
Does not allow duplicate elements.
Stores only unique value.
Provides efficient search and insertion operations.
Useful when uniqueness of data is required.

Set implementation classes:

HashSet:Stores unique elements and does not maintain insertion order.
Set<String> set = new HashSet<>();
LinkedHashSet: Stores unique elements and maintains insertion order.
Set<String> set = new LinkedHashSet<>();
TreeSet:Stores unique elements in sorted order.
Set<String> set = new TreeSet<>();

Example:

Apple
Mango
Apple
Orange

Here, "Apple" is added twice.

Apple
Mango
Orange

But, the Set stores it only once because duplicates are not allowed.

Collection Interfaces in Java

Divya Divya — Wed, 10 Jun 2026 10:10:32 +0000

Collection:
Collection is an interface in Java used to store and manage a group of objects.
It is part of the Java Collection Framework.
Collections can automatically change their size by adding or removing elements.
It provides methods such as add(), remove(), and contains().
List, Set, and Queue are subinterfaces of Collection.
It helps in efficient storage and manipulation of data.

List:
List is an interface in the Java Collection Framework.
It stores elements in an ordered sequence.
It allows duplicate values.
Elements can be accessed using their index position.
Common implementations are ArrayList, LinkedList.
It is used when the order of elements is important.

Set:
Set is an interface in the Java Collection Framework.
It stores only unique elements.
Duplicate values are not allowed.
It is used when duplicate elements should be avoided.

File Handling Classes

Divya Divya — Thu, 04 Jun 2026 10:21:15 +0000

File Class:

The File class in Java is used to represent and manage files and directories. It provides methods to create files, check whether a file exists, get file information such as name and path, and delete files. It belongs to the java.io package.

The File class does not read or write data; it is mainly used for file and directory management.

Example:

import java.io.File;
import java.io.IOException;

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

        File file = new File("sample.txt");

        file.createNewFile();

        System.out.println("File Created");
    }
}

FileWriter:

FileWriter is a class in Java used to write character or text data into a file.
It belongs to the java.io package.
It provides methods such as write() to write data , flush() method is used to Save the written text immediately. close() to close the file after writing. The close() method automatically performs a flush before closing.
FileWriter is used to store data permanently in text files.

Example

import java.io.FileWriter;

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

        FileWriter fw = new FileWriter("test.txt", true);

        fw.write("Hello ");
        fw.flush();   // Data immediately written to file

        fw.write("World");
        fw.close();   // Writes remaining data and closes file
    }
}

true => Append mode. Existing data is not deleted; new data is added at the end.

FileReader:

FileReader is a class in Java used to read character or text data from a file. It belongs to the java.io package and provides the

read() method to read data from files.
read() reads one character at a time.
Each character is returned the ASCII value.
(char) ch converts the integer back to a character.
When no more characters are left, read() returns -1.
The loop stops and close() closes the file.

Example

FileReader fr = new FileReader("test.txt");

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

fr.close();

BuffeReader:

BufferedReader is a Java class used to read text data from a file or input stream efficiently. It reads data line by line using a buffer, making reading faster.
It provides the readLine() method, which reads one line at a time and returns it as a String. If there is no more data, it returns null.

Example

BufferedReader br = new BufferedReader(new FileReader("test.txt"));

String line = br.readLine();

System.out.println(line);

br.close();

BuferWriter:

BufferedWriter is a Java class used to write text data to a file efficiently using a buffer.
It reduces the number of file write operations and provides methods such as write(),newLine(), flush(), and close().

Example:

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

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

        BufferedWriter bw = new BufferedWriter(
                                new FileWriter("sample.txt"));

        bw.write("Ram");
        bw.newLine();      // Move to next line
        bw.write("Priya");

        bw.close();
    }
}

Collections in Java

Divya Divya — Thu, 04 Jun 2026 09:58:25 +0000

Collections in Java are used to store and manage groups of objects dynamically. They provide interfaces and classes such as List, Set, Queue, and ArrayList, making it easy to add, remove, search, and manipulate data efficiently.

Without collections, If you want to store many values , you would need seperate variables.

Why Use Collections?

Dynamic size
Easy to add and remove elements
Provides many built-in methods
Makes data management easier

Without collections, If you want to store many values , you would need seperate variables.

The Java Collections Framework:

Interfaces:Interfaces define the data structure.
Implementations:implementation classes provide the actual functionality.
Algorithms:algorithms perform operations such as sorting, searching, and reversing on collections.

Collections of Interfaces:

Collection
List
Set
Queue
Deque
Map

File Handling in Java

Divya Divya — Wed, 03 Jun 2026 11:26:26 +0000

File Handling:

File Handling is used to create, read , write , update , and delete files.
It using the program data stored permanently in the hard disk.So, that program after executed data does not deleted.
Java provides classes such as File , FileWriter , FileReader , BufferWriter and BufferedReader for file handling.

Example:
In a student management system , student details can be saved in a file and read again later when needed.

Why File Handling needed in Java

File handling is necessary for:

Data Persistence: Data saved in a file can be used later, even after the program is closed.
Data Communication: Files help different programs share data with each other.
Large Data Storage: Files can store large amounts of data that cannot fit in memory.
Log Management: Files can store logs to track program activities and help find errors.

Common File Handling Methods:
File handling methods in Java are createNewFile(), exists(), delete(), getName(), getAbsolutePath(), getCanonicalPath(), write(), read(), and close(). These methods are used to create, access, read, write, and manage files.

getAbsolutePath VS getCanonicalPath

AbsolutePath and CanonicalPath are used to get the locaation of a file in Java.

AbsolutePath:Return the complete path of the file exactly as it is specified. It does not remove special symbol like . and .. .

CanonicalPath:Returns the actual and unique path of the file by resolving and removing . and ...

Example

folder/../sample.txt

AbsolutePath
folder\..\sample.txt
Full path as written.

CanonicalPath
sample.txt
Cleaned and actual path.

why objects are passed as arguments in java

Divya Divya — Fri, 29 May 2026 07:51:43 +0000

Objects are passed as arguments in Java to send related data to a method together.It helps reduce passing many separate variables.A method can access object properties using the object reference.It makes the code cleaner and easier to manage.Objects are commonly used for real-world entities like Student, Car, or Employee.In Java, the reference of the object is passed to the method.

Throws
throws is a keyword in Java that is used in the signature of a method to indicate that this method might throw one of the listed type exceptions. The caller to these methods has to handle the exception using a try-catch block.

Declares possible exceptions.
Mainly used with checked exceptions.

Syntax
returnType methodName() throws ExceptionName


class Test {

    static void checkAge(int age) throws Exception {
        if (age < 18) {
            throw new Exception("Not Eligible");
        } else {
            System.out.println("Eligible");
        }
    }

    public static void main(String[] args) {
        try {
            checkAge(15);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

Dynamic Binding in Java?

Divya Divya — Fri, 22 May 2026 16:12:50 +0000

Dynamic binding refers to the process in which linking between method call and method implementation is resolved at run time (or, a process of calling an overridden method at run time).
Dynamic binding is also known as run-time polymorphism or late binding. Dynamic binding uses objects to resolve binding.

Characteristic of Dynamic binding:

Linking − Linking between method call and method implementation is resolved at run time.

Resolve mechanism − Dynamic binding uses object type to resolve binding.

Example − Method overriding is the example of Dynamic binding.

Type of Methods − Virtual methods use dynamic binding.
package com.tutorialspoint;

Example


class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
}

public class Tester {

   public static void main(String args[]) {
      Animal a = new Animal();   // Animal reference and object
      // Dynamic Binding      
      Animal b = new Dog();   // Animal reference but Dog object

      a.move();   // runs the method in Animal class
      b.move();   // runs the method in Dog class
   }
}

Exception in java

Divya Divya — Fri, 22 May 2026 16:11:11 +0000

Exception is an Even.
Exceptions are used to detect and handle errors during program execution so the program can continue safely.

Example

package practice;

public class Home {
     static int a=10;
    static int b=0;

    public static void main(String[] args) {
        System.out.println(a/b);
    }
}

Output

Variable a is store value
Variable b is store value and then java tries to calculate.
but, 10/0 division by zero is impossible because 10/0 is Infinity. So, Java throw an exception.

Why Exception are used?
Exceptions are used in Java to handle errors safely without stopping the entire program suddenly.

Prevent program crashes
Handle runtime errors safely
Maintain normal program flow
Show meaningful error messages

Two types of Exception

Checked Exception
Unchecked Exception

String in java?

Divya Divya — Tue, 19 May 2026 13:22:22 +0000

String:

String is a sequence of character used to store text.
String is class in Java.
String package name of Java.lan.
String are immutable(create once , cannot modified).
length is one of the String method.

Two way of creating String:

1. Literal String

A literal means writing the value directly inside quotes.
Reuses existing object if same value exists.It's Stored in String Pool.Memory efficient.

Example

string s="abc";

2.Using new keyword

newkeyword is used to create a new object manually.
Creates a new object every time.It's Stored in Heap memory.Uses more Memory.

Example

String str=new string("xyz");

Interface in java?

Divya Divya — Thu, 14 May 2026 11:33:24 +0000

Interface
An interface in Java is a blueprint of a class.
It contains methods that a class must implement.

Interface mainly helps to achieve:

Abstraction → hiding implementation details
Multiple inheritance → one class can implement multiple interfaces.

A class uses the implements keyword to implement an interface.
All methods inside an interface are public and abstract by default.
Variables inside an interface are automatically:

public
static
final

Syntax

interface Animal {

    void sound();   // abstract method
}

Abstract in Java?

Divya Divya — Thu, 14 May 2026 03:25:37 +0000

Java Abstract Class

An abstract class in Java is a class declared with the abstract keyword.
It is used to achieve abstraction, which means hiding implementation details and showing only essential functionality.

Key Features of Abstract Class

Cannot create objects directly
Can contain abstract methods and normal methods
Must be inherited by another class
Used as a base class

Syntax

abstract class ClassName {

}

Main Method

Car c = new Car();

Creates object for child class, not abstract class.

Important point

Vehicle v = new Vehicle();

Because abstract class objects cannot be created.

Abstract Method in Java

An abstract method is a method declared without a body.
It contains only the method declaration, and the implementation is provided by the subclass.

Syntax

abstract void sound();

No method body
Ends with semicolon ;

Important points:

Abstract methods can only be inside an abstract class
Child class must implement the abstract method
Used to achieve abstraction.

Rule

If a class contains an abstract method, the class must be abstract.

abstract class Animal {

    abstract void sound();
}

What is Final Keyword In Java?

Divya Divya — Wed, 13 May 2026 05:37:21 +0000

In Java, the final keyword is used to restrict changes and make code more secure and predictable.
It can be applied to variables, methods, and classes to prevent modification, overriding, or inheritance.
This helps in creating constant values, stable methods, and immutable classes.

Final variable: cannot be changed once assigned

Example

class Geeks {
    public static void main(String[] args) {
        final int i;
        i = 20;
        System.out.println(i);
    }
}

Final method: cannot be overridden

Example

class A {
    final void m1() {
        System.out.println("Final method");
    }
}

class B extends A {
    void m1() { } // compile-time error
}

Final class: cannot be inherited.

Example

final class A {
    // fields and methods
}

// Illegal
class B extends A { }