Java Arrays: Understanding 1D, 2D, and 3D Arrays

🚀 Understanding Arrays in Java – From 1D to 3D & Jagged Arrays Today I revised one of the most important core concepts in Java – Arrays and their different types: ✔️ 1D Array ✔️ 2D Array ✔️ 3D Array ✔️ Jagged Array (Irregular Array) Arrays are not just about storing values — they are about organizing data efficiently in memory. 🔹 1️⃣ One-Dimensional Array (1D) Stores data in a single line (like a list). Java 👇 int[] a = new int[5]; System.out.println(a.length); 📌 Key Points: 📍Stores elements in a single row. 📍Access using index: a[i] 📍a.length gives total size. 📍Best for storing marks, prices, IDs, etc. ✅ Real-Time Example: Storing marks of 5 students in a class. 🔹 2️⃣ Two-Dimensional Array (2D) Stores data in rows and columns (matrix format). Java 👇 int[][] a = new int[2][5]. 📌 Key Points: a.length → number of rows a[i].length → number of columns Access using a[i][j] Requires nested loops for traversal. ✅ Real-Time Example: School classroom seating arrangement (Rows = benches, Columns = students per bench). 🔹 3️⃣ Three-Dimensional Array (3D) Stores data in blocks → rows → columns. Java 👇 int[][][] a = new int[2][3][5]; 📌 Key Points: a.length → number of blocks a[i].length → rows a[i][j].length → columns Requires 3 nested loops. ✅ Real-Time Example: School → Classes → Students structure Or Company → Departments → Employees 🔹 4️⃣ Jagged Array (Irregular Array) When rows have different column sizes. Java 👇 int[][] a = new int[2][]; a[0] = new int[3]; a[1] = new int[5]; 📌 Key Points: Columns are NOT fixed. Memory efficient. Each row can have different size. Useful when data is uneven. ✅ Real-Time Example: Class A has 3 students, Class B has 5 students. Instead of wasting memory, we use a jagged array. 💡 Important Learning: ✔️ .length helps in dynamic traversal ✔️ Nested loops are key for multi-dimensional arrays ✔️ Jagged arrays save memory when data is irregular ✔️ Proper understanding improves problem-solving skills 📚 Mastering arrays builds a strong foundation for: 🔹 Data Structures 🔹 Matrix problems 🔹 Dynamic programming 🔹 Backend development Small concepts → Strong foundation. TAP Academy #Java #Arrays #DataStructures #FullStackDevelopment #LearningJourney #Programming

Most Java beginners think a variable is "just a box that stores data." But there's SO much more happening under the hood. 🧵 --- When you run a Java program, the JVM carves out a region in RAM called the JRE — divided into 4 segments: 📦 Code Segment → your bytecode lives here 🔵 Static Segment → static variables 🟢 Heap Segment → objects & instance variables 🟡 Stack Segment → local variables & method calls Every variable you declare lands in one of these. Knowing WHERE matters. --- There are 2 types of variables in Java: 🔷 INSTANCE VARIABLES → Declared inside a class, outside any method → Memory allocated in the HEAP → JVM auto-assigns default values (0, false, null) → Each object gets its own copy → Lives as long as the object lives 🔶 LOCAL VARIABLES → Declared inside a method → Memory allocated in the STACK → NO default values — must initialize before use → Temporary — dies when the method exits One rule that catches every beginner: Local variables have NO default values. Use without initializing = compiler error. Every time. --- Now the concept that separates beginners from intermediate devs 👇 PASS BY VALUE vs PASS BY REFERENCE 📋 Pass by Value: When you do b = a → Java COPIES the value. Change b later? a is untouched. Always. int a = 1000; b = a; b = 2000; → a is still 1000. 🔗 Pass by Reference: When you assign objects → Java copies the ADDRESS (reference). Both variables now point to the SAME object in memory. Change via b? a sees it too. Same object. Same heap address. Car a = new Car(); // address: 1000 Car b = a;     // b also points to 1000 b.name = "KIA";  // a.name is now "KIA" too 🤯 This is why Java strings and arrays behave "unexpectedly" for beginners. --- Quick Reference: Feature → Local vs Instance Definition → inside method vs inside class Scope → method only vs entire class Initialization → manual vs JVM default Memory → Stack vs Heap Lifetime → method ends vs object exists --- The moment you understand Stack vs Heap + Pass by Value vs Reference — Java starts making sense at a deeper level. Save this. Revisit it when debugging weird variable behavior. 🔖 #Java #Programming #LearnToCode #JavaDeveloper #OOP #CodingTips #ComputerScience #Upskill #Tech #SoftwareEngineering

