📚 The Rules of Programming (2023)

🔗 Download Link: https://shts.me/bsNS

💬 Tags: #programming

✅ By: @DataScience_Books - @DataScience4 - @EBooks2023

📚 How to Make Things Faster (2023)

🔗 Download Link: https://shts.me/PaPh

💬 Tags: #programming

✅ By: @DataScience_Books - @DataScience4 - @EBooks2023

📚 Quick Functional Programming (2023)

🔗 Download Link: https://link.pnfreegames.com/T9hj

💬 Tags: #programming

⛔️ ➕ interaction = ➕ books

✅ Click here 👉: Surprise 🎁

📚 Functional Design and Architecture (2023 - V9)

1⃣ Join Channel Download:
https://t.iss.one/+MhmkscCzIYQ2MmM8

2⃣ Download Book: https://t.iss.one/c/1854405158/92

💬 Tags: #Programming

USEFUL CHANNELS FOR YOU

# 📚 Connecting MySQL Database with Popular Programming Languages

#MySQL #Programming #Database #Python #Java #CSharp #PHP #Kotlin #MATLAB #Julia

MySQL is a powerful relational database management system. Here’s how to connect MySQL with various programming languages.

---

## 🔹 1. Connecting MySQL with Python
#Python #MySQL
Use the mysql-connector-python or pymysql library.

import mysql.connector

# Establish connection
conn = mysql.connector.connect(
    host="localhost",
    user="your_username",
    password="your_password",
    database="your_database"
)

cursor = conn.cursor()
cursor.execute("SELECT * FROM your_table")
result = cursor.fetchall()

for row in result:
    print(row)

conn.close()

---

## 🔹 2. Connecting MySQL with Java
#Java #JDBC
Use JDBC (Java Database Connectivity).

import java.sql.*;

public class MySQLJava {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/your_database";
        String user = "your_username";
        String password = "your_password";

