Harsh Gupta’s Post

🚀 Day 3 – Why String is Immutable in Java (and why it matters) One question I explored today: Why are "String" objects immutable in Java? String s = "hello"; s.concat(" world"); System.out.println(s); // still "hello" 👉 Instead of modifying the existing object, Java creates a new String But why was it designed this way? ✔ Security – Strings are widely used in sensitive areas (like class loading, file paths, network connections). Immutability prevents accidental or malicious changes. ✔ Performance (String Pool) – Since Strings don’t change, they can be safely reused from the pool, saving memory. ✔ Thread Safety – No synchronization needed, multiple threads can use the same String safely. 💡 This also explains why classes like "StringBuilder" and "StringBuffer" exist—for mutable operations when performance matters. Small design decision, but huge impact on how Java applications behave internally. #Java #BackendDevelopment #JavaInternals #LearningInPublic #SoftwareEngineering

Topic of the day String? Why String is Immutable? 👉 In Java, a String is immutable, which means once it is created, its value cannot be changed. Example: String s = "Hello"; s.concat(" World"); 👉 You might expect: "Hello World" 👉 But actual output: "Hello" Because concat() creates a new object, instead of modifying the existing one. 🔍 Why did Java designers make String immutable? ✔️ Security – Strings are used in sensitive areas (like DB connections, file paths, network URLs) ✔️ Thread Safety – No need for synchronization (safe in multithreading) ✔️ Performance – Enables String Pool (memory optimization) ✔️ Caching – Hashcode can be cached (used in HashMap) If you are doing multiple string modifications, prefer: 👉 StringBuilder (faster, not thread-safe) 👉 StringBuffer (thread-safe) #Java #JavaConcepts #InterviewPreparation #Programming #Developers #Programming #Development #Coding

🔢 Divisible Sum Pairs Problem | Java Solution 💻 Today I solved an interesting problem based on arrays and modular arithmetic! 📌 Problem: Given an array and a number k, count pairs (i, j) such that: 👉 i < j 👉 (arr[i] + arr[j]) % k == 0 ⚡ Approach: Instead of brute force O(n²), I used an optimized O(n) approach using remainder frequency. ✔️ Key Idea: Store frequency of (element % k) For each element, find its complement remainder Count valid pairs efficiently 💡 This improves performance significantly for large inputs! 🧠 Concepts Used: Arrays Modulo Arithmetic Hashing Technique 👨💻 Language: Java #Java #CodingPractice #DataStructures #Algorithms 

😜 Programmer Joke (with Java Proof) While explaining String immutability, I accidentally called it String immunity 😀 It's laughable. Then I thought about it—strings are immune to modification, thread attacks, and unsafe changes. Immunity → can’t be altered Immutability → new object created instead of modification Java Demo on Immunity: public class StringImmunityDemo {    public static void main(String[] args) {        String s = "secure";        s.concat("_breach");        System.out.println(s);    } } #Java #Immutable #Programming

🚀 100 Days of Java Tips — Day 15 Tip: Avoid using "==" with objects ❌ Many developers still make this mistake, especially when comparing objects. In Java, "==" checks reference (memory location), not actual value. Example: String a = new String("hello"); String b = new String("hello"); a == b → false ❌ a.equals(b) → true ✅ Why this matters: • Can lead to logical bugs • Very common mistake in interviews • Breaks real-world application logic silently Best practice: Always use ".equals()" when comparing values of objects ✔️ Use "==" only when you really want to compare memory references Small mistake. Big impact. Have you ever faced this issue? 👇 #Java #JavaTips #Programming #Developers #BackendDevelopment #CleanCode #SoftwareEngineering #CodingLife #Tech

