📚 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

---

# 📚 Java Programming Language – Part 10/10: Streams & Modern Java Features
#Java #Streams #Lambda #ModernJava #Programming

Welcome to the final part of our Java series! Today we'll explore powerful modern Java features including Streams API and Lambda expressions.

---

## 🔹 Lambda Expressions
Concise way to implement functional interfaces.

### 1. Basic Syntax

// Traditional way
Runnable r1 = new Runnable() {
    public void run() {
        System.out.println("Running!");
    }
};

// Lambda equivalent
Runnable r2 = () -> System.out.println("Running!");

### 2. Lambda Variations

// No parameters
() -> System.out.println("Hello")

// Single parameter
name -> System.out.println("Hello " + name)

// Multiple parameters
(a, b) -> a + b

// With return and body
(x, y) -> {
    int sum = x + y;
    return sum * 2;
}

---

## 🔹 Functional Interfaces
Single abstract method interfaces work with lambdas.

### 1. Common Functional Interfaces
| Interface | Method | Example Use |
|----------------|----------------|---------------------------|
| Predicate<T> | test(T t) | Filter elements |
| Function<T,R>| apply(T t) | Transform elements |
| Consumer<T> | accept(T t) | Perform actions |
| Supplier<T> | get() | Generate values |

### 2. Practical Example

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// Using Predicate
Predicate<String> startsWithA = name -> name.startsWith("A");
names.stream().filter(startsWithA).forEach(System.out::println);

// Using Function
Function<String, Integer> nameLength = String::length;
names.stream().map(nameLength).forEach(System.out::println);

---

## 🔹 Streams API
Powerful way to process collections functionally.

### 1. Stream Pipeline

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

int sum = numbers.stream()          // Source
    .filter(n -> n % 2 == 0)       // Intermediate operation
    .map(n -> n * 2)               // Intermediate operation
    .reduce(0, Integer::sum);      // Terminal operation

System.out.println(sum);  // 12 (2*2 + 4*2)

### 2. Common Stream Operations
| Operation | Type | Example |
|-----------|------|---------|
| filter | Intermediate | .filter(n -> n > 5) |
| map | Intermediate | .map(String::toUpperCase) |
| sorted | Intermediate | .sorted(Comparator.reverseOrder()) |
| forEach | Terminal | .forEach(System.out::println) |
| collect | Terminal | .collect(Collectors.toList()) |
| reduce | Terminal | .reduce(0, Integer::sum) |

---

## 🔹 Method References
Shortcut for lambda expressions.

### 1. Types of Method References

// Static method
Function<String, Integer> parser = Integer::parseInt;

// Instance method of object
Consumer<String> printer = System.out::println;

// Instance method of class
Function<String, String> upper = String::toUpperCase;

// Constructor
Supplier<List<String>> listSupplier = ArrayList::new;

---

## 🔹 Optional Class
Handle null values safely.

### 1. Basic Usage

Optional<String> name = Optional.ofNullable(getName());

String result = name
    .map(String::toUpperCase)
    .orElse("DEFAULT");

System.out.println(result);

### 2. Practical Example

public class UserService {
    public Optional<User> findUser(String id) {
        // May return null
        return Optional.ofNullable(database.findUser(id));
    }
}

// Usage:
userService.findUser("123")
    .ifPresentOrElse(
        user -> System.out.println("Found: " + user),
        () -> System.out.println("User not found")
    );

---

## 🔹 Modern Java Features (Java 8-17)
### 1. Records (Java 16)

public record Person(String name, int age) {}

// Automatically generates:
// - Constructor
// - Getters
// - equals(), hashCode(), toString()

### 2. Pattern Matching (Java 16)

if (obj instanceof String s) {
    System.out.println(s.length());
}

### 3. Text Blocks (Java 15)

String json = """
    {
        "name": "Alice",
        "age": 25
    }
    """;

# 📚 100 Essential Java Interview Questions
#Java #Interview #Programming #OOP #Collections #Multithreading

---

## 🔹 Core Java (20 Questions)
1. What is JVM, JRE, and JDK?
2. Explain public static void main(String[] args)
3. Difference between == and .equals()?
4. What are Java primitives? List all 8.
5. Explain autoboxing/unboxing
6. What are varargs?
7. Difference between String, StringBuilder, and StringBuffer
8. What are immutable objects? How to create them?
9. Explain final, finally, and finalize
10. What are annotations? Common built-in annotations?
11. Difference between throw and throws
12. What is static keyword?
13. Can we override static methods?
14. What is method overloading vs overriding?
15. What is this and super keywords?
16. Explain pass-by-value in Java
17. What are wrapper classes? Why needed?
18. What is enum? When to use?
19. Difference between instanceof and getClass()
20. What is type casting? Implicit vs explicit