        try {
            Connection conn = DriverManager.getConnection(url, user, password);
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT * FROM your_table");

            while (rs.next()) {
                System.out.println(rs.getString("column_name"));
            }

            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

---

## 🔹 3. Connecting MySQL with C# (.NET)
#CSharp #DotNet #MySQL
Use MySql.Data NuGet package.

using MySql.Data.MySqlClient;

string connStr = "server=localhost;user=your_username;database=your_database;password=your_password";
MySqlConnection conn = new MySqlConnection(connStr);

try {
    conn.Open();
    string query = "SELECT * FROM your_table";
    MySqlCommand cmd = new MySqlCommand(query, conn);
    MySqlDataReader reader = cmd.ExecuteReader();

    while (reader.Read()) {
        Console.WriteLine(reader["column_name"]);
    }
} catch (Exception ex) {
    Console.WriteLine(ex.Message);
} finally {
    conn.Close();
}

---

## 🔹 4. Connecting MySQL with PHP
#PHP #MySQL
Use mysqli or PDO.

<?php
$servername = "localhost";
$username = "your_username";
$password = "your_password";
$dbname = "your_database";

// Create connection
$conn = new mysqli($servername, $username, $password, $dbname);

// Check connection
if ($conn->connect_error) {
    die("Connection failed: " . $conn->connect_error);
}

$sql = "SELECT * FROM your_table";
$result = $conn->query($sql);

if ($result->num_rows > 0) {
    while($row = $result->fetch_assoc()) {
        echo $row["column_name"];
    }
} else {
    echo "0 results";
}

$conn->close();
?>

---

## 🔹 5. Connecting MySQL with Kotlin
#Kotlin #JDBC
Use JDBC (similar to Java).

import java.sql.DriverManager

fun main() {
    val url = "jdbc:mysql://localhost:3306/your_database"
    val user = "your_username"
    val password = "your_password"

    try {
        val conn = DriverManager.getConnection(url, user, password)
        val stmt = conn.createStatement()
        val rs = stmt.executeQuery("SELECT * FROM your_table")

        while (rs.next()) {
            println(rs.getString("column_name"))
        }

        conn.close()
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

---

## 🔹 6. Connecting MySQL with MATLAB
#MATLAB #Database
Use Database Toolbox.

conn = database('your_database', 'your_username', 'your_password', 'com.mysql.jdbc.Driver', 'jdbc:mysql://localhost:3306/your_database');

data = fetch(conn, 'SELECT * FROM your_table');
disp(data);

close(conn);

---

## 🔹 7. Connecting MySQL with Julia
#Julia #MySQL
Use MySQL.jl package.

using MySQL

conn = MySQL.connect("localhost", "your_username", "your_password", db="your_database")

result = MySQL.execute(conn, "SELECT * FROM your_table")

for row in result
    println(row)
end

MySQL.disconnect(conn)

---

# 📚 Java Programming Language – Part 1/10: Introduction to Java
#Java #Programming #OOP #Beginner #Coding

Welcome to this comprehensive 10-part Java series! Let’s start with the basics.

---

## 🔹 What is Java?
Java is a high-level, object-oriented, platform-independent programming language. It’s widely used in:
- Web applications (Spring, Jakarta EE)
- Mobile apps (Android)
- Enterprise software
- Big Data (Hadoop)
- Embedded systems

Key Features:
✔️ Write Once, Run Anywhere (WORA) – Thanks to JVM
✔️ Strongly Typed – Variables must be declared with a type
✔️ Automatic Memory Management (Garbage Collection)
✔️ Multi-threading Support

---

## 🔹 Java vs. Other Languages
| Feature | Java | Python | C++ |
|---------------|--------------|--------------|--------------|
| Typing | Static | Dynamic | Static |
| Speed | Fast (JIT) | Slower | Very Fast |
| Memory | Managed (GC) | Managed | Manual |
| Use Case | Enterprise | Scripting | System/Game |

---

## 🔹 How Java Works?
1. Write code in .java files
2. Compile into bytecode (.class files) using javac
3. JVM (Java Virtual Machine) executes the bytecode

HelloWorld.java → (Compile) → HelloWorld.class → (Run on JVM) → Output

---

## 🔹 Setting Up Java
1️⃣ Install JDK (Java Development Kit)
- Download from [Oracle] :https://www.oracle.com/java/technologies/javase-downloads.html
- Or use OpenJDK (Free alternative)

2️⃣ Verify Installation

java -version
javac -version

3️⃣ Set `JAVA_HOME` (For IDE compatibility)

---

## 🔹 Your First Java Program

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!"); 
    }
}

### 📌 Explanation:
- public class HelloWorld → Class name must match the filename (HelloWorld.java)
- public static void main(String[] args) → Entry point of any Java program
- System.out.println() → Prints output

### ▶️ How to Run?

javac HelloWorld.java  # Compiles to HelloWorld.class
java HelloWorld         # Runs the program

Output:

Hello, World!

---

## 🔹 Java Syntax Basics
✅ Case-Sensitive → myVar ≠ MyVar
✅ Class Names → PascalCase (MyClass)
✅ Method/Variable Names → camelCase (myMethod)
✅ Every statement ends with `;`

---

## 🔹 Variables & Data Types
Java supports primitive and non-primitive types.

### Primitive Types (Stored in Stack Memory)
| Type | Size | Example |
|-----------|---------|----------------|
| int | 4 bytes | int x = 10; |
| double | 8 bytes | double y = 3.14; |
| boolean | 1 bit | boolean flag = true; |
| char | 2 bytes | char c = 'A'; |

### Non-Primitive (Reference Types, Stored in Heap)
- String → String name = "Ali";
- Arrays → int[] nums = {1, 2, 3};
- Classes & Objects

---

### 📌 What’s Next?
In Part 2, we’ll cover:
➡️ Operators & Control Flow (if-else, loops)
➡️ Methods & Functions

Stay tuned! 🚀

#LearnJava #JavaBasics #CodingForBeginners

# 📚 Java Programming Language – Part 3/10: Methods & Functions
#Java #Programming #Methods #Functions #OOP

Welcome to Part 3 of our Java series! Today we'll dive into methods - the building blocks of Java programs.

---

## 🔹 What are Methods in Java?
Methods are blocks of code that:
✔️ Perform specific tasks
✔️ Can be reused multiple times
✔️ Help organize code logically
✔️ Can return a value or perform actions without returning

// Method structure
[access-modifier] [static] return-type methodName(parameters) {
    // method body
    return value; // if not void
}

---

## 🔹 Method Components
### 1. Simple Method Example

public class Calculator {
    
    // Method without return (void)
    public static void greet() {
        System.out.println("Welcome to Calculator!");
    }
    
    // Method with return
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static void main(String[] args) {
        greet();  // Calling void method
        int sum = add(5, 3);  // Calling return method
        System.out.println("Sum: " + sum);
    }
}

### 2. Method Parameters

public static void printUserInfo(String name, int age) {
    System.out.println("Name: " + name);
    System.out.println("Age: " + age);
}

### 3. Return Values

public static boolean isAdult(int age) {
    return age >= 18;
}

---

## 🔹 Method Overloading
Multiple methods with same name but different parameters.

public class MathOperations {
    
    // Version 1: Add two integers
    public static int add(int a, int b) {
        return a + b;
    }
    
    // Version 2: Add three integers
    public static int add(int a, int b, int c) {
        return a + b + c;
    }
    
    // Version 3: Add two doubles
    public static double add(double a, double b) {
        return a + b;
    }
    
    public static void main(String[] args) {
        System.out.println(add(2, 3));       // 5
        System.out.println(add(2, 3, 4));    // 9
        System.out.println(add(2.5, 3.7));  // 6.2
    }
}

---

## 🔹 Recursion
A method that calls itself.

### 1. Factorial Example

public static int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

### 2. Fibonacci Sequence

public static int fibonacci(int n) {
    if (n <= 1) {
        return n;
    }
    return fibonacci(n-1) + fibonacci(n-2);
}

---

## 🔹 Variable Scope
Variables have different scope depending on where they're declared.

public class ScopeExample {
    static int classVar = 10;  // Class-level variable
    
    public static void methodExample() {
        int methodVar = 20;  // Method-level variable
        System.out.println(classVar);  // Accessible
        System.out.println(methodVar); // Accessible
    }
    
    public static void main(String[] args) {
        int mainVar = 30;  // Block-level variable
        System.out.println(classVar);  // Accessible
        // System.out.println(methodVar); // ERROR - not accessible
        System.out.println(mainVar);   // Accessible
    }
}

---

## 🔹 Practical Example: Temperature Converter

public class TemperatureConverter {
    
    public static double celsiusToFahrenheit(double celsius) {
        return (celsius * 9/5) + 32;
    }
    
    public static double fahrenheitToCelsius(double fahrenheit) {
        return (fahrenheit - 32) * 5/9;
    }
    
    public static void main(String[] args) {
        System.out.println("20°C to Fahrenheit: " + celsiusToFahrenheit(20));
        System.out.println("68°F to Celsius: " + fahrenheitToCelsius(68));
    }
}

---

## 🔹 Best Practices for Methods
1. Single Responsibility Principle - Each method should do one thing
2. Descriptive Names - Use verbs (calculateTotal, validateInput)
3. Limit Parameters - Ideally 3-4 parameters max
4. Proper Indentation - Keep code readable
5. Documentation - Use JavaDoc comments

# 📚 Java Programming Language – Part 4/10: Object-Oriented Programming (OOP) Basics
#Java #OOP #Programming #Classes #Objects

Welcome to Part 4 of our Java series! Today we'll explore the fundamentals of Object-Oriented Programming in Java.

---

## 🔹 What is OOP?
Object-Oriented Programming is a paradigm based on:
- Objects (instances of classes)
- Classes (blueprints for objects)
- 4 Main Principles:
- Encapsulation
- Inheritance
- Polymorphism
- Abstraction

---

## 🔹 Classes and Objects

### 1. Class Definition

public class Car {
    // Fields (attributes)
    String brand;
    String model;
    int year;
    
    // Method
    public void startEngine() {
        System.out.println("Engine started!");
    }
}

### 2. Creating Objects

public class Main {
    public static void main(String[] args) {
        // Creating an object
        Car myCar = new Car();
        
        // Accessing fields
        myCar.brand = "Toyota";
        myCar.model = "Corolla";
        myCar.year = 2022;
        
        // Calling method
        myCar.startEngine();
    }
}

---

## 🔹 Constructors
Special methods called when an object is instantiated.

### 1. Default Constructor

public class Car {
    // Default constructor (created automatically if none exists)
    public Car() {
    }
}

### 2. Parameterized Constructor

public class Car {
    String brand;
    String model;
    int year;
    
    public Car(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
    }
}

// Usage:
Car myCar = new Car("Toyota", "Corolla", 2022);

### 3. Constructor Overloading

public class Car {
    // Constructor 1
    public Car() {
        this.brand = "Unknown";
    }
    
    // Constructor 2
    public Car(String brand) {
        this.brand = brand;
    }
}

---

## 🔹 Encapsulation
Protecting data by making fields private and providing public getters/setters.

public class BankAccount {
    private double balance;  // Private field
    
    // Public getter
    public double getBalance() {
        return balance;
    }
    
    // Public setter with validation
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
}

---

## 🔹 'this' Keyword
Refers to the current object instance.

public class Person {
    private String name;
    
    public Person(String name) {
        this.name = name;  // 'this' distinguishes field from parameter
    }
}

---

## 🔹 Practical Example: Student Management System

public class Student {
    private String id;
    private String name;
    private double gpa;
    
    public Student(String id, String name) {
        this.id = id;
        this.name = name;
    }
    
    // Getters and setters
    public String getId() { return id; }
    public String getName() { return name; }
    public double getGpa() { return gpa; }
    
    public void updateGpa(double newGpa) {
        if (newGpa >= 0 && newGpa <= 4.0) {
            this.gpa = newGpa;
        }
    }
    
    public void printInfo() {
        System.out.printf("ID: %s, Name: %s, GPA: %.2f\n", 
                         id, name, gpa);
    }
}

// Usage:
Student student1 = new Student("S1001", "Ahmed");
student1.updateGpa(3.75);
student1.printInfo();

---

## 🔹 Static vs Instance Members

| Feature | Static | Instance |
|---------------|---------------------------|---------------------------|
| Belongs to | Class | Object |
| Memory | Once per class | Each object has its own |
| Access | ClassName.member | object.iss.onember |
| Example | Math.PI | student.getName() |

public class Counter {
    static int count = 0;  // Shared across all instances
    int instanceCount = 0; // Unique to each object
    
    public Counter() {
        count++;
        instanceCount++;
    }
    
    public static void printCount() {
        System.out.println("Total count: " + count);
    }
}

---

# 📚 Java Programming Language – Part 5/10: Inheritance & Polymorphism
#Java #OOP #Inheritance #Polymorphism #Programming

Welcome to Part 5 of our Java series! Today we'll explore two fundamental OOP concepts: Inheritance and Polymorphism.

---

## 🔹 Inheritance in Java
Inheritance allows a class to acquire properties and methods of another class.

### 1. Basic Inheritance Syntax

// Parent class (Superclass)
class Vehicle {
    String brand;
    
    public void start() {
        System.out.println("Vehicle starting...");
    }
}

// Child class (Subclass)
class Car extends Vehicle {  // 'extends' keyword
    int numberOfDoors;
    
    public void honk() {
        System.out.println("Beep beep!");
    }
}

// Usage:
Car myCar = new Car();
myCar.brand = "Toyota";  // Inherited from Vehicle
myCar.start();          // Inherited method
myCar.honk();           // Child's own method

### 2. Inheritance Types
Java supports:
- Single Inheritance (One parent → one child)
- Multilevel Inheritance (Grandparent → parent → child)
- Hierarchical Inheritance (One parent → multiple children)

*Note: Java doesn't support multiple inheritance with classes*

---

## 🔹 Method Overriding
Subclass can provide its own implementation of an inherited method.

class Vehicle {
    public void start() {
        System.out.println("Vehicle starting...");
    }
}

class ElectricCar extends Vehicle {
    @Override  // Annotation (optional but recommended)
    public void start() {
        System.out.println("Electric car starting silently...");
    }
}

---

## 🔹 super Keyword
Used to access superclass members from subclass.

### 1. Accessing Superclass Methods

class ElectricCar extends Vehicle {
    @Override
    public void start() {
        super.start();  // Calls Vehicle's start()
        System.out.println("Battery check complete");
    }
}

### 2. Superclass Constructor

class Vehicle {
    String brand;
    
    public Vehicle(String brand) {
        this.brand = brand;
    }
}

class Car extends Vehicle {
    int doors;
    
    public Car(String brand, int doors) {
        super(brand);  // Must be first statement
        this.doors = doors;
    }
}

---

## 🔹 Polymorphism
"Many forms" - ability of an object to take many forms.

### 1. Compile-time Polymorphism (Method Overloading)

class Calculator {
    // Same method name, different parameters
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
}

### 2. Runtime Polymorphism (Method Overriding)

Vehicle v1 = new Vehicle();  // Parent reference, parent object
Vehicle v2 = new Car();      // Parent reference, child object

v1.start();  // Calls Vehicle's start()
v2.start();  // Calls Car's start() if overridden

---

## 🔹 final Keyword
Restricts inheritance and overriding.

final class CannotBeExtended { }  // Cannot be inherited

class Parent {
    final void cannotOverride() { }  // Cannot be overridden
}

---

## 🔹 Object Class
All classes implicitly extend Java's Object class.

Important methods:
- toString() - String representation
- equals() - Compare objects
- hashCode() - Hash code value

class MyClass { }  // Automatically extends Object

MyClass obj = new MyClass();
System.out.println(obj.toString());  // Outputs something like MyClass@1dbd16a6

---

# 📚 Java Programming Language – Part 6/10: Interfaces & Abstract Classes
#Java #OOP #Interfaces #AbstractClasses #Programming

Welcome to Part 6 of our Java series! Today we'll explore two crucial concepts for achieving abstraction in Java: Interfaces and Abstract Classes.

---

## 🔹 Interfaces in Java
Interfaces define contracts that classes must implement (100% abstraction).

### 1. Interface Declaration (Pre-Java 8)

interface Drawable {
    // Constant fields (implicitly public static final)
    String COLOR = "Black";
    
    // Abstract methods (implicitly public abstract)
    void draw();
    double calculateArea();
}

### 2. Implementing Interfaces

class Circle implements Drawable {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

### 3. Modern Interfaces (Java 8+) Features

interface Vehicle {
    // Traditional abstract method
    void start();
    
    // Default method (with implementation)
    default void honk() {
        System.out.println("Beep beep!");
    }
    
    // Static method
    static void printType() {
        System.out.println("I'm a vehicle");
    }
}

---

## 🔹 Abstract Classes
Classes that can't be instantiated and may contain abstract methods.

### 1. Abstract Class Example

abstract class Animal {
    // Concrete method
    public void breathe() {
        System.out.println("Breathing...");
    }
    
    // Abstract method (no implementation)
    public abstract void makeSound();
}

### 2. Extending Abstract Classes

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof woof!");
    }
}

// Usage:
Animal myPet = new Dog();
myPet.breathe();    // Inherited concrete method
myPet.makeSound();  // Implemented abstract method

---

## 🔹 Key Differences

| Feature | Interface | Abstract Class |
|------------------------|-----------------------------------|------------------------------------|
| Instantiation | Cannot be instantiated | Cannot be instantiated |
| Methods | All abstract (pre-Java 8) | Can have both abstract & concrete |
| Variables | Only constants | Any variables |
| Multiple Inheritance | Class can implement many interfaces | Class extends only one abstract class |
| Default Methods | Supported (Java 8+) | Not applicable |
| Constructor | No constructors | Can have constructors |
| When to Use | Define contracts/APIs | Share code among related classes |

---

# 📚 Java Programming Language – Part 8/10: Exception Handling
#Java #Exceptions #ErrorHandling #Programming

Welcome to Part 8 of our Java series! Today we'll master how to handle errors and exceptional situations in Java programs.

---

## 🔹 What are Exceptions?
Exceptions are events that disrupt normal program flow:
- Checked Exceptions (Compile-time) - Must be handled
- Unchecked Exceptions (Runtime) - Optional handling
- Errors (Serious problems) - Usually unrecoverable

---

## 🔹 Exception Hierarchy

Throwable
├── Error (e.g., OutOfMemoryError)
└── Exception
    ├── RuntimeException (Unchecked)
    │   ├── NullPointerException
    │   ├── ArrayIndexOutOfBoundsException
    │   └── ArithmeticException
    └── Other Exceptions (Checked)
        ├── IOException
        └── SQLException

---

## 🔹 Try-Catch Block
Basic exception handling structure:

try {
    // Risky code
    int result = 10 / 0;
} catch (ArithmeticException e) {
    // Handle specific exception
    System.out.println("Cannot divide by zero!");
} catch (Exception e) {
    // Generic exception handler
    System.out.println("Something went wrong: " + e.getMessage());
} finally {
    // Always executes (cleanup code)
    System.out.println("Cleanup completed");
}

---

## 🔹 Checked vs Unchecked Exceptions

| Feature | Checked Exceptions | Unchecked Exceptions |
|-----------------|----------------------------|----------------------------|
| Handling | Mandatory (compile error) | Optional |
| Inheritance | Extend Exception | Extend RuntimeException |
| When to Use | Recoverable situations | Programming errors |
| Examples | IOException, SQLException | NullPointerException, ArithmeticException |

---

## 🔹 Throwing Exceptions
### 1. Throw Keyword

public void withdraw(double amount) throws InsufficientFundsException {
    if (amount > balance) {
        throw new InsufficientFundsException("Not enough balance");
    }
    balance -= amount;
}

### 2. Throws Clause

public void readFile() throws IOException {
    FileReader file = new FileReader("data.txt");
    // File operations
}

---

## 🔹 Custom Exceptions
Create your own exception classes:

// Custom checked exception
public class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

// Custom unchecked exception
public class PaymentFailedException extends RuntimeException {
    public PaymentFailedException(String message) {
        super(message);
    }
}

---

## 🔹 Try-With-Resources
Automatic resource management (Java 7+):

try (FileInputStream fis = new FileInputStream("file.txt");
     BufferedReader br = new BufferedReader(new InputStreamReader(fis))) {
    // Auto-closed after try block
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

---

## 🔹 Practical Example: Bank Transactions

public class BankAccount {
    private double balance;
    
    public void deposit(double amount) throws InvalidAmountException {
        if (amount <= 0) {
            throw new InvalidAmountException("Deposit amount must be positive");
        }
        balance += amount;
    }
    
    public void withdraw(double amount) 
            throws InsufficientFundsException, InvalidAmountException {
        if (amount <= 0) {
            throw new InvalidAmountException("Withdrawal amount must be positive");
        }
        if (amount > balance) {
            throw new InsufficientFundsException("Not enough funds");
        }
        balance -= amount;
    }
}

// Usage:
BankAccount account = new BankAccount();
try {
    account.deposit(1000);
    account.withdraw(500);
    account.withdraw(600);  // Throws exception
} catch (InvalidAmountException | InsufficientFundsException e) {
    System.err.println("Transaction failed: " + e.getMessage());
}

---

# 📚 Java Programming Language – Part 9/10: Collections Framework
#Java #Collections #DataStructures #Programming

Welcome to Part 9 of our Java series! Today we'll explore the powerful Collections Framework - essential for handling groups of objects efficiently.

---

## 🔹 Collections Framework Overview
The Java Collections Framework provides:
- Interfaces (List, Set, Map, etc.)
- Implementations (ArrayList, HashSet, HashMap, etc.)
- Algorithms (Searching, Sorting, Shuffling)


---

## 🔹 Core Interfaces
| Interface | Description | Key Implementations |
|-----------|-------------|---------------------|
| List | Ordered collection (allows duplicates) | ArrayList, LinkedList |
| Set | Unique elements (no duplicates) | HashSet, TreeSet |
| Queue | FIFO ordering | LinkedList, PriorityQueue |
| Map | Key-value pairs | HashMap, TreeMap |

---

## 🔹 List Implementations
### 1. ArrayList

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add(1, "Charlie"); // Insert at index 1

System.out.println(names); // [Alice, Charlie, Bob]
System.out.println(names.get(0)); // Alice

### 2. LinkedList

List<Integer> numbers = new LinkedList<>();
numbers.add(10);
numbers.addFirst(5); // Add to beginning
numbers.addLast(20); // Add to end

System.out.println(numbers); // [5, 10, 20]

---

## 🔹 Set Implementations
### 1. HashSet (Unordered)

Set<String> uniqueNames = new HashSet<>();
uniqueNames.add("Alice");
uniqueNames.add("Bob");
uniqueNames.add("Alice"); // Duplicate ignored

System.out.println(uniqueNames); // [Alice, Bob] (order may vary)

### 2. TreeSet (Sorted)

Set<Integer> sortedNumbers = new TreeSet<>();
sortedNumbers.add(5);
sortedNumbers.add(2);
sortedNumbers.add(8);

System.out.println(sortedNumbers); // [2, 5, 8]

---

## 🔹 Map Implementations
### 1. HashMap

Map<String, Integer> ageMap = new HashMap<>();
ageMap.put("Alice", 25);
ageMap.put("Bob", 30);
ageMap.put("Alice", 26); // Overwrites previous value

System.out.println(ageMap.get("Alice")); // 26
System.out.println(ageMap.containsKey("Bob")); // true

### 2. TreeMap (Sorted by keys)

Map<String, String> sortedMap = new TreeMap<>();
sortedMap.put("Orange", "Fruit");
sortedMap.put("Carrot", "Vegetable");
sortedMap.put("Apple", "Fruit");

System.out.println(sortedMap); 
// {Apple=Fruit, Carrot=Vegetable, Orange=Fruit}

---

## 🔹 Iterating Collections
### 1. For-Each Loop

List<String> colors = List.of("Red", "Green", "Blue");
for (String color : colors) {
    System.out.println(color);
}

### 2. Iterator

Set<Integer> numbers = new HashSet<>(Set.of(1, 2, 3));
Iterator<Integer> it = numbers.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

### 3. forEach() Method (Java 8+)

Map<String, Integer> map = Map.of("A", 1, "B", 2);
map.forEach((key, value) -> 
    System.out.println(key + ": " + value));

---

## 🔹 Collections Utility Class
Powerful static methods for collections:

List<Integer> numbers = new ArrayList<>(List.of(3, 1, 4, 1, 5));

Collections.sort(numbers); // [1, 1, 3, 4, 5]
Collections.reverse(numbers); // [5, 4, 3, 1, 1]
Collections.shuffle(numbers); // Random order
Collections.frequency(numbers, 1); // 2

---