Forem: Mohammed mhanna

🌳 Mastering Data Structures in Java — Part 8: TreeMap

Mohammed mhanna — Fri, 31 Oct 2025 16:05:16 +0000

If HashMap is all about speed, then TreeMap is all about order.
It’s a powerful data structure when you need your data to stay sorted automatically — by keys.

Let’s explore what makes TreeMap unique and when to use it 👇

🧠 What Is a TreeMap?

A TreeMap in Java is a sorted map implementation based on a Red-Black Tree (a type of self-balancing binary search tree).

It stores key-value pairs just like a HashMap,
👉 but it keeps the keys in sorted order — either by natural ordering or by a custom comparator you define.

import java.util.TreeMap;

public class TreeMapDemo {
    public static void main(String[] args) {
        TreeMap<Integer, String> users = new TreeMap<>();

        users.put(3, "Ali");
        users.put(1, "Sara");
        users.put(2, "Omar");

        System.out.println(users);
    }
}

Output:

{1=Sara, 2=Omar, 3=Ali}
Notice how it sorted the keys automatically 🔥

⚙️ How It Works Internally

TreeMap uses a Red-Black Tree to store entries.

When you insert a key, it finds its correct position in the tree (based on comparison).

The tree stays balanced to keep operations efficient.

This allows O(log n) time for put(), get(), and remove() operations.

In contrast, HashMap uses hashing and provides average O(1) time, but no order.

🔍 Example: Natural Ordering (Strings)

TreeMap<String, Integer> grades = new TreeMap<>();

grades.put("Omar", 85);
grades.put("Sara", 92);
grades.put("Ali", 78);

System.out.println(grades);

Output:

{Ali=78, Omar=85, Sara=92}

Keys are sorted alphabetically.

🧩 Example: Custom Ordering

You can control the sorting logic using a Comparator.

import java.util.*;

public class CustomOrderTreeMap {
    public static void main(String[] args) {
        TreeMap<String, Integer> grades = new TreeMap<>(Comparator.reverseOrder());

        grades.put("Omar", 85);
        grades.put("Sara", 92);
        grades.put("Ali", 78);

        System.out.println(grades);
    }
}

Output:

{Sara=92, Omar=85, Ali=78}

Now it’s in descending order.

⚡ Performance Comparison

Operation	HashMap	TreeMap
Insertion	O(1) avg	O(log n)
Search	O(1) avg	O(log n)
Deletion	O(1) avg	O(log n)
Ordering	❌ Unordered	✅ Sorted
Null Keys	✅ Allowed	❌ Not Allowed

So if you don’t need ordering, go with HashMap.
If order matters, TreeMap is the right choice.

🌍 Where TreeMap Is Used in Real-World Projects

Leaderboards / Rankings

Sort players by score or performance dynamically.

TreeMap<Integer, String> leaderboard = new TreeMap<>(Comparator.reverseOrder());
leaderboard.put(95, "Sara");
leaderboard.put(87, "Ali");
leaderboard.put(92, "Omar");
System.out.println(leaderboard);

Navigable Structures (like Calendar Apps)

Quickly find the next event or previous event using methods like:

higherKey(), lowerKey(), ceilingKey(), floorKey().

Range Queries

Get sub-maps of data between two keys:

TreeMap<Integer, String> map = new TreeMap<>();
map.put(1, "A"); map.put(3, "B"); map.put(5, "C"); map.put(7, "D");

System.out.println(map.subMap(3, 7)); // {3=B, 5=C}

Configuration Management

When property keys must be stored in order (for readability or file export).

🧰 Common Methods

firstKey()
lastKey()
higherKey(K key)
lowerKey(K key)
subMap(K fromKey, K toKey)
headMap(K toKey)
tailMap(K fromKey)

Example:

TreeMap<Integer, String> map = new TreeMap<>();
map.put(1, "A");
map.put(2, "B");
map.put(3, "C");

System.out.println(map.firstKey()); // 1
System.out.println(map.lastKey());  // 3

💡 Pro Tips

Use TreeMap when you care about sorted keys.

For custom sorting, always pass a Comparator in the constructor.

If performance is your top priority, prefer HashMap.

Avoid null keys — they’ll throw NullPointerException.

🧩 Summary

TreeMap brings order to your mappings — it’s ideal when you need your data to stay sorted and searchable by key.
While it’s slower than HashMap, its power lies in navigation and range operations.

Think of it like a map that sorts itself — perfect for leaderboards, calendars, or any data where order matters.

🔥 Mastering Data Structures in Java - Part 7: HashMap

Mohammed mhanna — Thu, 30 Oct 2025 18:40:28 +0000

If you’ve ever needed to store key–value pairs (like usernames and passwords, or IDs and names) — you’ve already been thinking about a HashMap.
It’s one of the most powerful and widely used data structures in Java.

Let’s break it down completely 👇

🧠 What Is a HashMap?

A HashMap in Java is a part of the Collections Framework that stores data as key-value pairs.
It allows fast access, insertion, and deletion based on keys.

✅ Keys are unique
✅ One null key is allowed
✅ Multiple null values are allowed
✅ Not thread-safe by default

import java.util.HashMap;

public class HashMapDemo {
    public static void main(String[] args) {
        HashMap<Integer, String> users = new HashMap<>();

        users.put(101, "Mohammed");
        users.put(102, "Ali");
        users.put(103, "Omar");

        System.out.println(users.get(102)); // Output: Ali
    }
}

⚙️ How HashMap Works Internally

At its core, a HashMap uses an array of buckets.
Each bucket holds a linked list (or a tree since Java 8) of entries that share the same hash.

When you put(key, value):

Java calculates the hash code of the key.
It finds the correct bucket index in the array.
It stores the key–value pair there.
If another entry has the same hash, it’s linked in the same bucket (collision).

When you get(key):

Java finds the hash bucket for the key.
Then checks for equality using equals() to find the correct value.

HashMap<String, Integer> scores = new HashMap<>();
scores.put("Alice", 90);
scores.put("Bob", 85);

