Multithreading in Java: Understanding Threads and Synchronization

🚀 Day 25 | Core Java Learning Journey 📌 Topic: ArrayList & LinkedList in Java Today I learned about ArrayList and LinkedList, two important classes in the Java Collections Framework that implement the Java List Interface. Both are used to store ordered collections of elements, but they use different internal data structures and have different performance characteristics. 🔹 ArrayList ✔ ArrayList is a dynamic (growable) array implementation of the List interface. ✔ It automatically resizes when elements are added or removed. ✔ It allows duplicate elements and maintains insertion order. ✔ Elements can be accessed quickly using an index. Internal Data Structure: • Uses a resizable array. 📌Key Features: ✔ Fast random access using index (get, set operations) ✔ Allows null values and duplicate elements ✔ Maintains insertion order ✔ Automatically increases capacity when needed Best Use Case: ✔ When frequent data access (reading) is required. Example Implementation: • ArrayList 🔹 LinkedList ✔ LinkedList is another implementation of the List interface. ✔ It stores elements using nodes connected through links. ✔ Each node contains data and references to other nodes. ✔ It also implements Deque, so it can be used as a queue or stack. Internal Data Structure: • Doubly Linked List Each node contains: • Data • Reference to the previous node • Reference to the next node 📌Key Features : ✔ Efficient insertion and deletion of elements ✔ Allows duplicate elements ✔ Maintains insertion order ✔ Can be used as List, Queue, or Deque 🔹Types of Linked Lists (Conceptually): • Singly Linked List – Node points to next node • Doubly Linked List – Node points to both previous and next node • Circular Linked List – Last node connects back to the first node In Java, LinkedList is implemented as a Doubly Linked List. Example Implementation: • LinkedList 📌 Key Differences ✔ ArrayList uses a dynamic array ✔ LinkedList uses a doubly linked list structure ✔ ArrayList provides faster element access ✔ LinkedList provides faster insertion and deletion 📌 Key Takeaways ✔ Both ArrayList and LinkedList implement the List interface ✔ ArrayList is best for fast access and reading data ✔ LinkedList is better for frequent insertions and deletions ✔ Choosing the right data structure improves performance and efficiency Understanding these implementations helps developers select the most suitable data structure when working with collections in Java 💻⚡ Special thanks to Vaibhav Barde Sir for explaining these concepts clearly. #CoreJava #JavaLearning #ArrayList #LinkedList #JavaCollections #JavaDeveloper #Programming #LearningJourney

🚀 Day 139 of My Java Learning Journey 🤑 Hi learning warriors👋, Today I explored an interesting concept in Java — Array Equality Check 🤔 At first glance, two arrays may look the same… but are they really equal? Let’s see >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 💻 Code: >>>>>>> import java.util.Arrays; public class ArrayEquality { public static void main(String[] args) { int[] a = { 1, 3, 2, 4 }; int[] b = { 4, 2, 1, 3 }; int[] c = { 1, 3, 2, 4 }; System.out.println("array a and b: " + Arrays.equals(a, b)); System.out.println("array a and c: " + Arrays.equals(a, c)); } } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 🖥️ Output: >>>>>>>> array a and b: false array a and c: true 📌 Output Explanation: a and b → ❌ Not equal because order is different a and c → ✅ Equal because both content and order are same ⚡ Important Concept: Arrays.equals() checks: ✔ Same elements ✔ Same order ✔ Same length 👉 Even if elements are same but order changes → result will be false 💡 Important Tip: If you want to compare arrays without considering order, you should: Sort both arrays first using Arrays.sort() Then compare using Arrays.equals() 🔥 Real Insight: This concept is very useful in: Data comparison Testing Interview questions 💬 Engagement: Did you know this before? Or have you ever made this mistake while comparing arrays? 😅 👇 Let me know in the comments! 📢 CTA: Follow me for more daily Java learning updates 🚀 #Java #LearningJourney #Day139 #Coding #Programming #Developers #JavaDeveloper #Tech #Arrays #ProblemSolving #DevOps #day139 #codewithyuvi #logicalworld

