Java Collections Framework & Exception Handling Essentials

☕ #ThinkingInJava — Post No. 6 💡 Tricky Exception Handling Behavior Consider this code: class Test { public static void main(String[] args) { try { System.out.println(10/0); } catch (ArithmeticException e) { System.out.println(10/0); } finally { String s = null; System.out.println(s.length()); } } } 🤔 What will be the final exception? Many expect ArithmeticException. But the output is: Exception in thread "main" java.lang.NullPointerException 🎯 Key Concept 👉 The default exception handler handles only ONE exception at a time — the most recently raised exception. Execution flow: 1️⃣ 10/0 in try → ArithmeticException 2️⃣ 10/0 in catch → ArithmeticException again 3️⃣ s.length() in finally → NullPointerException Since the finally block runs last, the NullPointerException becomes the most recent exception. So the JVM reports NullPointerException, not ArithmeticException. 🔖 Takeaway When multiple exceptions occur, the most recently thrown exception is the one handled by the JVM's default exception handler. #Java #AutomationMeetsFuture #TestAutomationSpecialist

🚀 𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝗝𝗮𝘃𝗮 𝟴 𝗦𝘁𝗿𝗲𝗮𝗺 𝗔𝗣𝗜 𝘄𝗶𝘁𝗵 𝗢𝗻𝗲 𝗖𝗼𝗺𝗽𝗹𝗲𝘁𝗲 𝗘𝘅𝗮𝗺𝗽𝗹𝗲 The 𝗦𝘁𝗿𝗲𝗮𝗺 𝗔𝗣𝗜, introduced in Java 8, allows developers to process collections in a 𝗳𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝗮𝗹 𝗮𝗻𝗱 𝗲𝗳𝗳𝗶𝗰𝗶𝗲𝗻𝘁 𝘄𝗮𝘆. It helps write 𝗰𝗹𝗲𝗮𝗻, 𝗿𝗲𝗮𝗱𝗮𝗯𝗹𝗲, 𝗮𝗻𝗱 𝗰𝗼𝗻𝗰𝗶𝘀𝗲 𝗰𝗼𝗱𝗲 when performing operations on collections. Below is a single example demonstrating multiple Stream operations like `filter`, `map`, `sorted`, `count`, and `collect`. 💻 𝗘𝘅𝗮𝗺𝗽𝗹𝗲 𝗖𝗼𝗱𝗲 ```java import java.util.*; import java.util.stream.*; public class StreamExample { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 3, 6); numbers.stream() .filter(n -> n > 3) .forEach(n -> System.out.println("Filter (>3): " + n)); numbers.stream() .map(n -> n * 2) .forEach(n -> System.out.println("Map (*2): " + n)); numbers.stream() .sorted() .forEach(n -> System.out.println("Sorted: " + n)); long count = numbers.stream() .filter(n -> n > 3) .count(); System.out.println("Count (>3): " + count); List<Integer> result = numbers.stream() .filter(n -> n > 3) .collect(Collectors.toList()); System.out.println("Collected List: " + result); } } ``` 📌 𝗘𝘅𝗽𝗹𝗮𝗻𝗮𝘁𝗶𝗼𝗻 🔹 𝗳𝗶𝗹𝘁𝗲𝗿() – Filters elements based on a condition 🔹 𝗺𝗮𝗽() – Transforms elements into another form 🔹 𝘀𝗼𝗿𝘁𝗲𝗱() – Sorts elements in ascending order 🔹 𝗳𝗼𝗿𝗘𝗮𝗰𝗵() – Performs an action on each element 🔹 𝗰𝗼𝘂𝗻𝘁() – Counts elements in the stream 🔹 𝗰𝗼𝗹𝗹𝗲𝗰𝘁() – Collects results into a collection like a List The Stream API makes Java programs more powerful, readable, and easier to maintain. #Java #Java8 #StreamAPI #Programming #SoftwareDevelopment #Coding #Developers

