Java Variable Data Types Explained

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

Day 17 –JAVA STRINGS Strings are one of the most powerful and frequently used concepts in Java. A String represents a sequence of characters and is immutable in nature. Mastering String methods is essential for real-world applications like validation, searching, parsing, and data processing. Examples- String str = "Developer"; System.out.println(str.length()); // 9 System.out.println(str.charAt(0)); // D System.out.println(str.indexOf('e'));  // 1 System.out.println(str.lastIndexOf('e'));// 7 System.out.println(str.contains("lop")); // true System.out.println(str.toUpperCase()); // DEVELOPER System.out.println(str.substring(0,4)); // Deve #Java #JavaFullStack #Arrays #CodingPractice #DSA #LearningInPublic #Programming

Many developers ask: Why do Java Collections not support primitive data types? The reason is that Java Collections work with objects, not primitives. To handle primitive values, Java uses Wrapper Classes like Integer, Double, and Character. Example: int → Integer double → Double char → Character This process is called Autoboxing and Unboxing. Understanding such small concepts can make a big difference in mastering Java. 🚀 #CoreJava #JavaTips #Programming #JavaDeveloper

Day 5 – Java Stream Practice | Finding Duplicate Characters Today I worked on finding duplicate characters in a string using Java Streams. Problem: Given a string, identify characters that appear more than once. Approach: Removed spaces from the string Converted characters into a stream using chars() Used Collectors.groupingBy() along with counting() to calculate frequency Filtered characters with count greater than 2 This exercise helped me strengthen my understanding of: Stream transformations (chars(), mapToObj()) Frequency counting using grouping operations Writing clean and functional-style Java code Sample Input: I Love Java Output: Duplicate characters along with their frequency Consistently practicing Java Streams is improving my approach to data processing and problem solving. #Java #100DaysOfCode #JavaStreams #ProblemSolving #CodingJourney

Revision | Day 6 – Multithreading Today I explored the basics of Multithreading in Java and why it is important for building high-performance applications. What is Multithreading? Multithreading allows a program to execute multiple threads (smaller units of a process) simultaneously. It helps improve application performance and better CPU utilization. Thread vs Runnable There are two main ways to create threads in Java: 1. Extending Thread class class MyThread extends Thread { public void run() { System.out.println("Thread is running"); } } 2. Implementing Runnable interface (recommended) class MyRunnable implements Runnable { public void run() { System.out.println("Thread is running"); } } Runnable is preferred because Java supports single inheritance but multiple interfaces. Synchronization When multiple threads access shared resources, it may cause inconsistent results. Synchronization ensures that only one thread accesses the critical section at a time. Example: synchronized void increment() { count++; } Deadlock Deadlock occurs when two or more threads wait for each other to release resources, causing the program to freeze. Example scenario: Thread 1 → lock1 → waiting for lock2   Thread 2 → lock2 → waiting for lock1 Both threads get stuck forever. Key takeaway: Understanding multithreading is essential for building scalable backend systems and handling concurrent requests efficiently. #Java #Multithreading #BackendDevelopment #JavaDeveloper #LearningInPublic

🚀 DSA in Java — Day 78 📌 Problem Solved: Binary Tree Level Order Traversal Today I solved the Binary Tree Level Order Traversal problem on LeetCode using Breadth First Search (BFS) with a Queue. In this problem, we traverse the binary tree level by level from left to right. 🔹 Approach Used: Used a Queue data structure Added the root node to the queue Processed nodes level by level Stored each level's values inside a list Added the list to the final result 🔹 Key Concepts Practiced: ✔ Binary Trees ✔ Breadth First Search (BFS) ✔ Queue in Java ✔ Level-wise traversal This problem helped me understand how queues are used to process nodes level-wise in trees, which is very useful in many tree problems. Consistent practice is making tree problems much clearer day by day. 💻 Language: Java 📚 Platform: LeetCode #DSA #Java #BinaryTree #LeetCode #CodingJourney #WomenInTech #100DaysOfCode

Another way abstraction is implemented in Java is through interfaces. Interfaces define a set of methods that a class must implement, but they do not provide the actual implementation. Things that became clear : • an interface represents complete abstraction • methods declared inside an interface are implicitly public and abstract • a class uses the implements keyword to follow the rules defined by an interface • the implementing class must provide the body for all the methods • interfaces help create loose coupling between components A simple example shows the idea: interface ICalculator { void add(int a, int b); void sub(int a, int b); } class CalculatorImpl implements ICalculator { public void add(int a, int b) { System.out.println(a + b); } public void sub(int a, int b) { System.out.println(a - b); } } In this structure the interface defines what operations should exist, while the implementing class decides how those operations work. This approach makes it easier to design flexible and maintainable systems. #java #oop #programming #learning #dsajourney

🚀 Java Collections — Stop Memorizing, Start Understanding This diagram looks simple… until you’re asked why things work the way they do. 👇 🔹 Iterable → Collection → List / Set / Queue Everything flows from here. If you don’t get this structure, you’re guessing. 🔹 List - Maintains order - Allows duplicates - ArrayList → fast read, slow insert - LinkedList → fast insert, slow access 🔹 Set - No duplicates allowed - HashSet → fastest, no order - LinkedHashSet → maintains insertion order - TreeSet → sorted, but slower 🔹 Queue / Deque - Built for processing (FIFO / LIFO) - Used in real-world systems like task scheduling 🔹 Map (Separate hierarchy) - Key-value structure - HashMap → O(1) (average) - LinkedHashMap → ordered - TreeMap → sorted (O(log n)) #Java #CollectionsFramework #Coding #DSA #BackendDevelopment

Day 10 of Java & Now I Know Where My Array Actually Lives 🧠💻 Today was not about writing arrays… It was about understanding what happens inside memory. And honestly this was powerful. 👉 Arrays are non-primitive (reference) types. That means: When we write int[] arr = new int[5]; • The variable arr lives in Stack memory • The actual array data lives in Heap memory • arr stores the reference (address) of that heap location So basically… We’re pointing to memory. 🔥 Contiguous Storage Array elements are stored next to each other in one continuous block. 5 integers = 5 × 4 bytes = 20 bytes All in one straight line. That’s why arrays are fast. ⚡ Random Access Java doesn’t search for elements. It calculates their address: Base Address + (Index × Size of Data Type) That’s why accessing the 1st element takes the same time as the 1,000,000th. O(1) access. Instant. Big realization today? Arrays aren’t just collections. They’re structured memory blocks optimized for speed. Day 10 and now I’m not just using arrays… I understand how they work internally. Leveling up every day 🚀🔥 Special thanks to Rohit Negi sir and Aditya Tandon sir🙌🏻🙌🏻 #Java #CoreJava #Arrays #Programming #LearningJourney #Developers #BuildInPublic

Today I Learned – Variables & Data Types in Java In Java, understanding variables and data types is fundamental for writing clean and efficient code. --> Variables Storage containers that hold data values in memory. Each variable has a name, type, and value. Example: int age = 25; String name = "Bharath"; --> Data Types Primitive Types (8 types): byte, short, int, long, float, double, char, boolean → Hold single values, memory-efficient. Reference/Object Types: Example: String, Array, Class objects → Hold addresses of objects in memory. -->Key Points Variables must be declared with a data type. Primitive types store actual values, while reference types store addresses. Using the right data type improves performance and readability. #Java #Programming #JavaDeveloper #DataTypes #Variables #SoftwareDevelopment #Coding #Developer #Tech #OOP #LearningInPublic #100DaysOfCode #BackendDevelopment #ProgrammingTips #TechCareer