Java orElse() Performance Gotcha

Recently revisited an important Java Streams concept: reduce() - one of the most elegant terminal operations for aggregation. Many developers use loops for summing or combining values, but reduce() brings a functional and expressive approach. Example: List<Integer> nums = List.of(1, 2, 3, 4); int sum = nums.stream() .reduce(0, Integer::sum); What happens internally? reduce() repeatedly combines elements: 0 + 1 = 1 1 + 2 = 3 3 + 3 = 6 6 + 4 = 10 Why it matters: ✔ Cleaner than manual loops ✔ Great for immutable / functional style code ✔ Useful for sum, max, min, product, concatenation, custom aggregation ✔ Common in backend processing pipelines Key Insight: Integer::sum is just a method reference for: (a, b) -> a + b Small concepts like this make code more readable and scalable. Still amazed how much depth Java Streams offer beyond just filter() and map(). #Java #Programming #BackendDevelopment #SpringBoot #JavaStreams #Coding #SoftwareEngineering

𝗝𝗮𝘃𝗮’𝘀 𝗠𝗼𝘀𝘁 𝗔𝗻𝗻𝗼𝘆𝗶𝗻𝗴 𝗢𝘃𝗲𝗿𝗹𝗼𝗮𝗱: List.remove(index) 𝘃𝘀 remove(value) ⚠️ 𝗦𝗮𝗺𝗲 𝗺𝗲𝘁𝗵𝗼𝗱 - 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝗺𝗲𝗮𝗻𝗶𝗻𝗴 🤯 remove(int index) vs remove(Object o) Tiny type change - different behavior. 𝗪𝗵𝗲𝗿𝗲 𝗶𝘁 𝗯𝗿𝗲𝗮𝗸𝘀 🔥 List<Integer> list = new ArrayList<>(List.of(10,20,30)); list.remove(1); // index -> removes 20 Integer i = 1; list.remove(i); // object -> tries to remove 1 𝗦𝗮𝗺𝗲 𝗻𝘂𝗺𝗯𝗲𝗿. 𝗗𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝗿𝗲𝘀𝘂𝗹𝘁 💥 You think index. Java sees object. 𝗡𝗼𝘁 𝗼𝗻𝗹𝘆 𝗹𝗼𝗴𝗶𝗰 - 𝗮𝗹𝘀𝗼 𝗰𝗼𝘀𝘁 🐢 remove(index) - no search remove(value) - extra O(n) lookup 𝗪𝗵𝘆 𝗶𝘁 𝗵𝘂𝗿𝘁𝘀 😤 silent bug same-looking code wrong element or nothing removed 𝗔𝗱𝘃𝗶𝗰𝗲 ✅ Make intent explicit: remove((int) i) or remove(Integer.valueOf(x)) Never rely on overloads in critical paths. #java #backend #softwareengineering #coding #programming #javatips #cleancode #bug #performance

𝐖𝐡𝐲 𝐢𝐬 𝐦𝐲 𝐂𝐮𝐬𝐭𝐨𝐦 𝐀𝐧𝐧𝐨𝐭𝐚𝐭𝐢𝐨𝐧 𝐫𝐞𝐭𝐮𝐫𝐧𝐢𝐧𝐠 𝐧𝐮𝐥𝐥? 🤯 Every Java developer eventually tries to build a custom validation or logging engine, only to get stuck when method.getAnnotation() returns null. The secret lies in the @Retention meta-annotation. If you don't understand these three levels, your reflection-based engine will never work: 1️⃣ SOURCE (e.g., @Override, @SuppressWarnings) Where? Only in your .java files. Why? It’s for the compiler. Once the code is compiled to .class, these annotations are GONE. You cannot find them at runtime. 2️⃣ CLASS (The default!) Where? Stored in the .class file. Why? Used by bytecode analysis tools (like SonarLint or AspectJ). But here's the kicker: the JVM ignores them at runtime. If you try to read them via Reflection — you get null. 3️⃣ RUNTIME (e.g., @Service, @Transactional) Where? Stored in the bytecode AND loaded into memory by the JVM. Why? This is the "Magic Zone." Only these can be accessed by your code while the app is running. In my latest deep dive, I built a custom Geometry Engine using Reflection. I showed exactly how to use @Retention(RUNTIME) to create a declarative validator that replaces messy if-else checks. If you’re still confused about why your custom metadata isn't "visible," this breakdown is for you. 👇 Link to the full build and source code in the first comment! #Java #Backend #SoftwareArchitecture #ReflectionAPI #CleanCode #ProgrammingTips

