Java String & Garbage Collection Explained

📝 Day 10/30 – LeetCode #49 (Group Anagrams) | Java The challenge in this problem was identifying a common way to group words that contain the same characters in different orders. Comparing each string with all others would be inefficient and overly complex. The key insight was to sort the characters of each word and use the sorted result as a key in a HashMap. Words that produce the same key are anagrams and can be grouped together. This approach keeps the solution organized and scalable while making good use of Java collections. This problem highlighted how transforming data into the right form often makes grouping problems much easier. #LeetCode #Java #DSA #HashMap #Strings #ProblemSolving #Consistency #LearningInPublic

When learning Core Java concepts, I faced one of the most important and underrated topics — String. I had many confusions regarding String before learning it, like whether it is a data type or something else. Later, I got clarity that String is not a data type; it is a class in Java and learned its real declaration. Once I understood that String is a class, I started exploring how object creation happens behind the scenes — including stack and heap memory representation and many other internal details. I tried to explain my understanding through the explanation shown below. After exploring this topic deeply, I realized how helpful it was in clearing all my misunderstandings regarding String. #java#CoreJava#StringInJava#LearningJava

Java — HashMap internals blew my mind 🤯 At first, I thought HashMap was just: #Java_Code map.put(key, value); Simple… until I asked how it actually works. Here’s what I learned 👇 1️⃣ Key’s hashCode() is calculated 2️⃣ Hash is converted to an index 3️⃣ Entry stored in a bucket 4️⃣ If collision happens → linked list / tree used From Java 8 onwards: 📌Long collision chains → Red-Black Tree 📌Lookup becomes faster Biggest learning for me: hashCode() and equals() decide HashMap performance. Bad implementation = slow map. Good implementation = near O(1). HashMap isn’t magic. It’s smart engineering. #Java #HashMap #JavaInternals #CollectionsFramework

Today I learned the Two Pointer technique in Java. It helped me understand how to solve certain array problems more efficiently by using two indexes instead of nested loops. I practiced it on a simple problem: checking whether a sorted array contains two numbers whose sum equals a target value. This technique: improves time complexity avoids unnecessary loops works well with sorted data. #Java #DSA #TwoPointers #Learning #ProblemSolving

Java☕ — Collections changed everything 📦 Before collections, my code looked like this: #Java_Code int[] arr = new int[100]; Fixed size. No flexibility. Painful logic. Then I met the Java Collections Framework. #Java_Code List<Integer> list = new ArrayList<>(); Suddenly I could: ✅Grow data dynamically ✅Use built-in methods ✅Write cleaner logic The biggest lesson for me wasn’t syntax, it was choosing the right collection. 📌ArrayList → fast access 📌LinkedList → frequent insert/delete 📌HashSet → unique elements 📌HashMap → key-value data Java isn’t powerful because of loops. It’s powerful because of its collections. #Java #CollectionsFramework #ArrayList #HashMap #LearningInPublic

Understanding Global Variables in Java 🌐: Unlock the power of variables that live throughout your program! Learn how they simplify data sharing across methods while keeping your code clean and efficient. #JavaProgramming #CodingTips #LearnJava #GlobalVariables #DeveloperLife #SoftwareEngineering"

--- 🔤 Strings in Java – A Core Concept Every Developer Must Know Strings are one of the most used data types in Java. From handling user input to building dynamic applications, mastering Strings is essential. ✨ Key highlights: Strings are immutable Powerful built-in String methods Easy concatenation & manipulation Safe and efficient comparisons Understanding Strings helps write cleaner, safer, and more optimized Java code 🚀 #Java #StringsInJava #JavaProgramming #CoreJava #Coding #SoftwareDevelopment #LearningJava #TAPACADAMY ---

Most confusing fundamental concepts in Java: == vs equals(). Key Learnings: • == operator  - Compares references for objects (memory location)  - Compares values for primitives  - For objects, it checks whether both references point to the same object • equals() method  - Defined in Object class  - Default behavior compares references  - Many classes like String, Integer, wrapper classes, and collections override equals() to compare actual values/content • Why this matters  - Two objects can be different in memory but still be logically equal  - Example:   new String("Java") == new String("Java") → false   new String("Java").equals("Java") → true • Important rule  - If a class overrides equals(), it should also override hashCode()  - This is critical for correct behavior in HashMap and HashSet Final takeaway: Use == for primitive comparison. Use equals() for object content comparison. Always know which equals() implementation is being executed. Strong fundamentals make debugging easier and code more reliable. #Java #CoreJava #Equals #HashCode #Programming #SoftwareEngineering #LearningJourney #100DaysOfLearning

📘 Today I Learned: Why HashSet Has No Index in Java Today I learned something interesting about HashSet in Java. When we write: HashSet<Integer> set = new HashSet<>(); it looks simple, but internally Java does something important. 🔍 What Happens Internally? HashSet is backed by a HashMap. That means each element you add to a HashSet is actually stored as a key inside a HashMap, with a dummy value. So conceptually, it becomes something like: HashMap<Integer, Object> map; 🗂 How Elements Are Stored Elements are not stored in order and not stored by index. Instead, each element: Generates a hashCode() Gets placed into a bucket based on that hash Example (simplified): Bucket 2 → 2 Bucket 10 → 10 Bucket 15 → 15 Each bucket can hold one or more elements if collisions happen. ❓ Why There Is No Index Because elements live in hash-based buckets, not in sequential positions like: 0, 1, 2, 3... So operations like: set.get(0); don’t make sense for a HashSet. 🔁 How We Access Elements Instead We use iteration: for (int x : set) { System.out.println(x); } This gives sequential access, without exposing how data is stored internally. 🌱 Key Learning HashSet trades index-based access for fast lookups and clean abstraction using hashing. If we need: Index → List Insertion order → LinkedHashSet Sorted order → TreeSet Learning these small internal details really helps in understanding why Java collections behave the way they do, not just how to use them. #Java #LearningInPublic #JavaCollections #HashSet #BackendDevelopment #SoftwareEngineering

Most people know that String is immutable in Java. Very few can explain why. This question looks simple, but it reveals how deeply you understand Java. String is immutable mainly because Java uses it everywhere — in passwords, URLs, database connections, and file paths. If a String could be changed after creation, it would become a serious security risk. Another big reason is memory efficiency. Java stores Strings in a common pool, so multiple references can point to the same object. Immutability makes this sharing safe and prevents unexpected side effects. It also helps with performance. String’s hashcode is cached, which makes it reliable and fast when used as a key in HashMap. And since it can’t be modified, String is naturally thread-safe. Questions like this remind me that learning Java isn’t about memorizing answers. It’s about understanding the design decisions behind the language. Keep learning. Keep questioning. That’s how strong engineers are built. #Java #CoreJava #JavaDeveloper #SoftwareEngineering #Learning