🚀 Java Series — Day 5: Executor Service & Thread Pool Creating threads manually is easy… But managing them efficiently? That’s where real development starts ⚡ Today, I explored Executor Service & Thread Pool — one of the most important concepts for building scalable and high-performance Java applications. 💡 Instead of creating new threads again and again, Java allows us to reuse a pool of threads — saving time, memory, and system resources. 🔍 What I Learned: ✔️ What is Executor Service ✔️ What is Thread Pool ✔️ Difference between manual threads vs thread pool ✔️ How it improves performance & resource management 💻 Code Insight: import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Demo { public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(3); for (int i = 1; i <= 5; i++) { int task = i; executor.execute(() -> { System.out.println("Executing Task " + task + " by " + Thread.currentThread().getName()); }); } executor.shutdown(); } } ⚡ Why it matters? 👉 Better performance 👉 Controlled thread usage 👉 Avoids system overload 👉 Used in real-world backend systems 🌍 Real-World Use Cases: 💰 Banking & transaction processing 🌐 Web servers handling multiple requests 📦 Background task processing systems 💡 Key Takeaway: Don’t create threads blindly — manage them smartly using Executor Service for scalable and production-ready applications 🚀 📌 Next: CompletableFuture & Async Programming 🔥#Java #Multithreading #ExecutorService #ThreadPool #BackendDevelopment #JavaDeveloper #100DaysOfCode #CodingJourney #LearnInPublic

🔍 @Autowired vs @Inject vs @Resource in Spring In Spring, there are three annotations used for Dependency Injection: 1️⃣ @Autowired 2️⃣ @Inject 3️⃣ @Resource They all inject dependencies, but they come from different specifications and follow different rules. 1️⃣ @Autowired 📌 Provided by: Spring Framework 📌 Package: 'org.springframework.beans.factory.annotation.Autowired' Key Points ✔ Injects dependency by type ✔ Most commonly used in Spring ✔ Supports @Qualifier for resolving multiple beans Example @Autowired private UserService userService; If multiple beans exist: @Autowired @Qualifier("userServiceImpl") private UserService userService; 2️⃣ @Inject 📌 Provided by: Java Dependency Injection (JSR-330) 📌 Package: 'javax.inject.Inject' Key Points ✔ Works similar to @Autowired ✔ Injects dependency by type ✔ Framework independent (not only Spring) Example @Inject private UserService userService; If multiple beans exist: @Inject @Named("userServiceImpl") private UserService userService; 3️⃣ @Resource 📌 Provided by: Java EE (JSR-250) 📌 Package: javax.annotation.Resource Key Points ✔ Injects dependency by name first ✔ If name not found → fallback to type Example @Resource private UserService userService; Or explicitly: @Resource(name = "userServiceImpl") private UserService userService; 🧠 Simple Way to Remember @Autowired → Spring style injection @Inject → Java standard DI @Resource → Name-based injection #SpringBoot #SpringFramework #Java #DependencyInjection #BackendDevelopment

What’s New in Java 26 (Key Features Developers Should Know) 1. Pattern Matching Enhancements Java continues improving pattern matching for switch and instanceof. Example: if (obj instanceof String s) { System.out.println(s.toUpperCase()); } Why it matters: Cleaner, safer type checks with less boilerplate. 2. Structured Concurrency (Evolving) Helps manage multiple concurrent tasks as a single unit. Example: try (var scope = new StructuredTaskScope.ShutdownOnFailure()) { scope.fork(() -> fetchUser()); scope.fork(() -> fetchOrders()); scope.join(); } Why it matters: Simplifies multi-threaded code and error handling. 3. Scoped Values (Better than ThreadLocal) A safer alternative to ThreadLocal for sharing data. Example: ScopedValue<String> user = ScopedValue.newInstance(); ScopedValue.where(user, "admin").run(() -> { System.out.println(user.get()); }); Why it matters: Avoids memory leaks and improves thread safety. 4. Virtual Threads Improvements Virtual threads continue to mature (Project Loom). Example: Thread.startVirtualThread(() -> { System.out.println("Lightweight task"); }); Why it matters: Handle thousands of concurrent requests with minimal resources. 5. Foreign Function & Memory API (Stabilization) Interact with native code without JNI. Example: MemorySegment segment = Arena.ofAuto().allocate(100); Why it matters: High-performance native integration (AI, ML, system-level apps). 6. Performance & GC Improvements Ongoing improvements in: - ZGC - G1 GC - Startup time - Memory efficiency Why it matters: Better latency and throughput for large-scale applications. 7. String Templates (Further Refinement) Simplifies string formatting and avoids injection issues. Example: String name = "Java"; String msg = STR."Hello \{name}"; Why it matters: Cleaner and safer string construction. Stay updated, but adopt carefully especially for non-LTS releases. #Java #Java26 #BackendEngineering #SpringBoot #Concurrency #Performance #SoftwareEngineering

