Java Arrays: Memory, Storage, and Access

🚀 Java Series – Day 2 📌 Topic: Arrays.asList() vs List.of() 🔹 What is Arrays.asList()? It converts an array into a fixed-size list 👉 You can change elements but cannot add/remove 🔹 What is List.of()? It creates an immutable list 👉 No modification allowed at all 🔹 Key Differences ✔ Arrays.asList() • Fixed size list • set() allowed ✅ • add/remove ❌ • null allowed ✅ ✔ List.of() • Completely immutable • No add/remove/set ❌ • null NOT allowed ❌ 🔹 Example List<String> list1 = Arrays.asList("Java", "Python"); list1.set(1, "C++"); // ✅ Allowed List<String> list2 = List.of("Java", "Python"); list2.set(1, "C++"); // ❌ Error 🔹 Important Point 👉 Arrays.asList() → backed by array 👉 List.of() → safe & immutable 💡 Key Takeaway Use Arrays.asList() when working with arrays Use List.of() when you need fixed, safe data Consistency is the key 🔥 Day 2 complete ✅ What do you think about this? 👇 #Java #JavaDeveloper #Programming #BackendDevelopment #CodingJourney #100DaysOfCode

Tackling the "Silent Overflow" in Java 🛑🔢 I recently worked through LeetCode #7: Reverse Integer, and it was a fantastic deep dive into how Java handles 32-bit integer limits and the dangers of "silent overflows." The Problem: Reverse the digits of a signed 32-bit integer. If the reversed number goes outside the 32-bit signed range of [-2^{31}, 2^{31} - 1], the function must return 0 The "Asymmetry" Challenge: In Java, Integer.MIN_VALUE is -2,147,483,648, while Integer.MAX_VALUE is 2,147,483,647. The negative range is one unit larger than the positive range due to Two's Complement arithmetic. This creates a massive trap: using Math.abs() on the minimum value will actually overflow and remain negative! My Optimized Solution Strategy: I implemented a two-pronged approach to handle these edge cases efficiently: 1️⃣ Pre-emptive Boundary Filtering: I added a specific optimization check at the very beginning: if(x >= Integer.MAX_VALUE - 4 || x <= Integer.MIN_VALUE + 6) return 0;. This catches values at the extreme ends of the 32-bit range immediately, neutralizing potential Math.abs overflow before the main logic even begins. 2️⃣ 64-bit Buffering: I used a long data type for the reversal calculation. This provides a 64-bit "safety net," allowing the math to complete so I can verify if the result fits back into a 32-bit int boundary. Complexity Analysis: 🚀 Time Complexity: O(log_10(n))— The loop runs once for every digit in the input (at most 10 iterations for any 32-bit integer). 💾 Space Complexity: O(1)— We use a constant amount of extra memory regardless of the input size. Small details like bit-range asymmetry can break an entire application if ignored. This was a great reminder that as developers, we must always think about the physical limits of our data types! #Java #LeetCode #SoftwareDevelopment #ProblemSolving #Algorithms #CleanCode #JavaProgramming #DataStructures #CodingLife

While continuing with object oriented concepts in Java, the static keyword was an important idea to understand. Unlike instance variables that belong to individual objects, static members belong to the class itself. Things that became clear : • a static variable is shared among all objects of a class • only one copy of a static variable exists for the entire class • static members can be accessed using the class name instead of an object • static variables are useful when a value should be common for every object • they are often used for things like counters, configuration values, or shared settings A small example helps illustrate the idea: class LoanApp { static float rateOfInterest = 9.5f; } public class Test { public static void main(String[] args) { System.out.println(LoanApp.rateOfInterest); } } Here the interest rate belongs to the class rather than any specific object. Understanding the difference between instance data and class-level data made the structure of programs much clearer. #java #oop #programming #learning #dsajourney

Ever wondered how to manage hundreds of custom objects efficiently in Java? Arrays aren’t just for primitive data types—they can handle objects too. 🚀 Recently, I explored Arrays of Objects in Java and discovered some powerful concepts every beginner should know: 🔹 Arrays Can Store Objects Just like arrays of "int" or "String", you can create arrays for custom classes. For example, an "Employee[]" array lets you store and manage multiple employee objects in a clean, structured way. 🔹 Eliminate Redundant Code Instead of creating dozens of variables ("e1, e2, e3…"), a single array combined with loops lets you input, update, and display data efficiently. This approach can replace hundreds of repetitive lines with just a few. 🔹 The Homogeneous Rule Java arrays are strictly type-safe. An "Employee[]" can store only "Employee" objects—not "Customer" objects—even though both are classes. Each array is dedicated to one specific type. 🔹 Default Values Matter Primitive arrays get default values ("0", "false", etc.), but object arrays are initialized with "null" references. You must explicitly create each object before using it to avoid "NullPointerException". Understanding these fundamentals not only improves code efficiency but also builds a strong foundation for mastering data structures and object-oriented programming in Java. #Java #Programming #CodingJourney #JavaBasics #Developers

Exploring Java Stack Data Structure 🚀 In this simple example, I used Java's Stack to store different data types using Object type. It helped me better understand: - LIFO (Last In First Out) principle - How Stack works in Java - Storing multiple data types in one structure Always learning, always improving. 💻 import java.util.Stack; public class Main {   public static void main(String[] args) {     Stack<Object> my_stack =new Stack<>();     my_stack.push(1.25);     my_stack.push(78);     my_stack.push(true);     my_stack.push("engin");     my_stack.push(9999999L);     my_stack.push('E');     System.out.println(my_stack);           } } https://lnkd.in/d3hZN9B4 #Java #DataStructures #Programming #Learning

