Skip to main content
All Java Snippets Spring JUnit Hibernate 8086
Ankur in Java

Mastering TreeSet in Java: A Guide for Developers

Today, we're diving into an essential part of the Java Collections Framework: the TreeSet class. If you've been working with Java for a while, you've likely encountered HashSet for its blazing fast operations or LinkedHashSet for its predictable iteration order. But what if you need a set that not only stores unique elements but also keeps them in a sorted order? Enter TreeSet – your go-to for naturally ordered or custom-ordered sets. Let's explore its functionalities, advantages, and how to effectively use it in your Java applications. What is a Java TreeSet? In Java, a TreeSet is a concrete implementation of the Set interface, which in turn extends the SortedSet and NavigableSet interfaces. This means it provides all the capabilities of a standard Set (no duplicate elements) along with the power of ordering and navigation. Under the hood, TreeSet is backed by a TreeMap. This is a crucial detail, as TreeMap stores its elements in a Red-Black tree structure. This self-balancing binary search tree ensures that operations like adding, removing, and searching elements have a time complexity of O(log n) – making it very efficient for large datasets. Key Characteristics of TreeSet: Stores Unique Elements: Like all Set implementations, TreeSet does not allow duplicate elements. If you try to add an element that already exists, the operation will be ignored, and the set will remain unchanged. Maintains Sorted Order: This is its defining feature. Elements are stored in ascending order by default, either based on their natural ordering or a custom comparator you provide. No Null Elements: TreeSet does not permit null elements. Attempting to add a null will result in a NullPointerException. This is because null cannot be compared with other elements. Non-Synchronized: TreeSet is not thread-safe. If multiple threads access a TreeSet concurrently and at least one thread modifies it, external synchronization must be performed. You can use Collections.synchronizedSortedSet() for this purpose. Performance: Operations like add(), remove(), and contains() have an average time complexity of O(log n).

2 min read
Ankur in Java

Java Hashtable: A Dive into Synchronized HashMaps

In the world of Java, when you need to store key-value pairs, HashMap is often your first thought. But what if you need thread-safety—what if multiple threads need to access and modify your map concurrently without corrupting its data? Enter Hashtable. While Hashtable might seem like an older, perhaps less frequently used, sibling to HashMap, it offers a distinct advantage: built-in synchronization. Let's explore Hashtable in detail, understanding its characteristics, how to use it, and when it's the right choice. What is Hashtable? java.util.Hashtable is a concrete implementation of the Map interface in Java. It stores data in key-value pairs and uses a hashing mechanism to efficiently store and retrieve objects. Key characteristics include: Synchronization: All public methods of Hashtable are synchronized. This means that only one thread can access a Hashtable instance at a time, ensuring data consistency in a multi-threaded environment. Nulls Not Allowed: Unlike HashMap, Hashtable does not allow null keys or null values. Attempting to insert a null key or value will result in a NullPointerException. Legacy Class: Hashtable is part of Java's legacy collections framework, dating back to Java 1.0. While functional, newer (and often more performant) synchronized map implementations like ConcurrentHashMap are generally preferred for new development. Initial Capacity and Load Factor: Hashtable uses an initial capacity (default 11) and a load factor (default 0.75). When the number of entries exceeds (capacity * load factor), the Hashtable automatically rehashes and increases its capacity.

2 min read
Ankur in Java

The Java LinkedList Class: A Comprehensive Guide

The LinkedList class in Java's Collections Framework is a powerful and flexible implementation of both the List and Deque interfaces. Unlike ArrayList, which is a dynamic array, LinkedList is a doubly-linked list structure. This fundamental difference dictates its performance characteristics and ideal use cases. What is a Doubly-Linked List? A LinkedList stores its elements in individual nodes. Each node contains three parts: The data (the element itself). A pointer to the next node in the sequence. A pointer to the previous node in the sequence. Because it is a doubly-linked list, traversal can happen in both forward and backward directions. Internal Structure Visualization HEAD TAIL ↓ ↓ [null|Data1|→] ↔ [←|Data2|→] ↔ [←|Data3|null]

1 min read
Ankur in Java

The Developer’s Guide to Email Validation in Java: From Basics to Bulletproof

