Java String vs StringBuilder vs StringBuffer Performance Comparison

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

✨ Exploring the Power of Strings in Java ✨ Strings may look simple, but they’re one of the most powerful and frequently used features in Java. Every Java developer works with them daily—whether it’s handling user input, building applications, or processing data. 💡 What makes Java Strings special? A string is a sequence of characters enclosed in double quotes. Unlike characters (which use single quotes), strings can store entire words, sentences, and even large data. But here’s the interesting part 👇 🔹 Strings are Objects In Java, strings aren’t primitive types—they’re objects stored in the heap memory of the JRE. This gives them powerful built-in functionality and efficient memory management. 🔹 Immutable vs Mutable Strings • Immutable (String class) → Once created, the value cannot change. Perfect for fixed data like names or IDs. • Mutable (StringBuffer & StringBuilder) → Can be modified anytime. Ideal for dynamic data like passwords, emails, or large text processing. 🔹 String Pool Magic Java optimizes memory using the String Constant Pool: • Strings created without new → Stored in constant pool (no duplicates). • Strings created with new → Stored in heap (duplicates allowed). This small detail makes Java memory management super efficient 🚀 🔹 Common String Operations Every Developer Uses ✔ Concatenation → + operator or concat() ✔ Comparison → equals(), equalsIgnoreCase(), compareTo() ✔ Handy Methods → length() | charAt() | substring() | replace() | split() | trim() | toUpperCase() | toLowerCase() These methods are the everyday tools that make Java development smooth and powerful.

🔹 Java 8 (Released 2014) – Foundation Release This is still widely used in many projects. Key Features: Lambda Expressions Functional Interfaces Streams API Method References Optional Class Default & Static methods in interfaces Date & Time API (java.time) Nashorn JavaScript Engine 👉 Example: Java list.stream().filter(x -> x > 10).forEach(System.out::println); 🔹 Java 17 (LTS – 2021) – Modern Java Standard Most companies are moving to this LTS version. Key Features: Sealed Classes Pattern Matching (instanceof) Records (finalized) Text Blocks (multi-line strings) New macOS rendering pipeline Strong encapsulation of JDK internals Removed deprecated APIs (like Nashorn) 👉 Example: Java record Employee(String name, int salary) {} 🔹 Java 21 (LTS – 2023) – Latest Stable LTS 🚀 Highly recommended for new projects. Key Features: Virtual Threads (Project Loom) ⭐ (BIGGEST CHANGE) Structured Concurrency (preview) Scoped Values (preview) Pattern Matching for switch (final) Record Patterns Sequenced Collections String Templates (preview) 👉 Example (Virtual Thread): Java Thread.startVirtualThread(() -> { System.out.println("Lightweight thread"); }); 🔹 Java 26 (Future / Latest Enhancements – Expected 2026) ⚡ (Not all finalized yet, but based on current roadmap & previews) Expected / Emerging Features: Enhanced Pattern Matching Primitive Types in Generics (Project Valhalla) ⭐ Value Objects (no identity objects) Improved JVM performance & GC Better Foreign Function & Memory API More concurrency improvements Scoped/Structured concurrency finalized 👉 Example (Concept): Java List<int> numbers; // possible future feature

📌 Optional in Java — Avoiding NullPointerException NullPointerException is one of the most common runtime issues in Java. Java 8 introduced Optional to handle null values more safely and explicitly. --- 1️⃣ What Is Optional? Optional is a container object that may or may not contain a value. Instead of returning null, we return Optional. Example: Optional<String> name = Optional.of("Mansi"); --- 2️⃣ Creating Optional • Optional.of(value)    → value must NOT be null  • Optional.ofNullable(value)    → value can be null  • Optional.empty()    → represents no value  --- 3️⃣ Common Methods 🔹 isPresent() Checks if value exists 🔹 get() Returns value (not recommended directly) --- 4️⃣ Better Alternatives 🔹 orElse() Returns default value String result =   optional.orElse("Default"); 🔹 orElseGet() Lazy default value 🔹 orElseThrow() Throws exception if empty --- 5️⃣ Transforming Values 🔹 map() Optional<String> name = Optional.of("java"); Optional<Integer> length =   name.map(String::length); --- 6️⃣ Why Use Optional? ✔ Avoids null checks everywhere   ✔ Makes code more readable   ✔ Forces handling of missing values   ✔ Reduces NullPointerException  --- 7️⃣ When NOT to Use Optional • As class fields   • In method parameters   • In serialization models  --- 🧠 Key Takeaway Optional makes null handling explicit and safer, but should be used wisely. It is not a replacement for every null. #Java #Java8 #Optional #CleanCode #BackendDevelopment