System.out.println(scores.get("Alice")); // 90

💡 Tip: Always override both equals() and hashCode() when using custom objects as keys!

🧩 Example: Custom Key

class Employee {
    int id;
    String name;

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

    @Override
    public int hashCode() {
        return id;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Employee)) return false;
        Employee e = (Employee) obj;
        return this.id == e.id;
    }
}

public class Main {
    public static void main(String[] args) {
        HashMap<Employee, Double> salaries = new HashMap<>();
        salaries.put(new Employee(1, "Ali"), 3000.0);
        salaries.put(new Employee(2, "Sara"), 3500.0);

        System.out.println(salaries.get(new Employee(1, "Ali"))); // 3000.0
    }
}

✅ Even though we created a new Employee object, it works because of correctly overridden equals() and hashCode().

⚡ Performance

Average complexity for put(), get(), remove() → O(1)

Worst case (lots of hash collisions) → O(n)

Java 8 improved this by converting long linked lists into balanced trees when collisions become too large.

🧱 When to Use HashMap

Use Case	HashMap?
Need to map keys to values	✅ Yes
Need fast lookup by key	✅ Yes
Need order preserved	❌ No
Need thread-safety	❌ No (Use `ConcurrentHashMap`)
Need sorting by key	❌ No (Use `TreeMap`)

🌍 Where HashMap Is Used in Real-World Projects

Caching Systems
Store recently used data for quick access.

HashMap<String, String> cache = new HashMap<>();
cache.put("user:101", "Ali");

Database Result Mapping
When reading from a database, mapping IDs to entities.

Configurations & Settings
Store app settings as key-value pairs.

Counting Frequency of Words or Items

HashMap<String, Integer> wordCount = new HashMap<>();
for (String word : sentence.split(" ")) {
    wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);
}

Session Management in Web Apps
Track active user sessions using userId as a key.

🧰 Common Methods

put(K key, V value)
get(Object key)
remove(Object key)
containsKey(Object key)
containsValue(Object value)
keySet()
values()
entrySet()
clear()
size()

Example:

for (Map.Entry<Integer, String> entry : users.entrySet()) {
    System.out.println(entry.getKey() + " -> " + entry.getValue());
}

🧩 Pro Tips

Use LinkedHashMap if you need predictable iteration order.

Use ConcurrentHashMap for thread-safe operations.

Avoid mutable keys — changing them breaks the map’s structure.

Load Factor (default 0.75) controls when to resize the hash table.

💡 Summary

HashMap is the backbone of many Java systems — caches, databases, configurations, and beyond.
It’s fast, flexible, and incredibly powerful — but only when you understand how hashing really works.

🧠 Mastering Data Structures in Java — Part 6: HashSet

Mohammed mhanna — Wed, 29 Oct 2025 13:12:42 +0000

🔍 What Is a HashSet?

A HashSet is a collection in Java that stores unique elements — no duplicates allowed.
It’s part of the java.util package and is backed by a HashMap internally.

Think of it like a bag of unique cards 🎴 — if you try to add the same card again, it just ignores it.

⚙️ Quick Example

import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        HashSet<String> countries = new HashSet<>();

        countries.add("Japan");
        countries.add("Canada");
        countries.add("Japan"); // duplicate ignored

        System.out.println(countries); // [Japan, Canada]
        System.out.println("Contains Canada? " + countries.contains("Canada")); // true
    }
}

✅ Output:

[Japan, Canada]
Contains Canada? true

🧠 Notice how “Japan” appears only once — HashSet automatically handles duplicates.

⚙️ How It Works Internally

Under the hood, a HashSet uses a HashMap where:

Elements are stored as keys.

A dummy value (usually a static constant) acts as the value.

When you call add(element):

The element’s hashCode() is computed.

It’s placed into a bucket based on that hash.

If another element has the same hash (collision), it’s stored in a linked list or tree within that bucket.

The equals() method ensures duplicates are not added.

⚙️ Common Methods

Method	Description
`add(E e)`	Adds element if not already present
`remove(Object o)`	Removes element
`contains(Object o)`	Checks if element exists
`isEmpty()`	Returns true if empty
`size()`	Returns number of elements
`clear()`	Removes all elements

🧮 Time Complexity

Operation	Average	Worst Case
add()	O(1)	O(n)
remove()	O(1)	O(n)
contains()	O(1)	O(n)
iteration	O(n)	O(n)

⚡ HashSet provides constant-time performance for most operations — that’s why it’s widely used for lookups and membership checks.

💡 Key Features

🚫 No duplicates — each element is unique.

⚡ Fast lookup using hashing.

🔀 No guaranteed order — iteration order may differ from insertion order.

📦 Allows one null element.

❌ Not thread-safe — use Collections.synchronizedSet() for concurrency.

🔍 Example: Removing Duplicates from a List

import java.util.*;

public class RemoveDuplicates {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
        HashSet<Integer> unique = new HashSet<>(numbers);

        System.out.println(unique); // [1, 2, 3, 4, 5]
    }
}

👉 This is one of the most common and elegant uses of a HashSet.

🔍 Example: Checking Membership Efficiently

HashSet<String> users = new HashSet<>();
users.add("mohammed");
users.add("ahmed");

if (users.contains("mohammed")) {
    System.out.println("Welcome back!");
}

This operation is instant (O(1)) — much faster than searching a list.

🧩 HashSet vs TreeSet vs LinkedHashSet

Feature	HashSet	LinkedHashSet	TreeSet
Order	No order	Maintains insertion order	Sorted order
Speed	Fastest	Slightly slower	Slower (due to sorting)
Backed By	HashMap	LinkedHashMap	TreeMap
Allows Null	Yes	Yes	No
Use Case	Unordered unique items	Preserve insertion order	Sorted unique items

🌍 Real-World Uses of HashSet

🧾 Removing Duplicates

Cleaning up data — for example, user emails or IDs that appear multiple times.

🔐 Checking Membership

Efficient “already exists?” checks (e.g., registered usernames, cached results).

🧠 Tracking Unique Events

