Mastering the Streams API in Java 8 for clean, efficient code

🚀 𝗠𝗮𝘀𝘁𝗲𝗿𝗶𝗻𝗴 𝗗𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝗰𝘆 𝗜𝗻𝗷𝗲𝗰𝘁𝗶𝗼𝗻 — 𝗧𝗵𝗲 𝗦𝗲𝗰𝗿𝗲𝘁 𝘁𝗼 𝗖𝗹𝗲𝗮𝗻 & 𝗦𝗰𝗮𝗹𝗮𝗯𝗹𝗲 𝗝𝗮𝘃𝗮 𝗖𝗼𝗱𝗲 Java learning focus: Dependency Injection (DI) — a powerful pattern that separates object creation from object usage. 𝗜𝗻 𝘁𝗿𝗮𝗱𝗶𝘁𝗶𝗼𝗻𝗮𝗹 𝗰𝗼𝗱𝗲: 𝗰𝗹𝗮𝘀𝘀 𝗖𝗮𝗿 {   𝗽𝗿𝗶𝘃𝗮𝘁𝗲 𝗘𝗻𝗴𝗶𝗻𝗲 𝗲𝗻𝗴𝗶𝗻𝗲 = 𝗻𝗲𝘄 𝗘𝗻𝗴𝗶𝗻𝗲(); } 𝘛𝘩𝘦 𝘊𝘢𝘳 𝘪𝘴 𝘵𝘪𝘨𝘩𝘵𝘭𝘺 𝘤𝘰𝘶𝘱𝘭𝘦𝘥 𝘸𝘪𝘵𝘩 𝘌𝘯𝘨𝘪𝘯𝘦. 𝘊𝘩𝘢𝘯𝘨𝘦 𝘵𝘩𝘦 𝘌𝘯𝘨𝘪𝘯𝘦 𝘵𝘺𝘱𝘦, 𝘢𝘯𝘥 𝘺𝘰𝘶 𝘳𝘦𝘸𝘳𝘪𝘵𝘦 𝘵𝘩𝘦 𝘊𝘢𝘳. 😩 𝗪𝗶𝘁𝗵 𝗗𝗜: 𝗰𝗹𝗮𝘀𝘀 𝗖𝗮𝗿 {   𝗽𝗿𝗶𝘃𝗮𝘁𝗲 𝗘𝗻𝗴𝗶𝗻𝗲 𝗲𝗻𝗴𝗶𝗻𝗲;   𝗽𝘂𝗯𝗹𝗶𝗰 𝗖𝗮𝗿(𝗘𝗻𝗴𝗶𝗻𝗲 𝗲𝗻𝗴𝗶𝗻𝗲) { 𝘁𝗵𝗶𝘀.𝗲𝗻𝗴𝗶𝗻𝗲 = 𝗲𝗻𝗴𝗶𝗻𝗲; } } 𝘕𝘰𝘸, 𝘢𝘯𝘺 𝘦𝘯𝘨𝘪𝘯𝘦 𝘤𝘢𝘯 𝘣𝘦 𝘪𝘯𝘫𝘦𝘤𝘵𝘦𝘥 — 𝘗𝘦𝘵𝘳𝘰𝘭, 𝘌𝘭𝘦𝘤𝘵𝘳𝘪𝘤, 𝘰𝘳 𝘏𝘺𝘣𝘳𝘪𝘥 🚗⚡ 💡 𝗪𝗵𝘆 𝗗𝗜 𝗺𝗮𝘁𝘁𝗲𝗿𝘀: 𝘗𝘳𝘰𝘮𝘰𝘵𝘦𝘴 𝘭𝘰𝘰𝘴𝘦 𝘤𝘰𝘶𝘱𝘭𝘪𝘯𝘨 𝘉𝘰𝘰𝘴𝘵𝘴 𝘵𝘦𝘴𝘵𝘢𝘣𝘪𝘭𝘪𝘵𝘺 𝘌𝘯𝘢𝘣𝘭𝘦𝘴 𝘐𝘯𝘷𝘦𝘳𝘴𝘪𝘰𝘯 𝘰𝘧 𝘊𝘰𝘯𝘵𝘳𝘰𝘭 𝘊𝘰𝘳𝘦 𝘰𝘧 𝘚𝘱𝘳𝘪𝘯𝘨 𝘍𝘳𝘢𝘮𝘦𝘸𝘰𝘳𝘬 𝘢𝘳𝘤𝘩𝘪𝘵𝘦𝘤𝘵𝘶𝘳𝘦 Frameworks like Spring take DI further using @Autowired, making object wiring automatic and clean. Think of DI like a phone getting its battery inserted — the phone doesn’t build it, it just uses it efficiently. 🔋 💼 𝗜𝗺𝗽𝗼𝗿𝘁𝗮𝗻𝘁 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀 & 𝗔𝗻𝘀𝘄𝗲𝗿𝘀 𝗤𝟭: 𝗪𝗵𝗮𝘁 𝗶𝘀 𝗗𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝗰𝘆 𝗜𝗻𝗷𝗲𝗰𝘁𝗶𝗼𝗻? ➡ It’s a design pattern where an object receives its dependencies from an external source rather than creating them internally. 𝗤𝟮: 𝗛𝗼𝘄 𝗶𝘀 𝗗𝗜 𝗿𝗲𝗹𝗮𝘁𝗲𝗱 𝘁𝗼 𝗜𝗻𝘃𝗲𝗿𝘀𝗶𝗼𝗻 𝗼𝗳 𝗖𝗼𝗻𝘁𝗿𝗼𝗹 (𝗜𝗼𝗖)? ➡ DI is a form of IoC — instead of the object controlling its dependencies, the framework or external code controls it. 𝗤𝟯: 𝗪𝗵𝗮𝘁 𝗮𝗿𝗲 𝘁𝗵𝗲 𝗯𝗲𝗻𝗲𝗳𝗶𝘁𝘀 𝗼𝗳 𝗗𝗜? ➡ Loose coupling, easier unit testing, flexibility, and cleaner code. 𝗤𝟰: 𝗪𝗵𝗮𝘁 𝗮𝗿𝗲 𝘁𝗵𝗲 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝘁𝘆𝗽𝗲𝘀 𝗼𝗳 𝗗𝗜 𝗶𝗻 𝗦𝗽𝗿𝗶𝗻𝗴? ➡ Constructor Injection, Setter Injection, and Field Injection. 𝗤𝟱: 𝗪𝗵𝗶𝗰𝗵 𝗶𝗻𝗷𝗲𝗰𝘁𝗶𝗼𝗻 𝘁𝘆𝗽𝗲 𝗶𝘀 𝗽𝗿𝗲𝗳𝗲𝗿𝗿𝗲𝗱 𝗶𝗻 𝗦𝗽𝗿𝗶𝗻𝗴? ➡ Constructor Injection — ensures dependencies are immutable and makes testing easier. 𝗤𝟲: 𝗖𝗮𝗻 𝘆𝗼𝘂 𝘂𝘀𝗲 𝗗𝗜 𝘄𝗶𝘁𝗵𝗼𝘂𝘁 𝗳𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸𝘀 𝗹𝗶𝗸𝗲 𝗦𝗽𝗿𝗶𝗻𝗴? ➡ Yes, DI is a pattern — you can manually implement it even in plain Java (as shown above). #Java #SpringBoot #DependencyInjection #OOP #SoftwareDesign #IoC #CleanCode #ProgrammingTips #DesignPatterns #JavaDeveloper

