Java Sorting with Comparable vs Comparator

🚀 Java Puzzle: Why this prints "100" even after using "final"? 🤯 Looks like a bug… but it’s actually Java behavior 👇 👉 Example: final int[] arr = {1, 2, 3}; arr[0] = 100; System.out.println(arr[0]); // 100 😮 👉 Wait… "final" but still changing? 🤔 💡 Reality of "final": - "final" → reference cannot change - NOT → object data cannot change 👉 So: - ❌ "arr = new int[]{4,5,6}" → not allowed - ✅ "arr[0] = 100" → allowed --- 🔥 Now the REAL twist 😳 final StringBuilder sb = new StringBuilder("Java"); sb.append(" Developer"); System.out.println(sb); // Java Developer 😮 👉 Again changing despite "final" 🔥 Golden Rule: 👉 "final" means: - You cannot point to a new object - But you CAN modify the existing object 💡 Common misconception: 👉 Many think "final = constant" (NOT always true) 💬 Did you also think "final" makes everything immutable? #Java #JavaDeveloper #Programming #Coding #100DaysOfCode #TechTips #JavaTips #InterviewPrep #Developers #SoftwareEngineering

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 🚀

🚀 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

Java Interview Question That Confuses Almost Everyone (Including Me) “Is Java pass by value or pass by reference?” Here’s the clarity I finally reached: Java is ALWAYS pass by value. No exceptions. But the confusion begins when we deal with objects. What actually happens with objects? When you pass an object to a method: Java passes a copy of the reference (address) Both references point to the same object in memory Two key scenarios: ✔ Modify object data → Changes are visible outside void modify(Test t) { t.x = 50; } Because both references point to the same object. ❌ Change the reference → No effect outside void change(Test t) { t = new Test(); t.x = 100; } Because now only the copied reference points to a new object. The mental model that clicked for me: Change object data → visible Change reference → no impact outside Final takeaway: Java is pass by value — but for objects, the value being passed is a reference. A huge thanks to PW Institute of Innovation and Syed Zabi Ulla sir for explaining this concept so thoroughly and clearly. #Java #SoftwareEngineering #Coding #ProgrammingConcepts #JavaDeveloper #TechInterviews#Java #Programming #SoftwareDevelopment #JavaDeveloper #CodingTips #Tech #BackendDevelopment #LearnToCode

Multithreading in Java — The Day My Application “Woke Up” A few months ago, I was working on a backend service for transaction processing. Everything looked fine until real users hit the system. Requests started piling up Response time slowed down System felt stuck At first, I thought it was a database issue. But the real problem? My application was doing everything one task at a time. That’s when I truly understood the power of Multithreading in Java. Instead of one thread handling everything: • One thread processes transactions • Another handles logging • Another validates requests Suddenly, the same application started handling multiple tasks simultaneously. What is Multithreading? It’s the ability of a program to execute multiple threads (smaller units of a process) concurrently, improving performance and responsiveness. Why it matters in real-world systems? Better performance Improved resource utilization Faster response time Essential for scalable backend systems How Java makes it easy: • Thread class • Runnable interface • ExecutorService But here’s the twist Multithreading is powerful, but dangerous if misused. I learned this the hard way: • Race conditions • Deadlocks • Synchronization issues My key takeaway: Multithreading doesn’t just make your app faster It forces you to think like a system designer. Have you ever faced performance issues that multithreading solved (or created 😅)? #Java #Multithreading #BackendDevelopment #SystemDesign #Performance #CodingJourney

🚀 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

One Java concept that helped me better understand sorting and comparing objects is Comparator & Comparable. In Java, both Comparable and Comparator are used to define how objects should be sorted. Comparable allows a class to define its default sorting logic using the "compareTo()" method. Comparator, on the other hand, lets us create custom sorting rules using the "compare()" method, which is useful when we want to sort objects in different ways. While exploring backend development, I noticed this concept is useful when sorting collections of objects such as employees, products, or students based on attributes like name, price, or ID. It helps organise data clearly and makes applications more flexible. This topic also appears frequently in Java interviews, because it checks whether developers understand object comparison, sorting collections, and writing cleaner, reusable logic. For me, learning the difference between "Comparable and Comparator" made working with collections much easier and more practical. 🧠 When sorting objects in Java projects, do you usually prefer using Comparable or Comparator, and why? 🙂 #Java #CoreJava #JavaCollections #Comparator #Comparable #BackendDevelopment #JavaDeveloper #DeveloperLearning

