Raushan Singh’s Post

Hello Connections, Post 17 — Java Fundamentals A-Z This one confuses every Java developer at least once. 😱 Can you spot the bug? 👇 public static void addTen(int number) { number = number + 10; } public static void main(String[] args) { int x = 5; addTen(x); System.out.println(x); // 💀 5 or 15? } Most developers say 15. The answer is 5. 😱 Java ALWAYS passes by value — never by reference! Here’s what actually happens 👇 // ✅ Understanding the fix public static int addTen(int number) { number = number + 10; return number; // ✅ Return the new value! } public static void main(String[] args) { int x = 5; x = addTen(x); // ✅ Reassign the result! System.out.println(x); // ✅ 15! } But wait — what about objects? public static void addName(List<String> names) { names.add("Mubasheer"); // ✅ This WORKS! } public static void main(String[] args) { List<String> list = new ArrayList<>(); addName(list); System.out.println(list); // [Mubasheer] ✅ } 🤯 Java passes the REFERENCE by value! You can modify the object — but not reassign it! Post 17 Summary: 🔴 Unlearned → Java passes objects by reference 🟢 Relearned → Java ALWAYS passes by value — even for objects! 🤯 Biggest surprise → This exact confusion caused a method to silently lose transaction data! Have you ever been caught by this? Drop a 📨 below! #Java #JavaFundamentals #BackendDevelopment #LearningInPublic #SDE2 Follow along for more! 👇

🚀 Day 5 of Java 8 Series 👉 Question: Find the frequency of each word in a given sentence using Java 8 Streams. import java.util.*; import java.util.function.Function; import java.util.stream.Collectors; public class WordFrequency {   public static void main(String[] args) {     String sentence = "java is great and java is powerful";     Map<String, Long> frequencyMap = Arrays.stream(sentence.split("\\s+"))         .collect(Collectors.groupingBy(             Function.identity(),             Collectors.counting()         ));     System.out.println(frequencyMap);   } } Output: {java=2, powerful=1, and=1, is=2, great=1} 🧠 Key Concepts Explained 👉 1. Arrays.stream() Converts an array into a Stream, which allows us to perform functional operations like filtering, grouping, and counting. In this example, after splitting the sentence into words, we use it to start the stream pipeline. 👉 2. split("\\s+") (Regex) \\s → matches any whitespace (space, tab, newline) + → matches one or more occurrences 💡 This ensures that even if there are multiple spaces between words, the sentence is split correctly into individual words. 👉 3. Collectors.groupingBy() This is used to group elements based on a key. Here, we group words by their value (Function.identity()) So all same words come under one group Example: java → [java, java] 👉 4. Collectors.counting() Used along with groupingBy() to count the number of elements in each group. Instead of storing a list of words, it directly gives the frequency #Java #Java8 #Streams #Coding #Developers #Learning

🚀 Day 6 of Java Series — Count Vowels Using Streams Ever wondered how to count vowels in a string using Java 8 in a clean and functional way? Here’s a simple yet powerful approach using Streams 👇 import java.util.*; import java.util.function.Function; import java.util.stream.Collectors; public class CountOfVowels { public static void main(String[] args) { String name = "Microservices"; List<String> vowels = Arrays.asList("a", "e", "i", "o", "u"); Map<String, Long> map = Arrays.stream(name.split("")) .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())); List<Map.Entry<String, Long>> finalMap = map.entrySet().stream() .filter(entry -> vowels.contains(entry.getKey())) .toList(); System.out.println(finalMap); } } 🔍 How it works: 1️⃣ name.split("") → Converts string into individual characters 2️⃣ groupingBy(Function.identity(), counting()) → Counts frequency of each character 3️⃣ Filter step → Keeps only vowels 4️⃣ Final result → List of vowels with their count 👉 Output: [e=2, i=2, o=1] #Java #Java8 #Streams #Coding #Developers #Learning

Java Puzzle for Today What will be the output of this program? String a = "Java"; String b = "Java"; String c = new String("Java"); System.out.println(a == b); System.out.println(a == c); System.out.println(a.equals(c)); Take a moment and guess before scrolling. Most beginners think the output will be: true true true But the actual output is: true false true Why does this happen? Because Java stores string literals in a special memory area called the String Pool. So when we write: String a = "Java"; String b = "Java"; Both variables point to the same object in the String Pool. But when we write: String c = new String("Java"); Java creates a new object in heap memory, even if the value is the same. That’s why: - "a == b" → true (same object) - "a == c" → false (different objects) - "a.equals(c)" → true (same value) Lesson: Use "equals()" to compare values, not "==". Small Java details like this can save you from real bugs in production. #Java #Programming #JavaPuzzle #Coding #SoftwareDevelopment

