Adding Array Elements in Java: A Simple Explanation

📘 Core Java – Day 5 Topic: Loops (for loop & simple pattern) Today, I learned about the concept of Loops in Core Java. Loops are used to execute a block of code repeatedly, which helps in reducing code redundancy and improving efficiency. In Java, the main types of loops are: 1. for loop 2. while loop 3. do-while loop 4. for-each loop 👉 I started by learning the for loop. 🔹 Syntax of for loop: for(initialization; condition; increment/decrement) { // statements } 🔹 Working of for loop: Initialization – initializes the loop variable (executed only once) Condition – checked before every iteration Execution – loop body runs if the condition is true Increment/Decrement – updates the loop variable Loop continues until the condition becomes false ⭐ Example: Simple Star Pattern using for loop for(int i = 1; i <= 5; i++) { for(int j = 1; j <= i; j++) { System.out.print("* "); } System.out.println(); } Output: * * * * * * * * * * * * * * * 🔹 Key Points: ✔ for loop is used when the number of iterations is known ✔ It keeps code structured and readable ✔ Nested for loops are commonly used in pattern programs 🚀 Building strong fundamentals in Core Java, one concept at a time. #CoreJava #JavaLoops #ForLoop #JavaProgramming #LearningJourney #Day5

📘 Day 12 – Java String | == vs equals() Today while learning Java, I understood an important concept about String comparison — the difference between == and equals(). What I learned 👇 🔹 String in Java String is a class String is immutable (once created, it cannot be changed) 🔹 == operator Checks memory reference Used to check whether both variables point to the same object String s1 = "Java"; String s2 = "Java"; System.out.println(s1 == s2); // true 🔹equals() method Checks the actual value/content of the string String s3 = new String("Java"); String s4 = new String("Java"); System.out.println(s3.equals(s4)); // true System.out.println(s3 == s4); // false 🔹 Difference == → compares memory equals() → compares value ✅ Conclusion: This concept is very important for Java interviews and for writing correct code. Learning basics like this helps me build strong Java fundamentals. #Day12 #Java #String #CoreJava #JavaBasics #JavaInterview #LearningJourney #PlacementPreparation

🚫 Java Method Overloading – Common Mistake Developers Make! Question: Explain the below lines of code int findSum(int a, int b) Long findSum(int a, int b) Common Answer: It's method overloading Correct Answer: ❌ This is NOT allowed in Java 🔴 Why? In Java, method signature = method name + parameter signature 👉 Return type is NOT part of the method signature So the compiler cannot decide which method to call. ✅ Valid ways to fix it ✔ Change parameter types: int findSum(int a, int b) Long findSum(long a, long b) ✔ Use only one return type: Long findSum(int a, int b) ✔ Use different method names: int findSumInt(int a, int b) Long findSumLong(int a, int b) 💡 Tip In Java Method overloading works on no. of parameters, types of parameters, parameters sequence not just on return types — even int vs Integer won’t help! 📌 Understanding such small concepts helps avoid compile-time errors and boosts core Java fundamentals. #Java #CoreJava #MethodOverloading #InterviewPreparation #JavaDeveloper #CodingConcepts

🔹 Local Variable Type Inference in Java (var) Java has always been known for being verbose but explicit. With Local Variable Type Inference, Java became a bit more developer-friendly ✨ 👉 What does it mean? Local Variable Type Inference allows Java to automatically infer the data type of a local variable at compile time. Instead of writing the full type, you write: “Java, you figure it out.” ✅ Why was it introduced? To reduce boilerplate code To improve readability To make Java feel more modern, without losing type safety ⚠️ Important rules to remember var is not dynamic typing (Java is still strongly typed) Works only for local variables The variable must be initialized Not allowed for: Class fields Method parameters Return types 💡 Best practice Use var when: The type is obvious from the right side It improves clarity, not confusion Avoid it when: It hides important domain meaning It hurts readability for others 💬 Java is evolving, but its core principles stay strong. Clean code > Short code. #Java #JavaDeveloper #CleanCode #Programming #BackendDevelopment #LearningInPublic

🚀 Core Java Insight: Variables & Memory (Beyond Just Syntax) Today’s Core Java session completely changed how I look at variables in Java — not as simple placeholders, but as memory-managed entities controlled by the JVM. 🔍 Key Learnings: ✅ Variables in Java Variables are containers for data Every variable has a clear memory location and lifecycle 🔹 Instance Variables Declared inside a class Memory allocated in the Heap (inside objects) Automatically initialized by Java with default values Examples of default values: int → 0 float → 0.0 boolean → false char → empty character 🔹 Local Variables Declared inside methods Memory allocated in the Stack No default values Must be explicitly initialized — otherwise results in a compile-time error 🧠 How Java Executes in Memory When a Java program runs: Code is loaded into RAM JVM creates a Java Runtime Environment (JRE) JRE is divided into: Code Segment Heap Stack Static Segment Each segment plays a crucial role in how Java programs execute efficiently. 🎯 Why This Matters Understanding Java from a memory perspective helps in: Writing cleaner, safer code Debugging issues confidently Answering interview questions with depth Becoming a developer who understands code — not just runs it 💡 Great developers don’t just write code. They understand what happens inside the system. 📌 Continuously learning Core Java with a focus on fundamentals + real execution behavior. #Java #CoreJava #JVM #JavaMemory #ProgrammingConcepts #SoftwareEngineering #InterviewPrep #DeveloperJourney #LearningEveryDay

🔍 Difference between Arrays.asList() and List.of() in Java Let’s understand this with a simple example 👇 List<Integer> ls = Arrays.asList(1, 2, 3, 4, 5, 6); List<Integer> lst = List.of(1, 2, 3, 4, 5, 6); ✅ Case 1: Arrays.asList() 1️⃣ Change value using index ls.set(0, 100); Output [100, 2, 3, 4, 5, 6] 2️⃣ Try to add a new element ls.add(7); ❌ UnsupportedOperationException 3️⃣ Try to remove an element ls.remove(2); ❌ UnsupportedOperationException 🔎 Analysis Arrays.asList() returns a fixed-size list It is backed by an array ✅ You can modify elements using set() ❌ You cannot add or remove elements ✅ null values are allowed 📌 Introduced in Java 1.2 ✅ Case 2: List.of() 1️⃣ Try to change value lst.set(0, 100); ❌ UnsupportedOperationException 2️⃣ Try to add a new element lst.add(7); ❌ UnsupportedOperationException 3️⃣ Try to remove an element lst.remove(1); ❌ UnsupportedOperationException 🔎 Analysis List.of() creates a fully immutable list ❌ You cannot add, remove, or modify ❌ null values are not allowed 📌 Introduced in Java 9 ❓ Main Question: When to use which? ✅ Use List.of() When you need a read-only / immutable list, such as: List<String> roles = List.of("ADMIN", "USER", "MANAGER"); ✔ Best for constants ✔ Prevents accidental modification ✔ Cleaner & safer code Arrays.asList() allows value modification but not size change, whereas List.of() creates a completely immutable list. #Java #JavaInterview #Collections #BackendDevelopment #SpringBoot #HappyLearning #JavaLearner #JVM

Hello everyone! Check out this short piece by Simon Ritter on local variable type inference in Java. Worth a read. Good Monday! #Java #BestPractices

🚀 Core Java Insight: Variables & Memory (Beyond Just Syntax) Today’s Core Java session completely changed how I look at variables in Java — not as simple placeholders, but as memory-managed entities controlled by the JVM. 🔍 Key Learnings: ✅ Variables in Java Variables are containers for data Every variable has a clear memory location and lifecycle 🔹 Instance Variables Declared inside a class Memory allocated in the Heap (inside objects) Automatically initialized by Java with default values Examples of default values: int → 0 float → 0.0 boolean → false char → empty character 🔹 Local Variables Declared inside methods Memory allocated in the Stack No default values Must be explicitly initialized — otherwise results in a compile-time error 🧠 How Java Executes in Memory When a Java program runs: Code is loaded into RAM JVM creates a Java Runtime Environment (JRE) JRE is divided into: Code Segment Heap Stack Static Segment Each segment plays a crucial role in how Java programs execute efficiently. 🎯 Why This Matters Understanding Java from a memory perspective helps in: Writing cleaner, safer code Debugging issues confidently Answering interview questions with depth Becoming a developer who understands code — not just runs it 💡 Great developers don’t just write code. They understand what happens inside the system. 📌 Continuously learning Core Java with a focus on fundamentals + real execution behavior. hashtag #Java #CoreJava #JVM #JavaMemory #ProgrammingConcepts #SoftwareEngineering #InterviewPrep #DeveloperJourney #LearningEveryDay

**Post 7 📘 Effective Java – Item 7** “Eliminate obsolete object references” One of the most **silent bugs in Java** is not a crash… It’s a **memory leak**. Java has Garbage Collection, but **GC is not magic**. If *you* keep references, GC can’t help you. 🔍 **Common mistake** We assume that once an object is “logically unused”, Java will clean it up. But if a reference still exists → **memory leak**. 💡 **Classic example** Implementing your own stack, cache, or listener list. If you pop an element from a stack but don’t null out the reference: ➡️ Object stays in memory ➡️ GC cannot reclaim it ✅ **Best practices** * Set references to `null` once they are no longer needed * Be extra careful with: * Custom data structures * Static fields * Caches * Listeners & callbacks * Prefer **weak references** (`WeakHashMap`) for caches when applicable 🧠 **Key takeaway** > Garbage Collection works on *reachability*, not *usefulness*. Writing clean Java isn’t just about syntax or performance — it’s also about **memory hygiene**. This one habit can save you from **production memory leaks** that are extremely hard to debug. source - Effective Java ~ Josch bloch #EffectiveJava #Java #MemoryManagement #GarbageCollection #CleanCode #SoftwareEngineering #BackendDevelopment