DEV Community: Mohamed Ajmal

Collections in Java.

Mohamed Ajmal — Thu, 04 Jun 2026 07:31:10 +0000

Java Collection Framework (JCF) is a set of classes and interfaces that provide ready-made data structures to store and manipulate groups of objects efficiently.

Java provides collection interfaces like List, Set, Map, and Queue, with ready-made classes such as ArrayList, HashSet, HashMap, and PriorityQueue, so you don’t have to write data-handling code from scratch. The Collection Framework improves productivity by making code more reusable, maintainable and faster to develop.

Core Components of the Framework:
The framework is structurally broken down into three main areas.

Interfaces: Abstract data types that define the standard behaviors of different collections.

Classes (Implementations): Concrete, ready-to-use data structures that implement those interfaces.

Algorithms: Polymorphic, static utility methods to perform complex routines like sorting and searching.

Features of Java Collection Framework

Provides ready-to-use data structures (e.g., Array-list, Hash-Set, Hash-map).

Offers interfaces (Collection, List, Set, Map, Queue) to define standard behaviors.

Supports dynamic resizing, unlike arrays with a fixed size.
Includes algorithms (sorting, searching, iteration) via the Collections utility class.

Improves code re-usability and performance by reducing boilerplate code.

Java File Handling.

Mohamed Ajmal — Wed, 03 Jun 2026 06:17:30 +0000

In Java, file handling means working with files like creating them, reading data, writing data or deleting them. It helps a program save and use information permanently on the computer.

Why File Handling is Required?

To store data permanently instead of keeping it only in memory.
To read and write data from/to files for later use.
To share data between different programs or systems.
To organize and manage large data efficiently.

To support file handling, Java provides the File class in the java.io package.

Operations

*Create a File *- In order to create a file in Java, you can use the createNewFile() method. If the file is successfully created, it will return a Boolean value true and false if the file already exists.
Write to a File - We use the FileWriter class along with its write() method in order to write some text to the file.
Read from a File - In Java, the read() method is used with classes like FileReader or InputStream to read data from a file one character or byte at a time.

It returns an integer value representing the character or byte read.When the end of the file is reached, the method returns -1 indicating no more data is available.
canRead a File - canRead() check if the file is readable.

5.canWrite a File - canWrite() checks whether the file can be written to by the program.

Existance of a File - exists() checks whether the specified file or directory exists on the file system.
Getting a path - getAbsolutePath() returns the full path of the file or directory in the file system.
Delete a File - We use the delete() method in order to delete a file.

Exception Handling in Java.

Mohamed Ajmal — Fri, 22 May 2026 06:07:15 +0000

Exception Handling in Java is a mechanism used to handle both compile-time (checked) and runtime (unchecked) exceptions, allowing a program to continue execution smoothly even in the presence of errors.

Handles abnormal conditions that occur during program execution.
Helps maintain program stability by preventing unexpected termination.

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

    int i = 10;
    int j = 0;

    try {
        int ans = i / j;
        System.out.println("Answer: " + ans);
    } catch (ArithmeticException e){
        System.out.println("Error: Division by 0!");
    } 
}

}

Output

Error: Division by 0!

String Methods in Java.

Mohamed Ajmal — Wed, 20 May 2026 07:19:31 +0000

Some Important String Methods in Java:

length() - Returns the length of the string.

EX:
String name = "Ajmal";
System.out.println(name.length());
O/P = 5

charAt() - Returns character at a specific index.

EX:
String name = "Ajmal";
System.out.println(name.charAt(0));
O/P = A

toLowerCase() - Converts string to Lowercase.

EX:
String name = "AJMAL";
System.out.println(name.toLowerCase());
O/P = ajmal

4.toUpperCase()- Converts string to uppercase.

EX:
String name = "ajmal";
System.out.println(name.toUpperCase());
O/P = AJMAL

5.equals() - Compares two strings.

EX:
String a = "Ajmal";
String b = "Ajmal";
System.out.println(a.equals(b));
O/P = true.

6.equalsIgnoreCase() - Compares strings ignoring case.

EX:
String a = "ajmal";
String b = "AJMAL";
System.out.println(a.equalsIgnoreCase(b));
O/P = true

7.contains() - Checks whether string contains given text.

EX:
String text = "Welcome Ajmal";
System.out.println(text.contains("Ajmal"));
O/P = true

8.startsWith() - Checks starting characters.

EX:
String name = "Java Programming";
System.out.println(name.startsWith("Java"));
O/P = true

9.endsWith() - Checks ending characters.

EX:
String name = "Ajmal.pdf";
System.out.println(name.endsWith(".pdf"));
O/P = true.

10.** substring()** - Extracts part of string.

EX:
String text = "WelcomeAjmal";
System.out.println(text.substring(7));
O/P = Ajmal

11.replace()- Replaces characters or words.

EX:
String text = "I like Java";
System.out.println(text.replace("Java", "Python"));
O/P = I like Python.

