"Java Stream API: A Guide to Processing Data"

💡 Why Does Java Still Use Primitive Data Types in 2025? With all the progress in Java — from records and sealed classes to virtual threads — you might wonder: 👉 Why does Java still have int, double, boolean, etc., instead of just using objects like Integer or Double everywhere? Let’s break it down 👇 ⚙️ 1️⃣ Performance at the Core Primitives are stored directly on the stack (or in registers), not as heap objects. That means: No object allocation overhead No garbage collection pressure Faster CPU-level access 📘 Example: int sum = 0; for (int i = 0; i < 1_000_000; i++) { sum += i; } This loop runs orders of magnitude faster than using Integer sum = 0; because the latter constantly creates and boxes new Integer objects. 🧠 2️⃣ Memory Efficiency Every object in Java has header metadata (usually 12–16 bytes). With primitives, there’s no per-value overhead — crucial when handling large data arrays. int[] numbers = new int[1_000_000]; // ~4 MB Integer[] numbersObj = new Integer[1_000_000]; // ~16 MB+ due to object headers That’s a 4x+ difference in memory use — and it matters in high-performance systems. 🔄 3️⃣ Simplicity in Low-Level Computation Primitives give direct control over arithmetic and bitwise operations without abstraction layers. This is essential for: Numeric computations Game engines High-frequency trading systems Data processing pipelines 🚀 4️⃣ But What About “Everything is an Object”? Java’s design balances OO principles with practical performance. Yes, Integer, Double, and Boolean exist — but they’re wrappers, not replacements. You can use them when you need features like null handling, generics, or collections. 🔬 5️⃣ Project Valhalla (Coming Soon) Java’s future (Project Valhalla) aims to introduce value types — combining the performance of primitives with the flexibility of objects. That might finally bridge this gap. But until then, primitives remain the foundation of Java performance. 🏁 In short: Java keeps primitives because they’re fast, memory-efficient, and predictable — all vital for scalable, low-latency systems. Object wrappers add flexibility — but primitives keep Java grounded in performance reality. 💬 What’s your take — should Java eventually unify primitives and objects, or keep them separate for clarity and performance? #Java #Performance #Programming #SoftwareEngineering #JVM #Javadeveloper

In Java, there are several ways to create and run threads, Spring Boot also have @Async annotation to run method code as thread. 1. Extending the Thread class You can create a subclass of Thread and override the run() method. ✅ Example: class MyThread extends Thread { @Override public void run() { System.out.println("Thread running " + Thread.currentThread().getName()); } } public class Main { public static void main(String[] args) { MyThread t1 = new MyThread(); t1.start(); } } 🧩 2. Implementing the Runnable interface ✅ Example: class MyRunnable implements Runnable { @Override public void run() { System.out.println("Thread running using Runnable interface: " + Thread.currentThread().getName()); } } public class Main { public static void main(String[] args) { Thread t1 = new Thread(new MyRunnable()); t1.start(); } } 🟢 Why preferred: Allows you to extend another class (since Java supports only single inheritance). ⚡ 3. Using Anonymous Class You can create and start a thread in one line using an anonymous inner class. ✅ Example: public class Main { public static void main(String[] args) { Thread t1 = new Thread(new Runnable() { @Override public void run() { System.out.println("Thread running using Anonymous class"); } }); t1.start(); } } 💡 4. Using Lambda Expression (Java 8+) ✅ Example: public class Main { public static void main(String[] args) { Thread t1 = new Thread(() -> { System.out.println("Thread running using Lambda expression"); }); t1.start(); } } ⚙️ 5. Using ExecutorService (Thread Pool) For multiple or managed threads, use an Executor Service. ✅ Example: import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Main { public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(2); executor.submit(() -> System.out.println("Thread 1 using ExecutorService")); executor.submit(() -> System.out.println("Thread 2 using ExecutorService")); executor.shutdown(); } } 🟢 Advantages: Reuses threads (avoids overhead of creating new threads repeatedly) Supports async tasks and better error handling 🧠 6. Using Callable and Future (for return values) Callable is like Runnable, but can return a value and throw exceptions. ✅ Example: import java.util.concurrent.*; public class Main { public static void main(String[] args) throws Exception { ExecutorService executor = Executors.newSingleThreadExecutor(); Callable<String> task = () -> { return "Result from thread: " + Thread.currentThread().getName(); }; Future<String> future = executor.submit(task); System.out.println(future.get()); executor.shutdown(); } }

