Strengthening Fundamentals with Weekly Reviews

Exploring Java Stack Data Structure 🚀 In this simple example, I used Java's Stack to store different data types using Object type. It helped me better understand: - LIFO (Last In First Out) principle - How Stack works in Java - Storing multiple data types in one structure Always learning, always improving. 💻 import java.util.Stack; public class Main {   public static void main(String[] args) {     Stack<Object> my_stack =new Stack<>();     my_stack.push(1.25);     my_stack.push(78);     my_stack.push(true);     my_stack.push("engin");     my_stack.push(9999999L);     my_stack.push('E');     System.out.println(my_stack);           } } https://lnkd.in/d3hZN9B4 #Java #DataStructures #Programming #Learning

Frontlines EduTech (FLM) Day 54 to 60- Al-Powered Java Full Stack Topics: Stated SQL(Database) Database intro SQL intro DML, DCL,DQL,TCL constraints Aggregate Functions Joins inner join, outer join

Day 20 Java I/O Deep Dive Today I went deeper into Java Input/Output and really understood how input is handled internally. Starting from the basics of Input Streams, I explored how data flows from the keyboard to the program using System.in and how Java processes that data step by step. Then I compared different ways of taking input in Java: 👉 System.in – the fundamental input stream, low-level and not very user-friendly 👉 Scanner – very easy to use, supports parsing of different data types, but comparatively slower 👉 BufferedReader – faster and more efficient, especially when dealing with large input data, but requires handling exceptions and manual parsing I also learned when to use what: ✔ For quick programs and beginners → Scanner is best ✔ For competitive programming or large data → BufferedReader is preferred This deep dive helped me understand not just how to write code, but why certain methods are faster and more efficient than others. Slowly building a strong foundation in Java Guided by Aditya Tandon sir #Java #IOStreams #CodingJourney #DeveloperLife

🧠 Java Logic + SQL Concept Practice Today I focused on strengthening basic logic through small problems. ✔️ Counted even numbers in an array ✔️ Found the largest element ✔️ Calculated string length without using built-in methods Also revisited a key SQL concept around JOINs, especially understanding which JOIN returns all rows from the left table. These small exercises help improve logical thinking and deepen understanding of core concepts. #Java #SQL #DSA #ProgrammingFundamentals #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

🚀 Continuing my Java Collection Framework learning series! I recently published a new video explaining different ways to fetch collection data in Java (Part-4) on my YouTube channel CodeFreeEducation. In this video, I explain multiple techniques to retrieve data from collections using both traditional and modern Java approaches. Topics covered in this video: • toString() • Ordinary for loop • For-each loop • Enumeration • Iterator • ListIterator • Spliterator • Lambda expressions • Method reference (forEach) • Streams 📂 Java Complete Notes: https://lnkd.in/gr5k28Yh 💻 Code Reference (GitHub): https://lnkd.in/g245HdWv 🎥 Watch the video here: https://lnkd.in/gmKG_Gce #Java #JavaProgramming #JavaCollectionFramework #JavaStreams #Iterator #CodeFreeEducation

In Java, we often hear that object creation is cheap and the JVM is optimized for it. That’s true — but only up to a point. In high-throughput backend systems, excessive object creation becomes a hidden performance issue. What happens in real systems: Large numbers of short-lived objects are created per request Memory allocation rate increases significantly Garbage collection runs more frequently Latency becomes inconsistent due to GC activity Individually, object creation is fast.But at scale, it creates memory pressure that directly impacts performance. This is especially noticeable in: High-traffic REST APIs Data transformation layers Logging and serialization-heavy flows The key learning for me was to be mindful of an object lifecycle, not just logic. Good Java performance isn’t just about efficient algorithms. It’s about how efficiently the JVM can manage the memory your code produces. #Java #JVM #PerformanceTuning #BackendEngineering #Microservices

🚀 Java Collections – List vs Set vs Map Yesterday I deepened my understanding of Collections in Java. ✔️ List → Ordered, allows duplicates ✔️ Set → Stores unique elements ✔️ Map → Key–value data structure Learning when to use the right collection is important for writing clean and efficient backend code. Also practiced DSA problems like: • Finding the first non-repeating element • Intersection of two arrays Choosing the right data structure makes problem-solving much more effective. #Java #Collections #DSA #BackendDevelopment #LearningInPublic #DeveloperJourney

Day 4 — Java Stream Practice Today’s focus was on solving a common problem using Java Streams: finding the most frequent element in a collection. Given a list of words, the task was to identify the element that appears the highest number of times. Approach: Grouped elements using Collectors.groupingBy() Counted occurrences with Collectors.counting() Streamed over the map entries Used max() with Map.Entry.comparingByValue() to find the highest frequency Extracted the result using map(Map.Entry::getKey) This exercise reinforced how Streams can simplify data processing by replacing traditional loops with a more declarative approach. Key learning: Breaking down a problem into smaller transformations makes the solution more readable and maintainable. Looking forward to exploring more real-world use cases of Java Streams. #Day4 #Java #JavaStreams #Coding #ProblemSolving #BackendDevelopment #LearnInPublic

Day 2/100 — Variables & Data Types in Java 🧱 Before you can write any meaningful Java program, you must understand one fundamental concept — how Java stores data in memory. That’s where variables and data types come in. A variable is simply a named container in memory. When you write int age = 25, you’re telling Java to reserve a space in memory, label it age, and store the value 25 inside it. A data type tells Java two things: • What type of value will be stored • How much memory should be allocated Java has 8 primitive data types: int → whole numbers double → decimal numbers char → a single character (always use single quotes) boolean → true or false long → large whole numbers float → decimal numbers with less precision byte → very small integers short → small integers ⚠️ One important thing beginners often miss: String is NOT a primitive data type. It’s a class, which is why it starts with a capital S. 3 rules you should always remember: ✔ Use single quotes (' ') for char ✔ Use double quotes (" ") for String ✔ long values should end with L → 123456789L ✔ float values should end with f → 3.14f 💻 Today's Challenge Declare 5 variables about yourself: • Name • Age • Height • City • Whether you are a student Use the correct data types for each one. Drop your code in the comments — I’ll check if the types are correct. 👇 #Java #100DaysOfJava #100DaysOfCode #CoreJava #LearnJava #JavaDeveloper #Programming