🚀 Fixed a Logical Bug in “Contains Duplicate II” (Sliding Window Problem in Java) Today I revisited one of the seemingly simple problems — “Contains Duplicate II” — and realized how small syntax choices can completely change logic flow 😅 At first, I wrote the code using a mix of C++ and Java syntax, which caused compilation and logical issues. But while debugging, I learned some key lessons that made my solution cleaner, faster, and interview-ready 💪 🧩 The Problem Given an integer array nums and an integer k, return true if there are two distinct indices i and j such that: nums[i] == nums[j] && |i - j| <= k ⚙️ My Fixed Java Code import java.util.HashSet; class Solution { public boolean containsNearbyDuplicate(int[] nums, int k) { HashSet<Integer> set = new HashSet<>(); int i = 0; int j = 0; int n = nums.length; while (j < n) { if (Math.abs(j - i) > k) { set.remove(nums[i]); i++; } if (set.contains(nums[j])) { return true; } set.add(nums[j]); j++; } return false; } } ❌ Mistakes I Made Initially 1️⃣ Used set.get() and set.end — which belong to C++, not Java. ✅ Fixed by using set.contains(nums[j]). 2️⃣ Didn’t maintain a proper sliding window size. ✅ Simplified with if (Math.abs(j - i) > k) to ensure the window never exceeds k elements. 3️⃣ Didn’t clearly understand the window logic — that we remove older elements as we move forward. ✅ Learned to visualize the window as a moving frame over the array. 4️⃣ Overcomplicated the logic. ✅ Cleaned it up using a simple while loop and HashSet. 🧠 What I Learned Clean, minimal code > fancy syntax. Always check for language-specific methods — C++ vs Java can trick you! The sliding window technique isn’t about moving two pointers randomly — it’s about maintaining constraints efficiently. Debugging teaches more than success on the first try. 🎯 Targeting Product-Based & EdTech Companies As part of my SDE preparation for product-based and EdTech companies like FloBiz, Scaler, Razorpay, Unacademy, and Swiggy, I’m focusing on building strong fundamentals — not just solving problems, but deeply understanding why they work. 💬 Final Thought Every “wrong submission” is just a lesson wrapped in logic. Keep coding, keep debugging, and every small improvement compounds over time 💻🔥 Masai Prepleaf by Masai Newton School PhonePe Paytm Paytm Payments Bank Razorpay Razor Group PayU #Java #DSA #ProblemSolving #LeetCode #LearningInPublic #SoftwareDevelopment #ProductBasedPreparation #CodeWithDilsah #EdTech #FrontendDeveloper #FloBiz