🚀🎊Day 81 of 90 – Java Backend Development ✨🎆 In Java, Wrapper classes provide a way to use primitive data types (like int, boolean, etc.) as objects. Since Java is an object-oriented language, many of its most powerful features—like Collections (ArrayList, HashMap) and Generics—only work with objects, not primitives. 👉Why do we need them? Primitives are fast and memory-efficient, but they lack the "bells and whistles" of objects. Wrapper classes bridge this gap by "wrapping" a primitive value inside an object. i) Collections Support: You cannot create an ArrayList<int>, but you can create an ArrayList<Integer>. ii) Utility Methods: They provide handy methods for conversion (e.g., converting a String to an int). iii) Null Values: Primitives must have a value; Wrapper objects can be null, which is useful in databases or web forms. 👉Autoboxing and unboxing Modern Java (since version 5) handles the conversion between primitives and wrappers automatically. This makes your code much cleaner. 1. Autoboxing The automatic conversion of a primitive type to its corresponding wrapper class. int primitive = 10; Integer wrapper = primitive; // Autoboxing 2. Unboxing The reverse process: converting a wrapper object back into a primitive. Integer wrapper = 20; int primitive = wrapper; // Unboxing 👉 Useful features: Wrapper classes aren't just containers; they are packed with static utility methods. For example: i) Parsing Strings: int x = Integer.parseInt("123"); ii) Constants: Integer.MAX_VALUE or Double.NaN. iii) Type Conversion: myInteger.doubleValue(); #Wrapperclass #PrimitiveDataType #Autoboxing #Autounboxing

🚀Stream API in Java - Basics Every Developer Should Know When I started using Stream API, I realized how much cleaner and more readable Java code can become. 👉Stream API is used to process collections of data in a functional and declarative way. 💡What is a Stream? A stream is a sequence of elements that support operations like: ->filtering ->mapping ->sorting ->reducing 💠Basic Example List<String> list = Arrays.asList("Java", "Python", "Javascript", "C++"); list.stream().filter(lang-> lang.startsWith("J")) .forEach(System.out : : println); 👉 outputs :Java, Javascript 💠Common Stream Operations ☑️filter() -> selects elements ☑️map() -> transforms data ☑️sorted() -> sorts elements ☑️forEach() -> iterates over elements ☑️collect() -> converts stream back to collection 💠Basic Stream Pipeline A typical stream works in 3 steps: 1. Source -> collection 2. Intermediate Operations -> filter, map 3. Terminal operation -> forEach, collect ⚡Why Stream API? . Reduces boilerplate code . Improves readability . Encourages functional programming . Makes data processing easier ⚠️Important Points to remember . Streams don't store data, they process it . Streams are consumed once . Operations are lazy (executed only when needed) And Lastly streams API may seem confusing at first, but with practice it becomes a go-to tool for working with collections. #Java #StreamAPI #JavaDeveloper #Programming #SoftwareEngineering #BackendDevelopment #LearningInPublic

🚀 Java Revision Journey – Day 25 Today I revised the PriorityQueue in Java, a very important concept for handling data based on priority rather than insertion order. 📝 PriorityQueue Overview A PriorityQueue is a special type of queue where elements are ordered based on their priority instead of the order they are added. 👉 By default, it follows natural ordering (Min-Heap), but we can also define custom priority using a Comparator. 📌 Key Characteristics: • Elements are processed based on priority, not FIFO • Uses a heap data structure internally • Supports standard operations like add(), poll(), and peek() • Automatically resizes as elements are added • Does not allow null elements 💻 Declaration public class PriorityQueue<E> extends AbstractQueue<E> implements Serializable ⚙️ Constructors Default Constructor PriorityQueue<Integer> pq = new PriorityQueue<>(); With Initial Capacity PriorityQueue<Integer> pq = new PriorityQueue<>(10); With Comparator PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.reverseOrder()); With Capacity + Comparator PriorityQueue<Integer> pq = new PriorityQueue<>(10, Comparator.reverseOrder()); 🔑 Basic Operations Adding Elements: • add() → Inserts element based on priority Removing Elements: • remove() → Removes the highest-priority element • poll() → Removes and returns head (safe, returns null if empty) Accessing Elements: • peek() → Returns the highest-priority element without removing 🔁 Iteration • Can use iterator or loop • ⚠️ Iterator does not guarantee priority order traversal 💡 Key Insight PriorityQueue is widely used in algorithmic problem solving and real-world systems, such as: • Dijkstra’s Algorithm (shortest path) • Prim’s Algorithm (minimum spanning tree) • Task scheduling systems • Problems like maximizing array sum after K negations 📌 Understanding PriorityQueue helps in designing systems where priority-based processing is required, making it essential for DSA and backend development. Continuing to strengthen my Java fundamentals step by step 💪🔥 #Java #JavaLearning #PriorityQueue #DataStructures #JavaDeveloper #BackendDevelopment #Programming #JavaRevisionJourney 🚀