🚀 Day 7 – Optional Class in Java (Avoid NullPointerException like a Pro) 📘 Prepare with Pankaj Tired of NullPointerException ruining your code? 😓 Java 8 introduced Optional to handle null values in a better way. 💡 What is Optional? Optional is a container object that may or may not contain a value. 👉 Why use Optional? ✔ Avoid NullPointerException ✔ Write cleaner code ✔ Force null handling 📌 Common Methods: 1. of() → value must be present 2. ofNullable() → value can be null 3. isPresent() → check value 4. get() → get value (avoid direct use) 5. orElse() → default value 6. orElseThrow() → throw exception 💻 Example: Optional<String> name = Optional.ofNullable("Pankaj"); System.out.println(name.orElse("Default Name")); 👉 Output: Pankaj 🔥 Best Practice: Instead of: if(name != null) Use: Optional.ofNullable(name).ifPresent(System.out::println); --- 💬 Do you use Optional in your code? Comment YES / NO 👇 #PrepareWithPankaj #Java #Optional #Java8 #BackendDeveloper #Coding #InterviewPreparation

🚨 Java Developers — Beware of the FINALLY Block! Most devs think they understand how finally behaves until it overrides a return value, mutates an object, or hides an exception completely. Here are the most important — and dangerous — finally block traps every Java developer must know 👇 🔥 1. finally ALWAYS executes Even if the method returns or throws an exception. This is why cleanup logic goes here. But it also means: try { return 1; } finally { System.out.println("Still runs"); } ⚠️ 2. finally can override your return value This is the #1 interview trap. try { return 1; } finally { return 2; } 👉 Output: 2 finally silently replaces your original return. This has caused countless production bugs. 🧠 3. It can modify returned objects Even if the object is returned, finally still gets a chance to mutate it. StringBuilder sb = new StringBuilder("Hello"); try { return sb; } finally { sb.append(" World"); } 👉 Output : Hello World ➡️ Because reference types are not copied — only primitives are. 💥 4. finally can swallow exceptions Huge debugging nightmare. try { throw new RuntimeException("Original error"); } finally { return; // Exception is LOST } The program proceeds as if nothing went wrong! This is why return statements inside finally are dangerous. 🚫 5. Rare cases where finally does NOT run System.exit() JVM crash Hardware/power failure Fatal native code error Anywhere else → it ALWAYS runs. ✅ Best Practices for Safe Java Code ✔ Use finally for cleanup only ✔ Prefer try-with-resources (Java 7+) ✔ Avoid return inside finally ✔ Keep finally blocks minimal ✔ Avoid modifying returned objects 💡 When you understand the actual lifecycle of try → catch → finally, you avoid subtle, production-breaking bugs that even senior developers sometimes miss. #Java #JavaDeveloper #ProgrammingTips #CodeQuality #CleanCode #SoftwareEngineering #Developers #CodingTips #TechLearning #FullStackDeveloper #BackendDevelopment #JavaInterview #100DaysOfCode #LearningEveryday #TechCommunity

Why String Pool exists in Java (and how it actually works) ? Most developers know this: Java has something called a String Pool. But why does it even exist? The problem: Strings are used everywhere In real applications, the same string values get created again and again. Example: "hello" Without optimization, this would create multiple identical objects in memory. The solution: String Pool Java stores string literals in a special memory area called the String Pool. So instead of creating new objects every time: 👉 Java reuses existing ones How it works: When you write: String s1 = "hello"; String s2 = "hello"; Java checks the pool: If "hello" already exists → reuse it If not → create and store it So both s1 and s2 point to the same object But, String s3 = new String("hello"); This forces a new object creation even if "hello" exists in the pool. Why this matters: String Pool helps: • Save memory • Improve performance • Avoid unnecessary object creation #Java #JVM #StringPool #CSFundamentals #BackendDevelopment