🚀 Day 134 of My Java Learning Journey 😎 Hey bug hunters, Today I practiced a small but useful Java Stream API logic to calculate the average of numbers in a list. Instead of using loops and manual calculations, Java provides a cleaner way using Collectors utility methods. This makes the code shorter, readable, and more efficient. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 💻 Java Code ----------------> public class AverageOfList { public static void main(String[] args) { List<Integer> list = Arrays.asList(10, 20, 30, 40, 50); Double average = list.stream() .collect(Collectors.averagingInt(Integer::intValue)); System.out.println("Average of Integer List: " + average); } } !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 🖥 Output: -------------> Average of Integer List: 30.0 📌 Output Explanation list.stream() converts the list into a Stream for processing. Collectors.averagingInt() calculates the average value of the elements. Integer::intValue converts each Integer object to a primitive int. The result is returned as a Double value. ⭐ Important Concept Collectors.averagingInt() is a built-in method in Java that helps calculate the average of integer values directly from a stream without writing manual logic. 💡 Important Tip Using Stream API with Collectors can reduce boilerplate code and make operations like sum, average, grouping, and filtering much simpler. 🤔 Question for Developers Can you modify this program to calculate the average of only even numbers in the list? I enjoy exploring these small Java programs because they improve logical thinking and help understand Java concepts more deeply. 🚀 Follow my journey as I continue learning Java every day. #Java #JavaProgramming #JavaDeveloper #StreamAPI #Coding #Programming #Developers #TechLearning #ProblemSolving #LearningInPublic #100DaysOfCode #DevOps #Day134 #CodeWithYuvi