Understanding the Magic Under the Hood: How the JVM Works ☕️⚙️ Ever wondered how your Java code actually runs on any device, regardless of the operating system? The secret sauce is the Java Virtual Machine (JVM). The journey from a .java file to a running application is a fascinating multi-stage process. Here is a high-level breakdown of the lifecycle: 1. The Build Phase 🛠️ It all starts with your Java Source File. When you run the compiler (javac), it doesn't create machine code. Instead, it produces Bytecode—stored in .class files. This is the "Write Once, Run Anywhere" magic! 2. Loading & Linking 🔗 Before execution, the JVM's Class Loader Subsystem takes over: • Loading: Pulls in class files from various sources. • Linking: Verifies the code for security, prepares memory for variables, and resolves symbolic references. • Initialization: Executes static initializers and assigns values to static variables. 3. Runtime Data Areas (Memory) 🧠 The JVM manages memory by splitting it into specific zones: • Shared Areas: The Heap (where objects live) and the Method Area are shared across all threads. • Thread-Specific: Each thread gets its own Stack, PC Register, and Native Method Stack for isolated execution. 4. The Execution Engine ⚡ This is the powerhouse. It uses two main tools: • Interpreter: Quickly reads and executes bytecode instructions. • JIT (Just-In-Time) Compiler: Identifies "hot methods" that run frequently and compiles them directly into native machine code for massive performance gains. The Bottom Line: The JVM isn't just an interpreter; it’s a sophisticated engine that optimizes your code in real-time, manages your memory via Garbage Collection (GC), and ensures platform independence. Understanding these internals makes us better developers, helping us write more efficient code and debug complex performance issues. #Java #JVM #SoftwareEngineering #Programming #BackendDevelopment #TechExplainers #JavaVirtualMachine #CodingLife

#Post11 In the previous post(https://lnkd.in/dynAvNrN), we saw how to create threads in Java. Now let’s talk about a problem. If creating threads is so simple… why don’t we just create a new thread every time we need one? Let’s say we are building a backend system. For every incoming request/task, we create a new thread: new Thread(() -> { // process request }).start(); This looks simple. But this approach breaks very quickly in real systems because of below mentioned problems. Problem 1: Thread creation is expensive Creating a thread is not just creating an object. It involves: • Allocating memory (stack) • Registering with OS • Scheduling overhead Creating thousands of threads = performance degradation Problem 2: Too many threads → too much context switching We already saw this earlier(https://lnkd.in/dYG3v-vb). More threads does NOT mean more performance. Instead: • CPU spends more time switching • Less time doing actual work Problem 3: No control over thread lifecycle When you create threads manually: • No limit on number of threads • No reuse • Hard to manage failures This quickly becomes difficult to manage as the system grows. So what’s the solution? Instead of creating threads manually: we use something called the Executor Framework. In simple words consider the framework to be like: Earlier, we were manually hiring a worker (thread) for every task. With Executor, we have a team of workers (thread pool), and we just assign tasks to them. Key idea Instead of: Creating a new thread for every task We do: Submit tasks to a pool of reusable threads This is exactly what Java provides using: Executor Framework Key takeaway Manual thread creation works for learning, but does not scale in real-world systems. Thread pools help: • Control number of threads • Reduce overhead • Improve performance We no longer manage threads directly — we delegate that responsibility to the Executor Framework. In the next post, we’ll see how Executor Framework works and how to use it in Java. #Java #Multithreading #Concurrency #BackendDevelopment #SoftwareEngineering