I've worked with this library a lot and can say it's really helps with more or less simple object mapping, but if you have rather complicated relations between your classes it takes some time to build correct MapStruct infrastructure. I'd recomment everybody to dive deeper into the documentation and make your life easier. 😎 👍

Java25 : main() , Compact Source, IO In Java 25 : The language significantly simplifies writing a main method by removing much of the traditional boilerplate. The new "Compact Source Files and Instance Main Methods" feature (JEP 512) allows you to write simple programs without a class wrapper, a public or static modifier, or the String[] args parameter. Writing main methods in Java 25 - 1.Traditional main method The classic, fully-featured main method remains the standard for most applications and is fully backward-compatible. // MyProgram.java public class MyProgram { public static void main(String[] args) { System.out.println("Hello, " + args[0] + "!"); } } 2. Simplified main method within a class For smaller programs, you can now write a less verbose main method inside a class, omitting the public, static, and String[] args parts. The JVM will look for this simplified version if it doesn't find the traditional one. java // HelloWorld.java class HelloWorld { void main() { System.out.println("Hello, World!"); } } 3. "Compact source file" with instance main For the most minimal entry point, you can place the simplified main method directly in a file without an enclosing class. The compiler automatically wraps the code in an implicit, unnamed class. // Minimal.java void main() { System.out.println("Hello from a compact source file!"); } 4. Using the java.lang.IO helper class To further reduce boilerplate for console I/O, Java 25 introduces a java.lang.IO helper class, making it easier to read and write from the console. java // IOExample.java import static java.lang.IO.*; void main() { var name = readln("What's your name? "); println("Hello, " + name + "!"); } Article: Java's main method gets a beginner-friendly reboot In its latest long-term support (LTS) version, Java 25, the platform has made a significant update to how developers, particularly beginners, can write the entry point to their programs. By finalizing JEP 512, which introduces "Compact Source Files and Instance Main Methods," Java has shed some of its long-standing "boilerplate" to become more accessible and intuitive. The feature, which was refined over several preview releases (including Java 21–24), provides a smoother on-ramp for new programmers by removing the need to understand complex, enterprise-level concepts like public, static, and the String[] args parameter from day one.