Game achievements, visited URLs, or user actions that should happen only once.

🗃 Efficient Lookup Tables

Fast lookups for values without caring about order — like tags, keywords, or filters.

⚙️ Example: Unique Visitors in a Web App

import java.util.HashSet;

public class UniqueVisitors {
    public static void main(String[] args) {
        HashSet<String> visitors = new HashSet<>();

        visitors.add("user123");
        visitors.add("guest456");
        visitors.add("user123"); // duplicate

        System.out.println("Unique visitors: " + visitors.size());
    }
}

✅ Output:

Unique visitors: 2

⚠️ Common Mistakes

❌ Expecting insertion order — HashSet does not maintain it.

❌ Forgetting to override hashCode() and equals() in custom objects.

❌ Using mutable objects as keys — changing them breaks hash consistency.

🧩 Example: Custom Object in HashSet

import java.util.*;

class Student {
    String name;
    int id;

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

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student s = (Student) o;
        return id == s.id;
    }
}

public class CustomHashSet {
    public static void main(String[] args) {
        HashSet<Student> set = new HashSet<>();

        set.add(new Student("Ali", 1));
        set.add(new Student("Ali", 1)); // duplicate ignored

        System.out.println("Total students: " + set.size()); // 1
    }
}

Without overriding hashCode() and equals(), this would incorrectly count as 2 students.

💡 Final Thought

The HashSet is your go-to structure when you want uniqueness and speed without worrying about order.
It’s one of the fastest and most memory-efficient collections in Java — a real workhorse behind the scenes of many high-performance systems. ⚡

🧠 Mastering Data Structures in Java — Part 5: Queue

Mohammed mhanna — Tue, 28 Oct 2025 17:42:20 +0000

🔍 What Is a Queue?

A Queue is a First-In, First-Out (FIFO) data structure.
That means the first element added is the first one removed — just like waiting in line at a coffee shop ☕.

Think of it as a pipeline:

Enqueue → add to the end
Dequeue → remove from the front

In Java, the Queue is part of the java.util package and is represented by the Queue interface.

⚙️ Basic Example

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> orders = new LinkedList<>();

        orders.add("Order #1");
        orders.add("Order #2");
        orders.add("Order #3");

        System.out.println("Orders: " + orders); // [Order #1, Order #2, Order #3]

        System.out.println("Serving: " + orders.poll()); // removes Order #1
        System.out.println("Next in line: " + orders.peek()); // Order #2
    }
}

🧩 Methods:

add(e) → Add element to queue

poll() → Remove and return front element (returns null if empty)

peek() → View front element (without removing)

remove() → Remove front element (throws exception if empty)

⚙️ Queue Implementations in Java

Java offers several ways to implement a Queue — each with different use cases:

Class	Type	Description
`LinkedList`	Non-blocking	Basic FIFO queue
`PriorityQueue`	Non-blocking	Orders elements by priority
`ArrayDeque`	Non-blocking	Double-ended queue (Deque)
`ConcurrentLinkedQueue`	Thread-safe	Non-blocking queue for concurrency
`BlockingQueue`	Thread-safe	Used in producer-consumer patterns

⚙️ Example: PriorityQueue

import java.util.PriorityQueue;

public class PriorityExample {
    public static void main(String[] args) {
        PriorityQueue<Integer> pq = new PriorityQueue<>();

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

        while (!pq.isEmpty()) {
            System.out.println(pq.poll());
        }
    }
}

✅ Output:

10
20
30

Elements are automatically ordered — smallest comes first!

🔁 Real-World Use Cases of Queues

Queues are everywhere — in both system-level and application-level designs:

🖥 1. Task Scheduling

OS schedulers and thread pools use queues to manage jobs in order.

📬 2. Messaging Systems

Message brokers (like Kafka, RabbitMQ, or ActiveMQ) rely on queues to store and process messages sequentially.

🌐 3. Web Servers

Web servers manage client requests using queues to handle high traffic efficiently.

🎮 4. Gaming

Queues manage player actions, events, and network messages to ensure order.

🧮 5. Producer–Consumer Pattern

A background thread produces data, another consumes it — synchronized via a queue.

⚙️ Example: Producer–Consumer with Queue

import java.util.LinkedList;
import java.util.Queue;

public class ProducerConsumer {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();

        // Producer
        for (int i = 1; i <= 5; i++) {
            queue.add(i);
            System.out.println("Produced: " + i);
        }

        // Consumer
        while (!queue.isEmpty()) {
            System.out.println("Consumed: " + queue.poll());
        }
    }
}

🧮 Time Complexity

Operation	Time Complexity
Enqueue	O(1)
Dequeue	O(1)
Peek	O(1)
Search	O(n)

⚠️ Common Mistakes

❌ Using add() and not handling exceptions when queue is full.

❌ Confusing poll() and remove() — poll() is safer.

❌ Using wrong queue type for concurrency.

❌ Expecting random access (queues don’t support indexes).

⚖️ Stack vs Queue

Feature	Stack	Queue
Principle	LIFO	FIFO
Example	Browser Back Button	Task Scheduling
Key Methods	push(), pop(), peek()	add(), poll(), peek()

💡 Final Thought

The Queue is the backbone of many real-world systems — from task schedulers to message queues.
It models the flow of data, requests, and actions in a natural and organized way.

Mastering Queues helps you think like a system designer — not just a programmer. 🧠💪

🧠 Mastering Data Structures in Java — Part 4: Stack

Mohammed mhanna — Mon, 27 Oct 2025 14:20:25 +0000

🔍 What Is a Stack?

A Stack is a Last-In, First-Out (LIFO) data structure.
This means the last element added is the first one to be removed — just like a stack of plates 🍽️.

👉 You can only access the top plate (element) at any given time.

In Java, the Stack is part of the java.util package:

import java.util.Stack;