Stuck in Java 8? Here’s a 2-minute guide to the most asked LTS features! ☕️🚀 If you're preparing for a Java interview, you need to know more than just the basics. Interviewers are increasingly focusing on the evolution from Java 8 to 21. Here is a quick breakdown of the "Must-Know" features for your next technical round: 🌱 Java 8: The Functional Revolution The foundation of modern Java. Lambda Expressions: Passing behavior as a parameter. 1.list.forEach(item -> System.out.println(item)); 2.(var x, var y) -> x + y; Stream API: Declarative data processing (Filter, Map, Sort). Optional Class: Say goodbye to NullPointerException. Default Methods: Adding logic to interfaces without breaking old code. 🧹 Java 11: Modernization & Cleanup Var for Lambdas: Standardizes local variable syntax in functional code. (var x, var y) -> x + y; New HTTP Client: Finally, a modern, asynchronous way to handle web requests. String Utilities: Handy methods like .isBlank(), .strip(), and .repeat(). 🏗️ Java 17: Expressive Syntax Focuses on reducing boilerplate and better inheritance control. Sealed Classes: Restrict which classes can extend your code. public sealed class Shape permits Circle, Square {} Records: One-liner immutable data classes. public record User(String name, int id) {} Text Blocks: Clean multi-line strings without the \n mess. ⚡ Java 21: High-Performance Concurrency The current gold standard for scalability. Virtual Threads: Lightweight threads that make I/O-bound tasks incredibly fast. Pattern Matching for Switch: Cleaner type checking. switch (obj) { case Integer i -> System.out.println("Int: " + i); case String s -> System.out.println("String: " + s); default -> System.out.println("Unknown"); } Sequenced Collections: Better control over the order of elements (First/Last). #Knowledge Sharer #Learning

💡Functional Interfaces in Java — The Feature That Changed Everything When Java 8 introduced functional interfaces, it quietly transformed the way we write code. At first, it may look like “just another interface rule” — but in reality, it unlocked modern Java programming. 🔹 What is a Functional Interface? A functional interface is simply an interface with exactly one abstract method. @FunctionalInterface interface Calculator { int operate(int a, int b); } That’s it. But this “small restriction” is what makes lambda expressions possible. 🔹 Why Do We Need Functional Interfaces? Before Java 8, passing behavior meant writing verbose code: Runnable r = new Runnable() { @Override public void run() { System.out.println("Running..."); } }; Now, with functional interfaces: Runnable r = () -> System.out.println("Running..."); 👉 Cleaner 👉 More readable 👉 Less boilerplate 🔹 The Real Power: Passing Behavior Functional interfaces allow us to pass logic like data. list.stream() .filter(x -> x % 2 == 0) .map(x -> x * 2) .forEach(System.out::println); Instead of telling Java how to do something, we describe what to do. This is called declarative programming — and it’s a game changer. 🔹 Common Built-in Functional Interfaces Java provides powerful utilities in "java.util.function": - Predicate<T> → condition checker - Function<T, R> → transformation - Consumer<T> → performs action - Supplier<T> → provides value 🔹 Why Only One Abstract Method? Because lambda expressions need a clear target. If multiple abstract methods existed, the compiler wouldn’t know which one the lambda refers to. 👉 One method = One behavior contract 🔹 Real-World Impact Functional interfaces are everywhere: ✔ Stream API ✔ Multithreading ("Runnable", "Callable") ✔ Event handling ✔ Spring Boot (filters, callbacks, transactions) ✔ Strategy pattern 🔹 Key Takeaway Functional interfaces turned Java from: ➡️ Object-oriented only into ➡️ Object-oriented + Functional programming hybrid 🔁 If this helped you understand Java better, consider sharing it with your network. #Java #FunctionalProgramming #Java8 #SoftwareDevelopment #Backend #SpringBoot #Coding

💅 Java Collections Framework — Complete Roadmap => One of the most important topics every Java developer must master is the Java Collections Framework (JCF). From List, Set, Queue, and Map to classes like ArrayList, HashMap, LinkedList, TreeMap, and PriorityQueue — understanding when and why to use each collection can make your code cleaner, faster, and more efficient. 👉 Prior to Java 2, Java provided ad hoc classes such as Dictionary, Vector, Stack, and Properties to store and manipulate groups of objects. Although these classes were quite useful, they lacked a central, unifying theme. Thus, the way that you used Vector was different from the way that you used Properties. #What is Java Collections Framework? -> A collections framework is a unified architecture for representing and manipulating collections. All collections frameworks contain the following: -> Interfaces − These are abstract data types that represent collections. Interfaces allow collections to be manipulated independently of the details of their representation. In object-oriented languages, interfaces generally form a hierarchy. -> Implementations, i.e., Classes − These are the concrete implementations of the collection interfaces. In essence, they are reusable data structures. -> Algorithms − These are the methods that perform useful computations, such as searching and sorting, on objects that implement collection interfaces. The algorithms are said to be polymorphic: that is, the same method can be used on many different implementations of the appropriate collection interface. -> In addition to collections, the framework defines several map interfaces and classes. Maps store key/value pairs. Although maps are not collections in the proper use of the term, but they are fully integrated with collections. 👉 In this roadmap, I covered: ✔ Collections hierarchy ✔ Important classes & interfaces ✔ Time complexities ✔ Best use cases ✔ Beginner tips Save this for your Java journey 🔖 Which Java collection do you use the most? 👇 #Java #JavaCollections #JCF #CollectionsFramework #Programming #Developers #Coding #BackendDevelopment #DSA #SoftwareEngineering