You've built a registration form. Users are signing up. Everything looks great until you check your database and find john@@example..com, test@, and my personal favorite: notanemail. Sound familiar? Email validation isn't just a nice-to-have—it's your first line of defense against bad data, frustrated users, and those 3 AM "why aren't emails working?" emergencies. Let's explore how to validate email addresses in Java using regex patterns that actually work in production. Why Regex for Email Validation? Before we jump into patterns, let's address the elephant in the room: yes, you could validate emails by splitting strings and checking conditions manually. But regex gives you: Conciseness: One pattern instead of dozens of if-else statements Maintainability: Update one regex instead of refactoring spaghetti code Performance: Compiled patterns are surprisingly fast Industry standard: Every developer understands regex (or should!) That said, perfect email validation is impossible. Even RFC-5322 compliant validators can't tell you if [email protected] is real or if the mailbox exists. We're checking format, not deliverability.

1 min read
Ankur in Java

Building Native Installers for Java Applications with JPackage

Creating distributable installers for Java desktop applications has traditionally been a complex process requiring third-party tools and extensive configuration. JPackage, introduced in Java 14 and stabilized in later versions, eliminates this complexity by providing a built-in command-line tool that generates platform-native installers directly from Java applications. Understanding JPackage JPackage is a powerful packaging tool that bundles Java applications with a custom Java Runtime Environment (JRE), producing platform-specific installers such as EXE and MSI for Windows, DMG and PKG for macOS, and DEB and RPM for Linux distributions. This approach ensures end users can install and run applications without requiring a separate Java installation on their systems. The tool integrates with jlink under the hood to create optimized runtime images, resulting in smaller distribution packages that include only the necessary Java modules. JPackage also supports desktop integration features including application shortcuts, Start Menu entries, file associations, and custom icons.

1 min read
Ankur in Java

Sending Emails in Spring Boot 3: A Complete Guide

Email isn't just for newsletters; it's the backbone of modern application workflows. From sending critical account verification links to delivering daily reports, a reliable email system is non-negotiable. Luckily, Spring Boot makes sending emails clean, configurable, and production-ready with its powerful JavaMailSender interface. In this comprehensive guide, we'll walk you through everything you need to know to become an email pro with Spring Boot 3. We'll cover sending plain text and rich HTML emails, handling attachments, and supercharging your system with asynchronous processing for blazing-fast performance. Let's get started. 1. Setting the Stage: Project Setup First things first, we need to tell our Spring Boot project that we intend to use its mail-sending capabilities. We do this by adding a single dependency to our pom.xml file.

1 min read
Ankur in 8086

Introduction to Memory Segmentation in 8086

The complete starting point for 8086 study: the processor's 1978 origins, why Intel built it, its headline features, real-world applications, and the memory segmentation mechanism that lets 16-bit registers address a full 1 MB — with the physical address formula, all four segment registers, overlap rules, .COM vs .EXE differences, and the .MODEL directive.

1 min read
Ankur in Java

Tail vs Non-Tail Recursion in Java: Definitions, Examples, and When It Matters

Quick summary Tail recursion is when a function’s recursive call is the last operation before returning, enabling tail-call elimination in languages/runtimes that support it; non-tail recursion performs additional work after the recursive call returns. In Java, tail-call optimization is not guaranteed by the JVM, so tail recursion does not reduce stack usage unless transformed to iterative code; still, converting non-tail recursion to tail style can make iterative conversion straightforward and avoid stack overflow in production. What is recursion? Recursion is a divide-and-conquer technique where a function calls itself with smaller inputs until a base case is reached, with the JVM allocating a stack frame for each invocation; deep recursion risks StackOverflowError if not controlled. Each call must eventually reduce the problem and hit a base case to terminate safely and predictably.

1 min read
Ankur in Java

Java DelayQueue — A Specialized BlockingQueue for Delayed Elements

In concurrent programming, often you need to schedule work or tasks to happen after a delay: e.g. timeouts, scheduled retries, delayed tasks, rate limiting, delayed processing, etc. Java’s java.util.concurrent package provides a handy queue for such use cases — DelayQueue — which accepts elements that become available only after a specified delay. In this post, we will explore: What is a DelayQueue The Delayed interface How DelayQueue works internally Key methods and behaviors A simple producer/consumer example Real-world use cases & caveats Summary 1. What is DelayQueue DelayQueue<E extends Delayed> is an unbounded blocking queue whose elements must implement the Delayed interface. An element can be retrieved (via take() or poll(...)) only when its delay has expired. Until then, it stays “dormant” inside the queue. Some important characteristics: The head of the queue is the delayed element whose expiration (delay) is earliest (i.e. whose delay will expire first). If no element has expired yet, poll() returns null, and take() blocks until an element becomes available. The queue is unbounded — operations like put() or offer() never block (unless out of memory). The queue uses internal locking (ReentrantLock) for thread safety. Iterators over the queue are weakly consistent and do not guarantee ordered traversal. In short: DelayQueue is like a priority queue (ordered by expiration time) combined with blocking/waiting semantics.

2 min read