⚙️ Example: Using Stack in Java

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<String> browserHistory = new Stack<>();

        browserHistory.push("Google");
        browserHistory.push("YouTube");
        browserHistory.push("GitHub");

        System.out.println(browserHistory); // [Google, YouTube, GitHub]

        System.out.println("Top: " + browserHistory.peek()); // GitHub

        browserHistory.pop();
        System.out.println("After back: " + browserHistory); // [Google, YouTube]
    }
}

🧩 Operations:

push() → Add element to top

pop() → Remove top element

peek() → View top element

empty() → Check if stack is empty

search() → Find position of an element

⚙️ Internal Working

Under the hood, Java’s Stack class extends Vector, so it’s synchronized and thread-safe, but slower in single-threaded contexts.

A modern alternative is Deque, which provides faster stack operations:

import java.util.ArrayDeque;

Deque<Integer> stack = new ArrayDeque<>();
stack.push(10);
stack.push(20);
System.out.println(stack.pop()); // 20

🧠 Use ArrayDeque instead of Stack for better performance.

Operation	Time Complexity
Push	O(1)
Pop	O(1)
Peek	O(1)
Search	O(n)

💡 Real-World Uses of Stack

Stacks are everywhere in computer science. Here are a few real-world scenarios:

🧾 1. Undo/Redo Mechanisms

Applications like text editors use stacks to track user actions.

Undo Stack stores previous states.
Redo Stack re-applies undone actions.

🌐 2. Browser Navigation

Every time you visit a page, it’s pushed onto the stack.
When you click “Back,” it pops the last page and shows the previous one.

🧮 3. Expression Evaluation

Stacks are used in:

Converting infix to postfix expressions

Evaluating arithmetic expressions
Example: (3 + 5) * 2 → Processed using stacks.

💻 4. Function Call Stack

Each method call is pushed onto the call stack.
When the method finishes, it’s popped off. This is handled automatically by the JVM.

🔁 5. DFS Algorithms

Depth-First Search (DFS) in graphs uses a stack to keep track of visited nodes.

⚠️ Common Mistakes

❌ Forgetting that Stack is synchronized → may impact performance.

❌ Using Stack where ArrayDeque is better.

❌ Popping from an empty stack → throws EmptyStackException.

Feature	Stack
Principle	LIFO
Core Operations	push(), pop(), peek()
Performance	O(1) for most
Implementation	Vector (synchronized) or ArrayDeque (recommended)
Best For	Backtracking, undo systems, expression parsing, recursion tracking

🧠 Final Thought

A Stack is one of the simplest yet most powerful data structures.
It represents how programs manage memory, logic, and state.
Once you understand stacks, you understand recursion, backtracking, and control flow — all critical to becoming an advanced Java developer. 💪

🧠 Mastering Data Structures in Java - Part 3 - LinkedList

Mohammed mhanna — Sun, 26 Oct 2025 17:47:36 +0000

🔍 What Is a LinkedList?

A LinkedList in Java is a linear data structure where elements (called nodes) are connected using references (links).
Each node stores:

The data itself, and

A reference (or pointer) to the next (and previous) node in the sequence.

In Java, LinkedList is a doubly-linked list — meaning each node knows both its previous and next neighbor.

You’ll find it in the Java Collections Framework:

import java.util.LinkedList;

⚙️ Example

import java.util.LinkedList;

public class Example {
    public static void main(String[] args) {
        LinkedList<String> tasks = new LinkedList<>();

        tasks.add("Write code");
        tasks.add("Test code");
        tasks.add("Deploy app");

        System.out.println(tasks); // [Write code, Test code, Deploy app]

        tasks.addFirst("Plan feature");
        tasks.addLast("Refactor");
        System.out.println(tasks); // [Plan feature, Write code, Test code, Deploy app, Refactor]

        tasks.remove("Test code");
        System.out.println(tasks); // [Plan feature, Write code, Deploy app, Refactor]
    }
}

🧩 How It Works Internally

A LinkedList consists of nodes linked together.
Each node contains:

[ previous | data | next ]

When adding/removing elements:

ArrayList shifts elements → O(n)

LinkedList just changes links → O(1) (if position is known)

However, random access like get(index) is slower → O(n).

⚙️ Common Methods

Method	Description
`add(E e)`	Adds an element at the end
`addFirst(E e)` / `addLast(E e)`	Adds at beginning or end
`remove()` / `removeFirst()` / `removeLast()`	Removes elements
`get(int index)`	Retrieves element by index
`getFirst()` / `getLast()`	Retrieves first or last element
`size()`	Returns list size
`clear()`	Removes all elements

⚖️ LinkedList vs ArrayList

Feature	ArrayList	LinkedList
Structure	Dynamic array	Doubly-linked list
Access time	O(1)	O(n)
Insert/remove (middle)	O(n)	O(1) if node known
Memory usage	Less	More (extra pointers)
Use case	Frequent access	Frequent insert/delete

✅ Rule of thumb:

Choose ArrayList → when you read data often.

Choose LinkedList → when you insert or remove elements often.

🌍 Real-World Use Cases

Music players: Playlist queue (next/previous song navigation)

Undo/Redo systems: Navigating previous and next actions

Web browsers: Forward and backward page navigation

Task scheduling: Maintaining dynamic to-do or job queues

Memory management systems: Storing free/used memory blocks dynamically

Example:

LinkedList<String> browserHistory = new LinkedList<>();
browserHistory.add("Google");
browserHistory.add("StackOverflow");
browserHistory.add("GitHub");

⚡ Pro Tips

Use LinkedList for queues and stacks — it implements both Deque and List interfaces.

Deque<Integer> queue = new LinkedList<>();
queue.add(1);
queue.add(2);
System.out.println(queue.remove()); // 1

Avoid random access like list.get(1000) — it’s slow.
Can contain null elements.
Not thread-safe, so use Collections.synchronizedList() if needed.

🧮 Performance Summary

Operation	Time Complexity
Add/Remove First	O(1)
Add/Remove Last	O(1)
Add/Remove Middle	O(n)
Get by Index	O(n)
Iteration	O(n)

💡 Final Thought

Think of LinkedList as a flexible train — you can easily attach or detach wagons (nodes) without rearranging the entire train.
It might not be as fast to jump between wagons, but it’s perfect when the structure itself keeps changing.