🚀 TAP Academy – Day 15 | Introduction to Strings in Java ☕ Today’s concept is one of the most important topics because nearly 70% of real-world data is handled in String format such as names, emails, passwords, addresses, etc. 📌 What is a String? A String is a sequence of characters enclosed within double quotation marks (" "). Ex: String name = "Java"; String email = "student@gmail.com"; 👉 In Java, String is not a primitive data type 📌 Strings are Objects in Java Here, the class name is String 📌 Types of Strings Strings are divided into two types: 1️⃣ Immutable String Immutable means cannot be changed after creation. Ex:(real world) Date of Birth Gender ID number In Java: String s = "Java"; s.concat(" Programming"); System.out.println(s); output: Java Explanation: The original string is NOT changed A new object is created instead 2️⃣ Mutable String Mutable means can be changed after creation. In Java, mutable strings are created using: StringBuilder StringBuffer Example: StringBuilder sb = new StringBuilder("Java"); sb.append(" Programming"); System.out.println(sb); output: Java Programming 📌 3 Ways to Create Immutable Strings ✅Method 1: Using new keyword 🖋️Object is created in Heap memory 🖋️Duplicate objects are allowed 🖋️Creates a new object every time Ex: String s1 = new String("Java"); String s2 = new String("Java"); System.out.println(s1 == s2); // false Because both have different memory locations. ✅Method 2: Without using new keyword 🖋️Stored in String Constant Pool (SCP) inside heap 🖋️Duplicate objects are NOT allowed 🖋️Memory efficient Ex: String s1 = "Java"; String s2 = "Java"; System.out.println(s1 == s2); // true Because both refer to same memory location. ✅Method 3: Using Character Array char[] ch = {'J','a','v','a'}; String s = new String(ch); System.out.println(s); Output:Java 👉Converts character array into String object 📌 String Comparison Methods 1️⃣ Using == operator Compares reference (memory address) String s1 = "Java"; String s2 = "Java"; System.out.println(s1 == s2); // true 2️⃣ Using equals() method Compares values String s1 = new String("Java"); String s2 = new String("Java"); System.out.println(s1.equals(s2)); // true 3️⃣ Using compareTo() method Compares character by character String s1 = "Java"; String s2 = "Jaya"; System.out.println(s1.compareTo(s2)); Output:-21 4️⃣ Using equalsIgnoreCase() method Compares values ignoring case String s1 = "JAVA"; String s2 = "java"; System.out.println(s1.equalsIgnoreCase(s2)); Output:true 📌 Key Summary Points ✅ String = Collection of characters ✅ == compares address ✅ equals() compares values ✅ compareTo() compares character by character ✅ equalsIgnoreCase() ignores case 📌 Real-World Importance Strings are used everywhere: Login systems Emails Banking systems Student records Web applications Without Strings, real-world software cannot exist. 💼#TAP Academy #Java #String #JavaProgramming #LearningJourney #SoftwareDevelopment #JavaDeveloper #Coding

📘 Java Learning – Collections Framework (Part 6: Map Interface & HashMap) 🗺️🚀 Continuing my Core Java Collections journey, today I started exploring Map, which stores data as key–value pairs. 🔰 Map Interface • Used to represent data as key–value pairs • Both keys and values are objects • Duplicate keys not allowed, values can be duplicated • Each key–value pair is called an Entry • Map is NOT a child of Collection 📌 Difference • Collection → group of individual objects • Map → group of key–value pairs Example: 101 → "Java" (Entry) 101 = key, Java = value 🔰 Important Map Methods • put(key, value) – adds / replaces value • get(key) • remove(key) • containsKey(), containsValue() • size(), isEmpty(), clear() 🔰 Collection Views of Map • keySet() → Set of keys • values() → Collection of values • entrySet() → Set of entries 🔰 Map.Entry Interface • Each key–value pair is an Entry • Entry exists only inside Map Key methods: • getKey() • getValue() • setValue() 🔰 HashMap (C) • Underlying data structure: Hash Table • No duplicate keys, values can repeat • Insertion order not preserved • One null key allowed, multiple null values allowed • Not synchronized → not thread-safe 🧪 Short Example HashMap m = new HashMap(); m.put(101, "Java"); m.put(102, "Python"); m.put(103, "Programming"); m.put(102, "Spring"); // replaces value System.out.println(m); Set s = m.keySet(); System.out.println(s); // [101, 102, 103] Collection c = m.values(); System.out.println(c); // [Java, Spring, Programming] Set s1 = m.entrySet(); Iterator itr = s1.iterator(); while (itr.hasNext()) {   Map.Entry m1 = (Map.Entry) itr.next();   if (m1.getKey().equals(102)) {     m1.setValue("Python");   } } System.out.println(m); // {101=Java, 102=Python, 103=Programming} ⭐ Key Takeaway • Map is for relationships (key → value) • HashMap is fast but not thread-safe Building strong Java fundamentals, one Map at a time ☕💻 #Java #CoreJava #CollectionsFramework #Map #HashMap #JavaCollections #LearningJourney

