Java Stream API: Transform, Filter, and Flatten

💻 Day 7 of #100DaysOfJava Today was all about arrays getting more interesting. What started as simple 2D arrays quickly turned into exploring jagged arrays — where every row can have a different size. It was fun seeing how Java handles flexible data structures. The most interesting part today? Final arrays. Even though the array reference cannot change, the values inside it still can. Small concept, but it really shows how Java handles memory and references. Every day I code, I realize programming is less about memorizing syntax and more about understanding how things work under the hood. On to Day 8 🚀 #100DaysOfJava #100DaysOfCode #Java #JavaProgramming #CodingJourney #LearningInPublic #DeveloperJourney #ProgrammingLife #CodeNewbie #CodeDaily #CodingPractice #TechJourney #FutureDeveloper #SoftwareDeveloper #DevelopersOfLinkedIn #TechCommunity #ProgrammingStudent #ComputerScience #WomenInTech #BuildInPublic

Refactoring for Clarity: Array Manipulation in Java 👨💻 I’ve just finished a practical exercise on array manipulation. While the goal was simple (summing two arrays), I used it as an opportunity to apply improvements. - Method decomposition: Separated concerns into specialized methods (Read, Calculate, Display). - Input validation: Built a robust loop to handle invalid inputs and prevent crashes. - Data Formatting: Used printf to create a clear, readable results table. Small improvements in logic and organization make a huge difference in software quality. #Java #Algorithms #CleanCode #Backend #LearningToCode

 🚀 Day 17 – Understanding Class vs Object in Java Today was focused on one of the most fundamental concepts in Object-Oriented Programming: Class vs Object. Instead of just reading theory, I implemented a practical example to clearly understand how objects are created from a class blueprint. 🧠 What I Strengthened: ✔ A class as a blueprint/template ✔ Objects as real-world instances ✔ Instance variables for storing object-specific data ✔ Methods to define object behavior ✔ Creating and using multiple objects 💡 Key Learning: A class defines structure. An object gives it life. Understanding this distinction is crucial because every scalable software system is built around object interaction. Today helped me think more in terms of modeling real-world entities into structured code — an essential skill for backend and application development. #100DaysOfCode #Java #OOP #ClassAndObject #SoftwareDevelopment #JavaDeveloper #BackendDeveloper #ProgrammingFundamentals #CodingJourney #TechGrowth #ComputerScience #DeveloperGrowth #LearningDaily

Stop using ArrayList for everything. Picking the right data structure isn't just about making your code work; it's about making it perform. Choosing a Set over a List can be the difference between an O(n) and an O(1) lookup. This infographic is one of the best visual breakdowns I’ve seen for the Java Collections Framework: List: When order and duplicates matter. Set: When uniqueness is your top priority. Queue: For that "first-in, first-out" processing flow. Map: When you need fast retrieval via key-value pairs. Which one do you find yourself reaching for most often in your day-to-day? #Java #Programming #SoftwareEngineering #JavaCollections #CodingTips

🚀 Understanding the 4 Pillars of Object-Oriented Programming (OOP) Object-Oriented Programming is built on four important concepts that help developers write secure, reusable, and scalable code. 📌 The 4 Pillars of OOP: 🔐 Encapsulation Binding data and methods together in a single class and protecting data using private variables with getters and setters. 🧩 Abstraction Hiding complex implementation details and showing only the essential features using abstract classes or interfaces. 🧬 Inheritance Reusing code by allowing one class to inherit properties and methods from another class. 🔄 Polymorphism The ability of a method to perform different actions depending on the object (method overloading and overriding). Understanding these four pillars is the foundation of becoming a strong Java developer. Step by step, improving my knowledge of Java and OOP concepts 💻🔥 #Java #OOP #Programming #Encapsulation #Inheritance #Polymorphism #Abstraction #DeveloperJourney

🔢 Mastering Arrays in Java 🚀 Arrays are one of the most fundamental concepts in Java that every developer must understand. From storing multiple values to performing efficient operations, arrays are the backbone of data handling. ✨ Key Takeaways: ✔ Fixed size data structure ✔ Stores elements of the same type ✔ Fast access using index ✔ Foundation for advanced concepts like collections 💡 Whether you're a beginner or revising core concepts, mastering arrays is the first step toward strong problem-solving skills in Java. #Java #Programming #Coding #Developers #Learning #DataStructures #JavaBasics #TechSkills

🔐 Java OOP – Understanding Encapsulation Yesterday I learned about one of the core OOP concepts: Encapsulation. ✔️ Wrapping data and methods together ✔️ Restricting direct access using private variables ✔️ Accessing data through getters and setters A simple realization: Instead of exposing variables directly, we control how data is read and modified. This concept is widely used in backend development — especially in DTOs, entities, and API models. Building strong fundamentals step by step. #Java #OOP #Encapsulation #BackendDevelopment #LearningInPublic #DeveloperJourney

💡 Understanding the Diamond Problem in Multiple Inheritance In Object-Oriented Programming, multiple inheritance allows a class to inherit from more than one parent class. But this can introduce a serious problem called the Diamond Problem. Imagine this inheritance structure: Class A / \ Class B Class C \ / Class D Both Class B and Class C inherit from Class A and override the same method show(). Example: class B extends A { void show() { System.out.println("B"); } } class C extends A { void show() { System.out.println("C"); } } Now when Class D inherits from both: D obj = new D(); obj.show(); Which method should run? B.show() C.show() This creates ambiguity because the compiler cannot determine which method implementation to use. To avoid this confusion, Java does NOT support multiple inheritance with classes. Instead, Java allows multiple inheritance through interfaces, where the implementing class explicitly defines the behavior. Understanding these design decisions helps us appreciate why Java prioritizes clarity, simplicity, and maintainability. #Java #ObjectOrientedProgramming #OOP #JavaDeveloper #SoftwareEngineering #ProgrammingConcepts #Coding #ComputerScience #LearnToCode #TechEducation:

Today I practiced Generics in Java. Generics help us write reusable and type-safe code. Instead of creating separate methods for different data types, we can use a generic type to handle multiple types with the same logic. In this example, a single generic method display() prints both Integer and Double arrays. Learning small concepts like this helps write cleaner and more flexible Java code 🚀 Saketh Kallepu Anand Kumar Buddarapu Uppugundla Sairam Kishor Kumar #Java #Generics #Programming #LearningJourney