trim() - Removes spaces from beginning and end.

Ex:
String text = " Java ";
System.out.println(text.trim());
O/P = Java(remove the spaces).

split() - Splits string into array.

EX:
String text = "HTML,CSS,JS";
String[] arr = text.split(",");
System.out.println(arr[0]);
O/P = HTML

indexOf() - Returns index position.

EX:
String text = "Java";
System.out.println(text.indexOf('v'));
O/P = 2

concat() - Joins strings.

EX:
String a = "Java";
String b = "Program";
System.out.println(a.concat(b));
O/P = Java Program

16.valueOf() - Converts other data types to string.

EX:
int num = 100;
String result = String.valueOf(num);
System.out.println(result);
O/P = 100

String in Java.

Mohamed Ajmal — Wed, 20 May 2026 01:04:27 +0000

String is an object that represents a sequence of characters. Unlike some other languages where strings are primitive types or arrays of characters, Java treats every string as an instance of the java.lang.String class.

Creation Methods:

You can create strings in two primary ways:

String Literal: Most common and memory-efficient.String s = "Hello";

Using new Keyword: Creates a new object in heap memory even if the same string already exists in the pool.
String s = new String("Hello");

Key Concepts:

Immutability: Once created, a String object cannot be changed. It actually create a Brand new String objects.

Memory Management: Java uses a special memory area called the String Constant Pool (SCP) to store string literals. If you create multiple strings with the same literal value, they all point to the same object in the pool to save memory.

Essential String Methods:

The Java String Class provides dozens of built-in methods for manipulation:

length() - Returns the number of characters in the string.
charAt - (int index)Returns the character at the specified index.
equals(String another)Compares the actual content of two strings.
substring(int start, int end)Extracts a portion of the string.
toUpperCase() / toLowerCase()Converts the string case.
trim()Removes leading and trailing whitespace.

Mutable Alternatives:

If your program needs to modify strings frequently (like in a loop), use these mutable classes to avoid creating excessive temporary objects.

StringBuilder: Best for single-threaded environments because it is faster (not synchronized).

StringBuffer: Used for multi-threaded environments as it is thread-safe (synchronized).

Abstraction in Java.

Mohamed Ajmal — Wed, 13 May 2026 05:30:52 +0000

Abstraction in Java is a core Object-Oriented Programming (OOP) principle that focuses on hiding internal implementation details and showing only the essential functionality to the user.

Why We Use Abstraction:

Reduces Complexity: By hiding unnecessary technical details, abstraction makes large systems easier to understand, manage, and navigate.

Enhances Security: It protects sensitive internal logic and data by only allowing users to access what is necessary through a public interface.

Improves Maintainability: Changes to the internal code (the "how") do not break the rest of the application as long as the public abstract structure remains the same.

Promotes Code Re-usability: It allows you to define common behaviors in one place (an abstract class) and share them across multiple sub classes.

In Java, we use abstraction when we want to hide the complex implementation details of a system and only show the essential features to the user.

To Improve Maintainability: Since the internal implementation is hidden, you can change the underlying code without affecting the code that uses the abstraction.

How to create: Use the abstract keyword for the class and its unimplemented methods.

How to use: Inherit the abstract class using the extends keyword in a subclass, which must then provide implementations for the abstract methods.

Key Rules for Abstraction:-

No Instantiation: You cannot create an object of an abstract class or an interface.

Method Signature: If a class has at least one abstract method, the class itself must be declared abstract.

Implementation Requirement: Any concrete (non-abstract) subclass extending an abstract class or implementing an interface must override and implement all inherited abstract methods.

Constructors: Abstract classes can have constructors (to initialize shared fields), but interfaces cannot

Encapsulation in Java

Mohamed Ajmal — Tue, 12 May 2026 05:55:46 +0000

Encapsulation in Java is the process of wrapping data (variables) and the code that acts on that data (methods) together as a single unit, typically a class.

Encapsulation in Java is achieved using:

Private data members,
Public getter and setter methods.

Benefits:

Data Control: You can make a class read-only (by providing only getters) or write-only (by providing only setters).

Validation: Setters allow you to add logic to validate data before it is saved (e.g., ensuring an age is not negative).

Security: It protects sensitive internal states from unauthorized modification.

Maintainability: You can change the internal implementation of a class without breaking the code that uses it.

Example : class Programmer {

private String name;

public String getName() { return name; }

public void setName(String name) {

    this.name = name;
}

}

public class Geeks {

public static void main(String[] args){

    Programmer p = new Programmer();
    p.setName("Geek");
    System.out.println("Name=> " + p.getName());
}

}

Output: Name=> Geek

Package in Java.

Mohamed Ajmal — Tue, 21 Apr 2026 06:17:40 +0000

Package is the Primary way to organize the related classes, Interface and sub packages in to shared name space. That helps to improve organization, maintainability, and re-usability.