---

## 🔹 OOP Concepts (15 Questions)
21. 4 Pillars of OOP with examples
22. What is abstraction vs encapsulation?
23. Difference between abstract class and interface (Java 8+)
24. Can an interface have constructors?
25. What is polymorphism? Runtime vs compile-time
26. What is method hiding?
27. What is composition vs inheritance?
28. What is the Liskov Substitution Principle?
29. How to achieve multiple inheritance in Java?
30. What is a singleton? Thread-safe implementation
31. What is a factory pattern?
32. What is a marker interface?
33. What is a POJO?
34. What is the instanceof operator used for?
35. What is object cloning? Shallow vs deep copy

---

## 🔹 Collections Framework (15 Questions)
36. Collections hierarchy diagram explanation
37. Difference between List, Set, and Map
38. ArrayList vs LinkedList
39. HashSet vs TreeSet
40. HashMap vs HashTable vs ConcurrentHashMap
41. How HashMap works internally?
42. What is hashing? Hashcode/equals contract
43. What is Comparable vs Comparator?
44. Fail-fast vs fail-safe iterators
45. How to make collections immutable?
46. What is PriorityQueue?
47. Difference between Iterator and ListIterator
48. What are Java 8 stream APIs?
49. map() vs flatMap()
50. What are collectors? Common collectors

---

## 🔹 Exception Handling (10 Questions)
51. Exception hierarchy in Java
52. Checked vs unchecked exceptions
53. What is try-with-resources?
54. Can we have try without catch?
55. What is exception propagation?
56. Difference between throw and throws
57. How to create custom exceptions?
58. What is Error vs Exception?
59. Best practices for exception handling
60. What is @SuppressWarnings?

---

## 🔹 Multithreading (15 Questions)
61. Process vs thread
62. Ways to create threads
63. Runnable vs Callable
64. Thread lifecycle states
65. What is synchronization?
66. synchronized keyword usage
67. What are volatile variables?
68. What is deadlock? How to avoid?
69. What is thread starvation?
70. wait(), notify(), notifyAll() methods
71. What is thread pool? Executor framework
72. What is Future and CompletableFuture?
73. What is atomic variable?
74. What is ThreadLocal?
75. Concurrent collections in Java

---

## 🔹 Java 8+ Features (10 Questions)
76. What are lambda expressions?
77. Functional interfaces in Java
78. Method references types
79. Optional class purpose
80. Stream API operations
81. map() vs flatMap()
82. What are default methods?
83. What are static methods in interfaces?
84. New Date/Time API benefits
85. Records and sealed classes

---

## 🔹 JVM & Performance (10 Questions)
86. JVM architecture overview
87. What is classloader?
88. What is bytecode?
89. What is JIT compiler?
90. Heap memory structure
91. What is garbage collection? Types of GC
92. String pool concept
93. How to handle memory leaks?
94. What is OutOfMemoryError? Common causes
95. JVM tuning parameters

---

# 📚 JavaScript Tutorial - Part 1/10: The Complete Beginner's Guide
#JavaScript #WebDev #Programming #BeginnerFriendly

Welcome to Part 1 of our comprehensive 10-part JavaScript series! This tutorial is designed for absolute beginners with detailed explanations and practical examples.

---

## 🔹 What is JavaScript?
JavaScript is a high-level, interpreted programming language that:
- Runs in web browsers (client-side)
- Can also run on servers (Node.js)
- Adds interactivity to websites
- Works with HTML/CSS to create dynamic web pages

Key Features:
✔️ Event-driven programming
✔️ Supports object-oriented and functional styles
✔️ Dynamically typed
✔️ Asynchronous operations (callbacks, promises)

---

## 🔹 JavaScript vs Other Languages
| Feature | JavaScript | Python | Java |
|---------------|---------------|---------------|---------------|
| Typing | Dynamic | Dynamic | Static |
| Execution | Interpreted | Interpreted | Compiled |
| Platform | Browser/Server| Multi-purpose | JVM |
| Paradigms | Multi-paradigm| Multi-paradigm| OOP |

