🌟 **Java Learning Series - Day 5: Loops!** 🌟

Ready to make your code work harder, not smarter? 💪 Today, we're diving into the wonderful world of loops! 🔁 We'll explore `for`, `while`, and `do-while` loops – your essential tools for repeating actions and automating tasks. Understanding loops is crucial for writing efficient and dynamic Java programs. They allow you to execute a block of code multiple times based on a condition. Let's get looping! 👇

```java
public class LoopExamples {
public static void main(String[] args) {
System.out.println("--- For Loop (Known number of iterations) ---");
// A 'for' loop is ideal when you know how many times you want to loop.
for (int i = 0; i < 3; i++) {
System.out.println("For loop count: " + i);
}

System.out.println("n--- While Loop (Condition-controlled) ---");
// A 'while' loop executes as long as a condition is true.
// The condition is checked *before* each iteration.
int countWhile = 0;
while (countWhile < 3) {
System.out.println("While loop count: " + countWhile);
countWhile++;
}

System.out.println("n--- Do-While Loop (Executes at least once) ---");
// A 'do-while' loop is similar to 'while', but its body is executed at least once
// because the condition is checked *after* the first iteration.
int countDoWhile = 0;
do {
System.out.println("Do-While loop count: " + countDoWhile);
countDoWhile++;
} while (countDoWhile < 3);

System.out.println("n--- Do-While example (condition initially false) ---");
// See how this runs once even if 'neverRun < 5' is immediately false!
int neverRun = 5;
do {
System.out.println("This runs at least once: " + neverRun);
neverRun++;
} while (neverRun < 5);
}
}
```

Output example:
```
--- For Loop (Known number of iterations) ---
For loop count: 0
For loop count: 1
For loop count: 2

--- While Loop (Condition-controlled) ---
While loop count: 0
While loop count: 1
While loop count: 2

--- Do-While Loop (Executes at least once) ---
Do-While loop count: 0
Do-While loop count: 1
Do-While loop count: 2

--- Do-While example (condition initially false) ---
This runs at least once: 5
```

💡 **Your Challenge!**
Modify the `for` loop above to print only even numbers from 0 to 10 (inclusive). Hint: You might need to change the loop's increment or add an `if` statement! Share your solution in the comments! 👇

---

Day 5: Loops \(for, while, do\-while\) \- Code & Output

Here's your Telegram post for Day 7 of the Java learning series!

---

🚀 Day 7 of our Java journey is here, and it's a big one! Today, we're diving into the fundamental world of **Arrays and ArrayLists**! 🎉 You'll learn how to store collections of data efficiently. Arrays offer a fixed-size container for primitives or objects, while ArrayLists provide a dynamic, resizable solution for objects, part of Java's powerful Collections Framework. Understanding these is crucial for organizing your data structures. Let's conquer them! 💡

```java
import java.util.ArrayList;
import java.util.Arrays; // Needed for Arrays.toString()

public class DataCollections {
public static void main(String[] args) {
// --- Working with Arrays ---
System.out.println("--- Working with Arrays ---");
int[] numbers = new int[3]; // Declare an array of 3 integers
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;

System.out.println("Array elements: " + Arrays.toString(numbers));
System.out.println("First element of array: " + numbers[0]);

// --- Working with ArrayLists ---
System.out.println("n--- Working with ArrayLists ---");
ArrayList<String> fruits = new ArrayList<>(); // Create an ArrayList of Strings
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");
fruits.add("Date");

System.out.println("ArrayList elements: " + fruits);
System.out.println("Size of ArrayList: " + fruits.size());
System.out.println("Element at index 1: " + fruits.get(1));

fruits.remove("Banana"); // Remove an element by value
// fruits.remove(0); // You can also remove by index

System.out.println("ArrayList after removing Banana: " + fruits);
System.out.println("Does ArrayList contain 'Apple'? " + fruits.contains("Apple"));
}
}
```

Output example:
```
--- Working with Arrays ---
Array elements: [10, 20, 30]
First element of array: 10

--- Working with ArrayLists ---
ArrayList elements: [Apple, Banana, Cherry, Date]
Size of ArrayList: 4
Element at index 1: Banana
ArrayList after removing Banana: [Apple, Cherry, Date]
Does ArrayList contain 'Apple'? true
```