💡 Java Internals: How HashMap Actually Works Many developers use HashMap every day, but very few understand what actually happens internally. Here is the complete flow in 5 core concepts: 0️⃣ Implementation of HashMap HashMap is one of the main implementations of the Map interface. public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable Key facts: • Stores key–value pairs • Allows 1 null key and multiple null values • Not thread-safe 1️⃣ Internal Structure (Nodes & Buckets) Internally HashMap stores entries as Nodes. Each Node contains four components: • Key → identifier used to retrieve value • Value → actual stored data • Hash → hash value derived from key • Next pointer → link to the next node in case of collision All nodes are stored in an array called the bucket table Node<K,V>[] table Each index in this array is called a bucket 2️⃣ How Data is Stored in HashMap Insertion happens in three steps: Step 1 - Hashing the key hash = key.hashCode() Java improves distribution internally: hash = h^(h>>>16) Step 2 — Calculating the index index = (n - 1)&hash where n = array size. HashMap keeps capacity as a power of 2 to make this fast. Step 3 — Store in bucket If bucket is empty → entry stored directly. If not → collision occurs 3️⃣ Collision Handling A collision happens when multiple keys map to the same bucket index. Example: map.put("apple",50) map.put("orange",80) Both may land in the same bucket. Handling differs by Java version. Before Java 8 Bucket → Linked List Worst-case search: O(n) After Java 8,If bucket size exceeds 8 entries: Linked List → Red Black Tree New complexity:O(log n) This process is called Treeification,happens only when table size ≥ 64 4️⃣ HashMap Resizing (Rehashing) HashMap automatically resizes to maintain efficiency. Default values: Initial Capacity = 16 Load Factor = 0.75 Resize condition: size > capacity × loadFactor Example: 16×0.75 = 12 The 13th insertion triggers resizing 5️⃣ What Happens During Resizing 🌟 Array size doubles 16 → 32 → 64 → 128 🌟 All existing entries are rehash redistributed 🌟 Each entry moves to its new bucket position Performance Summary Average case: get() → O(1) put() → O(1) Worst case: Before Java 8 → O(n) After Java 8 → O(log n) Interesting HashMap Facts 🔹 HashMap capacity is always a power of 2 so (n - 1) & hash can replace slower modulo operations. 🔹 Treeification occurs only when bucket size ≥ 8 AND table size ≥ 64 🔹 During resizing, entries do not require full rehash computation Because the capacity doubles, each entry either: stays in the same index or moves to index + oldCapacity This clever optimization makes resizing much faster than expected. HashMap is a great example of how arrays, hashing, linked lists, and trees combine to build a highly efficient data structure. #Java #HashMap #JavaCollections #SoftwareEngineering #BackendDevelopment #JavaInterview #InterviewPreparation