Revision | Day 3 – Java Collections Framework Continuing my Java Backend Revision Series, today I revised the Java Collections Framework, one of the most important parts of Core Java used in almost every backend application. The Collections Framework provides data structures and algorithms to efficiently store and manipulate groups of objects. Key Interfaces in Collections Some of the most commonly used interfaces are: • List – Ordered collection that allows duplicates • Set – Collection that does not allow duplicates • Queue – Used for processing elements in a specific order • Map – Stores data in key–value pairs Backend Use Cases In real backend applications, collections are used for: • Storing database query results • Managing API response data • Caching frequently accessed data • Processing large datasets Key Takeaway Understanding collections is essential for writing efficient backend code and solving coding interview problems. #Java #JavaBackend #JavaCollections #BackendDeveloper #SpringBoot #Programming #InterviewPreparation #LearningInPublic #Spring #Revision #Backend #Software #Developer #2026

💡 Decouple Your Tasks: Understanding the Java ExecutorService 🚀 Are you still manually managing new Thread() in your Java applications? It might be time to level up to the ExecutorService! I've been reviewing concurrency patterns recently and put together this quick overview of why this framework (part of java.util.concurrent) is crucial for building robust, scalable software. The core idea? Stop worrying about the threads and start focusing on the tasks. The ExecutorService decouples task submission from task execution. Instead of your main code managing thread lifecycles, you give the task (a Runnable or Callable) to the ExecutorService. It acts as a smart manager with a dedicated team (a thread pool) ready to handle the workload. Check out the diagram below to see how it works! 👇 Why should you use it? 1️⃣ Resource Management: Creating threads is expensive. Reusing existing threads in a pool saves overhead and prevents your application from exhausting system memory. 2️⃣ Controlled Concurrency: You control the number of threads. You can't overwhelm your CPU if you limit the pool size. 3️⃣ Cleaner Code: It separates the work (your tasks) from the mechanism that runs it (threading logic). Here is a quick example of a Fixed Thread Pool in action: Java // 1. Create a managed pool (3 threads) ExecutorService manager = Executors.newFixedThreadPool(3); // 2. Submit your work (it goes to the queue first) manager.submit(() -> { System.out.println("🚀 Processing data on: " + Thread.currentThread().getName()); }); // 3. Clean up (vital!) manager.shutdown(); Which type of Thread Pool do you find yourself using the most in your projects? (Fixed, Cached, or Scheduled?) Let's discuss in the comments! 👇 #Java #Programming #Concurrency #SoftwareEngineering #Backend #TechTips