🚨 This small Java mistake can give wrong comparisons I used to write this: if (price == 0.1 + 0.2) { // logic } Looks correct… but it may fail ❌ --- 👉 Why? Floating-point calculations are not always exact in Java. 👉 0.1 + 0.2 = 0.30000000000000004 So comparison with "==" can fail. --- ✅ Better way: if (Math.abs(price - (0.1 + 0.2)) < 0.0001) { // logic } --- 💡 Lesson: Never use "==" for floating-point comparison. Small detail… but critical in real applications. Have you faced this before? 👇 #Java #CoreJava #Programming #BackendDeveloper #Coding #TechLearning

Before Java 8 — HashMap used an array of LinkedLists for collision handling. Worst case lookup was O(n) — if many keys hashed to the same bucket, you'd traverse the entire chain. Java 8+ — Still starts with LinkedLists, but when a bucket has ≥ 8 nodes, it automatically converts to a Red-Black Tree (TreeNode). This drops worst-case lookup to O(log n). It reverts back to a list if nodes fall to ≤ 6. The critical thresholds to remember for interviews: TREEIFY_THRESHOLD = 8 → list becomes tree UNTREEIFY_THRESHOLD = 6 → tree reverts to list MIN_TREEIFY_CAPACITY = 64 → table must also have ≥ 64 buckets before treeifying #java

🔥 Day 14: Immutable Class (How String is Immutable in Java) One of the most important concepts in Java — especially for interviews 👇 🔹 What is an Immutable Class? 👉 Definition: An immutable class is a class whose objects cannot be changed once created. 🔹 Example: String String s = "Hello"; s.concat(" World"); System.out.println(s); // Hello (not changed) 👉 Why Because String is immutable 🔹 How String Becomes Immutable? ✔ String class is final (cannot be extended) ✔ Internal data is private & final ✔ No methods modify the original object ✔ Any change creates a new object 🔹 Behind the Scenes String s1 = "Hello"; String s2 = s1.concat(" World"); System.out.println(s1); // Hello System.out.println(s2); // Hello World 👉 s1 remains unchanged 👉 s2 is a new object 🔹 Why Immutability is Important? ✔ Thread-safe (no synchronization needed) ✔ Security (safe for sharing data) ✔ Caching (String Pool optimization) ✔ Reliable & predictable behavior 🔹 How to Create Your Own Immutable Class? ✔ Make class final ✔ Make fields private final ✔ No setters ✔ Initialize via constructor only ✔ Return copies of mutable objects 🔹 Real-Life Analogy 📦 Like a sealed box — once created, you cannot change what’s inside. 💡 Pro Tip: Use immutable objects for better performance and safety in multi-threaded applications. 📌 Final Thought: "Immutability = Safety + Simplicity + Performance" #Java #Immutable #String #Programming #JavaDeveloper #Coding #InterviewPrep #Day14

Your threads are not slow… they are just waiting. Most developers blame performance. But the real culprit is often #thread #contention. 🔹 What’s actually happening? Multiple threads → fighting for the same resource Only one wins → others just sit idle (blocked) 👉 CPU is free 👉 Threads exist 👉 But work is NOT happening 🔹 Common Mistake synchronized(this) { // heavy logic + DB calls + API calls } ❌ You just locked EVERYTHING ❌ Other threads are now waiting unnecessarily 🔹 Fix (Simple but Powerful) 👉 Keep critical section as small as possible synchronized(this) { // only shared resource logic } Move heavy work outside the lock 🔹 Real Insight Performance issue ≠ slow code It’s often → threads waiting for locks 🔹 Some Interview Questions 1️⃣ What is thread contention? 2️⃣ How does synchronization impact performance? 3️⃣ What is a critical section? 4️⃣ How can you reduce contention in Java? 5️⃣ Difference between blocking and waiting threads? 🔹 Key Takeaway 👉 More threads ≠ faster system 👉 Less blocking = better performance 💬 Have you ever debugged a “slow” system that turned out to be locking? #Java #Multithreading #Performance #Backend #InterviewPrep

->A simple Java concept that’s easy to overlook 👇 Immutable Strings 🔒 String str = "hello"; str.concat(" world"); System.out.println(str); // still "hello" Strings don’t change after creation. Operations like concat() create a new object instead ♻️ str=str.concat(" world"); System.out.println(str); // "hello world" Small detail ⚡ But important while writing logic 🧠 #Java #BackendDevelopment #Programming