---

## 🔹 How JavaScript Runs?
1. Browser loads HTML/CSS
2. JavaScript engine (V8, SpiderMonkey) executes JS code
3. Can manipulate DOM (Document Object Model)
4. Handles user interactions

HTML → Browser → JavaScript Engine → Execution

---

## 🔹 Setting Up JavaScript
### 1. In HTML File (Most Common)

<script>
  // Your JavaScript code here
  alert("Hello World!");
</script>

<!-- OR External File -->
<script src="script.js"></script>

### 2. Browser Console
- Press F12 → Console tab
- Type JS commands directly

### 3. Node.js (Server-Side)

node filename.js

---

## 🔹 Your First JavaScript Program

// Single line comment
/* Multi-line 
   comment */

// Print to console
console.log("Hello World!"); 

// Alert popup
alert("Welcome to JavaScript!");

// HTML output
document.write("<h1>Hello from JS!</h1>");

---

## 🔹 Variables & Data Types
JavaScript has 3 ways to declare variables:

### 1. Variable Declaration

let age = 25;        // Mutable (block-scoped)
const PI = 3.14;     // Immutable 
var name = "Ali";    // Old way (function-scoped)

### 2. Data Types
| Type | Example | Description |
|-------------|--------------------------|--------------------------|
| Number | 42, 3.14 | All numbers |
| String | "Hello", 'World' | Text data |
| Boolean | true, false | Logical values |
| Object | {name: "Ali", age: 25} | Key-value pairs |
| Array | [1, 2, 3] | Ordered lists |
| Null | null | Intentional empty value |
| Undefined | undefined | Uninitialized variable |

### 3. Type Checking

typeof "Hello";    // "string"
typeof 42;         // "number"
typeof true;       // "boolean"
typeof {};         // "object"

---

## 🔹 Operators
### 1. Arithmetic

let x = 10, y = 3;
console.log(x + y);  // 13
console.log(x - y);  // 7
console.log(x * y);  // 30
console.log(x / y);  // 3.333...
console.log(x % y);  // 1 (modulus)

### 2. Comparison

console.log(5 == "5");   // true (loose equality)
console.log(5 === "5");  // false (strict equality)
console.log(5 != "5");   // false
console.log(5 !== "5");  // true

### 3. Logical

true && false;    // AND → false
true || false;    // OR → true
!true;            // NOT → false

---

## 🔹 Type Conversion
### 1. Explicit Conversion

String(123);        // "123"
Number("3.14");     // 3.14
Boolean(1);         // true

### 2. Implicit Conversion

"5" + 2;      // "52" (string concatenation)
"5" - 2;      // 3 (numeric operation)

---

## 🔹 Practical Example: Simple Calculator

<script>
  let num1 = parseFloat(prompt("Enter first number:"));
  let num2 = parseFloat(prompt("Enter second number:"));
  
  console.log(`Addition: ${num1 + num2}`);
  console.log(`Subtraction: ${num1 - num2}`);
  console.log(`Multiplication: ${num1 * num2}`);
  console.log(`Division: ${num1 / num2}`);
</script>

---

# 📚 JavaScript Tutorial - Part 2/10: Control Flow & Functions
#JavaScript #WebDev #Programming #Beginners

Welcome to Part 2 of our JavaScript series! Today we'll master decision-making and functions - the building blocks of programming logic.

---

## 🔹 Conditional Statements
Control program flow based on conditions.

### 1. if-else Statement

let age = 18;

if (age >= 18) {
    console.log("You're an adult");
} else {
    console.log("You're a minor");
}

### 2. Ternary Operator (Shorthand if-else)

let message = (age >= 18) ? "Adult" : "Minor";
console.log(message);

### 3. switch-case Statement

let day = 3;
let dayName;

switch(day) {
    case 1: dayName = "Monday"; break;
    case 2: dayName = "Tuesday"; break;
    case 3: dayName = "Wednesday"; break;
    default: dayName = "Unknown";
}

console.log(dayName); // "Wednesday"

---

## 🔹 Loops
Execute code repeatedly.

### 1. for Loop

for (let i = 1; i <= 5; i++) {
    console.log(`Count: ${i}`);
}
// Output: 1, 2, 3, 4, 5

### 2. while Loop

let count = 1;
while (count <= 5) {
    console.log(count);
    count++;
}