🚀 Java String vs StringBuffer vs StringBuilder — Explained Simply Understanding how Java handles memory, mutability, and performance can completely change how you write efficient code. Here’s the quick breakdown 👇 🔒 String Immutable (once created, cannot change) Stored in String Constant Pool (SCP) Memory efficient but costly in loops 🔐 StringBuffer Mutable + Thread-safe Slower due to synchronization Safe for multi-threaded environments ⚡ StringBuilder Mutable + Fast Not thread-safe Best choice for performance-heavy operations 🧠 Real Insight (Important for Interviews): 👉 "java" literals share the same memory (SCP) 👉 new String("java") creates a separate object 👉 s = s + "dev" creates a NEW object every time 👉 StringBuilder.append() modifies the SAME object 🔥 Golden Rule: Constant data → String Multi-threading → StringBuffer Performance / loops → StringBuilder ⚠️ Common Mistake: Using String inside loops 👇 Leads to multiple object creation → memory + performance issues 💬 Let’s Discuss (Drop your answers): Why is String immutable in Java? What happens when you use + inside loops? StringBuilder vs StringBuffer — what do you use by default? Difference between == and .equals()? Can StringBuilder break in multi-threading? 👇 I’d love to hear your thoughts! #Java #JavaDeveloper #Programming #Coding #SoftwareEngineering #InterviewPreparation #TechLearning #BackendDevelopment #PerformanceOptimization #Developers #JavaTips #LearnToCode #CleanCode

Spring Bean Lifecycle – Step by Step Flow 1️⃣ Container Starts The Spring container starts and reads configuration. Example sources: XML configuration Java Config Annotations (@Component, @Bean) 2️⃣ Bean Instantiation Spring creates the bean object. Example: UserService userService = new UserService(); 3️⃣ Dependency Injection Spring injects required dependencies. Example: @Autowired PaymentService paymentService; Spring sets properties and constructor dependencies. 4️⃣ Aware Interfaces (Optional) If the bean implements Aware interfaces, Spring provides container details. Examples: BeanNameAware ApplicationContextAware BeanFactoryAware 5️⃣ BeanPostProcessor (Before Initialization) Spring runs BeanPostProcessor before initialization. Method: postProcessBeforeInitialization() Used for custom processing. 6️⃣ Initialization Spring runs initialization methods. Possible ways: @PostConstruct afterPropertiesSet() (InitializingBean) custom init-method 7️⃣ BeanPostProcessor (After Initialization) Spring runs: postProcessAfterInitialization() Here frameworks often create proxies (AOP). 8️⃣ Bean Ready to Use Now the bean is fully initialized and available for use in the application. 9️⃣ Bean Destruction (Shutdown) When the container stops: Spring calls destruction methods. Examples: @PreDestroy destroy() (DisposableBean) custom destroy-method Simple Flow Diagram Container Start ↓ Bean Instantiation ↓ Dependency Injection ↓ Aware Interfaces ↓ BeanPostProcessor (Before Init) ↓ Initialization ↓ BeanPostProcessor (After Init) ↓ Bean Ready to Use ↓ Bean Destroyed ✅ Short Interview Answer > In Spring, the IoC container manages the bean lifecycle. It starts with bean instantiation, performs dependency injection, executes aware interfaces, calls BeanPostProcessor before and after initialization, runs initialization methods, makes the bean ready for use, and finally calls destruction methods when the container shuts down. #SpringFramework #Java #BackendDevelopment #InterviewPreparation #Learning #Developers #SpringBoot

Still using loops in Java? You might be missing something powerful… 🚀 Day 6 of Prepare with Pankaj 💻 🔹 What is Stream? A Stream is a sequence of elements used to process collections (List, Set) in a functional and efficient way. 🔹 Why use Streams? ✔ Less code (no complex loops) ✔ Better readability ✔ Easy parallel processing 🔹 Common Operations: 👉 filter() Used to filter data Example: Get only even numbers 👉 map() Used to transform data Example: Multiply each number by 2 👉 collect() Used to collect the result into a List or Set 🔹 Simple Example: import java.util.*; import java.util.stream.*; public class Main { public static void main(String[] args) { List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); List<Integer> result = list.stream() .filter(n -> n % 2 == 0) .map(n -> n * 2) .collect(Collectors.toList()); System.out.println(result); } } 💡 Conclusion: Streams help you write clean, concise, and efficient code. Must-know for every Java developer! #Java #Java8 #Streams #BackendDeveloper #Coding #PrepareWithPankaj 🚀