Your #finally block might NOT run. Yes… even though Java guarantees it. 🔹 The Assumption Most developers believe: 👉 “finally always executes” 🔹 The Reality try { System.exit(0); } finally { System.out.println("Will this run?"); } Output: Nothing 🔹 What just happened? `System.exit(0)` → JVM shuts down immediately → `finally` block is #skipped --- 🔹 Why this matters ❌ Cleanup logic may never run ❌ Resources may not close ❌ Production issues → hard to debug 🔹 Real Insight `finally` runs… 👉 Only if JVM is still alive 🔹 #Interview #Questions 1️⃣ Does `finally` always execute? 2️⃣ When does `finally` NOT execute? 3️⃣ What does `System.exit()` do internally? 4️⃣ Can `finally` skip due to JVM crash? 5️⃣ What happens if `kill -9` is used? 6️⃣ Does `finally` run after `return`? 7️⃣ What if exception occurs in `finally`? 8️⃣ Can `finally` override return values? 9️⃣ What is the order: try → catch → finally? 🔟 Does `finally` execute after uncaught exception? 1️⃣1️⃣ What happens if thread is interrupted? 1️⃣2️⃣ Can infinite loop skip `finally`? 1️⃣3️⃣ Difference between `final`, `finally`, `finalize()`? 1️⃣4️⃣ When is `finalize()` called? 1️⃣5️⃣ Is `finalize()` reliable? 1️⃣6️⃣ What are alternatives to `finally`? 1️⃣7️⃣ What is try-with-resources? 1️⃣8️⃣ How does AutoCloseable work? 1️⃣9️⃣ Can multiple finally blocks exist? 2️⃣0️⃣ Best practices for resource cleanup? #finally "always runs” is a myth #JVM control > language guarantee 💬 Which of these surprised you the most? #Java #CoreJava #Backend #InterviewPrep #Programming #SoftwareDevelopment #Engineering

Checked vs Unchecked Exceptions - Know the Difference ⚠️ 🔹 Checked Exceptions ▸ Checked at compile time ▸ Must be handled (try-catch or throws) ▸ Not handled → code won’t compile ▸ Examples: IOException, SQLException, FileNotFoundException 🔹 Unchecked Exceptions ▸ Occur at runtime ▸ No need to handle (but recommended) ▸ Extend RuntimeException ▸ Examples: NullPointerException, ArrayIndexOutOfBoundsException 💡 Simple Way to Remember → Checked = Compiler forces handling → Unchecked = Runtime errors 🚀 Best Practice ▸ Use Checked → for recoverable scenarios (e.g., file not found → retry) ▸ Use Unchecked → for programming bugs (e.g., null → fix the code) #Java #SpringBoot #ExceptionHandling #JavaDeveloper #BackendDeveloper

🫟 𝑾𝒉𝒂𝒕 𝒂𝒄𝒕𝒖𝒂𝒍𝒍𝒚 𝒉𝒂𝒑𝒑𝒆𝒏𝒔 𝒘𝒉𝒆𝒏 𝑱𝑽𝑴 𝒓𝒖𝒏𝒔 𝒚𝒐𝒖𝒓 𝑱𝒂𝒗𝒂 𝒑𝒓𝒐𝒈𝒓𝒂𝒎 ? 𝐖𝐞 𝐚𝐥𝐥 𝐰𝐫𝐢𝐭𝐞 "𝐦𝐚𝐢𝐧()" 𝐦𝐞𝐭𝐡𝐨𝐝 𝐁𝐮𝐭 𝐡𝐚𝐯𝐞 𝐲𝐨𝐮 𝐞𝐯𝐞𝐫 𝐭𝐡𝐨𝐮𝐠𝐡𝐭 𝐰𝐡𝐚𝐭 𝐉𝐕𝐌 𝐝𝐨𝐞𝐬 𝐢𝐧𝐭𝐞𝐫𝐧𝐚𝐥𝐥𝐲 𝐭𝐨 𝐬𝐭𝐚𝐫𝐭 𝐲𝐨𝐮𝐫 𝐩𝐫𝐨𝐠𝐫𝐚m ? 🔍 Let’s break it down simply 📝 𝐒𝐭𝐞𝐩-𝐛𝐲-𝐒𝐭𝐞𝐩 𝐄𝐱𝐞𝐜𝐮𝐭𝐢𝐨𝐧 1️⃣ Class Loading ▫️ JVM loads the class into memory 2️⃣ Method Lookup ▫️ JVM looks for exact method signature: 𝐩𝐮𝐛𝐥𝐢𝐜 𝐬𝐭𝐚𝐭𝐢𝐜 𝐯𝐨𝐢𝐝 𝐦𝐚𝐢𝐧(𝐒𝐭𝐫𝐢𝐧𝐠[] 𝐚𝐫𝐠𝐬) ▫️ Signature must match exactly 3️⃣ No Object Creation ▫️JVM does NOT create an object ▫️Because "main()" is static ▫️It is called using class name directly 4️⃣ Method Invocation ▫️ JVM directly calls 5️⃣ Execution Starts ▫️ Program execution begins from "main()" 🧭 𝐈𝐦𝐩𝐨𝐫𝐭𝐚𝐧𝐭 𝐈𝐧𝐬𝐢𝐠𝐡𝐭 "main()" is the entry point of Java program ▫️JVM specifically looks for this method ▫️ If not found → program will not run ❌ 🔁 𝐋𝐨𝐚𝐝 𝐂𝐥𝐚𝐬𝐬 → 𝐅𝐢𝐧𝐝 𝐦𝐚𝐢𝐧() → 𝐂𝐚𝐥𝐥 𝐝𝐢𝐫𝐞𝐜𝐭𝐥𝐲 → 𝐄𝐱𝐞𝐜𝐮𝐭𝐞 ♣️ We write just one method but JVM does a lot behind the scenes to run it. 🎈Did you know this flow before? Or just wrote "main()" without thinking much? Let’s discuss 💬 #Java #JVM #JavaDeveloper #Programming #TechJourney #LearnBySharing #JavaConcepts #InterviewPrep #BackendDevelopment