💡 Tech Deep Dive: Decoding JSON Arrays with Gson Ever noticed how most of our Spring (or general Java) application logic revolves around a single JSON object for requests and responses? It’s the standard practice. But for a recent personal project, I hit a technical snag: I needed my program to consume and process an array of JSON objects, not just one. I had a string containing a list of objects, and the standard Gson constructor—which maps a single JSON string to a Java object—wasn't cutting it. That's when I uncovered two elegant techniques within the Gson library: the TypeToken and the JsonArray. The Solution: Using TypeToken (My Choice) The standard way to map a JSON to a Java object works great: Java // Works for a single JSON object MyObject obj = gson.fromJson(jsonString, MyObject.class); But when dealing with an array of objects ([{}, {}, ...]), Gson can't tell the difference between a List<MyObject> and just MyObject.class because of type erasure at runtime. The solution? TypeToken! By using TypeToken, we provide Gson with the full, parameterized type information (List<MyObject>), allowing for a direct, one-line mapping: Java // Works for a JSON array to a List<MyObject> Type type = new TypeToken<List<MyObject>>() {}.getType(); List<MyObject> list = gson.fromJson(jsonArrayString, type); This approach is super clean! It instantly converts the entire JSON array into a readily usable List that I could then easily run lambda operations and other stream logic on. No extra looping required! The Alternative: Using JsonArray The other interesting path is using JsonArray. This approach first parses the raw JSON string into a JsonArray object, which is part of Gson's DOM (Document Object Model) representation. Java // Step 1: Parse the string into a JsonArray object JsonArray jsonArray = JsonParser.parseString(jsonArrayString).getAsJsonArray(); // Step 2: Manually iterate and map each element List<MyObject> list = new ArrayList<>(); for (JsonElement element : jsonArray) {    MyObject obj = gson.fromJson(element, MyObject.class);    list.add(obj); } While it requires an extra step of manual iteration, it’s a powerful approach when you need to inspect or modify the JSON elements before converting them into Java objects. It’s always fascinating how diving into the specifics of a library reveals such powerful and nuanced solutions. Highly recommend looking into TypeToken if you ever run into a complex JSON mapping scenario! --------------------------------------------------------------------------------- Img Source - My own unpublished code #Java #Gson #JSON #TypeToken #SoftwareDevelopment #TechTip #Software #ThirdPartyLibrary #Google #ObjectArray #Programming #PersonalProject #Learning

