Java String Pool and == vs equals()

🚀 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

Day 12 Today’s Java practice was about solving the Leader Element problem. Instead of using nested loops, I used a single traversal from right to left, which made the solution clean and efficient. A leader element is one that is greater than all the elements to its right. Example: Input: {16,17,5,3,4,2} Leaders: 17, 5, 4, 2 🧠 Approach I used: ->Start traversing from the rightmost element ->Keep track of the maximum element seen so far ->If the current element is greater than the maximum, it becomes a leader ->This is an efficient approach with O(n) time complexity and no extra space. ================================================= // Online Java Compiler // Use this editor to write, compile and run your Java code online class Main {   public static void main(String[] args) {     int a [] ={16,17,5,3,4,2};     int length=a.length;     int maxRight=a[length-1];     System.out.print("Leader elements are :"+maxRight+" ");           for(int i=a[length-2];i>=0;i--)     {       if(a[i]>maxRight)       {         maxRight=a[i];         System.out.print(maxRight+" ");       }     }   } } Output:Leader elements are :2 4 5 17  #AutomationTestEngineer #Selenium #Java #DeveloperJourney #Arrays

Java Devs, let's talk about a core concept that makes our code cleaner and more flexible: "Method Overloading"! Ever wanted to perform similar operations with different inputs without creating a bunch of uniquely named methods? That's where Method Overloading shines! It's a fantastic example of compile-time polymorphism (aka static polymorphism or early binding) that allows a class to have multiple methods with the "same name", as long as their parameter lists are different. Key takeaways: *   Same method name, different parameters = ✅ *   Cannot overload by return type alone (parameters *must* differ) ⚠️ *   The compiler is smart! It picks the most specific match. 🧠 Check out this quick example: ```java class Product {     public int multiply(int a, int b) { // Multiplies two numbers         return a * b;     }     public int multiply(int a, int b, int c) { // Multiplies three numbers         return a * b * c;     } } // Output: // Product of the two integer value: 2 // Product of the three integer value: 6 ``` See how elegant that is? One `multiply` method, multiple functionalities! What are your favorite use cases for Method Overloading in your Java projects? Share in the comments! 👇 #Java #JavaDevelopment #Programming #SoftwareDevelopment #BeginnerProgramming

🚀 Java Trap: Why "finally" Doesn’t Change the Returned Value 👇 👉 Primitive vs Object Behavior in "finally" 🤔 Looks tricky… but very important to understand. --- 👉 Example 1 (Primitive): public static int test() { int x = 10; try { return x; } finally { x = 20; } } 👉 Output: 10 😲 Why not 20? 💡 Java stores return value before executing "finally" - "x = 10" stored - "finally" runs → changes "x" to 20 - But already stored value (10) is returned --- 👉 Example 2 (Object): public static StringBuilder test() { StringBuilder sb = new StringBuilder("Hello"); try { return sb; } finally { sb.append(" World"); } } 👉 Output: Hello World 😲 Why changed here? 💡 Object reference is returned - Same object is modified in "finally" - So changes are visible --- 🔥 Rule to remember: - Primitive → value copied → no change - Object → reference returned → changes visible --- 💭 Subtle concept… very common interview question. #Java #Programming #Coding #Developers #JavaTips #InterviewPrep 🚀