🚀 **Understanding Why We Create Objects in Java | JVM Memory Basics** While learning Java and OOP concepts, one important question arises: **Why do we create objects in Java?** To understand this, we need to look at how the **Java program execution process** works inside the JVM. 1️⃣ Compilation Phase A Java program is first compiled using the **Java Compiler (javac)**, which converts the `.java` file into a `.class` file containing **bytecode**. ``` Main.java → Main.class ``` This `.class` file is stored on the **hard disk**. --- 2️⃣ Class Loading When we run the program using the **Java Virtual Machine**, the **Java ClassLoader** loads the `.class` file into RAM. At this stage, the JVM loads: * Class metadata * Static variables * Static blocks * Method definitions ⚠️ **Important:** Non-static variables are **not created yet**. 3️⃣ Program Execution Starts The JVM searches for the entry point of the program: public static void main(String[] args) Execution begins from the **first line of the `main()` method**. 4️⃣ Static vs Non-Static Members **Static Members** * Loaded when the class is loaded. * Stored in the **method area**. * Accessible without creating an object. Example: ```java static int a = 10; ``` **Non-Static Members** * Created only when an object is created. * Stored in **Heap memory**. Example: ```java int x = 10; ``` --- ### 5️⃣ Why Do We Create Objects? Objects are created for two main reasons: ✔ To allocate memory for **non-static members** ✔ To access **non-static variables and methods** Example: ```java Main obj = new Main(); ``` --- ### 6️⃣ What Happens When We Use the `new` Operator? When the JVM encounters: ```java new Main(); ``` The following steps occur: 1️⃣ Memory is allocated in the **Heap** 2️⃣ Non-static variables are loaded into memory 3️⃣ Variables are initialized (default or assigned values) 4️⃣ Constructor is executed 5️⃣ The memory address of the object is returned The variable `obj` stores the **reference (address)** of the object. --- ### 7️⃣ Example Program ```java public class Main {   int x = 10;   public static void main(String[] args) {     int y = 10;     System.out.println(y);     Main obj = new Main();     System.out.println(obj.x);   } } ``` In this example: * `y` is stored in **Stack memory** * `x` is stored in **Heap memory** * `obj` is a **reference variable** pointing to the object --- ### 8️⃣ Garbage Collection Once the `main()` method finishes execution: * Local variables are removed from the stack * The reference to the object may be lost If no references point to the object anymore, the **Java Garbage Collector** automatically removes it from memory. This process is called **Garbage Collection**. --- #Java #OOP #JVM #JavaMemoryModel #Programming #SoftwareEngineering #BackendDevelopment

Why Java Is Not a Pure Object-Oriented Language A pure object-oriented programming language is one where everything in the program is treated as an object. In such languages, even basic values like numbers, characters, and boolean values are represented as objects. There are no primitive data types. javava is a language that embraces many object-oriented concepts, yet it does not fully qualify as a purely object-oriented language. Here are the key reasons why: 1. Presence of Primitive Data Types Java includes several primitive data types, such as: - int - float - double - char - boolean - long - short - byte These types are not objects, which contradicts the principle that all values in a program should be objects. For example, in the code snippet below, `a` is a primitive value, not an object: ```java int a = 5; System.out.println(a); ``` In contrast, languages like Smalltalk treat even numbers and boolean values as objects. 2. Use of the static Keyword Java permits the declaration of methods and variables using the static keyword. Static members are associated with the class itself rather than with an instance of the class, allowing access without creating an object. This undermines the principle that all operations should occur through objects. For instance: ```java class Test { static int count = 0; static void show() { System.out.println("Hello"); } } ``` In this example, the method `show()` can be called without instantiating an object. 3. Wrapper Classes and Primitive Conversion Java offers wrapper classes such as: - Integer - Float - Double - Character - Boolean These classes enable primitive values to be treated as objects. However, Java still relies on primitive types through mechanisms like autoboxing and unboxing. For example: ```java public class BoxingExample { public static void main(String[] args) { Integer i = new Integer(10); Integer j = new Integer(20); Integer k = new Integer(i.intValue() + j.intValue()); System.out.println("Output: " + k); } } ``` In this case, primitive values #ProgrammingConcepts #SoftwareEngineering #Coding #BackendDevelopment #JavaInterview #TechLearning #ProgrammingEducation #CodeNewbie #DeveloperLife #ComputerScience #ProgrammingTips #JavaConcepts

What actually happens when we use Runnable vs Thread. While studying Java Multithreading, I explored how the Runnable interface works and some interesting cases. Let me Breakdown to you, I. Creating a Thread using Runnable Instead of extending the Thread class, we can implement the Runnable interface. Steps: 1. Create a class that implements Runnable 2. Override the run() method 3. Pass the Runnable object to a Thread 4. Call start() Example: class MyRunnable implements Runnable { public void run() { System.out.println("Child Thread"); } } class ThreadDemo { public static void main(String[] args) { MyRunnable r = new MyRunnable(); Thread t = new Thread(r); t.start(); } } Once start() is called, a new thread is created and the run() method executes. But things become interesting when explore different cases. Case 1: t.start() A new thread is created. The run() method executes in that new thread while the main thread continues running. Case 2: t.run() No new thread is created. run() behaves like a normal method call, and everything runs in the main thread. Case 3: r.run() Again, no thread is created. This simply executes the method like a normal function. Case 4: r.start() This causes a compile-time error. Why? Because the Runnable interface does not contain the start() method. Only the Thread class has it. Why Runnable is Preferred? Java supports single inheritance. If we extend the Thread class, our class cannot extend any other class. But when we implement Runnable: • We still get multithreading • We can extend another class • The design becomes more flexible That’s why the Runnable approach is recommended in real-world applications. II. Thread Names in Java Every thread has a default name like: main Thread-0 Thread-1 We can get or change the name using: • getName() • setName() Example: Thread.currentThread().getName(); Thread.currentThread().setName("MyMainThread"); III. Getting the Current Thread To know which thread is currently executing: Thread.currentThread() This is very useful while debugging multithreaded programs. #Day5 #Java #Multithreading #BackendDevelopment #SystemDesign #SoftwareEngineering