🚀 Spring Bean Lifecycle – Master It Like a pro If you’re working with Spring Boot and haven’t deeply understood the Bean Lifecycle, you’re missing the core engine behind: ✔️ Dependency Injection ✔️ AOP (Proxies) ✔️ Transactions ✔️ Application Context Magic 📌 Here’s a crisp breakdown from the visual cheat sheet: 🔄 Lifecycle Flow 👉 Instantiation → Dependency Injection → Aware Interfaces → 👉 Pre Initialization → Initialization → Post Initialization → 👉 Ready to Use → Destruction 💡 Critical Insights (Interview + Real-World) ✅ BeanPostProcessor is the real hero → Used internally for AOP, Transactions, Security ✅ Initialization Order Matters → @PostConstruct → afterPropertiesSet() → custom init method ✅ Where are proxies created? → postProcessAfterInitialization() 🔥 ✅ Prototype Scope Trap → Spring does NOT manage destruction ✅ Prefer: → @PostConstruct over InitializingBean → @PreDestroy over DisposableBean ⸻ 🎯 Why this matters in real projects? Understanding lifecycle helps you: ✔️ Debug tricky dependency issues ✔️ Optimize startup performance ✔️ Design better microservices ✔️ Control bean initialization & destruction ⸻ 💬 One-Line Interview Answer: “Spring Bean lifecycle starts with instantiation, followed by dependency injection, aware callbacks, pre/post initialization via BeanPostProcessors, and ends with destruction callbacks when the context shuts down.” ⸻ 📊 I’ve attached a complete visual cheat sheet for quick revision. ⸻ #SpringBoot #Java #Microservices #BackendDevelopment #InterviewPrep #SoftwareEngineering #SpringFramework #TechLearning #Developers #Coding :::

Still confused about how Java actually runs your code? 🤔 Here’s a simple breakdown of how the JVM works 👇 👉 1. Build Phase ✔️ Java code (.java) is compiled using javac ✔️ Converted into bytecode (.class files) 👉 2. Class Loading ✔️ JVM loads classes using: Bootstrap Class Loader Platform Class Loader System Class Loader 👉 3. Linking ✔️ Verify → Prepare → Resolve ✔️ Ensures code is safe and ready to run 👉 4. Initialization ✔️ Static variables & blocks are initialized 👉 5. Runtime Data Areas ✔️ Method Area & Heap (shared) ✔️ Stack, PC Register, Native Stack (per thread) 👉 6. Execution Engine ✔️ Interpreter executes bytecode line by line ✔️ JIT Compiler converts hot code into machine code for speed 👉 7. Native Interface (JNI) ✔️ Interacts with native libraries when needed 💡 JVM is the reason behind Java’s “Write Once, Run Anywhere” power. 📌 Save this post 🔁 Repost to help others 👨💻 Follow Abhishek Sharma for more such content #Java #JVM #SystemDesign #BackendDevelopment #SoftwareEngineer #Developers #TechJobs #Programming #LearnJava