🚀 Day 135 of My Java Learning Journey 🤩 Respected connections, Today I explored how to rotate elements of a list in Java using the Collections.rotate() method. List rotation means shifting elements either left or right by a certain number of positions. Java provides a simple built-in method to do this without writing manual logic. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 💻 Java Code: -----------------> public class ListRotation { public static void main(String[] args) { List<Integer> list = Arrays.asList(10, 20, 30, 40, 50); System.out.println("Original List: " + list); // Left Side Rotation Collections.rotate(list, -3); System.out.println("After three time left rotation: " + list); // Right Side Rotation Collections.rotate(list, +3); System.out.println("After three time right rotation: " + list); } } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 🖥 Output: --------------> Original List: [10, 20, 30, 40, 50] After three time left rotation: [40, 50, 10, 20, 30] After three time right rotation: [10, 20, 30, 40, 50] 📌 Output Explanation Collections.rotate(list, distance) shifts elements in the list. If the distance is positive, elements rotate to the right. If the distance is negative, elements rotate to the left. In this example: rotate(list, -3) moves the list 3 positions to the left. rotate(list, +3) moves the list 3 positions to the right, restoring the original list. ⭐ Important Concept Collections.rotate() is a utility method from the Collections framework that simplifies list manipulation operations such as circular shifting of elements. 💡 Important Tip Instead of writing complex loops for shifting elements, using Collections.rotate() keeps your code clean, readable, and efficient. 🤔 Question for Developers Can you modify this program to rotate the list based on user input instead of a fixed number like 3? Small Java concepts like this help improve problem-solving and understanding of the Collections framework. 🚀 Follow my journey as I continue exploring Java every day. #Java #JavaProgramming #JavaDeveloper #CollectionsFramework #Coding #Programming #Developers #TechLearning #ProblemSolving #LearningInPublic #100DaysOfCode #DevOps #Logical #day135 #CodeWithYuvi

🚀 Day 19 at TAP Academy – Exploring Java Arrays in Depth Today’s session was focused on gaining a deeper understanding of Java Arrays and how they are used in real programming scenarios. We started with a quick recap of the limitations of arrays, such as storing only homogeneous data, fixed size allocation, and the requirement of contiguous memory. 💡 One of the key topics covered was the three different ways to create arrays in Java: 1️⃣ Standard array creation using new keyword (most commonly used in real programs). 2️⃣ Creating arrays with predefined values using new int[]{} syntax. 3️⃣ Shorthand array initialization using {} without the new keyword. We also explored how arrays can be created for different primitive data types like byte, short, int, float, double, char, and boolean, along with the corresponding Scanner methods used to take input from users. 🔤 Another interesting concept was handling character input in Java, where we learned the workaround using: scan.next().charAt(0) since Java does not provide a direct nextChar() method. 📦 The session then moved to Arrays of Strings, which highlighted how Java treats Strings as objects and how they can be stored and accessed in arrays similar to primitive types. 👨💻 One of the most important parts of the class was learning about Arrays of Objects using an Employee class example. This helped in understanding: ✔ How objects are created and stored in arrays ✔ The concept of pass-by-reference ✔ How loops can be used to optimize code and avoid repetition when dealing with multiple objects This approach makes programs scalable and efficient, allowing the same logic to work whether we handle 2 objects or thousands of objects. ⚙️ Finally, we explored Command Line Arguments (String[] args), which clarified how Java programs can receive inputs directly from the command line during execution. This concept also introduced how all command-line inputs are treated as Strings, which leads into the next important topic — Java Strings. 📚 Key Takeaways from Today’s Session: • Different ways to create arrays in Java • Arrays with primitive data types and Scanner methods • Handling character input using charAt() • Working with arrays of Strings • Creating and managing arrays of objects • Understanding command line arguments in Java • Writing optimized and scalable code using loops Every session at TAP Academy continues to strengthen my core Java concepts and programming logic, bringing me one step closer to becoming a better developer. 💻✨ #Java #Programming #JavaArrays #LearningJourney #Coding #SoftwareDevelopment #TAPAcademy #JavaDeveloper 🚀

Day 6-7 of Learning Java : Today I started my journey into Java programming which is taught by Aditya Tandon Sir. Here are the key concepts I learned today: Conditional Statements In Java:- Java uses conditional statements to decide which block of code should execute based on condition is true or false. Types:- • If statement • If else statement • Else If ladder • Switch statement • The Ternary Operator ∆ If statement:-The most basic control flow statement. It executes a block of code only if the given condition is true. Example:- if (age >= 18) { System.out.println("You are eligible to vote."); } ∆ If else statement:-It executes a block of code, when if condition is false, the else block runs. Example:- if (score >= 50) { System.out.println("Pass"); } else { System.out.println("Fail"); } ∆ Else If ladder:-When you have multiple conditions to check, you use a ladder. Java tests them from top to bottom and executes the first one that is true. Example:- int score = 85; if (score >= 90) { System.out.println("Grade: A"); } else if (score >= 80) { System.out.println("Grade: B"); } else { System.out.println("Grade: F (Fail)"); } ∆ The switch Statement:-Instead of a long chain of else if statements, a switch is comparing a single variable against a list of constant values. Example:- int day = 3; switch (day) { case 1: System.out.println("Monday"); break; case 2: System.out.println("Tuesday"); break; case 3: System.out.println("Wednesday"); break; default: System.out.println("Invalid day"); } ∆ The Ternary Operator (? :):-This is a shorthand of the if-else statement. It is the only operator in Java that takes three operands. Syntax: variable = (condition) ? value_if_true : value_if_false; This is just the beginning. Excited to continue this journey Special thanks to Rohit Negi bhaiya & Aditya Tandon Sir. #Day6 #Java #Coding #Learning #Consistency

Day 39 of Learning Java: Downcasting & instanceof Explained Clearly 1. What is Downcasting? Downcasting is the process of converting a parent class reference → child class reference. It is the opposite of Upcasting. 👉 Key Points: Requires explicit casting Used to access child-specific methods Only works if the object is actually of the child class Example: class A {} class B extends A {} A ref = new B(); // Upcasting B obj = (B) ref; // Downcasting 💡 Here, ref actually holds a B object, so downcasting is safe. 2. When Downcasting Fails If the object is NOT of the target subclass → it throws: ClassCastException 📌 Example: A ref = new A(); B obj = (B) ref; // Runtime Error 👉 This is why we need a safety check! 3. instanceof Keyword (Safety Check ) The instanceof keyword is used to check whether an object belongs to a particular class before casting. 📌 Syntax: if (ref instanceof B) { B obj = (B) ref; } 💡 Prevents runtime errors and ensures safe downcasting. 4. Real-World Example class SoftwareEngineer { void meeting() { System.out.println("Attending meeting"); } } class Developer extends SoftwareEngineer { void coding() { System.out.println("Writing code"); } } class Tester extends SoftwareEngineer { void testing() { System.out.println("Testing application"); } } 📌 Manager Logic using instanceof: void review(SoftwareEngineer se) { if (se instanceof Developer) { Developer dev = (Developer) se; dev.coding(); } else if (se instanceof Tester) { Tester t = (Tester) se; t.testing(); } } 💡 This is a real use of polymorphism + safe downcasting 5. Key Rules to Remember ✔ Downcasting requires upcasting first ✔ Always use instanceof before downcasting ✔ Helps access child-specific behavior ✔ Wrong casting leads to runtime exceptions 💡 My Key Takeaways: Upcasting gives flexibility, Downcasting gives specificity instanceof is essential for writing safe and robust code This concept is widely used in real-world applications, frameworks, and APIs #Java #OOP #LearningInPublic #100DaysOfCode #Programming #Developers #JavaDeveloper #CodingJourney

📘 Java Learning – Multithreading (Part 3: Runnable Interface, Thread Names & Priorities) 🚀🎯 Continuing my learning journey into Java Multithreading. In this post, I explored how to define threads using the Runnable interface, along with concepts like thread names and priorities. 🔰 Defining a Thread using Runnable Interface A thread can also be defined by implementing the Runnable interface, which is present in the java.lang package and contains only one method: • run() 📌 Two Approaches to Define a Thread 1️⃣ Extending Thread class 2️⃣ Implementing Runnable interface 📌 Example – Runnable Implementation class MyRunnable implements Runnable { public void run() { System.out.println("Child Thread"); } public static void main(String[] args) { MyRunnable r = new MyRunnable(); Thread t = new Thread(r); t.start(); System.out.println("Main Thread"); } } ✔ Output may appear in mixed order because execution depends on the Thread Scheduler. 🔰 Best Approach to Define a Thread Between the two approaches, implementing Runnable is recommended. Reason: • If a class extends Thread, it cannot extend any other class • If a class implements Runnable, it can still extend another class ✔ This provides better flexibility in design. 🔰 Common Thread Constructors Some commonly used constructors of the Thread class: Thread() Thread(Runnable r) Thread(String name) Thread(Runnable r, String name) Thread(ThreadGroup g, String name) Thread(ThreadGroup g, Runnable r) Thread(ThreadGroup g, Runnable r, String name) Thread(ThreadGroup g, Runnable r, String name, long stackSize) 🔰 Getting and Setting Thread Name Every thread in Java has a name (default or programmer-defined). Methods used: • getName() • setName(String name) Example: System.out.println(Thread.currentThread().getName()); // main Thread.currentThread().setName("first thread"); System.out.println(Thread.currentThread().getName()); To get the current executing thread reference: Thread.currentThread() 🔰 Thread Priority Every thread has a priority ranging from 1 (lowest) to 10 (highest). Standard constants: • Thread.MIN_PRIORITY • Thread.NORM_PRIORITY • Thread.MAX_PRIORITY If two threads have the same priority, the execution order depends on the Thread Scheduler. 🔰 Default Priority • Default priority of main thread → 5 • Child threads inherit priority from the parent thread Methods used: • getPriority() • setPriority(int p) Example: t.setPriority(5); t.setPriority(10); t.setPriority(100); // IllegalArgumentException ⭐ Key Takeaways • Threads can be created using the Runnable interface • Implementing Runnable offers better design flexibility • Every thread has a name and priority • Priority range: 1 to 10 Learning multithreading step by step while strengthening Java fundamentals ☕💻 #Java #CoreJava #Multithreading #JavaDeveloper #Concurrency #LearningJourney

🚀 Day 26 | Core Java Learning Journey 📌 Topic: Legacy Classes in Java & Iteration Interfaces Today I learned about Legacy Classes in Java and the iteration mechanisms used to traverse elements in collections. These concepts were introduced in early versions of Java and later became compatible with the Java Collections Framework. Understanding them helps in learning how Java collections evolved over time. 🔹 What are Legacy Classes in Java? ✔ Legacy Classes are the classes that were introduced before Java 1.2, when the Java Collections Framework did not exist. ✔ These classes were part of the original Java library. ✔ Later, they were updated to work with the Collections Framework, but modern alternatives are usually preferred today. 📌 Five Important Legacy Classes 1️⃣ Vector ✔ Dynamic array similar to ArrayList ✔ Synchronized (thread-safe) by default ✔ Allows duplicate elements ✔ Maintains insertion order 2️⃣ Stack ✔ Subclass of Vector ✔ Follows LIFO (Last In First Out) principle ✔ Common methods: • push() – add element • pop() – remove top element • peek() – view top element 3️⃣ Hashtable ✔ Stores key–value pairs ✔ Synchronized (thread-safe) ✔ Does not allow null key or null value ✔ Considered the older version of HashMap 4️⃣ Dictionary ✔ Abstract class used for storing key–value pairs ✔ Parent class of Hashtable ✔ Rarely used in modern Java 5️⃣ Properties ✔ Subclass of Hashtable ✔ Stores configuration data as String key–value pairs ✔ Commonly used in .properties files 🔹 Iteration Interfaces in Java To traverse elements in collections, Java provides different iteration mechanisms. 📌 Enumeration ✔ One of the oldest iteration interfaces ✔ Mainly used with legacy classes like Vector and Hashtable ✔ Supports read-only traversal Methods: • hasMoreElements() • nextElement() 📌 Iterator ✔ Introduced with the Java Collections Framework ✔ Used to iterate over most collection classes Methods: • hasNext() • next() • remove() 📌 ListIterator ✔ Advanced version of Iterator used with List implementations ✔ Supports bidirectional traversal Additional Methods: • hasPrevious() • previous() • nextIndex() • previousIndex() • add() • set() 📌 Difference: Enumeration vs Iterator vs ListIterator ✔ Enumeration → Used with legacy classes, forward traversal only, no modification ✔ Iterator → Works with most collections, forward traversal, supports remove() ✔ ListIterator → Used with lists, supports forward & backward traversal, allows modification of elements Learning these concepts improves understanding of how Java collections work internally and how iteration mechanisms evolved in Java 💻⚡ Special thanks to Vaibhav Barde Sir for explaining these concepts clearly. #CoreJava #JavaLearning #LegacyClasses #Iterator #ListIterator #Enumeration #JavaCollections #JavaDeveloper #Programming #LearningJourney

Understanding Multithreading in Java 🔹 In this example, I explored two approaches for creating threads: • Extending the Thread class • Implementing the Runnable interface package multithreading; /* 1️⃣ Extending Thread Class When a class extends the Thread class, it becomes a thread class. Objects of this class can run in a separate thread. However, the actual task that the thread executes must be written inside the run() method. When start() is called, the JVM creates a new thread and internally invokes the run() method. */ class CommonResource extends Thread {   public void commonResource(String t){     System.out.println("common resources " + t);   }   @Override   synchronized public void run() {     String currT = Thread.currentThread().getName();     if(currT.equals("bheem")){       System.out.println("bheem thread");     }     else if(currT.equals("kalia")){       System.out.println("kalia thread");     }     else{       System.out.println("raju thread");     }     try{       Thread.sleep(5000);     }     catch(Exception e){       e.printStackTrace();     }     commonResource(currT);   } } /* 2️⃣ Creating a Common Resource using the Runnable interface. Instead of extending Thread, it is generally recommended to implement the Runnable interface. Advantages: • The task is separated from the thread. • The class can still extend another class (Java doesn't support multiple inheritance). • This approach is widely used in industry (especially with thread pools). */ class CommonResource1 implements Runnable {   public void commonResource(String t){     System.out.println("common resources " + t);   }   /*   Multiple threads will share the same object of this class.   Because the run() method is synchronized, only one thread   can execute it at a time for this shared object.   */   @Override   synchronized public void run() {     String currT = Thread.currentThread().getName();     if(currT.equals("bheem")){       System.out.println("bheem thread");     }     else if(currT.equals("kalia")){       System.out.println("kalia thread");     }     else{       System.out.println("raju thread");     }     try{       Thread.sleep(5000);     }     catch(Exception e){       e.printStackTrace();     }     commonResource(currT);   } } public class ThreadsUsesCommonResource {   public static void main(String[] args){     // Creating a shared resource object     CommonResource1 commonResource1 = new CommonResource1();     // Creating multiple threads that use the same resource     Thread t1 = new Thread(commonResource1);     t1.setName("kalia");     Thread t2 = new Thread(commonResource1);     t2.setName("bheem");     Thread t3 = new Thread(commonResource1);     t3.setName("raju");     // start() → JVM creates a new thread → run() method executes     t1.start();     t2.start();     t3.start();   } } #Java #Multithreading #Synchronized #BackendDevelopment #LearningInPublic