**Small challenge:**
Your challenge for today: Modify the `fruits` ArrayList in the code to add a new fruit, "Grape", at the *second* position (index 1), and then iterate through the updated ArrayList using a `for-each` loop to print each fruit on a new line! 🍇👩‍💻

---

Day 7: Arrays and ArrayLists \- Code & Output

🚀 Day 8 of our Java journey! Today we're diving into two incredibly powerful collection types: `HashMaps` and `HashSets`. 📚 These data structures are essential for efficient data storage and retrieval, offering lightning-fast operations.

`HashMaps` store data in key-value pairs, perfect for looking up information quickly, while `HashSets` ensure you only store unique elements. Both are built on the concept of hashing, which allows for O(1) average-case performance for adding, removing, and checking for elements. Get ready to supercharge your Java applications! 💡

```java
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map; // Import for Map.Entry

public class Day8Collections {
public static void main(String[] args) {
// --- HashMap Example ---
System.out.println("--- HashMap Example ---");
HashMap<String, Integer> studentGrades = new HashMap<>();

// Adding elements (Key-Value pairs)
studentGrades.put("Alice", 95);
studentGrades.put("Bob", 88);
studentGrades.put("Charlie", 92);
studentGrades.put("Alice", 97); // Updates Alice's grade (keys must be unique)

System.out.println("Student Grades: " + studentGrades);

// Getting an element by key
System.out.println("Bob's grade: " + studentGrades.get("Bob"));

// Checking if a key exists
System.out.println("Contains Charlie? " + studentGrades.containsKey("Charlie"));
System.out.println("Contains David? " + studentGrades.containsKey("David"));

// Removing an element by key
studentGrades.remove("Bob");
System.out.println("Grades after removing Bob: " + studentGrades);

// Iterating through HashMap using entrySet()
System.out.println("nIterating through grades:");
for (Map.Entry<String, Integer> entry : studentGrades.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}

// --- HashSet Example ---
System.out.println("n--- HashSet Example ---");
HashSet<String> uniqueCourses = new HashSet<>();

// Adding elements (only unique elements are stored)
uniqueCourses.add("Java Basics");
uniqueCourses.add("Data Structures");
uniqueCourses.add("Algorithms");
uniqueCourses.add("Java Basics"); // Duplicate, will not be added again

System.out.println("Unique Courses: " + uniqueCourses);

// Checking if an element exists
System.out.println("Contains 'Algorithms'? " + uniqueCourses.contains("Algorithms"));
System.out.println("Contains 'Python Basics'? " + uniqueCourses.contains("Python Basics"));

// Removing an element
uniqueCourses.remove("Data Structures");
System.out.println("Courses after removing 'Data Structures': " + uniqueCourses);

// Size of the set
System.out.println("Number of unique courses: " + uniqueCourses.size());

// Iterating through HashSet
System.out.println("nIterating through courses:");
for (String course : uniqueCourses) {
System.out.println("- " + course);
}
}
}
```

Output example:
```
--- HashMap Example ---
Student Grades: {Alice=97, Bob=88, Charlie=92}
Bob's grade: 88
Contains Charlie? true
Contains David? false
Grades after removing Bob: {Alice=97, Charlie=92}

Iterating through grades:
Alice: 97
Charlie: 92

--- HashSet Example ---
Unique Courses: [Java Basics, Algorithms, Data Structures]
Contains 'Algorithms'? true
Contains 'Python Basics'? false
Courses after removing 'Data Structures': [Java Basics, Algorithms]
Number of unique courses: 2

Iterating through courses:
- Java Basics
- Algorithms
```

🤔 **Your Challenge:** How would you retrieve all the *keys* from the `studentGrades` HashMap and store them in a `HashSet`? Give it a try! 👇

---

Day 8: HashMaps and HashSets \- Code & Output

Here's your Telegram post and quiz question:

---