🚀 Mastering Data Structures in Java — Part 2: ArrayList

Mohammed mhanna — Sat, 25 Oct 2025 17:35:50 +0000

If Arrays are the foundation of data storage in Java, then ArrayListis the evolved version — smarter, flexible, and ready for modern programming needs.

In this post, we’ll explore how ArrayListworks, how it differs from arrays, when to use it, and how to get the most out of it in real-world applications.

🔹 What Is an ArrayList?

An ArrayList is a resizable array — part of Java’s java.util package — that grows or shrinks automatically as elements are added or removed.

It’s backed by an internal Array, but you don’t have to worry about resizing or managing indexes manually.

import java.util.ArrayList;

ArrayList<String> names = new ArrayList<>();
names.add("Mohammed");
names.add("Sara");
names.add("Omar");

System.out.println(names); // [Mohammed, Sara, Omar]

🔹 How ArrayList Works Internally

Under the hood, an ArrayList maintains:

A dynamic array to store elements.

A capacity (current size of the internal array).

When the array fills up, a new array with a larger capacity is created, and elements are copied over.

That’s why adding elements can sometimes trigger a resize operation — which is more expensive than a simple insertion.

🧩 Default capacity grows by 50% each time (since Java 8).

🔹 Declaring and Initializing

ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(20);
numbers.add(30);

✅ Using type inference (Java 7+):

ArrayList<String> fruits = new ArrayList<>();

✅ Initializing with values:

ArrayList<String> colors = new ArrayList<>(List.of("Red", "Green", "Blue"));

Method	Description
`add(E e)`	Adds element to the end
`add(int index, E e)`	Inserts element at a specific index
`get(int index)`	Returns element at index
`set(int index, E e)`	Updates element at index
`remove(int index)`	Removes element at index
`size()`	Returns number of elements
`contains(Object o)`	Checks if element exists
`clear()`	Removes all elements

📘 Full Reference: ArrayList (Java SE 8 Docs)

🔹 Example: Managing a To-Do List

import java.util.ArrayList;

public class TodoApp {
    public static void main(String[] args) {
        ArrayList<String> tasks = new ArrayList<>();

        tasks.add("Learn Java");
        tasks.add("Build Projects");
        tasks.add("Read about JVM");

        tasks.remove("Read about JVM");
        tasks.add(1, "Practice Data Structures");

        System.out.println("Tasks: " + tasks);
        System.out.println("First task: " + tasks.get(0));
    }
}

🧾 Output:

Tasks: [Learn Java, Practice Data Structures, Build Projects]
First task: Learn Java

🔹 Differences Between Array and ArrayList

Feature	Array	ArrayList
Size	Fixed	Dynamic
Type	Can hold primitives and objects	Only objects
Syntax	`int[] arr = new int[5];`	`ArrayList<Integer> list = new ArrayList<>();`
Performance	Slightly faster for fixed data	Slightly slower (resize overhead)
Utilities	No built-in utilities	Rich methods (`add`, `remove`, `contains`, etc.)

🌍 Where ArrayLists Are Used in Real-World Projects

ArrayLists are used everywhere in real-world Java applications — especially when you don’t know the size of your data beforehand:

User Management Systems 👥

To store and manage dynamic user data (names, IDs, profiles).

ArrayList<User> users = new ArrayList<>();

E-Commerce Platforms 🛒

To hold lists of products in a shopping cart or search results.

ArrayList<Product> cartItems = new ArrayList<>();

Mobile Applications 📱

To display items in a RecyclerView (Android) — typically backed by an ArrayList.

Log and Event Systems 🧾

To accumulate logs dynamically before writing to a file or database.

ArrayList<String> logs = new ArrayList<>();
logs.add("Application started");
logs.add("User logged in");

🔹 Performance Insights

Operation	Time Complexity	Notes
Access (get/set)	O(1)	Direct index access
Insert at end	Amortized O(1)	Resizing may occur
Insert/remove at middle	O(n)	Elements shifted
Search	O(n)	Linear search
Clear	O(n)	Removes all elements

🧠 Pro Tip:
If you plan heavy insertion/removal operations, consider using a LinkedList
instead.

🔹 Avoid Common Mistakes

🚫 Forgetting Generics:

ArrayList list = new ArrayList(); // ❌ Not type-safe
list.add("Hello");
list.add(123); // Compiles, fails later

✅ Correct:

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

🚫 Using == for value comparison:

if (list.get(0) == "Hello") // ❌

✅ Use .equals() instead:

if (list.get(0).equals("Hello"))

Pro Tips to Master ArrayList

✅ Set an initial capacity if you know approximate data size:

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

This avoids multiple costly resize operations.

✅ Convert between Array and ArrayList:

String[] arr = {"A", "B", "C"};
ArrayList<String> list = new ArrayList<>(Arrays.asList(arr));

✅ Use streams with ArrayList:

list.stream().filter(x -> x.startsWith("A")).forEach(System.out::println);

💬 Final Thought

ArrayLists bring the power of dynamic storage while keeping the simplicity of arrays.
Master them, and you’ll unlock a crucial step toward understanding Java Collections Framework.

Next up in the series:
🔜 LinkedList in Java — When You Need Fast Insertions

🧠 Mastering Data Structures in Java — Part 1: Arrays

Mohammed mhanna — Fri, 24 Oct 2025 14:11:52 +0000

If you’re serious about becoming an excellent Java developer, understanding data structures isn’t optional — it’s essential.
They define how your program organizes and manipulates data, and mastering them will drastically improve your problem-solving and efficiency.

Let’s start from the foundation of all data structures — the Array.

🔹 What Is an Array?

An Array in Java is a container object that holds a fixed number of elements of a single type.

Each element is accessed using an index, starting from 0.
Think of it like labeled boxes 🧱 — each one stores a value, and you can find it instantly if you know the label.

int[] numbers = {10, 20, 30, 40, 50};
System.out.println(numbers[0]); // Output: 10
System.out.println(numbers[4]); // Output: 50

