Learn Python daily with bite-sized lessons, code examples, output previews, and fun quizzes. Perfect for beginners and enthusiasts!
https://t.me/Python_basic_to_advance

🚀 Java Learning Series - Day 3! 🚀

Ready to make your code *do things*? Today, we're diving into the powerful world of **Operators in Java**! ➕➖✖️➗ These special symbols are the backbone of computation and logic, allowing you to perform calculations, make comparisons, and control program flow. Understanding operators is crucial for writing dynamic and interactive Java applications. Let's get started! 💪

```java
public class OperatorShowcase {
public static void main(String[] args) {
// 1. Arithmetic Operators (+, -, *, /, %)
int a = 10;
int b = 3;
System.out.println("--- Arithmetic Operators ---");
System.out.println("a + b = " + (a + b)); // Addition: 13
System.out.println("a - b = " + (a - b)); // Subtraction: 7
System.out.println("a * b = " + (a * b)); // Multiplication: 30
System.out.println("a / b = " + (a / b)); // Division (integer): 3
System.out.println("a % b = " + (a % b)); // Modulo (remainder): 1

// 2. Assignment Operators (=, +=, -=, *=, /=, %=)
int c = 5;
c += 2; // Equivalent to c = c + 2;
System.out.println("n--- Assignment Operators ---");
System.out.println("c after c += 2: " + c); // Output: 7

// 3. Relational Operators (==, !=, >, <, >=, <=)
int x = 10;
int y = 5;
System.out.println("n--- Relational Operators ---");
System.out.println("x > y is " + (x > y)); // Output: true
System.out.println("x == y is " + (x == y)); // Output: false
System.out.println("x != y is " + (x != y)); // Output: true

// 4. Logical Operators (&&, ||, !)
boolean isJavaFun = true;
boolean isDay3 = true;
System.out.println("n--- Logical Operators ---");
System.out.println("isJavaFun && isDay3 is " + (isJavaFun && isDay3)); // AND: true
System.out.println("!isJavaFun is " + (!isJavaFun)); // NOT: false

// 5. Unary Operators (++, --)
int i = 7;
i++; // Post-increment: i becomes 8
System.out.println("n--- Unary Operators ---");
System.out.println("i after i++: " + i); // Output: 8
--i; // Pre-decrement: i becomes 7
System.out.println("i after --i: " + i); // Output: 7
}
}
```

Output example:
```
--- Arithmetic Operators ---
a + b = 13
a - b = 7
a * b = 30
a / b = 3
a % b = 1

--- Assignment Operators ---
c after c += 2: 7

--- Relational Operators ---
x > y is true
x == y is false
x != y is true

--- Logical Operators ---
isJavaFun && isDay3 is true
!isJavaFun is false

--- Unary Operators ---
i after i++: 8
i after --i: 7
```

**Small challenge:** 🤔
What will be the value of `result` after these lines of code?
```java
int num1 = 20;
int num2 = 6;
int result = num1 % num2;
```
Share your answer in the comments below! 👇

---

Day 3: Operators in Java \- Code & Output

Here's your Telegram post and quiz question!

---

👋 Hey Java Learners! Ready to make your programs smart? 🧠 Today, on Day 4, we're diving into the heart of decision-making: Conditional Statements! `if`, `else if`, and `else` are your tools to guide program flow based on conditions. They allow your code to react dynamically to different inputs and scenarios. Let's make your code react dynamically! ✨

```java
public class Day4Conditionals {
public static void main(String[] args) {
int score = 85; // Try changing this value!

if (score >= 90) {
System.out.println("Grade: A (Excellent!)");
} else if (score >= 80) {
System.out.println("Grade: B (Very Good!)");
} else if (score >= 70) {
System.out.println("Grade: C (Good)");
} else if (score >= 60) {
System.out.println("Grade: D (Pass)");
} else {
System.out.println("Grade: F (Fail)");
}

System.out.println("n--- Another example ---");
boolean isRaining = true;
if (isRaining) {
System.out.println("Remember your umbrella! ☔");
} else {
System.out.println("Enjoy the clear sky! ☀️");
}
}
}
```

Output example:
```
Grade: B (Very Good!)

--- Another example ---
Remember your umbrella! ☔
```

💡 **Challenge:** Try modifying the `Day4Conditionals.java` example to check if a given `int` variable (e.g., `int number = -5;`) is `positive`, `negative`, or `zero`! Share your solution in the comments! 👇

---

Day 4: Conditional Statements \(if, else if, else\) \- Code & Output

🌟 **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.

---