Java Strings: Core Concepts and Optimization Techniques

Missed posting yesterday. Used the time to revise Java fundamentals. Revision in Java isn’t about rereading syntax. It’s about rediscovering why things work the way they do. Yesterday’s revision focused on: • How memory is managed inside the JVM • Why equals() matters beyond comparisons • How exceptions propagate through method calls • The real difference between == and .equals() These topics feel small — until they cause real bugs. Frameworks change. APIs evolve. But Java fundamentals stay relevant. Revising basics is not going backward. It’s upgrading how you think. Back today. Building on stronger foundations. #Java #CoreJava #JVM #BackendDevelopment #SoftwareEngineering #LearningInPublic #BuildInPublic

Why write 5 lines of loop when 1 line of Stream can do it? Today: Iterating a list using Java Stream API. Comment if you still prefer for-loops #JavaProgramming #Streams #TechLearning #InterviewPrep

🚀 Today I Learned: Pass by Value vs Pass by Reference in Java Understanding this concept cleared one of the biggest confusions in Core Java for me. 🔹 Pass by Value (Primitive Types) Java passes a copy of the variable. Changes inside the method do NOT affect the original value. 🔹 Objects in Java Java still passes by value — but the value is the reference to the object. So when we modify the object inside a method, the original object gets updated. 🪣 The “Bucket of Water” example made it super easy to understand: 1.Primitive → Copy of water 🪣 (original stays same) 2.Object → Same bucket 🪣 (changes reflect everywhere) 💡 Key Takeaway: Java is always Pass by Value, but object references point to the same memory. Small concept. Big impact in debugging and interviews. #Java #CoreJava #ProgrammingConcepts #JavaDeveloper #LearningJourney #Coding

🚀 Java Core Interview Series – Part 2 Encapsulation in Java Encapsulation is one of the most important OOP principles in Java. It ensures: ✔ Data Hiding ✔ Controlled Access ✔ Secure Object State ✔ Better Maintainability In real backend development: Entities, DTOs, and Services rely on encapsulation. Spring Boot uses getters/setters for data binding and validation internally. Without encapsulation: account.balance = -500 ❌ (Invalid state possible) With encapsulation: Invalid updates are prevented through business logic ✅ Strong Encapsulation = Secure & Maintainable Backend Code 🔥 I’ve explained the concept with a practical BankAccount example in this post. You can find my Java practice code here: 🔗 https://lnkd.in/gkmM6MRM More core Java concepts coming next 🚀 #Java #Encapsulation #OOPS #BackendDevelopment #CoreJava

DSA Practice – Bubble Sort Implementation in Java :- What is Bubble Sort ? Bubble Sort is a simple comparison-based sorting algorithm where adjacent elements are compared and swapped if they are in the wrong order. This process repeats until the array becomes sorted. How It Works: Traverse the array multiple times Compare adjacent elements Swap them if they are in the wrong order After each iteration, the largest element “bubbles up” to its correct position #JAVA #DSA

🚀Java practice - Day 87 Completed! 👍 Problem: Sum of Squares of Special Elements Language: Java Today’s problem was about identifying special elements in a 1-indexed array. An element is considered special if its index divides the length of the array (n % i == 0). The task was to calculate the sum of the squares of such elements.✨ #Day87 #Java #LeetCode #Arrays #ProblemSolving #DailyCoding #Consistency #100DaysOfCode

You already know interfaces in Java. A Functional Interface is simply an interface with exactly one abstract method — nothing more. This constraint is intentional and it allows Java to represent behavior as a value. Runnable is a classic example. It defines a single contract: void run(); Because there is only one abstract method, the compiler can infer intent and accept a lambda as its implementation. Runnable task = () -> {   System.out.println("Executing task for Anwer Sayeed"); }; The lambda doesn’t replace Runnable. It implements its contract, concisely. This design choice is what enabled Java’s functional style without breaking its object-oriented foundations. #Java #FunctionalInterface #Runnable #LambdaExpressions #JavaDeveloper #CleanCode #Multithreading

🚀 Java practice - Day 89 Completed! 👍 Problem: Find Minimum Operations to Make All Elements Divisible by Three Language: Java Today’s problem was about minimizing operations. We’re given an array, and in one operation we can add or subtract 1 from any element. The goal is to make all elements divisible by 3 using the minimum number of operations. ✨ #Day89 #Java #LeetCode #Arrays #ProblemSolving #DailyCoding #Consistency #100DaysOfCode

Java☕ — Reflection made frameworks less magical🪞 I used to wonder how Spring creates objects automatically. Then I discovered Reflection API. 📝Reflection allows Java to: ✅Inspect classes at runtime ✅Access fields & methods dynamically ✅Create objects without new #Java_Code Class<?> clazz = Class.forName("com.example.User"); Object obj = clazz.getDeclaredConstructor().newInstance(); That blew my mind. Realization for me: Frameworks use reflection to reduce boilerplate. 📝But also: ✅Slower than normal calls ✅Breaks encapsulation ✅Should be used carefully Reflection isn’t for daily coding. It’s for building libraries and frameworks. #Java #Reflection #AdvancedJava #BackendDevelopment

#100daysofcodingchallenge - Day14 Question: Write a Java program to read an array of integers and print the minimum and maximum sum of n-1 elements from the array. Input: Enter number of elements: 5 Enter elements: 1 2 3 4 5 Output: Minimum sum of n-1 elements: 10 Maximum sum of n-1 elements: 14 #100daysofcodingchallenge #codingchallenge #day14 #practicecoding #corejava #problemsolving