When you create an array, its size is fixed — it can’t grow or shrink.

🔹 How Arrays Work in Memory

Arrays in Java are objects stored on the heap, but their reference lives on the stack.

When you create an array like this:

int[] arr = new int[5];

arr → reference variable (on stack)

new int[5] → actual array object (on heap)

Each index points to a memory location that holds your data.

🔹 Types of Arrays

One-Dimensional Array

String[] fruits = {"Apple", "Banana", "Cherry"};

Multi-Dimensional Array

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6}
};
System.out.println(matrix[1][2]); // Output: 6

Jagged Arrays (arrays of arrays with different sizes)

int[][] jagged = {
    {1, 2},
    {3, 4, 5},
    {6}
};

🔹 Why Use Arrays?

Arrays are fast and efficient for:

Accessing elements directly by index — O(1)

Iterating through elements — O(n)

They’re memory efficient, and they form the foundation of higher-level data structures like ArrayList, Stack, and Queue.

But they also have limitations:

❌ Fixed size once created

❌ Costly insertions or deletions in the middle

❌ Lack of built-in resizing or dynamic memory handling

That’s why we have collections like ArrayList — but to understand those, you must master arrays first.

🌍 Where Arrays Are Used in Real-World Projects

Arrays aren’t just for theory or beginner examples — they play a crucial role behind the scenes in almost every Java project:

Game Development 🎮

Arrays are used to store:

Game maps or grids (e.g., tiles in a 2D game)

Player inventories

Coordinates and movement history

char[][] map = {
    {'#', '#', '#'},
    {'#', 'P', ' '},
    {'#', '#', '#'}
};

Data Processing and Analytics 📊

When processing numeric datasets, arrays hold large volumes of data efficiently for computation.

Example:
Processing sensor readings, financial data, or temperature logs

double[] temperatures = {22.5, 21.8, 23.1, 24.0};

Image and Audio Processing 🎧

Images are stored as pixel arrays; sounds are stored as waveform arrays.

int[][] image = new int[1080][1920]; // pixel values

System-Level Programming ⚙️

Arrays are heavily used in:

Buffer management
Networking (byte arrays)
Reading/writing data streams

byte[] buffer = new byte[1024];
inputStream.read(buffer);

Machine Learning / AI 🤖

Libraries often rely on multi-dimensional arrays (tensors) for operations like:

Matrix multiplications
Feature scaling
Weight storage

🔹 Common Array Operations

Traversing an Array

int[] nums = {1, 2, 3, 4, 5};
for (int num : nums) {
    System.out.println(num);
}

Finding the Maximum Element

int max = nums[0];
for (int i = 1; i < nums.length; i++) {
    if (nums[i] > max) {
        max = nums[i];
    }
}
System.out.println("Max: " + max);

Copying Arrays

✅ Using System.arraycopy()

int[] src = {1, 2, 3};
int[] dest = new int[3];
System.arraycopy(src, 0, dest, 0, src.length);

✅ Using Arrays.copyOf()

int[] copied = Arrays.copyOf(src, src.length);

Sorting Arrays

import java.util.Arrays;

int[] arr = {5, 2, 8, 1, 3};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [1, 2, 3, 5, 8]

Searching in Arrays

int index = Arrays.binarySearch(arr, 5);
System.out.println("Found at index: " + index);

🔹 Best Practices When Working with Arrays

✅ Use meaningful names

int[] studentScores = new int[10];

✅ Always check array bounds
Accessing an invalid index causes:

ArrayIndexOutOfBoundsException

✅ Use Arrays class for utilities
java.util.Arrays
provides methods like sort(), equals(), copyOf(), and fill().

✅ Prefer Collections for flexibility
If your data size is not fixed, use ArrayList
instead.

🔹 Practical Example: Counting Even Numbers

public class EvenCounter {
    public static void main(String[] args) {
        int[] numbers = {2, 5, 8, 10, 13, 20};
        int count = 0;

        for (int n : numbers) {
            if (n % 2 == 0) count++;
        }

        System.out.println("Even numbers: " + count);
    }
}

🔹 Common Mistakes to Avoid

🚫 Forgetting new when creating arrays:

int[] arr; 
arr = {1, 2, 3}; // ❌ Error

✅ Correct:

int[] arr = new int[]{1, 2, 3};

🚫 Mixing array types:

int[] arr = {1, 2, "three"}; // ❌ Error

💡 Final Thought

Arrays may seem simple, but mastering them teaches you how Java handles memory and performance at a low level.
Once you get Arrays deeply, you’ll understand why Java Collections are built the way they are — and you’ll use them more intelligently.

Next up in the series:
🚀 “ArrayList in Java — Dynamic Arrays that Grow with You”

🧬 Java Supports Single Inheritance Only — But!

Mohammed mhanna — Thu, 23 Oct 2025 18:16:21 +0000

If you’ve ever heard that “Java supports only single inheritance”, you might think Java is limited compared to languages like C++ that allow multiple inheritance.

But the truth is... Java gives you the best of both worlds — simplicity and flexibility — without the messy diamond problems. Let’s break it down 👇

🧩 What Is Inheritance in Java?

Inheritance allows one class to acquire the properties and behaviors (fields and methods) of another.

It’s one of the core pillars of Object-Oriented Programming (OOP).

class Animal {
    void eat() {
        System.out.println("Eating...");
    }
}

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

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();  // Inherited
        d.bark(); // Own behavior
    }
}

✅ Dog inherits from Animal.
✅ We get code reuse and a clear hierarchy.

🚫 Why Only Single Inheritance?

In Java, a class cannot inherit from more than one class:

class A {}
class B {}
class C extends A, B {} // ❌ Compilation error

Reason?
To avoid ambiguity and complexity that come from multiple inheritance.

Imagine both A and B have a method show().
If C inherits from both, which show() should it call?

That’s the famous “Diamond Problem” 💎

💡 But Wait — Java Isn’t Limited!