Day 12 – Java Arrays, Wrapper Classes & Literals. Today I learned some powerful core Java concepts that strengthen the foundation of programming. Disadvantages of Arrays Arrays store homogeneous data only (same data type). Array size is fixed once created. Arrays require contiguous memory allocation. They cannot grow or shrink dynamically. Example: Java Copy code int[] arr = new int[5]; arr[0] = 10; arr[1] = 20; // arr[5] = 60; ArrayIndexOutOfBoundsException Wrapper Classes in Java Java is not purely object-oriented because it supports primitive data types. Primitive types are NOT objects. Wrapper classes convert: Primitive ➝ Object Object ➝ Primitive Example: Java Copy code int x = 10; Integer obj = Integer.valueOf(x); // Boxing int y = obj.intValue(); // Unboxing Makes Java more object-oriented Required for Collections (ArrayList, etc.) Primitive → Wrapper Mapping: Primitive Wrapper int Integer double Double char Character boolean Boolean Literals in Java A literal is a constant value assigned to a variable. Java Copy code int year = 2000; Here: int → datatype year → variable 2000 → literal Numeric literals Character literals Boolean literals String literals Why Arrays Were Introduced? Using multiple variables: int a, b, c, d, e; Problems: Hard to manage Difficult to access dynamically Not scalable Solution: Java Copy code int[] ages = new int[10]; Types of Arrays 1-D Array Java Copy code int[] a = new int[10]; 2-D Array (Rectangular) Java Copy code int[][] a = new int[2][5]; Jagged Array Java Copy code int[][] a = new int[2][]; a[0] = new int[3]; a[1] = new int[5]; Key Takeaways Arrays are objects Created at runtime Stored in heap memory Length is fixed Require contiguous memory

📘 Java Learning – Collections Framework (Part 4: Set & Its Implementations) 🚀 Continuing my Core Java Collections journey, this time I focused on Set-based collections — where uniqueness and ordering rules really matter. Here’s a crisp breakdown 👇 2️⃣ Set Interface • Child interface of Collection • Duplicates are NOT allowed • Insertion order is NOT preserved • No new methods — only Collection methods are used Use Set when uniqueness is the top priority. 🔰 HashSet (C) • Underlying data structure: Hash Table • No duplicates • No insertion order • Allows one null • Heterogeneous objects supported • Best choice for fast search operations 📌 Important behavior Trying to add a duplicate doesn’t throw an error — add() simply returns false. 🧪 Short Example: HashSet hs = new HashSet(); hs.add("Java"); hs.add("Python"); hs.add("Java"); // ignored hs.add(null); System.out.println(hs); 🔰 LinkedHashSet (C) • Child class of HashSet • Underlying structure: HashTable + LinkedList • Insertion order is preserved • Still no duplicates 📌 Common use case Used in cache-like applications where: • Duplicates are not allowed • Insertion order must be maintained 🧪 Short Example: LinkedHashSet lhs = new LinkedHashSet(); lhs.add("A"); lhs.add("B"); lhs.add("C"); System.out.println(lhs); // [A, B, C] 🔰 SortedSet (I) • Child interface of Set • Stores elements in a sorted order • Sorting can be: • Natural ordering • Custom ordering (Comparator) 📌 Useful methods: • first(), last() • headSet(), tailSet(), subSet() • comparator() 📌 Natural sorting: • Numbers → Ascending order • Strings/Characters → Alphabetical order ⭐ Key Takeaway • HashSet → Fast search, no order • LinkedHashSet → Order + uniqueness • SortedSet → Ordered & structured data Choosing the right Set implementation is a design decision, not just an API choice 💡 Building strong Java fundamentals, one collection at a time ☕💻 #Java #CoreJava #CollectionsFramework #Set #HashSet #LinkedHashSet #SortedSet #JavaCollections #LearningJourney