🚀 Day 9 of our Java learning series is here! Today, we're diving deep into the fascinating world of *String Manipulation* in Java. 🔧 Strings are fundamental for almost every application, from displaying text to processing user input. Java's `String` class is packed with powerful methods to help you work with text efficiently. Get ready to master extracting, replacing, and transforming text! ✨ Let's code!

```java
public class StringManipulationDemo {
public static void main(String[] args) {
String message = " Hello, Java Learners! Welcome. ";

System.out.println("Original String: '" + message + "'");

// 1. Trim leading/trailing spaces
String trimmedMessage = message.trim();
System.out.println("Trimmed String: '" + trimmedMessage + "'");

// 2. Convert to uppercase
System.out.println("Uppercase: " + trimmedMessage.toUpperCase());

// 3. Find the index of a substring
int javaIndex = trimmedMessage.indexOf("Java");
System.out.println("Index of 'Java': " + javaIndex);

// 4. Extract a substring
String greeting = trimmedMessage.substring(0, 5); // "Hello"
System.out.println("Greeting: " + greeting);

// 5. Replace part of the string
String modifiedMessage = trimmedMessage.replace("Learners", "Developers");
System.out.println("Modified Message: " + modifiedMessage);

// 6. Check if string contains a specific substring
boolean containsWelcome = trimmedMessage.contains("Welcome");
System.out.println("Contains 'Welcome'? " + containsWelcome);
}
}
```

Output example:
```
Original String: ' Hello, Java Learners! Welcome. '
Trimmed String: 'Hello, Java Learners! Welcome.'
Uppercase: HELLO, JAVA LEARNERS! WELCOME.
Index of 'Java': 7
Greeting: Hello
Modified Message: Hello, Java Developers! Welcome.
Contains 'Welcome'? true
```

💡 **Your Small Challenge:**
Modify the code to extract the word "Welcome" from the `trimmedMessage` using the `substring()` method combined with `indexOf()`. Share your solution! 👇

---

Day 9: String Manipulation \- Code & Output

🚀 Day 10: Master File I/O in Java! 📁

Hello Java enthusiasts! 👋 Today marks a significant milestone as we dive into **File Input/Output (I/O)**. This is where your programs learn to interact with the outside world, reading from and writing to files on your system. Imagine saving user data, configurations, or processing logs – it all starts here! We'll explore how to effortlessly handle text files, making your applications truly persistent. Let's get hands-on and make your Java programs truly powerful! 💪✍️📖

```java
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileIOExample {
public static void main(String[] args) {
String filename = "mydata.txt";
String contentToWrite = "Hello, Java learners!nThis is Day 10 of our journey.nWe are mastering File I/O.";

// --- Writing to a file (try-with-resources ensures auto-closing) ---
System.out.println("Attempting to write data to " + filename + "...");
try (BufferedWriter writer = new BufferedWriter(new FileWriter(filename))) {
writer.write(contentToWrite);
System.out.println("✅ Successfully wrote data to " + filename);
} catch (IOException e) {
System.err.println("❌ Error writing to file: " + e.getMessage());
}

// --- Reading from a file ---
System.out.println("n--- Attempting to read data from " + filename + " ---");
try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
System.out.println("✅ Finished reading data from " + filename);
} catch (IOException e) {
System.err.println("❌ Error reading from file: " + e.getMessage());
}
}
}
```

Output example:
```
Attempting to write data to mydata.txt...
✅ Successfully wrote data to mydata.txt

--- Attempting to read data from mydata.txt ---
Hello, Java learners!
This is Day 10 of our journey.
We are mastering File I/O.
✅ Finished reading data from mydata.txt
```

### 🧠 Small Challenge:
1. **Append, Don't Overwrite:** Modify the `FileWriter` constructor to `new FileWriter(filename, true)` to append new content to `mydata.txt` instead of overwriting it. Add a new line like "Appending more content!" and run the code again.
2. **Number Series:** Create a *new* file (e.g., `numbers.txt`) and write numbers from 1 to 5 into it, each on a new line. Then, read and print the content of this `numbers.txt` file.

---

📦 Day 12: Packages and Import Statements! 📚

Ready to level up your Java organization skills? Today we're diving into `packages` and `import` statements! Packages help us organize our classes, prevent naming conflicts, and make our code more modular. Think of them as folders for your Java files. The `import` statement is your key 🔑 to easily access classes from other packages without typing their full name every time. Let's explore how they work! ✨