Even though Java restricts multiple inheritance for classes,
it allows multiple inheritance through interfaces ✅

⚙️ Example: Multiple Inheritance via Interfaces

interface CanFly {
    void fly();
}

interface CanSwim {
    void swim();
}

class Duck implements CanFly, CanSwim {
    public void fly() {
        System.out.println("Flying...");
    }

    public void swim() {
        System.out.println("Swimming...");
    }
}

public class Main {
    public static void main(String[] args) {
        Duck d = new Duck();
        d.fly();
        d.swim();
    }
}

✅ A class can implement multiple interfaces
✅ Avoids ambiguity because interfaces only declare methods — they don’t provide full implementations (unless using default methods, handled explicitly).

🧠 Why Interfaces Solve the Problem

Interfaces give Java a way to provide multiple behavior types safely:

They specify what a class should do, not how.

The implementing class defines the actual behavior.

No confusion — no diamond problem.

And since Java 8, interfaces can also have default methods,
but if there’s a conflict, the implementing class must override it — giving full control to the developer.

Feature	Multiple Inheritance Allowed?	Example
Classes	❌ No	`class C extends A, B` (not allowed)
Interfaces	✅ Yes	`class C implements X, Y`
Mix (Class + Interfaces)	✅ Yes	`class C extends A implements X, Y`

🧭 The Real Takeaway

Java chose clarity over chaos.
You still get multiple behaviors through interfaces,
but without the dangers of conflicting implementations.

👉 So yes — Java supports single inheritance of classes,
but multiple inheritance of type definitions (interfaces).

💬 Final Thought

Think of it this way:

Java lets you inherit structure once,
but inherit abilities many times. 💪

❓Question for You

Do you prefer using interfaces for flexibility or abstract classes for structured hierarchies?
Share your thoughts in the comments 👇

🔒public, private, and protected in Java

Mohammed mhanna — Wed, 22 Oct 2025 18:00:36 +0000

n Java, access modifiers control who can see or use your class members (fields, methods, or constructors).

They’re one of the pillars of encapsulation, helping you protect your code and define clear boundaries between classes.

Let’s break down the three most important ones — public, private, and protected — and when to use each 👇

🧩 What Are Access Modifiers?

Access modifiers define the visibility of a class or its members across your project.

In Java, we mainly use:

public → visible everywhere

private → visible only inside the same class

protected → visible in the same package + subclasses

There’s also default (package-private) when no modifier is specified — visible only inside the same package.

🌍 public: Accessible Everywhere

A public member can be accessed from anywhere — even from another package.

public class Car {
    public String brand;

    public void start() {
        System.out.println("Car started!");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.brand = "Toyota";   // ✅ Allowed
        car.start();            // ✅ Allowed
    }
}

✅ When to use:

For methods or classes that need to be used by many other parts of your program (like APIs or utility methods).

When exposing controlled access to other packages.

📘 More: Java public Access Modifier Docs

🔒 private: Hide and Protect

A private member is only accessible inside the same class.
This is the strongest level of protection and a cornerstone of encapsulation.

public class Account {
    private double balance;

    public void deposit(double amount) {
        if (amount > 0)
            balance += amount;
    }

    public double getBalance() {
        return balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account acc = new Account();
        // acc.balance = 1000; ❌ Error
        acc.deposit(500);       // ✅ Allowed
        System.out.println(acc.getBalance()); // ✅ 500.0
    }
}

✅ When to use:

For sensitive or internal data you don’t want accessed directly.

To maintain control over how values are read or changed (through getters/setters).

📘 More: Encapsulation in Java

🛡 protected: Share with Subclasses

A protected member is accessible:

Inside the same package, and

By subclasses, even if they’re in another package.