### 3. do-while Loop

let x = 1;
do {
    console.log(x);
    x++;
} while (x <= 5);

### 4. for...of Loop (Arrays)

const colors = ["red", "green", "blue"];
for (const color of colors) {
    console.log(color);
}

### 5. for...in Loop (Objects)

const person = {name: "Ali", age: 25};
for (const key in person) {
    console.log(`${key}: ${person[key]}`);
}

---

## 🔹 Functions
Reusable blocks of code.

### 1. Function Declaration

function greet(name) {
    return `Hello, ${name}!`;
}
console.log(greet("Ali")); // "Hello, Ali!"

### 2. Function Expression

const square = function(x) {
    return x * x;
};
console.log(square(5)); // 25

### 3. Arrow Functions (ES6+)

const add = (a, b) => a + b;
console.log(add(2, 3)); // 5

### 4. Default Parameters

function createUser(name, role = "user") {
    console.log(`${name} is a ${role}`);
}
createUser("Ali"); // "Ali is a user"

### 5. Rest Parameters

function sum(...numbers) {
    return numbers.reduce((total, num) => total + num, 0);
}
console.log(sum(1, 2, 3)); // 6

---

## 🔹 Practical Example: Grade Calculator

function calculateGrade(score) {
    if (score >= 90) return "A";
    else if (score >= 80) return "B";
    else if (score >= 70) return "C";
    else return "F";
}

const studentScore = 85;
console.log(`Grade: ${calculateGrade(studentScore)}`); // "Grade: B"

---

## 🔹 Scope in JavaScript
### 1. Global Scope

const globalVar = "I'm global";

function test() {
    console.log(globalVar); // Accessible
}

### 2. Function Scope (var)

function test() {
    var functionVar = "I'm function-scoped";
}
console.log(functionVar); // Error: Not accessible

### 3. Block Scope (let/const)

if (true) {
    let blockVar = "I'm block-scoped";
}
console.log(blockVar); // Error: Not accessible

---

## 🔹 Error Handling
### 1. try-catch-finally

try {
    // Risky code
    nonExistentFunction();
} catch (error) {
    console.log("Error occurred:", error.message);
} finally {
    console.log("This always executes");
}

### 2. Throwing Custom Errors

function divide(a, b) {
    if (b === 0) throw new Error("Cannot divide by zero!");
    return a / b;
}

---

## 🔹 Best Practices
1. Use strict equality (===) over ==
2. Prefer const/let over var
3. Keep functions small/single-purpose
4. Always handle errors
5. Use descriptive names for functions/variables

---

### 📌 What's Next?
In Part 3, we'll cover:
➡️ Arrays & Array Methods
➡️ Objects & JSON
➡️ Destructuring

#LearnJavaScript #CodingBasics #WebDevelopment 🚀

Practice Exercise:
1. Create a function to check if a number is even/odd
2. Write a loop that prints prime numbers up to 20
3. Make a temperature converter function (Celsius ↔️ Fahrenheit)

# 📚 JavaScript Tutorial - Part 3/10: Arrays, Objects & JSON
#JavaScript #WebDev #Programming #DataStructures

Welcome to Part 3 of our JavaScript series! Today we'll master arrays, objects, and JSON - essential for handling complex data.

---

## 🔹 Arrays in JavaScript
Ordered collections that can hold multiple values.

### 1. Creating Arrays

// Array literal (recommended)
const fruits = ['Apple', 'Banana', 'Orange'];

// Array constructor
const numbers = new Array(1, 2, 3);

// Mixed data types
const mixed = [1, 'Hello', true, {name: 'Ali'}];

### 2. Accessing Elements

console.log(fruits[0]);  // "Apple" (0-based index)
console.log(fruits.length);  // 3

### 3. Common Array Methods
| Method | Description | Example |
|--------|-------------|---------|
| push() | Add to end | fruits.push('Mango') |
| pop() | Remove from end | fruits.pop() |
| shift() | Remove from start | fruits.shift() |
| unshift() | Add to start | fruits.unshift('Kiwi') |
| slice() | Get sub-array | fruits.slice(1, 3) |
| splice() | Add/remove items | fruits.splice(1, 0, 'Berry') |

---

## 🔹 Modern Array Methods (ES6+)
Powerful functional programming tools.

### 1. forEach()

fruits.forEach(fruit => console.log(fruit));

### 2. map()