#Post1 Internal working of HashMap And Hash collision 👇 When we insert a value: map.put("Apple", 10) Java performs these steps: 1️⃣ It calls hashCode() on the key. For example, Strings generate hash codes using a formula involving the prime number 31. 2️⃣ Using this hash, Java calculates the bucket index inside the internal array. Now the entry is stored inside that bucket. Example internal structure: Bucket Array [0] [1] [2] → (Apple,10) [3] [4] But what if two keys map to the same bucket? This situation is called a hash collision. Example: [2] → (Apple,10) → (Banana,20) → (Mango,30) HashMap handles collisions by storing multiple entries inside the same bucket. Before Java 8 • Entries were stored in a Linked List After Java 8 • If the bucket size grows beyond 8, the linked list is converted into a Red-Black Tree This improves search performance: O(n) → O(log n) Now let’s see what happens during get() when a bucket has multiple entries. When we call: map.get("Apple") Java performs these steps: 1️⃣ It recomputes the hashCode() of the key 2️⃣ It finds the same bucket index using (capacity - 1) & hash 3️⃣ If multiple nodes exist in that bucket, Java traverses the nodes For each node it checks: existingNode.hash == hash AND existingNode.key.equals(key) Once the correct key is found, the corresponding value is returned. Summary: Two different keys can generate the same hash, which causes a hash collision. HashMap handles collisions by storing entries as a Linked List or Red-Black Tree inside the bucket. 📌 Note HashMap is not thread safe. In the upcoming post, we will explore the thread-safe alternative to HashMap. #Java #SoftwareEngineering #BackendDevelopment #DataStructures #Programming #LearnInPublic

Day 7/50 | #50DaysOfCode 📍 Platform: LeetCode 💻 Language: Java ✅ 167. Two Sum II - Input Array Is Sorted (Medium) Today’s problem focused on finding two numbers in a sorted array that sum up to a target. It helped reinforce the two-pointer technique and efficient array traversal. 🔎 Approach: Use two pointers: one at the start (left) and one at the end (right) of the array Calculate the sum of numbers at both pointers If sum equals target, return the 1-indexed positions [left+1, right+1] If sum < target, move left pointer forward If sum > target, move right pointer backward Continue until the solution is found 📌 Example: Input: numbers = [2,7,11,15], target = 9 Output: [1,2] Explanation: 2 + 7 = 9 → indices 1 and 2 This problem strengthened my understanding of two-pointer techniques, sorted arrays, and constant space solutions in Java. #DSA #LeetCode #Java #CodingJourney #ProblemSolving #Consistency #LearningJourney #50DaysOfCode #LinkedIn

🔹 In Java, the Map hierarchy forms the foundation for key-value data structures: Map interface → HashMap, LinkedHashMap, TreeMap. Each has its own behavior and use-case in terms of ordering, and sorting. Many developers use HashMap daily, but do you know what happens behind the scenes? Let’s decode it 👇 HashMap Internals: Beyond Simple Key-Value Storage 1️⃣ Buckets & Nodes HashMap stores entries in an array of buckets. Each bucket contains nodes, and each node holds a key-value pair. 2️⃣ Hashing: The Core Mechanism Every key generates a hash code, which is used to compute the bucket index: index = (n - 1) & hash This ensures efficient data distribution and fast access. 3️⃣ Collision Handling When multiple keys map to the same bucket → collision occurs. Java handles collisions using: Linked List (Java < 8) Red-Black Tree (Java 8+, when bucket size > 8) 4️⃣ Insertion & Retrieval Insertion (put): hash → bucket → insert/update node Retrieval (get): hash → bucket → traverse nodes → match key 5️⃣ Resize & Load Factor Default capacity = 16, load factor = 0.75 When size > capacity × load factor, HashMap resizes (doubles capacity) to maintain performance 💡 Performance Insights Average case: O(1) ✅ Worst case: O(log n) after Java 8 ✅ Takeaway: A well-implemented hashCode() and equals() is key to fast, reliable HashMap performance. #Java #HashMap #DataStructures #Programming #SoftwareEngineering #CodingTips #DeveloperInsights

🚀 Java Deep Dive — Daemon Threads (Something many developers overlook) In Java, not all threads behave the same way. There are two types: • User Threads • Daemon Threads The JVM keeps running as long as at least one user thread is alive. But daemon threads work differently. They are background service threads used for supporting tasks like: • Garbage Collection • Monitoring • Background cleanup If all user threads finish, the JVM will terminate immediately, even if daemon threads are still running. Example: Java Example Thread thread = new Thread(() -> { while(true){ System.out.println("Running..."); } }); thread.setDaemon(true); thread.start(); If the main thread finishes, this daemon thread will not keep the JVM alive. Important rule: You must call "setDaemon(true)" before starting the thread, otherwise Java throws "IllegalThreadStateException". 💡 Key Insight Daemon threads are useful for background tasks that should not block application shutdown. #Java #Multithreading #BackendDevelopment #SoftwareEngineering #LearningInPublic

Many developers overlook a small but important difference in Java: == vs .equals() String s1 = new String("Java"); String s2 = new String("Java"); System.out.println(s1 == s2); // false System.out.println(s1.equals(s2)); // true ✔ == compares memory references (whether both variables point to the same object). ✔ .equals() compares the actual content of the objects. Even though s1 and s2 contain the same value, they are stored as different objects in memory, so == returns false. 💡 This distinction becomes critical when working with collections like HashMap, HashSet, or custom objects. Strong Java fundamentals often come down to understanding small details like these. #Java #Programming #JavaDeveloper #Coding #SoftwareEngineering LinkedIn Guide to Networking LinkedIn Learning Community LinkedIn Learning