⚡️ Day 7 — Mastering Null Handling & Optionals in Java Continuing my 100 Days of Java Backend, Spring Boot & AI Integration journey 💻 Today I revisited one of the most common issues every Java developer has faced at least once — the NullPointerException (NPE). Even though I’ve worked with it many times before, I decided to go back and strengthen my understanding — because clean, safe, and predictable code is what truly scales in production 🚀 ------------------------------------------------------------------------------- 🧠 What I Revised Today 💥 NullPointerException (NPE) The infamous runtime error that occurs when we try to access an object reference that points to null. 🛠️ Intro to Optional<T> Revisited how Optional helps avoid NPEs by wrapping potentially nullable values safely. ✅ Safe Value Retrieval: Instead of doing manual null checks — if (user != null && user.getEmail() != null) ------------------------------------------------------------------------------- I revised how to use: Optional.ofNullable(user) .map(User::getEmail) .ifPresent(System.out::println); ⚙️ Functional Operations with Optionals Used methods like map(), flatMap(), filter(), and orElse() to chain logic fluently without null worries. 🧱 Best Practices I Recalled: 1) Always return Optional from methods that might return null 2) Avoid using Optional.get() without checking presence 3) Prefer orElseGet() for lazy evaluation 4) Never use Optional for fields or serialization ------------------------------------------------------------------------------- Null handling may sound simple, but mastering it is the difference between defensive code and confident code 🧠✨ Tomorrow, I’ll be revising File Handling, Streams (I/O), and Serialization in Java to reinforce my backend fundamentals ⚙️ #100DaysOfJavaBackend #Day7 #JavaDeveloper #SpringBoot #BackendDevelopment #OptionalClass #NullPointerException #CleanCode #FunctionalProgramming #SoftwareDevelopment #LearningJourney #CodingJourney #AIDeveloper

🌊 Java Stream API — The Modern Way to Process Data! 🚀 🔹 What is Stream API? The Stream API (introduced in Java 8) allows developers to process collections of data in a declarative, functional-style way — making code cleaner, faster, and more readable. It helps you perform operations like filtering, mapping, sorting, reducing, and more — without writing loops! 💡 🔥 Core Stream API Topics: 1️⃣ What is a Stream? 2️⃣ Creating Streams (from List, Array, or File) 3️⃣ Intermediate Operations → filter(), map(), sorted(), distinct() 4️⃣ Terminal Operations → collect(), forEach(), count(), reduce() 5️⃣ Stream Pipeline Concept 6️⃣ Parallel Streams 7️⃣ Stream vs Collection 8️⃣ Lazy Evaluation 9️⃣ Optional and Stream Integration 🔟 Best Practices & Performance Tips 💬 Example: List<String> names = List.of("Akash", "Anil", "Arun", "Bala"); names.stream() .filter(n -> n.startsWith("A")) .map(String::toUpperCase) .forEach(System.out::println); ✨ Output → AKASH ANIL ARUN ✅ Key Benefits: 🔸 Reduces boilerplate code 🔸 Enables functional programming 🔸 Improves readability and maintainability. 💡 "Write less code, do more work — that’s the power of Stream API!" .🌊 Core Stream API Topics — Simplified! 🚀 1️⃣ What is a Stream? A Stream is a sequence of elements that supports sequential and parallel operations on data sources like collections or arrays. 2️⃣ Creating Streams You can create streams from Collections, Arrays, or Files using methods like stream(), Arrays.stream(), or Files.lines(). 3️⃣ Intermediate Operations These transform a stream into another stream. They are lazy (executed only when needed). 👉 Examples: filter(), map(), sorted(), distinct(). 4️⃣ Terminal Operations These produce a result or a side-effect and end the stream pipeline. 👉 Examples: collect(), forEach(), count(), reduce(). 5️⃣ Stream Pipeline A chain of stream operations — starting from a data source, followed by intermediate operations, and ending with a terminal operation. 6️⃣ Parallel Streams Allow processing of data in multiple threads, improving performance for large data sets. 👉 Example: list.parallelStream(). 7️⃣ Stream vs Collection Collections store data, while Streams perform computations on that data. Streams don’t store elements. 8️⃣ Lazy Evaluation Intermediate operations are not executed immediately — they run only when a terminal operation is called. 9️⃣ Optional and Stream Integration Helps handle null or missing values safely using methods like findFirst(), findAny(), which return Optional. 🔟 Best Practices ✅ Avoid modifying source data ✅ Use parallel streams wisely ✅ Keep pipelines readable & efficient 💡 Stream API = Cleaner Code + Better Performance! 💻 #Java #StreamAPI #Java8 #Coding # Functional Programming# #LinkedInLearning