const upperFruits = fruits.map(fruit => fruit.toUpperCase());

### 3. filter()

const longFruits = fruits.filter(fruit => fruit.length > 5);

### 4. reduce()

const sum = [1, 2, 3].reduce((total, num) => total + num, 0);

### 5. find() & findIndex()

const banana = fruits.find(fruit => fruit === 'Banana');
const bananaIndex = fruits.findIndex(fruit => fruit === 'Banana');

### 6. some() & every()

const hasApple = fruits.some(fruit => fruit === 'Apple');
const allLong = fruits.every(fruit => fruit.length > 3);

---

## 🔹 Objects in JavaScript
Collections of key-value pairs (properties).

### 1. Creating Objects

// Object literal (recommended)
const person = {
    name: 'Ali',
    age: 25,
    hobbies: ['reading', 'coding'],
    address: {
        city: 'Dubai',
        country: 'UAE'
    }
};

### 2. Accessing Properties

// Dot notation
console.log(person.name);  // "Ali"

// Bracket notation (useful for dynamic keys)
const key = 'age';
console.log(person[key]);  // 25

### 3. Modifying Objects

// Add property
person.job = 'Developer';

// Delete property
delete person.age;

// Check property existence
'name' in person;  // true

---

## 🔹 Object Methods
### 1. Object.keys()

const keys = Object.keys(person);  // ["name", "age", ...]

### 2. Object.values()

const values = Object.values(person);

### 3. Object.entries()

for (const [key, value] of Object.entries(person)) {
    console.log(`${key}: ${value}`);
}

### 4. Object Spread (ES9+)

const newPerson = {...person, age: 26};

---

## 🔹 JSON (JavaScript Object Notation)
Universal data format for APIs.

### 1. JSON ↔️ JavaScript

// Object to JSON string
const jsonStr = JSON.stringify(person);

// JSON string to object
const parsedObj = JSON.parse(jsonStr);

### 2. JSON Structure

{
    "name": "Ali",
    "age": 25,
    "isStudent": false,
    "courses": ["Math", "CS"]
}

---

## 🔹 Destructuring Assignment
Unpack values from arrays/objects.

### 1. Array Destructuring

const [first, second] = fruits;
console.log(first);  // "Apple"

### 2. Object Destructuring

const {name, age} = person;
console.log(name);  // "Ali"

// With renaming
const {name: personName} = person;

### 3. Function Parameter Destructuring

function printUser({name, age}) {
    console.log(`${name} is ${age} years old`);
}

---

## 🔹 Practical Example: Todo List Manager

const todoList = [
    {id: 1, task: 'Buy groceries', completed: false},
    {id: 2, task: 'Do laundry', completed: true}
];

// Add new task
function addTask(task) {
    const newTask = {
        id: todoList.length + 1,
        task,
        completed: false
    };
    todoList.push(newTask);
}

// Mark task as complete
function completeTask(id) {
    const task = todoList.find(item => item.id === id);
    if (task) task.completed = true;
}

// Get pending tasks
function getPendingTasks() {
    return todoList.filter(task => !task.completed);
}

---

## 🔹 Best Practices
1. Use `const` for arrays/objects (the reference is constant)
2. Prefer functional methods (map, filter) over loops
3. Validate JSON before parsing
4. Use descriptive property names
5. Destructure deeply nested objects carefully

---

### 📌 What's Next?
In Part 4, we'll cover:
➡️ DOM Manipulation
➡️ Event Handling
➡️ Form Validation

#JavaScript #WebDevelopment #Programming 🚀

Practice Exercise:
1. Create an array of products (name, price, inStock)
2. Write functions to:
- Filter out-of-stock products
- Calculate total inventory value
- Sort by price (high-to-low)
3. Convert your array to JSON and back

🔥 Trending Repository: LearnRust

📝 Description: Rust Learning Resources

🔗 Repository URL: https://github.com/ImplFerris/LearnRust

🌐 Website: https://implrust.com

📖 Readme: https://github.com/ImplFerris/LearnRust#readme

📊 Statistics:
🌟 Stars: 1.8K stars
👀 Watchers: 32
🍴 Forks: 188 forks

💻 Programming Languages: Not available

🏷️ Related Topics:

#rust #learning #programming #rust_lang #rust_tutorial #learn_rust #rust_programming

==================================
🧠 By: https://t.iss.one/DataScienceN