Java Has Evolved — Here’s What Changed from JDK 8 to JDK 17 🚀 ☕ JDK 8 (2014) — The Modern Java Revolution Major Features: ✅ Lambda Expressions → Functional programming style ✅ Stream API → Process collections efficiently ✅ Functional Interfaces → @FunctionalInterface, Predicate, Function, etc. ✅ Default & Static Methods in Interfaces ✅ Optional Class → Avoid NullPointerException ✅ Date and Time API (java.time) → New modern date/time handling ✅ Nashorn JavaScript Engine ⚙️ JDK 9 (2017) — Modular Java Key Features: 🧩 Module System (Project Jigsaw) → module-info.java JShell (REPL) → Interactive Java shell Stream API Enhancements → takeWhile(), dropWhile(), iterate() Private Methods in Interfaces Factory Methods for Collections → List.of(), Set.of(), Map.of() ⚙️ JDK 10 (2018) — Developer Productivity Key Features: 🔹 Local Variable Type Inference → var keyword Garbage Collector Improvements (G1) Application Class-Data Sharing Parallel Full GC for G1 ⚙️ JDK 11 (2018) — LTS Release (Long-Term Support) Key Features: 🌐 New HttpClient API → Replaces old HttpURLConnection String Methods → isBlank(), lines(), strip(), repeat() Lambda Parameter Type Inference Removed Java EE & CORBA modules Single-file Source Code Execution → java Hello.java ⚙️ JDK 12 (2019) Key Features: 🧮 Switch Expressions (Preview) → switch usable as an expression JVM Constants API Shenandoah GC (low-pause-time GC) ⚙️ JDK 13 (2019) Key Features: 📜 Text Blocks (Preview) → Multi-line strings using """ Switch Expression Enhancements Reimplementation of Legacy Socket API ⚙️ JDK 14 (2020) Key Features: 🧱 Records (Preview) → Immutable data carriers (record Point(int x, int y)) 🕵️ Pattern Matching for instanceof (Preview) 🧍♂️ Helpful NullPointerException Messages Switch Expressions (Standardized) ⚙️ JDK 15 (2020) Key Features: 🧩 Sealed Classes (Preview) → Restrict which classes can extend a class Text Blocks (Standard) Hidden Classes EdDSA Algorithm Support (New Crypto) ⚙️ JDK 16 (2021) Key Features: 🧱 Records (Standard) 🕵️ Pattern Matching for instanceof (Standard) JEP 391: macOS/AArch64 support (Apple M1) Vector API (Incubator) Strong Encapsulation of JDK Internals ⚙️ JDK 17 (2021) — LTS Release Key Features: 🧩 Sealed Classes (Standard) 🕵️ Pattern Matching for switch (Preview) 🧱 Enhanced Pseudo-Random Number Generators (PRNG) Foreign Function & Memory API (Incubator) New macOS Rendering Pipeline (Metal API) Removed Deprecated RMI Activation, Applet API, etc.

#java 🟩 Day 47 – Exception Handling + Global Error Response in Spring Boot (HinEnglish, Step-by-Step, #Tech47) आज का लक्ष्य: Backend ko itna smart banana ki error aaye toh system tootey नहीं — balki samjhaaye --- 🔹 Step 1: What is Exception Handling? HinEnglish: Exception handling ka matlab hai unexpected errors ko catch karna aur unka proper response dena — taaki system crash na ho aur user ko meaningful message mile. 🧠 Real-world analogy: > Ek ATM machine jo card error pe quietly message dikhata hai — bina machine hang kiye. ✅ Benefits: - Prevents system crashes - Improves user experience - Helps debugging - Enables centralized error control --- 🔹 Step 2: Types of Exceptions ✅ Checked Exception: Compile-time (e.g., IOException) ✅ Unchecked Exception: Runtime (e.g., NullPointerException) ✅ Custom Exception: Business-specific errors (e.g., UserNotFoundException) --- 🔹 Step 3: Global Exception Handling - Use @ControllerAdvice + @ExceptionHandler - Create centralized class to handle all exceptions - Return structured response with status, message, timestamp 🧠 Example: `java @RestControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(UserNotFoundException.class) public ResponseEntity<ErrorResponse> handleUserNotFound(UserNotFoundException ex) { return new ResponseEntity<>(new ErrorResponse("User not found", LocalDateTime.now()), HttpStatus.NOT_FOUND); } } ` --- 🔹 Step 4: Java Full Stack Integration ✅ Spring Boot: Centralized error handling ✅ React: Show error messages via toast or modal ✅ Postman: Test error responses with invalid inputs ✅ DTOs: Use ErrorResponse class for structured output ✅ GitHub: Push code + README + screenshots ✅ Docker: Deploy with error logs enabled --- 🔹 Step 5: DSA + Tools Relevance ✅ DSA: Try-catch logic = control flow ✅ Tools: - IntelliJ debugger - Spring Boot actuator for error metrics - Logback for structured logging ✅ Monitoring: Use ELK stack or Prometheus for error tracking ✅ Validation: Use @Valid, @NotNull, @Size for input checks --- 🔹 Step 6: Interview Questions - Q1: What is the difference between checked and unchecked exceptions? - Q2: How do you implement global exception handling in Spring Boot? - Q3: What is the role of @ControllerAdvice? - Q4: How do you return custom error responses? - Q5: How do you handle validation errors? --- 🔹 Step 7: Practice Tasks - ✅ Create custom exceptions for UserNotFound, InvalidOrder - ✅ Build GlobalExceptionHandler class - ✅ Create ErrorResponse DTO - ✅ Test with invalid inputs via Postman - ✅ Document logic in Day47_ExceptionHandling/README.md - ✅ Push code, screenshots, and error flow diagram to GitHub --- 🎯 प्रेरणा का संदेश: > “Error handling is not about hiding mistakes — it’s about responding with grace. आज आपने backend ko samajhdar banaya.” JavaFullStack #ExceptionHandling #GlobalErrorResponse #SpringBoot #ReactJS #JavaMastery #Tech47 #GitHubShowcase

☕ JVM Architecture — Behind the Scenes of Every Java Program The Java Virtual Machine (JVM) is the heart of Java — it enables platform independence by running bytecode on any system. It performs 3 key functions: 1️⃣ Loads Java bytecode (.class files) 2️⃣ Verifies and prepares memory for classes 3️⃣ Executes the program 🧩 JVM Major Components JVM ├── Class Loader Subsystem ├── Runtime Data Areas └── Execution Engine    ├── Interpreter    ├── JIT Compiler    ├── Garbage Collector    ├── Native Interface (JNI)    └── Native Method Libraries 🔹 1. Class Loader Subsystem It’s the first component of the JVM, responsible for loading .class files into the JVM’s Runtime Data Areas, which reside inside the JVM process in the primary memory (RAM). Responsibilities: Loading → Linking → Initialization ✅ Loading: Loads class bytecode from disk, JARs, or remote sources using: Bootstrap ClassLoader → Core Java (<JAVA_HOME>/lib) Extension ClassLoader → Optional libs (lib/ext) Application ClassLoader → User-defined classes from classpath ✅ Linking: Verifies bytecode (security + correctness), prepares memory for static variables, and assigns default values. ✅ Initialization: Assigns actual values to statics and executes static blocks. At this stage, the class is ready for use. ☕ Java 8 vs Java 11 – Behind the Scenes Java 8 (Traditional Way) 1️⃣ Save Hello.java on disk (secondary memory) 2️⃣ Run javac Hello.java → generates Hello.class on disk 3️⃣ Run java Hello → Class Loader loads .class from disk → JVM executes it ✅ .class file exists on disk Java 11 (Single-File Execution) 1️⃣ Save Hello.java 2️⃣ Run java Hello.java → JVM compiles it internally 3️⃣ Bytecode (.class) generated temporarily in RAM 4️⃣ Class Loader loads in-memory bytecode into Method Area 5️⃣ After execution → bytecode discarded ✅ .class file lives only in memory 🧠 2. Runtime Data Areas Memory areas inside the JVM where program data lives during execution. RAM (Primary Memory) └── JVM Process   ├── Method Area → class info, static vars, bytecode   ├── Heap → objects   ├── Stack → Method calls, local variables, references   ├── PC Register → next instruction pointer   └── Native Method Stack → JNI/native calls ⚙️ 3. Execution Engine Once classes are loaded into the Method Area, the Execution Engine translates bytecode into native machine code and then the CPU runs that native code. Components: * Interpreter → Reads bytecode line by line (slower) * JIT Compiler → Converts hot spots to native code for speed * Garbage Collector → Reclaims unused memory from the Heap JNI & Native Libraries: * JNI (Java Native Interface): Allows Java to call C/C++ methods. * Native Method Libraries: Actual libraries (.dll, .so) used by JNI. ☕ Loved it? Drop a coffee — let’s keep the Java vibes strong! 💻 #Java #JVM #JavaDeveloper #JVMArchitecture #CoreJava #Programming #Developers #SoftwareEngineering #JavaCommunity #TechLearning #BackendDevelopment #LearnJava #CodeWithMohan

Quick Java 8 Streams Refresh — From Revisiting to Refining: Sometimes, going back to the basics helps you rediscover how powerful simple concepts can be. I recently took some time to refresh my Java 8 Stream skills I’ve attached the complete Java file — hoping it can serve as a handy reference for anyone revisiting Streams or learning them in depth. Here’s what’s inside. 🔹 Grouping and aggregation 🔹 Calculating totals using both Collectors.summingLong() and reduce() 🔹 Word and character frequency analysis 🔹 Merging and transforming multiple lists into one stream 🔹 Detecting duplicates, unique elements, and even the second-highest transaction 🔹 Sorting complex objects with Comparator.comparing() 🔹 Reversing words, removing nulls, partitioning data, and more Each snippet reminded me how Streams simplify Java code — making it more declarative, expressive, and concise. Here’s a small example ________________________________________________________________________ // Find second highest credit transaction List<Transaction> transactions2 = new ArrayList<>(); transactions2.add(new Transaction(transactionType.CREDIT, 10)); transactions2.add(new Transaction(transactionType.CREDIT, 50)); transactions2.add(new Transaction(transactionType.DEBIT, 100)); transactions2.add(new Transaction(transactionType.DEBIT, 20)); transactions2.add(new Transaction(transactionType.CREDIT, 30)); Transaction secondHighest = transactions2.stream()     .filter(t -> t.getType() == transactionType.CREDIT)          .sorted(Comparator.comparingInt(Transaction::getAmount).reversed())             .skip(1)                                         .findFirst()                                      .get(); System.out.println(secondHighest); ________________________________________________________________________ Full code attached below — feel free to explore and reuse! Let’s keep learning, refining, and sharing knowledge together. #Java #Java8 #Streams #FunctionalProgramming #CleanCode #CodingPractice #DeveloperCommunity #LearningInPublic

#java Day 61 – Java Multithreading Mastery (ExecutorService + Future + CompletableFuture) Goal: Backend ko parallel, scalable aur efficient banana. --- 🔹 Core Concepts - Multithreading: Multiple tasks ek saath run karna → fast response. - ExecutorService: Thread pool manage karta hai, manual thread creation avoid hota hai. - Future: Async computation ka result. - CompletableFuture: Advanced async pipelines with chaining + non-blocking execution. 🧠 Analogy: Ek kitchen jahan ek chef vs multiple chefs ek saath dishes bana rahe hain. --- 🔹 Code Demos ExecutorService `java ExecutorService pool = Executors.newFixedThreadPool(3); Runnable task = () -> System.out.println("Task by: " + Thread.currentThread().getName()); for (int i = 0; i < 5; i++) pool.submit(task); pool.shutdown(); ` Future `java Future<Integer> future = pool.submit(() -> { Thread.sleep(2000); return 42; }); System.out.println("Result: " + future.get()); ` CompletableFuture `java CompletableFuture.supplyAsync(() -> "Hello") .thenApply(msg -> msg + " World") .thenAccept(System.out::println); ` --- 🔹 Real-World Integration - Spring Boot: @Async + Executor config for async services. - React: Parallel API calls for faster UI. - Docker: Multiple backend containers handle concurrent requests. - Monitoring: JConsole, VisualVM, Prometheus. --- 🔹 Interview Prep - Thread vs Runnable vs Callable? - Why ExecutorService > manual threads? - How CompletableFuture improves async pipelines? - What is race condition & deadlock? --- 🔹 Practice Tasks - Create 10 tasks with ExecutorService. - Async factorial with Future. - Pipeline chaining with CompletableFuture. - Explore thenCombine() and thenCompose(). - Push code + results to GitHub. --- 🎯 Motivation: “Concurrency is not chaos — it’s controlled speed. Aaj aapne backend ko enterprise-ready banaya.” #Multithreading #ExecutorService #Future #CompletableFuture #Docker #Concurrency #BackendArchitecture #InterviewPrep #GitHubShowcase #StructuredLearning #LegacyDriven #Tech61

☕💻 JAVA THREADS CHEAT SHEET 🔹 🧠 What is a Thread? 👉 The smallest unit of execution in a process. Each thread runs independently but shares memory & resources with others. 🧩 Enables multitasking and parallel execution. 🔹 ⚙️ What is a Process? 👉 An executing instance of a program. Each process has its own memory space and can run multiple threads. 🧵 Types of Threads 👤 1️⃣ User Threads ✅ Created by users or apps. ✅ JVM waits for them before exit. 💡 Example: Thread t = new Thread(() -> System.out.println("User Thread")); t.start(); 👻 2️⃣ Daemon Threads ⚙️ Background threads (e.g., Garbage Collector). ❌ JVM doesn’t wait for them. 💡 Example: Thread d = new Thread(() -> {}); d.setDaemon(true); d.start(); 🚀 Creating Threads 🔸 Extending Thread: class MyThread extends Thread { public void run(){ System.out.println("Running..."); } } new MyThread().start(); 🔸 Implementing Runnable: new Thread(() -> System.out.println("Runnable running...")).start(); 🔄 Thread Lifecycle 🧩 NEW → RUNNABLE → RUNNING → WAITING/BLOCKED → TERMINATED 🕹️ Common Thread Methods 🧩 Method ⚡ Use start() Start a thread run() Thread logic sleep(ms) Pause execution join() Wait for thread interrupt() Interrupt thread setDaemon(true) Make daemon thread 🔒 Synchronization Prevents race conditions when multiple threads share data. synchronized void increment() { count++; } 💬 Thread Communication Use wait(), notify(), and notifyAll() for coordination. 🧠 Must be called inside a synchronized block. ⚡ Executor Framework (Thread Pooling) Efficient thread reuse for better performance. ExecutorService ex = Executors.newFixedThreadPool(3); ex.submit(() -> System.out.println("Task executed")); ex.shutdown(); 🏁 Pro Tips ✅ Prefer Runnable / ExecutorService ✅ Handle InterruptedException ✅ Avoid deprecated methods (stop(), suspend()) ✅ Use java.util.concurrent for safe multithreading 📢 Boost Your Skills 🚀 #Java #Threads #Multithreading #Concurrency #JavaDeveloper #JavaInterview #JavaCoding #JavaProgrammer #CodeNewbie #ProgrammingTips #DeveloperCommunity #CodingLife #LearnJava #JavaCheatSheet #ThreadPool #TechInterview #SoftwareEngineer #CodeWithMe #JavaExperts #BackendDeveloper #JavaLearning #JavaBasics #OOP #CodeDaily #CodingJourney #DevCommunity #JavaLovers #TechCareers #CodeSmarter #100DaysOfCode

🚀 From ObjectMapper to MapStruct — My Journey Through Java Object Mapping I’ve often had to map entities → DTOs (especially in Spring Boot apps). At first, I didn’t think much of it — until I realized there are many ways to do it… and not all are equal 👀 Here’s how I went from using ObjectMapper → ModelMapper → MapStruct. 🧩 Step 1: ObjectMapper From the Jackson library — usually used for JSON (de)serialization. Example: UserDTO dto = objectMapper.convertValue(userEntity, UserDTO.class); ✅ Pros Already available in most Spring Boot projects Zero setup Works even for nested objects ❌ Cons Reflection + JSON tree conversion → slower No compile-time type safety Can silently ignore missing fields 👉 Good for quick conversions or prototypes, but not for large systems. ⚙️ Step 2: ModelMapper A dedicated mapping library for Java objects. Example: ModelMapper mapper = new ModelMapper(); UserDTO dto = mapper.map(userEntity, UserDTO.class); ✅ Pros Simple API Automatically maps same-named fields Supports custom mappings ❌ Cons Still reflection-based → runtime overhead Harder to debug complex mappings No compile-time validation 👉 Better than ObjectMapper for mappings, but can become tricky at scale. 🧠 Step 3: MapStruct Compile-time code generation FTW ⚡ Example: @Mapper(componentModel = "spring") public interface UserMapper { UserDTO toDto(UserEntity entity); } ✅ Pros Generates pure Java mapping code at compile time → super fast Type-safe and compile-time checked Easy to test and debug Integrates perfectly with Spring via componentModel = "spring" ❌ Cons Need to rebuild project to see mapping changes 👉 The best choice for production projects — clean, fast, and safe. 💡 Why componentModel = "spring"? This tells MapStruct: “Hey, make this mapper a Spring bean.” That means you can directly inject it: @Service public class UserService { private final UserMapper mapper; public UserService(UserMapper mapper) { this.mapper = mapper; } } No manual instantiation, no boilerplate — just plug & play inside your Spring context. 🔚 TL;DR — Key Takeaways ObjectMapper Performance: Medium Type Safety: Runtime only (no compile-time checks) Setup: None Best For: Quick and simple conversions ModelMapper Performance: Medium Type Safety: Runtime only Setup: Minimal Best For: Small or medium apps with moderate mapping needs MapStruct Performance: Fast (compile-time generated code) Type Safety: Compile-time validation Setup: Requires annotation processor Best For: Large or enterprise applications where performance and safety matter 💬 Final Thoughts If you’re just starting out — use ObjectMapper or ModelMapper. But when performance, safety, and maintainability matter — 👉 MapStruct + Spring (componentModel = "spring") is the way to go.