🚀 Why IoC and DI aren’t just buzzwords — they’re game-changers in Spring Boot In modern Java development, building clean, maintainable applications means embracing two foundational concepts: Inversion of Control (IoC) and Dependency Injection (DI) — especially when using Spring Boot. 🔄 What is IoC? With IoC, the flow of control is flipped: instead of your code managing object creation and wiring, the framework’s IoC container takes over. Your classes declare what they need, and the container handles how and when those needs are fulfilled. In short: you ask for the engine, the container supplies it — you don’t construct it with new. This reduces boilerplate, tight coupling and lets you focus on business logic. 💉 And how DI brings IoC to life Dependency Injection is the mechanism through which IoC is realised. Instead of a class instantiating its dependencies, the container injects them for you (via constructor, setter or field). With DI: Your class becomes lighter – it only declares dependencies. You decouple implementation from interface — easier to swap out modules. Unit testing becomes simpler — you can provide mock dependencies rather than managing real ones. 🔍 Real-world in Spring Boot Imagine you have a service OrderService that needs a PaymentProvider. Without IoC/DI you might write: public class OrderService {   private final PaymentProvider provider = new StripePaymentProvider();   // …   } Here OrderService is tightly bound to StripePaymentProvider. With Spring Boot and DI, you write: @Service public class OrderService {   private final PaymentProvider provider;   // Constructor injection   public OrderService(PaymentProvider provider) {     this.provider = provider;   }   public void process(Order order) {     provider.pay(order);   } } And you declare StripePaymentProvider (or any other) as a bean. The Spring IoC container creates and injects it. Result: You can replace the provider with PayPalPaymentProvider or MockPaymentProvider for testing — with zero changes in OrderService. ✅ Why this matters Loose coupling — Components talk via abstractions, not concrete classes. Better testability — You can easily pass in mocks or stubs. Less boilerplate/config — Spring Boot’s auto-configuration + IoC container means fewer lines of wiring code. Scalability & maintainability — When your system grows, modules can evolve independently because dependencies are externally managed. #SpringBoot #Java #InversionOfControl #DependencyInjection #CleanArchitecture

💡 The No-Args Constructor When we talk about Java classes, we often focus on methods, encapsulation, or inheritance — but one of the most subtle yet powerful elements is the No-Argument Constructor (also called the default constructor). 🧩 Why is it Important? It ensures that an object can be created without explicitly passing any parameters. Frameworks like Hibernate, Spring, and Jackson rely on it heavily for object instantiation via reflection. If you define any constructor with parameters, Java won’t automatically provide a no-args one — you must define it manually. It’s especially useful in serialization/deserialization, ORM mapping, and dependency injection. Let’s look at an example 👇 class Employee { private String name; private int id; // No-args constructor public Employee() { System.out.println("No-Args Constructor Called"); this.name = "Unknown"; this.id = 0; } // Parameterized constructor public Employee(String name, int id) { this.name = name; this.id = id; } void display() { System.out.println("Employee: " + name + ", ID: " + id); } } public class EmployeeDriver { public static void main(String[] args) { Employee e1 = new Employee(); // uses no-args constructor Employee e2 = new Employee("Rahul", 101); // uses parameterized constructor e1.display(); e2.display(); } } 🧠 Key takeaway: Even if it seems trivial, the no-args constructor is vital for flexibility, framework compatibility, and maintaining clean object-oriented design. Ignoring it can lead to subtle runtime issues — especially when working with frameworks! #Java #Programming #SpringBoot #Hibernate #Developers #CodeBetter #OOP #SoftwareDevelopment #TechLearning

💡 Java 8 Feature Spotlight: Stream API 🚀 Before Java 8: Manual Iteration Pain: Working with collections meant lots of for-loops or iterators for tasks like filtering, transforming, or aggregating data. Mutability Hassles: Needed temporary lists and mutable storage, cluttering logic. Difficult Parallelization: Making iteration parallel was tricky and error-prone. Example (pre-Java 8): Filtering: ----------> List<Employee> highEarners = new ArrayList<>(); for (Employee e : employees) { if (e.getSalary() > 100000) { highEarners.add(e); } } ----------> Example (pre-Java 8): Transformation/Mapping: ----------> List<String> names = new ArrayList<>(); for (Employee e : employees) { names.add(e.getName()); } ----------> With Java 8’s Stream API: What is the Stream API? Stream API introduces a new abstraction for processing sequences of data, letting you write concise, declarative code to filter, map, sort, and aggregate. Mapping Operations with .map(): What is Mapping? Mapping is the process of converting each element in a stream to another form using a function. Why it Matters: In Java 8, the .map() method applies a transformation to every item in a stream, producing a new stream with the results. It makes data transformation intuitive and reduces boilerplate. Examples with Stream API: Elegant Filtering: ----------> List<Employee> highEarners = employees.stream() .filter(e -> e.getSalary() > 100000) .collect(Collectors.toList()); ----------> Elegant Mapping: ----------> List<String> names = employees.stream() .map(Employee::getName) .collect(Collectors.toList()); ----------> Numeric Mapping: List<Integer> doubledNumbers = numbers.stream() .map(n -> n * 2) .collect(Collectors.toList()); ----------> Key Improvements and Benefits: ✅ Less Code, More Clarity: Express complex operations in just a few lines. ✅ Readable and Declarative: Focus on what you want done, not how. ✅ Powerful Chaining: Easily combine mapping, filtering, sorting, and grouping. ✅ Effortless Parallelism: Easily unlock multi-core processing with .parallelStream(). In summary: Java 8’s Stream API—including its powerful mapping operations—makes your data workflows cleaner, faster, and much more expressive! #Java8 #StreamAPI #MapOperation #FunctionalProgramming #DataTransformation #TechInnovation #JavaProgramming

⚡ 10+ Approaches to Find Max or Min Value in Java 8 Streams — Master It Like a Pro 💪 Working with Java 8 Streams? Here are 10 powerful and elegant ways to find the maximum or minimum value from a list — all clean, modern, and interview-ready 👇 🧩 Sample Data List<Integer> myList = Arrays.asList(10, 15, 8, 49, 25, 98, 98, 32, 15); 🔥 Find Maximum Value — 10 Approaches List<Integer> myList = Arrays.asList(10,15,8,49,25,98,98,32,15); 1️⃣ Using instance comparator (compareTo on elements) myList.stream().max(Integer::compareTo).get(); 2️⃣ Using static comparator (Integer.compare) myList.stream().max(Integer::compare).get(); 3️⃣ Using IntStream for primitive comparison myList.stream().mapToInt(Integer::intValue).max().getAsInt(); 4️⃣ Using reduce() with Integer::max myList.stream().reduce(Integer::max).get(); 5️⃣ Using Collectors.summarizingInt() for all stats myList.stream().collect(Collectors.summarizingInt(i -> i)).getMax(); 6️⃣ Using Comparator.comparingInt() (good for objects too) myList.stream().max(Comparator.comparingInt(Integer::intValue)).get(); 7️⃣ Using Comparator.naturalOrder() for clean syntax myList.stream().max(Comparator.naturalOrder()).get(); 8️⃣ Using Comparable::compareTo (generic Comparable) myList.stream().max(Comparable::compareTo).get(); 9️⃣ Using custom lambda comparator (manual compare logic) myList.stream().max((a,b) -> a>b ? 1 : (a<b ? -1 : 0)).get(); 🔟 Using summaryStatistics() for one-line numeric max myList.stream().mapToInt(Integer::intValue).summaryStatistics().getMax(); 🕚 Using sorted() + skip() to pick last element myList.stream().sorted().skip(myList.size()-1).findFirst().get(); 🌙 Same Approaches for Find Minimum Value List<Integer> myList = Arrays.asList(10, 15, 8, 49, 25, 98, 98, 32, 15); 1️⃣ myList.stream().min(Integer::compareTo).get(); 2️⃣ myList.stream().min(Integer::compare).get(); 3️⃣ myList.stream().mapToInt(Integer::intValue).min().getAsInt(); 4️⃣ myList.stream().reduce(Integer::min).get(); 5️⃣ myList.stream().collect(Collectors.summarizingInt(i -> i)).getMin(); 6️⃣ myList.stream().min(Comparator.comparingInt(Integer::intValue)).get(); 7️⃣ myList.stream().min(Comparator.naturalOrder()).get(); 8️⃣ myList.stream().min(Comparable::compareTo).get(); 9️⃣ myList.stream().min((a, b) -> a > b ? 1 : (a < b ? -1 : 0)).get(); 🔟 myList.stream().mapToInt(Integer::intValue).summaryStatistics().getMin(); 🕚 myList.stream().sorted().findFirst().get(); 💡 Quick Summary for Efficiency 🧠 For numeric lists → mapToInt().max() or summaryStatistics() 🚀 For objects → Comparator.comparing() 📊 For analytics → Collectors.summarizingInt() 💪 For readability → reduce() or naturalOrder() ⚙️ For demos → sorted().skip() (less efficient) 👉 Follow me for more Java 8, Streams, and interview-ready code tips! 🔖 #Java #Java8 #Streams #CodingTips #FunctionalProgramming #InterviewPreparation #CleanCode #Developers #LinkedInLearning #CodeNewbie