Hello Connections, Post 20— Java Fundamentals A-Z This one compiles perfectly. But breaks everything at runtime. 😱 Can you spot the bug? 👇 @FunctionalInterface interface Calculator { int calculate(int a, int b); int multiply(int a, int b); // 💀 Won't compile! } The bug? A Functional Interface can have only ONE abstract method! Two abstract methods = not functional! 💀 Here’s the fix 👇 // ✅ One abstract method only! @FunctionalInterface interface Calculator { int calculate(int a, int b); // ✅ Only one! } // ✅ Use it with Lambda! Calculator add = (a, b) -> a + b; Calculator multiply = (a, b) -> a * b; Calculator subtract = (a, b) -> a - b; System.out.println(add.calculate(5, 3)); // 8 ✅ System.out.println(multiply.calculate(5, 3)); // 15 ✅ System.out.println(subtract.calculate(5, 3)); // 2 ✅ Java’s Built-in Functional Interfaces // Predicate — returns boolean Predicate<String> isEmpty = s -> s.isEmpty(); // Function — transforms input to output Function<String, Integer> length = s -> s.length(); // Consumer — takes input, returns nothing Consumer<String> print = s -> System.out.println(s); // Supplier — no input, returns value Supplier<String> greeting = () -> "Hello DBS!"; Post 20 Summary: 🔴 Unlearned → Functional Interface can have multiple methods 🟢 Relearned → Exactly ONE abstract method — that’s what makes it functional! 🤯 Biggest surprise → Built-in functional interfaces replaced 20+ custom interfaces in codebase! Which built-in functional interface do you use most? Drop below! 👇 #Java #JavaFundamentals #BackendDevelopment #LearningInPublic #SDE2 Follow along for more! 👇

Same result. Half the code. Most Java developers don’t use this 😱 Java Fundamentals Series | Part 21 Can you spot the improvement? 👇 List<String> names = Arrays.asList( "Alice", "Bob", "Charlie" ); // ❌ Verbose Lambda names.forEach(name -> System.out.println(name)); // ✅ Method Reference names.forEach(System.out::println); Cleaner. More readable. More professional. 💪 4 Types of Method References 👇 // 1. Static method Function<Integer, Integer> abs = Math::abs; // 2. Instance method of object Function<String, String> upper = String::toUpperCase; // 3. Instance method of instance String prefix = "DBS: "; Function<String, String> addPrefix = prefix::concat; // 4. Constructor reference Function<String, StringBuilder> builder = StringBuilder::new; Real-world example 👇 // ❌ Lambda transactions.stream() .map(t -> t.getAmount()) .forEach(a -> System.out.println(a)); // ✅ Method Reference transactions.stream() .map(Transaction::getAmount) .forEach(System.out::println); Summary: 🔴 Writing lambdas everywhere 🟢 Use method references when method already exists 🤯 Cleaner code = fewer lines + better readability ⸻ 👉 Posting more real-world fixes like this. Have you used method references? Drop a :: below 👇 #Java #JavaFundamentals #BackendDevelopment #LearningInPublic #SDE2

I used == for Strings when I first started learning Java… and got the wrong result 😅 That small mistake led me to understand one of the most important Java concepts: Heap Memory + String Constant Pool (SCP) Example 1 👇 String str1 = "Zayyni"; String str2 = "zayyni"; System.out.println(str1 == str2); // false System.out.println(str1.equals(str2)); // false System.out.println(str1.equalsIgnoreCase(str2)); // true Here: == → compares memory reference (same object or not) .equals() → compares actual content .equalsIgnoreCase() → compares content while ignoring case sensitivity Now the interesting part 👇 String str1 = new String("Zayyni"); String str2 = new String("Zayyni"; System.out.println(str1 == str2); // false System.out.println(str1.equals(str2)); // true Why? Because new String() creates a new object in Heap Memory every single time. Even if the value is the same, Java creates separate objects. But when we write: String str1 = "Zayyni"; String str2 = "Zayyni"; Java uses the String Constant Pool (SCP) where duplicate string literals are not created again. This saves memory and improves performance. That’s also one of the major reasons why String is immutable in Java — it makes pooling safe, efficient, and reliable. Sometimes the smallest Java concepts teach the biggest lessons. This topic is simple… but it appears in interviews more than people expect 👀 What Java concept confused you the most when you started? 👇 #Java #JavaDeveloper #SpringBoot #BackendDevelopment #Programming #SoftwareEngineering #Coding #Developers #JavaProgramming #JVM #StringPool #HeapMemory #InterviewPreparation #DeveloperLife #TechLearning #CleanCode #CodingJourney #LinkedInLearning #SoftwareDeveloper

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! 👇

Day14 Java Practice: Maximum Product of Three Elements in an Array While practicing Java, I solved an interesting array problem: 👉 Find the maximum product that can be formed using any three elements from the array. Example: Input: {10, 3, 5, 6, -20} At first, it looks like we just need the three largest numbers. But the twist is: negative numbers can change the result! 🧠 Key Idea: The product of two negative numbers becomes positive So we must compare: Product of the three largest numbers Product of two smallest (most negative) numbers and the largest number ================================================= // Online Java Compiler // Use this editor to write, compile and run your Java code online import java.util.*; class Main {   public static void main(String[] args) {     int a [] ={10,3,5,6,-20};     Arrays.sort(a);     int n=a.length;     System.out.println(Arrays.toString(a));     int result1=a[n-1]*a[n-2]*a[n-3];          int result2=a[0]*a[1]*a[n-1];          int result =Math.max(result1,result2);     System.out.println(result);        } } Output:[-20, 3, 5, 6, 10] 300 #JavaDeveloper #Arrays #CodingPractice #QualityEngineering #TechLearning