class Animal {
    protected void makeSound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    void bark() {
        makeSound(); // ✅ Accessible because Dog extends Animal
        System.out.println("Woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.bark();
    }
}

✅ When to use:

When designing a class meant to be extended, and you want subclasses to reuse some behaviors safely.

📘 More: Protected Access in Java

⚙️ Summary of Access Levels

Here’s a simple reference you can copy easily:

Modifier	Same Class	Same Package	Subclass	Outside Package
`public`	✅	✅	✅	✅
`protected`	✅	✅	✅	❌
default (no modifier)	✅	✅	❌	❌
`private`	✅	❌	❌	❌

🧠 Why Access Modifiers Matter

They’re not just about restrictions — they’re about control and clarity:

They make your classes safer by preventing accidental misuse.

They help you design cleaner APIs.

They make your code easier to maintain, since you decide what’s exposed and what’s hidden.

💡 Best Practices

Start as restrictive as possible (private) and loosen only when necessary.

Keep fields private — use getters/setters to manage access.

Use protected only for intended inheritance.

Use public for APIs or methods meant for other classes/packages.

🧭 Final Thoughts

Access modifiers are one of Java’s simplest yet most powerful features.
They help you protect your codebase, control visibility, and build robust, maintainable systems.

So next time you write a class, think:

“Who really needs to see this?” 👀

❓Question for You

Do you usually design your classes starting with everything private or open them up as you go?
Share your approach in the comments 👇

🧺 Built-in Data Structures in Java

Mohammed mhanna — Tue, 21 Oct 2025 12:30:56 +0000

When you start writing real-world Java programs, managing data efficiently becomes crucial. That’s where Java’s built-in data structures come into play — they help you store, organize, and manipulate data with ease.

Let’s explore the most important ones, when to use each, and how they make your programs more powerful 💪

🧠 What Are Data Structures?

A data structure is a way of organizing and storing data so it can be accessed and modified efficiently.

In Java, the Collections Framework and arrays provide ready-to-use data structures like lists, sets, and maps — all part of java.util.

🧩 1. Arrays

✅ Fixed size and fast access

int[] numbers = {1, 2, 3, 4, 5};
System.out.println(numbers[2]); // Output: 3

When to use:
When the number of elements is known in advance, and you need fast random access.

Limitation:
Size cannot be changed once created.

📘 More: Java Arrays (Official Docs)

📜 2. ArrayList

✅ Dynamic arrays with resizing
✅ Maintains insertion order

import java.util.ArrayList;

ArrayList<String> names = new ArrayList<>();
names.add("Ali");
names.add("Omar");
names.add("Sara");
System.out.println(names); // [Ali, Omar, Sara]

When to use:
When you need a resizable list that can grow or shrink dynamically.

📘 More: ArrayList Docs

🔁 3. LinkedList

✅ Doubly linked structure
✅ Efficient for frequent insertions and deletions

import java.util.LinkedList;

LinkedList<Integer> list = new LinkedList<>();
list.add(10);
list.add(20);
list.addFirst(5);
System.out.println(list); // [5, 10, 20]

When to use:
When you frequently insert or remove elements, especially in the middle of the list.

📘 More: LinkedList Docs

🚦 4. HashSet

✅ Unique elements only
✅ Fast lookups (based on hashing)

import java.util.HashSet;

HashSet<String> set = new HashSet<>();
set.add("Java");
set.add("Python");
set.add("Java"); // duplicate ignored
System.out.println(set); // [Java, Python]

When to use:
When you need to store unique items and don’t care about order.

📘 More: HashSet Docs

🗺 5. HashMap

✅ Stores key-value pairs
✅ Fast retrieval by key

import java.util.HashMap;

HashMap<Integer, String> map = new HashMap<>();
map.put(1, "Ali");
map.put(2, "Omar");
System.out.println(map.get(1)); // Ali

When to use:
When you need to associate keys with values — like a dictionary or lookup table.

📘 More: HashMap Docs

⏫ 6. Stack

✅ Last In, First Out (LIFO) structure

import java.util.Stack;

Stack<String> stack = new Stack<>();
stack.push("First");
stack.push("Second");
System.out.println(stack.pop()); // Second

When to use:
When you need to process elements in reverse order (e.g., undo operations, expression parsing).

📘 More: Stack Docs

⏬ 7. Queue

✅ First In, First Out (FIFO) structure

import java.util.LinkedList;
import java.util.Queue;

Queue<String> queue = new LinkedList<>();
queue.add("Task1");
queue.add("Task2");
System.out.println(queue.remove()); // Task1

When to use:
When you need to process elements in the same order they were added (e.g., scheduling tasks, print jobs).

📘 More: Queue Docs

🧭 Choosing the Right Data Structure

Goal	Use This
Fixed number of items	`Array`
Dynamic list of elements	`ArrayList`
Frequent insertions/removals	`LinkedList`
Unique elements	`HashSet`
Key-value pairs	`HashMap`
LIFO (Reverse order)	`Stack`
FIFO (Normal order)	`Queue`

🧠 Final Thoughts

Java’s built-in data structures are designed to make your life easier — you just need to know which one fits the job.

Start small:

Understand how each structure stores and accesses data.

Practice choosing the right one for the right scenario.

Then explore advanced ones like TreeSet, PriorityQueue, and `ConcurrentHashMap.

❓Question for You

Which built-in data structure do you use most in your Java projects — and why?
Share your answer in the comments 👇

🧩 Understanding the Object Class in Java

Mohammed mhanna — Mon, 20 Oct 2025 11:34:41 +0000

If you’ve ever wondered why every class in Java seems to have methods like toString() or equals(), the answer lies in the Object class — the ultimate parent of all classes in Java.

Let’s dive deep into what makes the Object class so fundamental and how to use it effectively.

🏛 What is the Object Class?

In Java, every class you create implicitly inherits from the Object class — even if you don’t explicitly say so.

That means this:

class MyClass {
    // extends Object implicitly
}

is the same as:

class MyClass extends Object {
}

So, every class you create automatically gains the core methods defined in Object.

🧰 Common Methods from Object

Here are the most commonly used methods that every Java class inherits:

toString()        // Returns a string representation of the object
equals(Object o)  // Compares two objects for equality
hashCode()        // Returns an integer hash code for the object
getClass()        // Returns the runtime class of the object
clone()           // Creates and returns a copy of the object (if supported)
finalize()        // Called before an object is garbage collected (deprecated)

These methods form the foundation of many features in Java — like collections, object comparison, and debugging.

🔍 Example: Using Object Methods

class Student {
    private String name;
    private int id;

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

    @Override
    public String toString() {
        return "Student{name='" + name + "', id=" + id + "}";
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Student)) return false;
        Student other = (Student) obj;
        return this.id == other.id && this.name.equals(other.name);
    }
}

public class Main {
    public static void main(String[] args) {
        Student s1 = new Student("Ali", 1);
        Student s2 = new Student("Ali", 1);

        System.out.println(s1);                   // calls toString()
        System.out.println(s1.equals(s2));        // true, because we overrode equals()
        System.out.println(s1.hashCode());        // inherited from Object (can override)
        System.out.println(s1.getClass().getName()); // Student
    }
}

🧠 Why the Object Class Exists

The Object class provides a common type for all Java objects.

That’s why you can do things like this:

Object obj = new Student("Ali", 1);

or store different types in a single collection (before generics were introduced):

List<Object> list = new ArrayList<>();
list.add("Hello");
list.add(42);
list.add(new Student("Ali", 1));

It’s what makes Java’s type system unified and consistent.

🧩 What Makes It Special

✅ It’s the root of the entire class hierarchy.

✅ It gives you default behavior for essential methods.

✅ It allows polymorphism and generic programming.

✅ It ensures every object in Java can be treated uniformly.

⚠️ A Note About finalize()

The finalize() method in Object was once used to clean up resources before an object is destroyed.

However, it’s now deprecated — unreliable and unnecessary.
👉 Use try-with-resources or explicit cleanup methods instead.

Learn more here: Oracle Docs on Finalize (deprecated)

💬 Final Thoughts

The Object class is like the invisible backbone of Java — always there, supporting everything you build.
Understanding it helps you grasp how inheritance, equality, and type systems truly work under the hood.

❓Question for You

How often do you override methods from the Object class — like equals() and toString() — in your own projects?
Share your experience in the comments 👇