Spring Boot Annotations for Java Developers

Multimap in Java:- In Java, a Multimap is a collection that maps a single key to multiple values. Unlike a standard java.util.Map, which associates each key with exactly one value, a Multimap allows you to store a "one-to-many" relationship efficiently. It is important to note that Multimap is not part of the standard Java Development Kit (JDK). It is primarily provided by popular third-party libraries like Google Guava and Apache Commons Collections. 1. Conceptual Difference Guava's Multimap is the industry standard. It provides two main sub-interfaces:   ListMultimap: Uses a List to store values. It allows duplicate values for the same key and maintains insertion order.     Implementation: ArrayListMultimap, LinkedListMultimap.   SetMultimap: Uses a Set to store values. It does not allow duplicate values for the same key.     Implementation: HashMultimap, TreeMultimap. Example using Guava: ListMultimap<String, String> multimap = ArrayListMultimap.create(); multimap.put("Fruit", "Apple"); multimap.put("Fruit", "Banana"); multimap.put("Vegetable", "Carrot"); // Returns [Apple, Banana] List<String> fruits = multimap.get("Fruit"); // Returns 3 (total entries) int totalEntries = multimap.size(); B. Apache Commons Collections Apache uses the MultiValuedMap interface.   Implementation: ArrayListValuedHashMap, HashSetValuedHashMap. 3. The "Native" Java Way (Java 8+) If you don't want to add a third-party library, you can achieve Multimap behavior using a standard Map<K, Collection<V>> combined with the computeIfAbsent method introduced in Java 8. Standard JDK Implementation: Map<String, List<String>> manualMultimap = new HashMap<>(); // Adds "Apple" to the list under "Fruit", creating the list if it doesn't exist manualMultimap.computeIfAbsent("Fruit", k -> new ArrayList<>()).add("Apple"); manualMultimap.computeIfAbsent("Fruit", k -> new ArrayList<>()).add("Banana"); 4. Why use a Multimap library? While the computeIfAbsent approach works, using a dedicated library like Guava offers several advantages:   Safety: get(key) returns an empty collection instead of null, avoiding NullPointerException.   Cleanliness: You don't have to manually initialize collections or check if a key exists.   Powerful Views: Methods like asMap() return a view of the Multimap as a Map<K, Collection<V>>, and entries() returns a flattened collection of all key-value pairs.   Automatic Cleanup: If you remove the last value for a key, the key is typically removed from the map automatically. #java #javascript #python #csharp #automationtesting