🚀 CyclicBarrier in Java — Small Concept, Powerful Synchronization In multithreading, coordination between threads is critical ⚡ 👉 CyclicBarrier allows multiple threads to wait for each other at a common point before continuing — ensuring everything stays in sync 🔥 💡 Think of it like a checkpoint 🏁 No thread moves forward until all have arrived! 🌍 Real-Time Example Imagine a report generation system 📊 Multiple threads fetch data from different APIs 📡 Each processes its own data ⚙️ Final report should generate only when all threads finish 👉 With CyclicBarrier, you ensure: ✅ All threads complete before aggregation ✅ No partial or inconsistent data ✅ Smooth parallel execution 💻 Quick Code Example import java.util.concurrent.CyclicBarrier; public class Demo { public static void main(String[] args) { CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("All threads reached. Generating final report...")); Runnable task = () -> { try { System.out.println(Thread.currentThread().getName() + " fetching data..."); Thread.sleep(1000); barrier.await(); System.out.println(Thread.currentThread().getName() + " done!"); } catch (Exception e) { e.printStackTrace(); } }; for (int i = 0; i < 3; i++) new Thread(task).start(); } } 💪 Why it’s powerful ✔️ Keeps threads perfectly synchronized ✔️ Prevents incomplete execution ❌ ✔️ Reusable for multiple phases ♻️ 🔥 Final Thought 👉 It’s a small but powerful feature — use it wisely based on your project needs to ensure the right level of synchronization without overcomplicating your design. #Java #Multithreading #Concurrency #BackendDevelopment #SoftwareEngineering

☕ Optional Class in Java 8 The Optional class in Java 8 is used to avoid NullPointerException (NPE). 👉 It is introduced by Oracle Corporation in Java 8. 🧠 Why Optional? 👉 Problem (Before Java 8): String name = null; System.out.println(name.length()); // ❌ NullPointerException 👉 Solution (Using Optional): Optional<String> name = Optional.ofNullable(null); System.out.println(name.orElse("Default")); ✔️ No crash ✔️ Safe handling of null 🔧 How to Create Optional Optional<String> op1 = Optional.of("Java"); // Not null Optional<String> op2 = Optional.ofNullable(null); // Can be null Optional<String> op3 = Optional.empty(); // Empty ⚙️ Important Methods (Must Know 🔥) 1️⃣ isPresent() 👉 Check value exists if(op.isPresent()) { System.out.println(op.get()); } 2️⃣ get() 👉 Get value (⚠️ risky if empty) 3️⃣ orElse() 👉 Default value if null op.orElse("Default"); 4️⃣ orElseGet() 👉 Default using function 5️⃣ orElseThrow() 👉 Throw exception if empty 6️⃣ map() 👉 Transform value op.map(String::toUpperCase); 7️⃣ ifPresent() 👉 Execute if value exists op.ifPresent(System.out::println); 💻 Real Example Optional<String> name = Optional.ofNullable("Ranjit"); name.ifPresent(n -> System.out.println(n)); String result = name.map(String::toUpperCase) .orElse("No Name"); System.out.println(result); 🌟 Advantages ✔️ Avoid NullPointerException ✔️ Clean & readable code ✔️ Functional style coding ⚠️ Best Practices ❌ Don’t use get() without check ❌ Don’t use Optional for fields (avoid overuse) ✔️ Use orElse, orElseGet, ifPresent

About POJO (Plain Old Java Object) A POJO (Plain Old Java Object) is a simple class in Java that is used to represent data. It does not depend on any special frameworks or libraries. 🔹 Key Features: Private Fields → Data members are kept private (encapsulation Constructors→ * Default (no-argument) * Parameterized (with values) * Getters & Setters → Used to access and modify data * No complex logic → Just simple data handling 👉 In short, POJO is mainly used to **store and transfer data** in a clean and simple way Code for POJO class // POJO Class class Student { // Private Fields private String name; private int age; // Zero-parameter (Default Constructor) public Student() { } // Parameterized Constructor public Student(String name, int age) { this.name = name; this.age = age; } // Getter Methods public String getName() { return name; } public int getAge() { return age; } // Setter Methods public void setName(String name) { this.name = name; } public void setAge(int age) { this.age = age; } } // Main Class to Test POJO public class Main { public static void main(String[] args) { // Using default constructor + setters Student s1 = new Student(); s1.setName("Lavanya"); s1.setAge(21); System.out.println("Name: " + s1.getName()); System.out.println("Age: " + s1.getAge()); // Using parameterized constructor Student s2 = new Student("Rahul", 22); System.out.println("Name: " + s2.getName()); System.out.println("Age: " + s2.getAge()); } } #POJO #privatefields #zeroparameterconstructor #parameterisedconstructor #setters&getters

Java tip: starting from Java 14, you can use switch expressions - the code becomes shorter and cleaner with logic involving multiple branches. Previously, you had to write it cumbersingly with break and assignments: => Old method String season; switch (month) { case 12: case 1: case 2: season = "Winter"; break; case 3: case 4: case 5: season = "Spring"; break; default: season = "Invalid"; } Now, you can immediately return the value from the switch: => New switch expression String season = switch (month) { case 12, 1, 2 -> "Winter"; case 3, 4, 5 -> "Spring"; default -> "Invalid"; }; What does this provide: - less code - no risk of forgetting to use break - it reads like an expression, not a "mini-procedure"

🚀 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