Defining a package is the primary way to organize related classes, interfaces, and sub-packages into a shared namespace.

Key purposes

Organization: Structures large projects into smaller, manageable, related units, similar to folders in a file directory.

Prevent Naming Conflicts: Allows different parts of a program to use classes with the same name without conflict.

Access Control: Manages visibility of classes, methods, or variables using modifiers like public, protected, or package-private.

Re-usability & Distribution: Packaged code is easier to import, reuse across projects, or distribute as a library.

Types of Packages

Built-in Packages: Provided by the Java API (Standard Library). (TBD)

    java.lang: Core classes like String and Math; automatically

imported into every program.

    java.util: Utility classes for collections, dates, and scanners.

    java.io: Support for input and output operations.


User-defined Packages: Created by developers to organize their own code.

Constructor in Java.

Mohamed Ajmal — Fri, 17 Apr 2026 23:07:02 +0000

A specialized block of code that similar to method that is automatically invoked when an instance of class is created. It's primary purpose is to initialize the state of the new object, often by assigning initial values to instance variables. It is used to set default or user-defined values for the object's attributes

Key Rules

Must match the exact name of the class,
Must not have an explicit return type, not even void,
Automatically called using the new keyword,
Can use access modifiers (public, private, protected) but cannot be abstract, static, final, or synchronized. (TBD)

Types

Default Constructor: Automatically provided by the Java compiler if no constructors are explicitly defined in the class. It initializes numeric fields to 0, boolean to false, and object references to null.
No-Arg Constructor: A constructor explicitly written by the programmer that accepts no parameters.
Parameterized Constructor: Takes one or more parameters to allow objects to be initialized with custom values at creation. (TBD)
Copy Constructor: Used to create a new object by copying the data from an existing instance of the same class. (TBD)

Java variables and Objects.

Mohamed Ajmal — Sat, 04 Apr 2026 05:57:31 +0000

Static variables: These are variables that are shared among all the instances of a class.

Non-static variables: These are variables that belong to each individual instance of a class.

Java Static Variables : When a variable is declared as static, then a single copy of the variable is created and shared among all objects at a class level. Static variables are essentially, global variables.

Java Non-static variables : Non-static variables are variables that belongs to a specified object of a class, it is also known as instance variable.
These variables are declared outside of a method, constructor or block. Each object created from the class gets its own separate copy of these variables.

Ref : https://www.geeksforgeeks.org/java/difference-between-static-and-non-static-variables-in-java/

Difference between static and non-static:

OBJECTS

In Java, an object is an instance of a class, created using the new keyword. The class acts as a blueprint, defining the object's attributes (state) and methods (behavior), while the object is the concrete entity with specific values in memory.

State: Represented by attributes (variables) that store data.

Behavior: Represented by methods (functions) that define the actions an object can perform.

Identity: A unique name or identifier that distinguishes one object from another, even if they have the same state and behavior.

OOPS Concepts in Java.

Mohamed Ajmal — Wed, 01 Apr 2026 05:57:28 +0000

Object-Oriented Programming (OOPS) is a paradigm that organize the code using Classes and objects.

The seven core concepts of Object-Oriented Programming (OOPS) include the four main pillars—Encapsulation, Abstraction, Inheritance, and Polymorphism—along with Classes, Objects, and Association. These concepts allow for modular, reusable, and secure code by organizing software around data rather than functions.

1.Class - Class is the Blueprint or Templates that defines data member (Attributes) and member functions (Behaviors).

2.Object - An instance of a class. It is a real-world entity that holds data and has a specific state and behavior.

3.Encapsulation- Wrapping data (variables) and code (methods) together as a single unit, hiding the internal state from the outside world to protect integrity.

4.Abstraction- Representing essential features while hiding unnecessary background details, simplifying complex systems.

5.Inheritance- The mechanism by which one class (subclass/child) acquires the properties and behaviors of another class (super class/parent), promoting code re-usability.

6.Polymorphism- The ability of an entity (method or object) to take on many forms, allowing one interface to be used for a general class of actions.

Java Basic Errors.

Mohamed Ajmal — Mon, 30 Mar 2026 05:55:20 +0000

public must be start with small letter.

Home.java:1: error: class, interface, enum, or record expected
Public class Home {
^
1 error

2.File name and Class name must be same.

Home.java:1: error: class home is public, should be declared in a file named home.java
public class home {
^
1 error

*In Java, text must always be inside double quotes *

Home.java:3: error: ')' or ',' expected
System.out.println(Hello, World!");
^
Home.java:3: error: unclosed string literal
System.out.println(Hello, World!");
^
2 errors

4.**Java is case-sensitive

You wrote: system ❌
Correct is: System ✅

Java thinks system is a package**

Home.java:3: error: package system does not exist
system.out.println("Hello, World!");
^
1 error

**missed the method name

Java expected an identifier (method name) after void, but it’s missing.**

Home.java:2: error: expected
public static void (String[] args) {
^
1 error