⏳Day 25 – 1 Minute Java Clarity – throw vs throws Two words, one letter difference… huge impact! ⚡ 📌 What is throw? Used to manually throw an exception inside a method. 👉 Followed by an exception object. 📌 What is throws? Used to declare that a method might throw an exception. 👉 Written in the method signature. 📌 Example: class AgeValidator {   // throws declares the exception   void validateAge(int age) throws IllegalArgumentException {     if (age < 18) {       throw new IllegalArgumentException("Age must be 18+"); // throw triggers it     }     System.out.println("Access granted ✅");   }   public static void main(String[] args) {     AgeValidator av = new AgeValidator();     try {       av.validateAge(15);     } catch (IllegalArgumentException e) {       System.out.println(e.getMessage());     }   } } 📌 Key Differences at a Glance: | Feature | throw | throws | | Purpose | Trigger an exception | Declare an exception | | Location | Inside method body | Method signature | | Followed by | Exception object | Exception class name | | Count | One exception at a time | Multiple allowed | 💡 Real-time Example: Think of a security guard 🏢 throw → Guard physically stops you ("You can't enter!") throws → Sign on the door ("ID required to enter") ⚠️ Interview Trap: Can throw handle checked exceptions without try-catch? 👉 NO! Checked exceptions thrown via `throw` must be caught or declared with `throws`! 📌 Quick Tip: java // Multiple exceptions with throws void readFile() throws IOException, FileNotFoundException {   // code } 💡 Quick Summary: ✔ throw → manually raises an exception (action) ✔ throws → warns callers about possible exceptions (declaration) ✔ throw is inside the method, throws is on the method ✔ throw handles one; throws can declare many 🔹 Next Topic → Custom Exceptions in Java Did you know you can throw any object that extends Throwable? Drop 🔥 if this was clear! #Java #ThrowVsThrows #ExceptionHandling #CoreJava #JavaProgramming #JavaDeveloper #BackendDeveloper #1MinuteJavaClarity #100DaysOfCode #Coding

🚀🎊Day 78 of 90 – Java Backend Development ✨🎆 A Memory Leak in Java occurs when objects are no longer being used by the application, but the Garbage Collector (GC) is unable to remove them from the heap memory because they are still being unintentionally referenced. Even though Java has automatic memory management, a leak will slowly consume the available heap space until the JVM throws an OutOfMemoryError (OOM), causing the application to crash. 👉1. How it happens (The "GCRoot" Problem) In Java, an object is eligible for garbage collection if it is "unreachable." The GC starts from GC Roots (like local variables in the active thread or static variables) and traces all references. i) Normal Behaviour: When a method finishes, its local variables are cleared, the objects they pointed to become unreachable, and the GC reclaims the memory. ii) The Leak: An object is "logically" dead (your code doesn't need it anymore), but a "physically" live reference still exists (e.g., a forgotten item in a static List). Because a path still exists from a GC Root, the GC assumes the object is still important and leaves it alone. 👉 2. Common Causes in Java 👉Static Collections Static variables live for the entire lifetime of the JVM. If you add objects to a static List or Map and never remove them, they will stay in memory forever. public class Cache {   private static Map<String, Object> map = new HashMap<>();   // If we never call map.remove(), this grows until OOM } 👉Unclosed resources: Connections to databases, files, or network sockets consume memory. If you don't call .close() (or use try-with-resources), the underlying native buffers may leak. 👉Inner classes: Non-static inner classes hold an implicit reference to their outer class. If the inner class object is passed around or stored, the outer class cannot be garbage collected, even if it's no longer used. 👉 Improper equals() and hashCode(): If you use custom objects as keys in a HashMap but don't implement equals() and hashCode() correctly, the Map won't find the duplicate keys. Instead, it will keep adding new entries every time you "update" a value, leading to a silent leak. 👉3. Symptoms of a memory Leak i) Performance Degradation: The GC runs more and more frequently (and takes longer) as it struggles to find free space, leading to "Stop-the-world" pauses. ii) Increased Memory Usage: The "Old Gen" (Tenured) space of the heap shows a steady upward trend in a sawtooth pattern that never returns to its baseline. iii) OutOfMemoryError: The application eventually crashes with java.lang.OutOfMemoryError: Java heap space. 👉 4. How to Detect and Fix To identify a leak, you need to look "inside" the JVM: i)Heap Dumps: Take a snapshot of the memory using jmap or via your IDE. ii)Analysis Tools: Use tools like Eclipse MAT (Memory Analyzer) or VisualVM. These tools show you which objects are taking up the most space and, more importantly, the "Path to GC Root" that is keeping them alive.

🚀🎊Day 86 of 90 – Java Backend Development ✨🎆 In Java, an Enum (short for "enumeration") is a special data type used to define a collection of constants. Think of it as a way to create a fixed list of predefined values that a variable can hold—like the days of the week, compass directions, or the states of a process. Before enums were introduced in Java 5, developers used public static final constants, which were prone to errors and lacked type safety. Enums solved this by making the code more readable and robust. 👉1. Basic syntax: Defining an enum is similar to defining a class, but you use the enum keyword. By convention, enum constants are written in uppercase. enum Level {  LOW,  MEDIUM,  HIGH } You can then use this enum in your code like this: Level myVar = Level.MEDIUM; 👉2. Why use enums? Type Safety: You can't accidentally assign a value that isn't part of the enum (e.g., you can't set a Level to "SUPER_HIGH" if it isn't defined). i) Readability: It makes it clear to anyone reading your code what the allowed options are. ii) Switch Statements: Enums work beautifully with switch blocks, making logic branching much cleaner. 👉3. Enums are classes: In Java, enums are more powerful than in many other languages because they are effectively classes. This means they can have: i) Fields: To store additional data for each constant. ii) Methods: To perform actions based on the constant. iii) Constructors: To initialize those fields (though they are always private or package-private). 👉Code explanation enum TrafficLight {   RED("STOP"),    YELLOW("CAUTION"),    GREEN("GO");   private String action;   // Constructor   TrafficLight(String action) {     this.action = action;   }   public String getAction() {     return this.action;   } } 👉4. Useful built-in methods: Every Java enum automatically inherits methods from the java.lang.Enum class: i) values() ----->Returns an array of all constants in the enum. ii) ordinal() ----->Returns the index of the constant (starting at 0). iii) valueOf(String)------>Returns the enum constant with the specified string name. 👉5. When to avoid them: While enums are great for fixed sets of data, don't use them if the list of values needs to change at runtime (e.g., a list of users or products from a database). Enums are strictly for compile-time constants. #Java #Enums

Optional Misuse Patterns in Java: The Problem: A user lookup crashes in production with NoSuchElementException. The developer is confused — they used Optional, so it should be safe. But they called .get() directly without checking if the value is present. The Optional wrapper added zero safety. Root Cause: Optional was introduced in Java 8 to make absent values explicit and force callers to handle the empty case. But calling .get() on an empty Optional throws NoSuchElementException — just as calling a method on null throws NullPointe java User u = userRepo.findById(id).get(); That one line is no safer than a null dereference. Optional.get() on an empty Optional throws NoSuchElementException. Calling a method on null throws NullPointerException. Different exception, identical outcome. The Optional wrapper added zero protection. Optional was introduced to make absence explicit and force the caller to handle it. But calling .get() skips the entire contract. You have paid the ceremony tax with zero safety benefit. The other anti-pattern is isPresent() + get() — it works, but it is just a verbose null check. The same bug is still possible if someone removes the isPresent() guard later. Three correct patterns: java // 1 — fail with a meaningful exception (service layer default) .orElseThrow(() -> new UserNotFoundException(id)) // 2 — provide a safe default .orElse(User.anonymous()) // 3 — return Optional to caller, let them decide return userRepo.findById(id); Prevention Checklist: ->Never call Optional.get() without an explicit guard ->Prefer orElseThrow() at service layer — fail fast with meaningful exception ->Use orElseGet() instead of orElse() when the default is expensive to create ->Return Optional<T> from repo/service when absence is expected and valid ->Never use Optional as a method parameter or entity field — only as return type ->Enable IntelliJ inspection: "Optional.get() without isPresent()" Lesson: Optional.get() without a guard is just a different way to write a NPE. Optional forces you to think about the empty case — use its API to handle it. orElseThrow() for service layers. orElse() for defaults. Return Optional when absence is valid. Never call .get() directly. It is not a safe operation. #Java #DataStructures #DSA #SystemDesign #SpringBoot #BackendDevelopment #SoftwareEngineering #JavaDeveloper #Programming

🚀 Java Practice: Custom Exception Handling I’ve been strengthening my core Java skills by practicing Custom Exception Handling, and here’s a small program I built based on a real-world scenario — Driving License Eligibility System. 💡 Concept Used: User-defined (custom) exceptions Exception propagation using throws Handling exceptions with try-catch Real-time validation logic 📌 Scenario: The program checks whether a person is eligible for a driving license based on age: ✅ 18–65 → Eligible ❌ Below 18 → UnderAgeException ❌ Above 65 → OverAgeException ⚙️ What I implemented: Created two custom exception classes: UnderAgeException OverAgeException Used meaningful error messages by overriding getMessage() Structured the program using multiple classes for clarity and modularity 🎯 Key Learning: Custom exceptions help in creating more readable, maintainable, and real-world oriented programs instead of relying only on predefined exceptions. 📚 This practice improved my understanding of how Java handles errors and how we can control program flow effectively. package exception; import java.util.Scanner; public class Goi_Custum_Exception { public static void main(String[] args) { GovOFKarnataka gk = new GovOFKarnataka(); gk.init(); } } class GovOFKarnataka{ void init() { Rto r = new Rto(); r.acceptInput(); try { r.verify(); } catch (Exception e) { // TODO Auto-generated catch block System.out.println(e.getMessage()); } } } class Rto{ int age; void acceptInput() { Scanner scan=new Scanner(System.in); System.out.println("Enter age: "); age=scan.nextInt(); } void verify() throws Exception{ if(age>=18&&age<=65) { System.out.println("Eligible for Driving Licence 🤩"); } else if(age>=65){ Exception oa = new OverAgeException(); throw oa; } else { Exception ua = new UnderAgeException(); throw ua; } } } class UnderAgeException extends Exception{ @Override public String getMessage() { return "Under Age Come After 18"; } } class OverAgeException extends Exception{ @Override public String getMessage() { // TODO Auto-generated method stub return "Over age you can go on others vehicle 😊"; } }

⏳Day 28 – 1 Minute Java Clarity – ArrayList vs LinkedList Both are Lists… but they work very differently! ⚡ 📌 ArrayList: Backed by a dynamic array internally. 👉 Best for frequent read/search operations. 📌 LinkedList: Backed by a doubly linked list internally. 👉 Best for frequent insert/delete operations. 📌 Example: import java.util.*; public class ListComparison {   public static void main(String[] args) {     // ArrayList     List<String> arrayList = new ArrayList<>();     arrayList.add("Alice");     arrayList.add("Bob");     arrayList.add(1, "Charlie"); // insert at index 1 – slow!     System.out.println(arrayList); // [Alice, Charlie, Bob]     // LinkedList     LinkedList<String> linkedList = new LinkedList<>();     linkedList.add("Alice");     linkedList.add("Bob");     linkedList.addFirst("Charlie"); // insert at start – fast! ✅     System.out.println(linkedList); // [Charlie, Alice, Bob]   } } 📌 Head-to-Head Comparison: | Feature | ArrayList | LinkedList | |---|---|---| | Internal Structure | Dynamic Array | Doubly Linked List | | Search (get) | O(1) ⚡ Fast | O(n) 🐢 Slow | | Insert/Delete (middle) | O(n) 🐢 Slow | O(1) ⚡ Fast | | Memory | Less (stores data) | More (stores data + pointers) | | Best for | Read-heavy apps | Write-heavy apps | 💡 Real-time Example: 📚 Library System: ArrayList → Finding a book by shelf number (direct index access) ⚡ LinkedList → Adding/removing books frequently from shelves (no shifting needed) ✅ ⚠️ Interview Trap: Which is faster for iteration? 👉 ArrayList is faster for iteration due to memory locality (cache friendly). 👉 LinkedList nodes are scattered in memory → more cache misses. 📌 Pro Tip: // Use ArrayList by default List<String> list = new ArrayList<>(); // Switch to LinkedList only when insert/delete at ends is the main operation Deque<String> deque = new LinkedList<>(); // used as a Queue/Stack 💡 Quick Summary: ✔ ArrayList → fast read, slow insert/delete (middle) ✔ LinkedList → slow read, fast insert/delete ✔ ArrayList uses less memory ✔ LinkedList doubles as a Queue and Stack ✔ Default choice → ArrayList ✅ 🔹 Next Topic → HashMap Deep Dive in Java Did you know ArrayList grows by 50% of its size when full? Drop 🔥 if this was new to you! #Java #ArrayList #LinkedList #JavaCollections #CoreJava #JavaProgramming #JavaDeveloper #BackendDeveloper #1MinuteJavaClarity #100DaysOfCode #DataStructures

🚀 Hey folks! I’m back with a Java concept — let’s decode Singleton in the simplest way possible 😄 🤔 What is Bill Pugh Singleton? (pronounced like “Bill Pew” 😄) Many of you know the Singleton pattern, but did you know there are multiple ways to implement it? 👉 Let’s quickly list them: 1️⃣ Eager Initialization 2️⃣ Lazy Initialization 3️⃣ Synchronized Singleton 4️⃣ Double-Checked Locking 5️⃣ Bill Pugh Singleton (Best Practice ⭐) 6️⃣ Enum Singleton (Most Secure) 🧠 Why Bill Pugh Singleton? It was popularized by Java expert Bill Pugh as a clean + efficient solution. 👉 It uses: Static inner class JVM class loading No locks, no volatile 🔥 Key Benefits ✔ Lazy loading (created only when needed) ✔ Thread-safe ✔ No synchronized overhead ✔ High performance ✔ Clean & simple ⚙️ How It Works (Internally) Step 1: Class Load Singleton s = Singleton.getInstance(); 👉 Only outer class loads ❗ Inner class NOT loaded yet Step 2: Method Call return Holder.INSTANCE; 👉 Now JVM triggers inner class loading Step 3: Inner Class Loads private static class Holder 👉 Loaded ONLY when accessed (Lazy 🔥) Step 4: Object Creation private static final Singleton INSTANCE = new Singleton(); 👉 Created once, safely 🔒 Why It’s Thread-Safe? JVM guarantees during class loading: ✔ Only ONE thread initializes ✔ Other threads WAIT ✔ Fully initialized object is shared 👉 Comes from Java Memory Model (JMM) ⚠️ Important Concept: Partial Construction What you THINK happens: Allocate memory Initialize object Assign reference What CAN happen (Reordering ❌): Allocate memory Assign reference ⚠️ Initialize object 💥 Real Problem Thread-1: instance = new Singleton(); Thread-2: System.out.println(instance.value); 👉 Output: Expected: 42   Actual:  0 ❌ 🚨 Object is visible BEFORE full initialization 👉 This is Partial Construction 🛠️ How volatile Fixes It (in DCL) private static volatile Singleton instance; ✔ Prevents reordering ✔ Ensures visibility ✔ Guarantees fully initialized object 🔥 Why Bill Pugh Avoids This? private static class Holder {   private static final Singleton INSTANCE = new Singleton(); } 👉 JVM ensures: No reordering No partial construction Happens-before guarantee 🧵 Internal Flow Thread-1 → creates instance Thread-2 → waits Thread-3 → waits 👉 All get SAME object 🏢 Simple Analogy Main Office = Singleton Storage Room = Holder 🚪 Room stays locked 👉 Opens only when needed 👉 Item created once 👉 Everyone uses same item ⚠️ Limitations ❌ Reflection can break it ❌ Serialization can break it 👉 Use Enum Singleton to fix these 🏁 Final Takeaway 👉 Bill Pugh = Lazy + Thread Safe + No Locks 🚀 💬 If this helped you understand Singleton better, drop a 👍 #Java #Multithreading #DesignPatterns #InterviewPrep #BackendDevelopment

💡 Java Basics Made Clear: `.equals()` vs `.hashCode()` (Plus a Spring Shortcut 🚀) This is one concept that looks simple—but can cause real bugs if misunderstood. 👉 What does `.equals()` do? It checks if two objects have the **same data (same content)**. 👉 What does `.hashCode()` do? It gives a **number (hash value)** that helps Java quickly find objects in collections like HashSet or HashMap. --- ⚠️ The Common Mistake: If you override `.equals()` but NOT `.hashCode()`, Java behaves unexpectedly. 👇 Example: ```java import java.util.*; class Person { String name; Person(String name) { this.name = name; } @Override public boolean equals(Object o) { return ((Person) o).name.equals(this.name); } } public class Test { public static void main(String[] args) { Set<Person> set = new HashSet<>(); set.add(new Person("Kartik")); set.add(new Person("Kartik")); System.out.println(set.size()); // ❌ Output: 2 (Should be 1) } } ``` 🤔 Why? * `.equals()` says both objects are SAME ✅ * But `.hashCode()` is different ❌ * So Java treats them as different objects --- ✅ The Fix: ```java @Override public int hashCode() { return name.hashCode(); } ``` ✔ Now output → `1` (Correct) --- 🚀 Spring / Lombok Shortcut (Best Practice) Instead of manually writing both methods, you can use Lombok: ```java import lombok.*; @Data class Person { private String name; } ``` 👉 `@Data` automatically generates: * `.equals()` * `.hashCode()` * getters, setters, and more You can also use: ```java @EqualsAndHashCode ``` 📌 This avoids human error and keeps code clean. --- 📌 Simple Rule: If two objects are equal using `.equals()` ➡️ They MUST have the same `.hashCode()` --- 🚀 Final Takeaway: * `.equals()` → checks equality * `.hashCode()` → helps in fast lookup * Always override BOTH or use Lombok annotations --- #Java #SpringBoot #Lombok #BackendDevelopment #CodingBestPractices #Developers

𝟒𝟎 𝐄𝐬𝐬𝐞𝐧𝐭𝐢𝐚𝐥 𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭 𝐀𝐧𝐧𝐨𝐭𝐚𝐭𝐢𝐨𝐧𝐬 𝐟𝐨𝐫 𝐃𝐞𝐯𝐞𝐥𝐨𝐩𝐞𝐫s Spring Boot annotations simplify Java application development, crucial for interview preparation. Here’s a curated list: 1.  @Required: Ensures a bean property must be set. 2.  @Autowired: Automatically injects dependencies. 3. @Configuration: Declares @Bean methods in a class. 4. @ComponentScan: Configures component scanning. 5. @Bean: Produces a managed Spring bean. 6. @Qualifier: Specifies bean injection options. 7. @Lazy: Delays bean initialization. 8. @Value: Injects a property value. 9. @Component: Marks a Spring component. 10. @Controller: Handles MVC views. 11. @Service: Marks service layer components. 12. @Repository: Marks DAOs with exception translation. 13. @EnableAutoConfiguration: Enables auto-configuration. 14. @SpringBootApplication: Configures Spring Boot app. 15. @RequestMapping: Maps HTTP methods. 16. @GetMapping: Handles HTTP GET requests. 17. @PostMapping: Maps HTTP POST requests. 18. @PutMapping: Maps HTTP PUT requests. 19. @DeleteMapping: Maps HTTP DELETE requests. 20. @PatchMapping: Maps HTTP PATCH requests. 21. @RequestBody: Binds HTTP request body. 22. @ResponseBody: Binds HTTP response body. 23. @PathVariable: Extracts URI values. 24. @RequestParam: Extracts query parameters. 25. @RequestHeader: Extracts header values. 26. @RestController: Combines @Controller and @ResponseBody. 27. @RequestAttribute: Binds request attributes. 28. @CookieValue: Binds HTTP cookie values. 29. @CrossOrigin: Enables CORS. 30. @Profile: Specifies bean profiles. 31. @Scope: Defines bean scopes. 32. @Conditional: Registers beans conditionally. 33. @Primary: Sets primary autowired beans. 34. @PropertySource: Adds PropertySource to Environment. 35. @EnableAsync: Enables asynchronous methods. 36. @EnableScheduling: Enables scheduled tasks. 37. @EnableCaching: Enables caching. 38. @RestControllerAdvice: Specializes @ControllerAdvice for REST. 39. @JsonIgnoreProperties: Ignores JSON properties. 40. @JsonProperty: Maps JSON properties to Java fields. Preparing for interviews? Start revising these today 𝗜’𝘃𝗲 𝗽𝗿𝗲𝗽𝗮𝗿𝗲𝗱 𝗶𝗻 𝗗𝗲𝗽𝘁𝗵 𝗝𝗮𝘃𝗮 𝗦𝗽𝗿𝗶𝗻𝗴𝗯𝗼𝗼𝘁 𝗯𝗮𝗰𝗸𝗲𝗻𝗱 𝗚𝘂𝗶𝗱𝗲, 𝟏𝟬𝟬𝟬+ 𝗽𝗲𝗼𝗽𝗹𝗲 𝗮𝗿𝗲 𝗮𝗹𝗿𝗲𝗮𝗱𝘆 𝘂𝘀𝗶𝗻𝗴 𝗶𝘁. 𝗚𝗲𝘁 𝘁𝗵𝗲 𝗴𝘂𝗶𝗱𝗲 𝗵𝗲𝗿𝗲: https://lnkd.in/dfhsJKMj keep learning, keep sharing ! #backend #java #springboot