```java
// --- File 1: Calculator.java ---
// (Save this in src/com/example/lib/Calculator.java)
package com.example.lib; // Declares this class belongs to 'com.example.lib'

public class Calculator {
public int add(int a, int b) {
return a + b;
}

public int subtract(int a, int b) {
return a - b;
}
}

// --- File 2: App.java ---
// (Save this in src/com/example/app/App.java)
package com.example.app; // Declares this class belongs to 'com.example.app'

// Import the Calculator class from the com.example.lib package
import com.example.lib.Calculator;
// Alternatively, import all classes from a package: import com.example.lib.*;

public class App {
public static void main(String[] args) {
System.out.println("Starting our application...");

// Using the imported Calculator class
Calculator calc = new Calculator();
int sum = calc.add(15, 7);
System.out.println("15 + 7 = " + sum);

int difference = calc.subtract(20, 5);
System.out.println("20 - 5 = " + difference);

// Without import, you'd need the fully qualified name:
// com.example.lib.Calculator anotherCalc = new com.example.lib.Calculator();
// System.out.println("Using FQN: " + anotherCalc.add(1, 1));
}
}
```

Output example:
```
Starting our application...
15 + 7 = 22
20 - 5 = 15
```

💡 Your challenge for today:
1. Create a new directory structure for a package named `com.myproject.data`.
2. Inside it, create a class `Person` with `name` (String) and `age` (int) fields, and a method `getDetails()` that returns a formatted string.
3. Modify your `App.java` (or create a new `Main.java`) to `import com.myproject.data.Person` and create a `Person` object, then print its details using the `getDetails()` method.

Share your setup if you get stuck! 🚀

---

Day 12: Packages and Import Statements \- Code & Output

🎉 Java Learning Series: Day 13! 🎉

Hello, Java learners! Today, we're diving into the heart of Java: **Object-Oriented Programming (OOP)**! 🚀 Get ready to understand the magic behind `Classes` and `Objects`.

Think of a `Class` as a blueprint or a template for creating something. It defines what attributes (data) and behaviors (methods) that "thing" will have. An `Object`, on the other hand, is a real-world instance of that class. You can create many objects from a single blueprint, each with its unique state but sharing the same defined behaviors. This concept brings structure, reusability, and modularity to your code! 🏗️💡

Let's see an example with a `Dog` class and its objects! 🐕‍🦺

```java
// Define a Class: Dog
class Dog {
// Attributes (properties) of a Dog
String name;
String breed;

// Constructor: A special method to create Dog objects
public Dog(String name, String breed) {
this.name = name;
this.breed = breed;
}

// Methods (behaviors) of a Dog
public void bark() {
System.out.println(name + " says Woof! Woof!");
}

public void displayInfo() {
System.out.println("Name: " + name + ", Breed: " + breed);
}
}

public class Day13_OOP {
public static void main(String[] args) {
// Create Objects (instances) of the Dog class
Dog myDog = new Dog("Buddy", "Golden Retriever"); // myDog is an object
Dog neighborDog = new Dog("Max", "German Shepherd"); // neighborDog is another object

// Access attributes and call methods on these objects
System.out.println("--- My Dog ---");
myDog.displayInfo();
myDog.bark();

System.out.println("n--- Neighbor's Dog ---");
neighborDog.displayInfo();
neighborDog.bark();

// Each object has its own unique data
// System.out.println(myDog.name); // Buddy
// System.out.println(neighborDog.name); // Max
}
}
```

Output example:
```
--- My Dog ---
Name: Buddy, Breed: Golden Retriever
Buddy says Woof! Woof!

--- Neighbor's Dog ---
Name: Max, Breed: German Shepherd
Max says Woof! Woof!
```

---
### Small Challenge:
Can you modify the `Dog` class to include an additional attribute like `age` (an `int`) and a new method called `play()` that prints "[Dog's Name] is playing fetch!"? Don't forget to update the constructor and create a new dog object with an age! 🐾🧠

Happy coding, and see you tomorrow! 👋

---