Java Advanced Features

Encryption and Decryption

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import java.security.MessageDigest;
import java.security.SecureRandom;

public class JCAOverview {
    public static void main(String[] args) throws Exception {

        // 1. Cipher -- the core encryption engine
        // Pattern: Cipher.getInstance("Algorithm/Mode/Padding")
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        System.out.println("Cipher algorithm: " + cipher.getAlgorithm());
        // Output: Cipher algorithm: AES/GCM/NoPadding

        // 2. KeyGenerator -- generates symmetric keys
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(256); // 256-bit AES key
        System.out.println("KeyGenerator algorithm: " + keyGen.getAlgorithm());
        // Output: KeyGenerator algorithm: AES

        // 3. MessageDigest -- hashing
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        System.out.println("MessageDigest algorithm: " + digest.getAlgorithm());
        // Output: MessageDigest algorithm: SHA-256

        // 4. SecureRandom -- cryptographically strong random numbers
        SecureRandom random = new SecureRandom();
        byte[] randomBytes = new byte[16];
        random.nextBytes(randomBytes);
        System.out.println("Generated " + randomBytes.length + " random bytes");
        // Output: Generated 16 random bytes

        // 5. List available providers
        for (java.security.Provider provider : java.security.Security.getProviders()) {
            System.out.println("Provider: " + provider.getName() + " v" + provider.getVersion());
        }
        // Output: Provider: SUN v22.0, Provider: SunJCE v22.0, ...
    }
}

import java.security.MessageDigest;
import java.nio.charset.StandardCharsets;

public class HashingExamples {
    public static void main(String[] args) throws Exception {

        String data = "Hello, World!";

        // SHA-256 hash
        String sha256Hash = hash(data, "SHA-256");
        System.out.println("SHA-256: " + sha256Hash);
        // Output: SHA-256: dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f

        // SHA-512 hash
        String sha512Hash = hash(data, "SHA-512");
        System.out.println("SHA-512: " + sha512Hash);
        // Output: SHA-512: 374d794a95cdcfd8b35993185fef9ba368f160d8daf432d08ba9f1ed1e5abe6cc69291e0fa2fe0006a52570ef18c19def4e617c33ce52ef0a6e5fbe318cb0387

        // MD5 (DO NOT use for security purposes)
        String md5Hash = hash(data, "MD5");
        System.out.println("MD5:    " + md5Hash);
        // Output: MD5:    65a8e27d8879283831b664bd8b7f0ad4

        // Demonstrate avalanche effect -- tiny change, completely different hash
        String data2 = "Hello, World?"; // changed ! to ?
        String hash2 = hash(data2, "SHA-256");
        System.out.println("\nOriginal:  " + sha256Hash);
        System.out.println("Modified:  " + hash2);
        // Completely different hashes despite one character difference
    }

    public static String hash(String data, String algorithm) throws Exception {
        MessageDigest digest = MessageDigest.getInstance(algorithm);
        byte[] hashBytes = digest.digest(data.getBytes(StandardCharsets.UTF_8));
        return bytesToHex(hashBytes);
    }

    private static String bytesToHex(byte[] bytes) {
        StringBuilder hexString = new StringBuilder();
        for (byte b : bytes) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }
        return hexString.toString();
    }
}

import java.security.MessageDigest;
import java.security.SecureRandom;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class SaltedHashing {
    public static void main(String[] args) throws Exception {

        String password = "mySecretPassword";

        // Generate a random salt (16 bytes = 128 bits)
        byte[] salt = generateSalt();
        System.out.println("Salt: " + Base64.getEncoder().encodeToString(salt));

        // Hash with salt
        String hashedPassword = hashWithSalt(password, salt);
        System.out.println("Hashed: " + hashedPassword);

        // Verify -- same password + same salt = same hash
        String verifyHash = hashWithSalt(password, salt);
        System.out.println("Verified: " + hashedPassword.equals(verifyHash));
        // Output: Verified: true

        // Different password = different hash
        String wrongHash = hashWithSalt("wrongPassword", salt);
        System.out.println("Wrong password match: " + hashedPassword.equals(wrongHash));
        // Output: Wrong password match: false
    }

    public static byte[] generateSalt() {
        byte[] salt = new byte[16];
        new SecureRandom().nextBytes(salt);
        return salt;
    }

    public static String hashWithSalt(String password, byte[] salt) throws Exception {
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        digest.update(salt); // add salt first
        byte[] hashBytes = digest.digest(password.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(hashBytes);
    }
}

import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class AESKeyGeneration {
    public static void main(String[] args) throws Exception {

        // Generate a new AES-256 key
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(256); // 128, 192, or 256 bits
        SecretKey secretKey = keyGen.generateKey();

        // Convert key to Base64 string (for storage)
        String encodedKey = Base64.getEncoder().encodeToString(secretKey.getEncoded());
        System.out.println("AES Key (Base64): " + encodedKey);
        System.out.println("Key length: " + secretKey.getEncoded().length + " bytes");
        // Output: Key length: 32 bytes (256 bits)

        // Reconstruct key from Base64 string
        byte[] decodedKey = Base64.getDecoder().decode(encodedKey);
        SecretKey reconstructedKey = new SecretKeySpec(decodedKey, "AES");
        System.out.println("Keys match: " + secretKey.equals(reconstructedKey));
        // Output: Keys match: true
    }
}

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.GCMParameterSpec;
import java.security.SecureRandom;
import java.util.Base64;

public class AESGCMEncryption {

    private static final int GCM_IV_LENGTH = 12;     // 96 bits (recommended for GCM)
    private static final int GCM_TAG_LENGTH = 128;    // 128 bits authentication tag

    public static void main(String[] args) throws Exception {

        // Generate AES-256 key
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(256);
        SecretKey secretKey = keyGen.generateKey();

        String plaintext = "This is a secret message that needs to be encrypted.";
        System.out.println("Original:  " + plaintext);

        // Encrypt
        String encrypted = encrypt(plaintext, secretKey);
        System.out.println("Encrypted: " + encrypted);

        // Decrypt
        String decrypted = decrypt(encrypted, secretKey);
        System.out.println("Decrypted: " + decrypted);

        // Verify
        System.out.println("Match: " + plaintext.equals(decrypted));
        // Output: Match: true

        // Encrypting the same text again produces DIFFERENT ciphertext (because of random IV)
        String encrypted2 = encrypt(plaintext, secretKey);
        System.out.println("\nSame plaintext, different ciphertext:");
        System.out.println("Encryption 1: " + encrypted);
        System.out.println("Encryption 2: " + encrypted2);
        System.out.println("Same ciphertext? " + encrypted.equals(encrypted2));
        // Output: Same ciphertext? false (because IV is different each time)
    }

    public static String encrypt(String plaintext, SecretKey key) throws Exception {
        // Generate a random IV
        byte[] iv = new byte[GCM_IV_LENGTH];
        new SecureRandom().nextBytes(iv);

        // Initialize cipher for encryption
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        GCMParameterSpec gcmSpec = new GCMParameterSpec(GCM_TAG_LENGTH, iv);
        cipher.init(Cipher.ENCRYPT_MODE, key, gcmSpec);

        // Encrypt
        byte[] ciphertext = cipher.doFinal(plaintext.getBytes("UTF-8"));

        // Prepend IV to ciphertext (IV is needed for decryption but is not secret)
        byte[] ivAndCiphertext = new byte[iv.length + ciphertext.length];
        System.arraycopy(iv, 0, ivAndCiphertext, 0, iv.length);
        System.arraycopy(ciphertext, 0, ivAndCiphertext, iv.length, ciphertext.length);

        return Base64.getEncoder().encodeToString(ivAndCiphertext);
    }

    public static String decrypt(String encryptedBase64, SecretKey key) throws Exception {
        byte[] ivAndCiphertext = Base64.getDecoder().decode(encryptedBase64);

        // Extract IV from the beginning
        byte[] iv = new byte[GCM_IV_LENGTH];
        System.arraycopy(ivAndCiphertext, 0, iv, 0, iv.length);

        // Extract ciphertext (rest of the bytes)
        byte[] ciphertext = new byte[ivAndCiphertext.length - iv.length];
        System.arraycopy(ivAndCiphertext, iv.length, ciphertext, 0, ciphertext.length);

        // Initialize cipher for decryption
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        GCMParameterSpec gcmSpec = new GCMParameterSpec(GCM_TAG_LENGTH, iv);
        cipher.init(Cipher.DECRYPT_MODE, key, gcmSpec);

        // Decrypt
        byte[] plaintext = cipher.doFinal(ciphertext);
        return new String(plaintext, "UTF-8");
    }
}

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import java.security.SecureRandom;
import java.util.Base64;

public class AESCBCEncryption {

    private static final int IV_SIZE = 16; // 128 bits for AES block size

    public static String encrypt(String plaintext, SecretKey key) throws Exception {
        // Generate random IV
        byte[] iv = new byte[IV_SIZE];
        new SecureRandom().nextBytes(iv);

        // Initialize cipher
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(iv));

        // Encrypt
        byte[] ciphertext = cipher.doFinal(plaintext.getBytes("UTF-8"));

        // Prepend IV to ciphertext
        byte[] result = new byte[iv.length + ciphertext.length];
        System.arraycopy(iv, 0, result, 0, iv.length);
        System.arraycopy(ciphertext, 0, result, iv.length, ciphertext.length);

        return Base64.getEncoder().encodeToString(result);
    }

    public static String decrypt(String encryptedBase64, SecretKey key) throws Exception {
        byte[] data = Base64.getDecoder().decode(encryptedBase64);

        // Extract IV
        byte[] iv = new byte[IV_SIZE];
        System.arraycopy(data, 0, iv, 0, iv.length);

        // Extract ciphertext
        byte[] ciphertext = new byte[data.length - iv.length];
        System.arraycopy(data, iv.length, ciphertext, 0, ciphertext.length);

        // Decrypt
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(iv));

        return new String(cipher.doFinal(ciphertext), "UTF-8");
    }

    public static void main(String[] args) throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(256);
        SecretKey key = keyGen.generateKey();

        String message = "AES-CBC encryption example";
        String encrypted = encrypt(message, key);
        String decrypted = decrypt(encrypted, key);

        System.out.println("Original:  " + message);
        System.out.println("Encrypted: " + encrypted);
        System.out.println("Decrypted: " + decrypted);
        // Output:
        // Original:  AES-CBC encryption example
        // Encrypted: (Base64 string - different each time due to random IV)
        // Decrypted: AES-CBC encryption example
    }
}

import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;

public class RSAEncryption {
    public static void main(String[] args) throws Exception {

        // Generate RSA key pair (2048 bits minimum, 4096 for high security)
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
        keyGen.initialize(2048);
        KeyPair keyPair = keyGen.generateKeyPair();

        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();

        System.out.println("Public key format: " + publicKey.getFormat());
        // Output: Public key format: X.509
        System.out.println("Private key format: " + privateKey.getFormat());
        // Output: Private key format: PKCS#8

        // Encrypt with public key
        String plaintext = "Secret message for RSA";
        String encrypted = encrypt(plaintext, publicKey);
        System.out.println("Encrypted: " + encrypted);

        // Decrypt with private key
        String decrypted = decrypt(encrypted, privateKey);
        System.out.println("Decrypted: " + decrypted);
        // Output: Decrypted: Secret message for RSA
    }

    public static String encrypt(String plaintext, PublicKey publicKey) throws Exception {
        // Use RSA with OAEP padding (recommended over PKCS1)
        Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] ciphertext = cipher.doFinal(plaintext.getBytes("UTF-8"));
        return Base64.getEncoder().encodeToString(ciphertext);
    }

    public static String decrypt(String encryptedBase64, PrivateKey privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] plaintext = cipher.doFinal(Base64.getDecoder().decode(encryptedBase64));
        return new String(plaintext, "UTF-8");
    }
}

import java.security.*;
import java.util.Base64;

public class DigitalSignatureExample {
    public static void main(String[] args) throws Exception {

        // Generate key pair
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
        keyGen.initialize(2048);
        KeyPair keyPair = keyGen.generateKeyPair();

        String message = "This document was signed by me.";

        // Sign with private key
        String signature = sign(message, keyPair.getPrivate());
        System.out.println("Signature: " + signature);

        // Verify with public key
        boolean isValid = verify(message, signature, keyPair.getPublic());
        System.out.println("Signature valid: " + isValid);
        // Output: Signature valid: true

        // Tamper with the message
        boolean isTamperedValid = verify("This document was NOT signed by me.", signature, keyPair.getPublic());
        System.out.println("Tampered message valid: " + isTamperedValid);
        // Output: Tampered message valid: false
    }

    public static String sign(String data, PrivateKey privateKey) throws Exception {
        Signature signer = Signature.getInstance("SHA256withRSA");
        signer.initSign(privateKey);
        signer.update(data.getBytes("UTF-8"));
        byte[] signatureBytes = signer.sign();
        return Base64.getEncoder().encodeToString(signatureBytes);
    }

    public static boolean verify(String data, String signatureBase64, PublicKey publicKey) throws Exception {
        Signature verifier = Signature.getInstance("SHA256withRSA");
        verifier.initVerify(publicKey);
        verifier.update(data.getBytes("UTF-8"));
        byte[] signatureBytes = Base64.getDecoder().decode(signatureBase64);
        return verifier.verify(signatureBytes);
    }
}

import java.util.Base64;
import java.nio.charset.StandardCharsets;

public class Base64Examples {
    public static void main(String[] args) {

        String original = "Hello, Java Encryption!";

        // Basic encoding/decoding
        String encoded = Base64.getEncoder().encodeToString(original.getBytes(StandardCharsets.UTF_8));
        System.out.println("Encoded: " + encoded);
        // Output: Encoded: SGVsbG8sIEphdmEgRW5jcnlwdGlvbiE=

        String decoded = new String(Base64.getDecoder().decode(encoded), StandardCharsets.UTF_8);
        System.out.println("Decoded: " + decoded);
        // Output: Decoded: Hello, Java Encryption!

        // URL-safe encoding (replaces + with - and / with _)
        byte[] binaryData = {(byte) 0xFF, (byte) 0xFE, (byte) 0xFD, (byte) 0xFC};
        String urlSafe = Base64.getUrlEncoder().encodeToString(binaryData);
        System.out.println("URL-safe: " + urlSafe);
        // Output: URL-safe: __79_A==

        // URL-safe without padding (no trailing = signs)
        String urlSafeNoPadding = Base64.getUrlEncoder().withoutPadding().encodeToString(binaryData);
        System.out.println("URL-safe (no padding): " + urlSafeNoPadding);
        // Output: URL-safe (no padding): __79_A

        // Encoding binary data (like encrypted bytes) for storage as text
        byte[] encryptedBytes = new byte[]{0x12, 0x34, 0x56, 0x78, (byte) 0x9A, (byte) 0xBC};
        String storable = Base64.getEncoder().encodeToString(encryptedBytes);
        System.out.println("Binary as text: " + storable);
        // Output: Binary as text: EjRWeJq8

        // Decode back to original bytes
        byte[] restored = Base64.getDecoder().decode(storable);
        System.out.println("Bytes match: " + java.util.Arrays.equals(encryptedBytes, restored));
        // Output: Bytes match: true
    }
}

import javax.crypto.Mac;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class HMACExample {
    public static void main(String[] args) throws Exception {

        // Generate a key for HMAC
        KeyGenerator keyGen = KeyGenerator.getInstance("HmacSHA256");
        SecretKey hmacKey = keyGen.generateKey();

        String message = "Order #12345: $99.99 charged to card ending in 4242";

        // Generate HMAC
        String hmac = generateHMAC(message, hmacKey);
        System.out.println("Message: " + message);
        System.out.println("HMAC:    " + hmac);

        // Verify HMAC -- same message + same key = same HMAC
        String verifyHmac = generateHMAC(message, hmacKey);
        System.out.println("Valid: " + hmac.equals(verifyHmac));
        // Output: Valid: true

        // Tampered message produces different HMAC
        String tamperedMessage = "Order #12345: $9999.99 charged to card ending in 4242";
        String tamperedHmac = generateHMAC(tamperedMessage, hmacKey);
        System.out.println("Tampered valid: " + hmac.equals(tamperedHmac));
        // Output: Tampered valid: false

        // Using a string-based key (common for API integrations)
        String apiSecret = "my-api-secret-key-do-not-share";
        SecretKeySpec stringKey = new SecretKeySpec(
            apiSecret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"
        );
        String apiHmac = generateHMAC("webhook-payload-data", stringKey);
        System.out.println("API HMAC: " + apiHmac);
    }

    public static String generateHMAC(String data, SecretKey key) throws Exception {
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(key);
        byte[] hmacBytes = mac.doFinal(data.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(hmacBytes);
    }
}

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;

public class WebhookVerification {

    /**
     * Verify a webhook signature.
     * The sender computes HMAC-SHA256 of the body using a shared secret
     * and sends it in the X-Signature header.
     */
    public static boolean verifyWebhook(String payload, String receivedSignature, String secret)
            throws Exception {

        SecretKeySpec key = new SecretKeySpec(
            secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"
        );

        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(key);
        byte[] computedBytes = mac.doFinal(payload.getBytes(StandardCharsets.UTF_8));

        // Convert to hex string for comparison
        StringBuilder hex = new StringBuilder();
        for (byte b : computedBytes) {
            hex.append(String.format("%02x", b));
        }
        String computedSignature = hex.toString();

        // Use constant-time comparison to prevent timing attacks
        return java.security.MessageDigest.isEqual(
            computedSignature.getBytes(),
            receivedSignature.getBytes()
        );
    }

    public static void main(String[] args) throws Exception {
        String webhookBody = "{\"event\":\"payment.completed\",\"amount\":9999}";
        String sharedSecret = "whsec_test_secret_key";

        // Simulate: sender computes signature
        SecretKeySpec key = new SecretKeySpec(
            sharedSecret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"
        );
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(key);
        byte[] sigBytes = mac.doFinal(webhookBody.getBytes(StandardCharsets.UTF_8));
        StringBuilder sigHex = new StringBuilder();
        for (byte b : sigBytes) {
            sigHex.append(String.format("%02x", b));
        }

        // Receiver verifies
        boolean valid = verifyWebhook(webhookBody, sigHex.toString(), sharedSecret);
        System.out.println("Webhook signature valid: " + valid);
        // Output: Webhook signature valid: true

        // Tampered payload fails
        boolean tampered = verifyWebhook(
            "{\"event\":\"payment.completed\",\"amount\":0}",
            sigHex.toString(), sharedSecret
        );
        System.out.println("Tampered webhook valid: " + tampered);
        // Output: Tampered webhook valid: false
    }
}

// Using Spring Security's BCryptPasswordEncoder (most common in Java projects)
// Add dependency: org.springframework.security:spring-security-crypto

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

public class BCryptPasswordExample {
    public static void main(String[] args) {

        BCryptPasswordEncoder encoder = new BCryptPasswordEncoder(12); // work factor = 12

        String rawPassword = "MySecureP@ssw0rd!";

        // Hash the password (salt is generated automatically)
        String hashedPassword = encoder.encode(rawPassword);
        System.out.println("Hashed: " + hashedPassword);
        // Output: Hashed: $2a$12$LJ/3Xq... (60 characters, different each time)

        // Hashing the same password again gives a DIFFERENT hash (different salt)
        String hashedPassword2 = encoder.encode(rawPassword);
        System.out.println("Hashed again: " + hashedPassword2);
        System.out.println("Same hash? " + hashedPassword.equals(hashedPassword2));
        // Output: Same hash? false (because salt is different)

        // Verify password -- this is how you check login credentials
        boolean matches = encoder.matches(rawPassword, hashedPassword);
        System.out.println("Correct password: " + matches);
        // Output: Correct password: true

        boolean wrongMatch = encoder.matches("WrongPassword", hashedPassword);
        System.out.println("Wrong password: " + wrongMatch);
        // Output: Wrong password: false
    }
}

import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import java.security.SecureRandom;
import java.util.Base64;

public class PBKDF2PasswordHashing {

    private static final int ITERATIONS = 210_000;  // OWASP recommendation (2023+)
    private static final int KEY_LENGTH = 256;       // bits
    private static final int SALT_LENGTH = 16;       // bytes

    public static void main(String[] args) throws Exception {

        String password = "MySecureP@ssw0rd!";

        // Hash the password
        String stored = hashPassword(password);
        System.out.println("Stored: " + stored);
        // Output: Stored: 210000:BASE64_SALT:BASE64_HASH

        // Verify
        boolean valid = verifyPassword(password, stored);
        System.out.println("Valid: " + valid);
        // Output: Valid: true

        boolean invalid = verifyPassword("WrongPassword", stored);
        System.out.println("Wrong password: " + invalid);
        // Output: Wrong password: false
    }

    public static String hashPassword(String password) throws Exception {
        // Generate random salt
        byte[] salt = new byte[SALT_LENGTH];
        new SecureRandom().nextBytes(salt);

        // Hash with PBKDF2
        PBEKeySpec spec = new PBEKeySpec(
            password.toCharArray(), salt, ITERATIONS, KEY_LENGTH
        );
        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
        byte[] hash = factory.generateSecret(spec).getEncoded();

        // Store iterations:salt:hash (all needed to verify later)
        return ITERATIONS + ":"
            + Base64.getEncoder().encodeToString(salt) + ":"
            + Base64.getEncoder().encodeToString(hash);
    }

    public static boolean verifyPassword(String password, String stored) throws Exception {
        String[] parts = stored.split(":");
        int iterations = Integer.parseInt(parts[0]);
        byte[] salt = Base64.getDecoder().decode(parts[1]);
        byte[] expectedHash = Base64.getDecoder().decode(parts[2]);

        // Hash the input password with the same salt and iterations
        PBEKeySpec spec = new PBEKeySpec(
            password.toCharArray(), salt, iterations, expectedHash.length * 8
        );
        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
        byte[] actualHash = factory.generateSecret(spec).getEncoded();

        // Constant-time comparison to prevent timing attacks
        return java.security.MessageDigest.isEqual(expectedHash, actualHash);
    }
}

import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.CipherOutputStream;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.GCMParameterSpec;
import java.io.*;
import java.security.SecureRandom;

public class FileEncryption {

    private static final int GCM_IV_LENGTH = 12;
    private static final int GCM_TAG_LENGTH = 128;

    public static void encryptFile(File inputFile, File outputFile, SecretKey key)
            throws Exception {

        byte[] iv = new byte[GCM_IV_LENGTH];
        new SecureRandom().nextBytes(iv);

        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        cipher.init(Cipher.ENCRYPT_MODE, key, new GCMParameterSpec(GCM_TAG_LENGTH, iv));

        try (FileOutputStream fos = new FileOutputStream(outputFile)) {
            // Write IV first (needed for decryption)
            fos.write(iv);

            try (FileInputStream fis = new FileInputStream(inputFile);
                 CipherOutputStream cos = new CipherOutputStream(fos, cipher)) {

                byte[] buffer = new byte[8192];
                int bytesRead;
                while ((bytesRead = fis.read(buffer)) != -1) {
                    cos.write(buffer, 0, bytesRead);
                }
            }
        }
    }

    public static void decryptFile(File inputFile, File outputFile, SecretKey key)
            throws Exception {

        try (FileInputStream fis = new FileInputStream(inputFile)) {
            // Read IV
            byte[] iv = new byte[GCM_IV_LENGTH];
            fis.read(iv);

            Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
            cipher.init(Cipher.DECRYPT_MODE, key, new GCMParameterSpec(GCM_TAG_LENGTH, iv));

            try (CipherInputStream cis = new CipherInputStream(fis, cipher);
                 FileOutputStream fos = new FileOutputStream(outputFile)) {

                byte[] buffer = new byte[8192];
                int bytesRead;
                while ((bytesRead = cis.read(buffer)) != -1) {
                    fos.write(buffer, 0, bytesRead);
                }
            }
        }
    }

    public static void main(String[] args) throws Exception {
        // Generate key
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(256);
        SecretKey key = keyGen.generateKey();

        // Create a test file
        File original = new File("secret_document.txt");
        try (FileWriter fw = new FileWriter(original)) {
            fw.write("This is my secret document with sensitive information.");
        }

        // Encrypt
        File encrypted = new File("secret_document.enc");
        encryptFile(original, encrypted, key);
        System.out.println("File encrypted: " + encrypted.getName());
        System.out.println("Original size: " + original.length() + " bytes");
        System.out.println("Encrypted size: " + encrypted.length() + " bytes");

        // Decrypt
        File decrypted = new File("secret_document_decrypted.txt");
        decryptFile(encrypted, decrypted, key);
        System.out.println("File decrypted: " + decrypted.getName());

        // Verify
        try (BufferedReader br = new BufferedReader(new FileReader(decrypted))) {
            System.out.println("Content: " + br.readLine());
        }
        // Output: Content: This is my secret document with sensitive information.

        // Cleanup
        original.delete();
        encrypted.delete();
        decrypted.delete();
    }
}

import java.security.SecureRandom;
import java.util.Base64;

public class SecureTokenGenerator {

    private static final SecureRandom secureRandom = new SecureRandom();

    /**
     * Generate a URL-safe token (for password reset links, API keys, etc.)
     */
    public static String generateToken(int byteLength) {
        byte[] tokenBytes = new byte[byteLength];
        secureRandom.nextBytes(tokenBytes);
        return Base64.getUrlEncoder().withoutPadding().encodeToString(tokenBytes);
    }

    /**
     * Generate a hex token (for session IDs, CSRF tokens)
     */
    public static String generateHexToken(int byteLength) {
        byte[] tokenBytes = new byte[byteLength];
        secureRandom.nextBytes(tokenBytes);
        StringBuilder hex = new StringBuilder();
        for (byte b : tokenBytes) {
            hex.append(String.format("%02x", b));
        }
        return hex.toString();
    }

    /**
     * Generate a numeric OTP (for SMS verification, 2FA)
     */
    public static String generateOTP(int digits) {
        int max = (int) Math.pow(10, digits);
        int otp = secureRandom.nextInt(max);
        return String.format("%0" + digits + "d", otp);
    }

    public static void main(String[] args) {
        // API key (32 bytes = 256 bits of entropy)
        System.out.println("API Key:     " + generateToken(32));
        // Output: API Key:     xK9mPq... (43 characters, URL-safe)

        // Session ID (16 bytes = 128 bits)
        System.out.println("Session ID:  " + generateHexToken(16));
        // Output: Session ID:  a1b2c3d4e5f6... (32 hex characters)

        // Password reset token (24 bytes = 192 bits)
        System.out.println("Reset Token: " + generateToken(24));
        // Output: Reset Token:  Mj7kL2... (32 characters, URL-safe)

        // 6-digit OTP
        System.out.println("OTP:         " + generateOTP(6));
        // Output: OTP:         384729

        // NEVER use java.util.Random for security tokens!
        // Random is predictable. SecureRandom uses OS entropy sources.
    }
}

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;

public class ConfigEncryptor {

    private static final int GCM_IV_LENGTH = 12;
    private static final int GCM_TAG_LENGTH = 128;
    private static final String PREFIX = "ENC(";
    private static final String SUFFIX = ")";

    private final SecretKey key;

    public ConfigEncryptor(String base64Key) {
        byte[] keyBytes = Base64.getDecoder().decode(base64Key);
        this.key = new SecretKeySpec(keyBytes, "AES");
    }

    public String encryptValue(String plaintext) throws Exception {
        byte[] iv = new byte[GCM_IV_LENGTH];
        new SecureRandom().nextBytes(iv);

        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        cipher.init(Cipher.ENCRYPT_MODE, key, new GCMParameterSpec(GCM_TAG_LENGTH, iv));
        byte[] ciphertext = cipher.doFinal(plaintext.getBytes("UTF-8"));

        byte[] combined = new byte[iv.length + ciphertext.length];
        System.arraycopy(iv, 0, combined, 0, iv.length);
        System.arraycopy(ciphertext, 0, combined, iv.length, ciphertext.length);

        return PREFIX + Base64.getEncoder().encodeToString(combined) + SUFFIX;
    }

    public String decryptValue(String encryptedValue) throws Exception {
        // Strip ENC(...) wrapper
        String base64 = encryptedValue.substring(PREFIX.length(), encryptedValue.length() - SUFFIX.length());
        byte[] combined = Base64.getDecoder().decode(base64);

        byte[] iv = new byte[GCM_IV_LENGTH];
        System.arraycopy(combined, 0, iv, 0, iv.length);
        byte[] ciphertext = new byte[combined.length - iv.length];
        System.arraycopy(combined, iv.length, ciphertext, 0, ciphertext.length);

        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        cipher.init(Cipher.DECRYPT_MODE, key, new GCMParameterSpec(GCM_TAG_LENGTH, iv));
        return new String(cipher.doFinal(ciphertext), "UTF-8");
    }

    public boolean isEncrypted(String value) {
        return value.startsWith(PREFIX) && value.endsWith(SUFFIX);
    }

    public static void main(String[] args) throws Exception {
        // In production, this key comes from environment variable or key vault
        // Generate once: Base64.getEncoder().encodeToString(KeyGenerator...generateKey().getEncoded())
        String masterKey = "k7Hn3pRqSvWxYz1A2bCdEfGhIjKlMnOp4qRsTuVw5X8=";

        ConfigEncryptor encryptor = new ConfigEncryptor(masterKey);

        // Encrypt sensitive config values
        Map config = new HashMap<>();
        config.put("db.url", "jdbc:mysql://localhost:3306/mydb");
        config.put("db.password", encryptor.encryptValue("SuperSecret123!"));
        config.put("api.key", encryptor.encryptValue("sk-abc123def456"));

        // Print config (safe to commit to version control)
        System.out.println("=== Encrypted Config ===");
        for (Map.Entry entry : config.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }
        // Output:
        // db.url = jdbc:mysql://localhost:3306/mydb
        // db.password = ENC(base64encodeddata...)
        // api.key = ENC(base64encodeddata...)

        // At runtime, decrypt the values
        System.out.println("\n=== Decrypted at Runtime ===");
        for (Map.Entry entry : config.entrySet()) {
            String value = entry.getValue();
            if (encryptor.isEncrypted(value)) {
                value = encryptor.decryptValue(value);
            }
            System.out.println(entry.getKey() + " = " + value);
        }
        // Output:
        // db.url = jdbc:mysql://localhost:3306/mydb
        // db.password = SuperSecret123!
        // api.key = sk-abc123def456
    }
}

// WRONG -- ECB mode leaks patterns
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding"); // NEVER DO THIS
cipher.init(Cipher.ENCRYPT_MODE, key);

// Encrypting "AAAAAAAAAAAAAAAA" twice produces the SAME ciphertext
// An attacker can see which blocks are identical

// RIGHT -- Use GCM mode (provides encryption + authentication)
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
byte[] iv = new byte[12];
new SecureRandom().nextBytes(iv);
cipher.init(Cipher.ENCRYPT_MODE, key, new GCMParameterSpec(128, iv));

// WRONG -- key is visible in source code and version control
private static final String SECRET_KEY = "MyHardcodedKey123";

// WRONG -- key is in a config file committed to Git
// application.properties: encryption.key=MyHardcodedKey123

// RIGHT -- key comes from environment variable
String key = System.getenv("ENCRYPTION_KEY");
if (key == null) {
    throw new IllegalStateException("ENCRYPTION_KEY environment variable not set");
}

// RIGHT -- key comes from a secrets manager (AWS Secrets Manager, HashiCorp Vault)
// String key = secretsManager.getSecret("encryption-key");

import java.util.Random;
import java.security.SecureRandom;

// WRONG -- java.util.Random is predictable (uses a linear congruential generator)
// If an attacker knows the seed, they can predict ALL future values
Random insecureRandom = new Random();
byte[] iv = new byte[16];
insecureRandom.nextBytes(iv); // PREDICTABLE IV -- defeats the purpose of encryption

// RIGHT -- SecureRandom uses OS entropy (e.g., /dev/urandom on Linux)
SecureRandom secureRandom = new SecureRandom();
byte[] safeIv = new byte[16];
secureRandom.nextBytes(safeIv); // Cryptographically unpredictable

// WRONG -- MD5 has known collision attacks since 2004
MessageDigest md5 = MessageDigest.getInstance("MD5");
byte[] hash = md5.digest(data.getBytes()); // Two different inputs can produce the same hash

// WRONG -- SHA-1 has been broken since 2017 (Google's SHAttered attack)
MessageDigest sha1 = MessageDigest.getInstance("SHA-1");

// RIGHT -- Use SHA-256 or SHA-512
MessageDigest sha256 = MessageDigest.getInstance("SHA-256");

// For passwords, do NOT use any SHA variant -- use bcrypt/scrypt/Argon2

// WRONG -- AES-CBC without HMAC. An attacker can modify the ciphertext
// and you will decrypt garbage without knowing it was tampered with.
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
// ... encrypt ...
// No way to detect if ciphertext was modified!

// RIGHT -- AES-GCM provides authenticated encryption.
// If the ciphertext is modified, decryption throws AEADBadTagException.
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
// ... encrypt ...
// Decryption automatically verifies integrity via the authentication tag

// WRONG -- Using a fixed IV
private static final byte[] FIXED_IV = new byte[12]; // all zeros
// Same key + same IV + different plaintexts = complete security failure in GCM mode

// WRONG -- Using a counter without proper management
int counter = 0;
byte[] iv = ByteBuffer.allocate(12).putInt(counter++).array();
// If the counter resets (app restart), you reuse IVs!

// RIGHT -- Always generate a random IV for each encryption
byte[] iv = new byte[12];
new SecureRandom().nextBytes(iv); // Fresh random IV every time

// WRONG -- Inventing your own "encryption" algorithm
public static String myEncrypt(String text) {
    StringBuilder result = new StringBuilder();
    for (char c : text.toCharArray()) {
        result.append((char) (c + 3)); // Caesar cipher -- trivially broken
    }
    return result.toString();
}

// WRONG -- XOR "encryption" with a repeated key
public static byte[] xorEncrypt(byte[] data, byte[] key) {
    byte[] result = new byte[data.length];
    for (int i = 0; i < data.length; i++) {
        result[i] = (byte) (data[i] ^ key[i % key.length]); // trivially broken
    }
    return result;
}

// RIGHT -- Use standard algorithms that have been analyzed by cryptographers
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
// AES has been analyzed by thousands of cryptographers since 1998
// and is approved for TOP SECRET government data

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Base64;

/**
 * SecureVault -- a utility class for common cryptographic operations.
 *
 * Features:
 * - AES-256-GCM encryption/decryption (authenticated encryption)
 * - PBKDF2 password hashing with salt
 * - HMAC-SHA256 message authentication
 * - Cryptographically secure token generation
 * - SHA-256 hashing for data integrity
 */
public class SecureVault {

    private static final int GCM_IV_LENGTH = 12;       // 96 bits
    private static final int GCM_TAG_LENGTH = 128;      // 128 bits
    private static final int PBKDF2_ITERATIONS = 210_000;
    private static final int PBKDF2_KEY_LENGTH = 256;   // bits
    private static final int SALT_LENGTH = 16;           // bytes

    private final SecureRandom secureRandom = new SecureRandom();

    // ===== ENCRYPTION / DECRYPTION (AES-256-GCM) =====

    /**
     * Generate a new AES-256 encryption key.
     */
    public SecretKey generateEncryptionKey() throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(256);
        return keyGen.generateKey();
    }

    /**
     * Reconstruct a key from its Base64-encoded form.
     */
    public SecretKey keyFromBase64(String base64Key) {
        byte[] keyBytes = Base64.getDecoder().decode(base64Key);
        return new SecretKeySpec(keyBytes, "AES");
    }

    /**
     * Export a key as a Base64 string (for secure storage).
     */
    public String keyToBase64(SecretKey key) {
        return Base64.getEncoder().encodeToString(key.getEncoded());
    }

    /**
     * Encrypt a string using AES-256-GCM.
     * The IV is prepended to the ciphertext in the output.
     */
    public String encrypt(String plaintext, SecretKey key) throws Exception {
        byte[] iv = new byte[GCM_IV_LENGTH];
        secureRandom.nextBytes(iv);

        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        cipher.init(Cipher.ENCRYPT_MODE, key, new GCMParameterSpec(GCM_TAG_LENGTH, iv));
        byte[] ciphertext = cipher.doFinal(plaintext.getBytes(StandardCharsets.UTF_8));

        byte[] combined = new byte[iv.length + ciphertext.length];
        System.arraycopy(iv, 0, combined, 0, iv.length);
        System.arraycopy(ciphertext, 0, combined, iv.length, ciphertext.length);

        return Base64.getEncoder().encodeToString(combined);
    }

    /**
     * Decrypt a string that was encrypted with encrypt().
     * Throws AEADBadTagException if the ciphertext was tampered with.
     */
    public String decrypt(String encryptedBase64, SecretKey key) throws Exception {
        byte[] combined = Base64.getDecoder().decode(encryptedBase64);

        byte[] iv = Arrays.copyOfRange(combined, 0, GCM_IV_LENGTH);
        byte[] ciphertext = Arrays.copyOfRange(combined, GCM_IV_LENGTH, combined.length);

        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        cipher.init(Cipher.DECRYPT_MODE, key, new GCMParameterSpec(GCM_TAG_LENGTH, iv));
        byte[] plaintext = cipher.doFinal(ciphertext);

        return new String(plaintext, StandardCharsets.UTF_8);
    }

    // ===== PASSWORD HASHING (PBKDF2) =====

    /**
     * Hash a password using PBKDF2-HMAC-SHA256.
     * Returns: "iterations:base64Salt:base64Hash"
     */
    public String hashPassword(String password) throws Exception {
        byte[] salt = new byte[SALT_LENGTH];
        secureRandom.nextBytes(salt);

        byte[] hash = pbkdf2(password.toCharArray(), salt, PBKDF2_ITERATIONS, PBKDF2_KEY_LENGTH);

        return PBKDF2_ITERATIONS + ":"
            + Base64.getEncoder().encodeToString(salt) + ":"
            + Base64.getEncoder().encodeToString(hash);
    }

    /**
     * Verify a password against a stored hash.
     */
    public boolean verifyPassword(String password, String storedHash) throws Exception {
        String[] parts = storedHash.split(":");
        int iterations = Integer.parseInt(parts[0]);
        byte[] salt = Base64.getDecoder().decode(parts[1]);
        byte[] expectedHash = Base64.getDecoder().decode(parts[2]);

        byte[] actualHash = pbkdf2(password.toCharArray(), salt, iterations, expectedHash.length * 8);

        return MessageDigest.isEqual(expectedHash, actualHash);
    }

    private byte[] pbkdf2(char[] password, byte[] salt, int iterations, int keyLength)
            throws Exception {
        PBEKeySpec spec = new PBEKeySpec(password, salt, iterations, keyLength);
        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
        return factory.generateSecret(spec).getEncoded();
    }

    // ===== HMAC (Message Authentication) =====

    /**
     * Generate an HMAC-SHA256 for data integrity verification.
     */
    public String hmac(String data, SecretKey key) throws Exception {
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(key);
        byte[] hmacBytes = mac.doFinal(data.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(hmacBytes);
    }

    /**
     * Verify an HMAC using constant-time comparison.
     */
    public boolean verifyHmac(String data, String expectedHmac, SecretKey key) throws Exception {
        String actualHmac = hmac(data, key);
        return MessageDigest.isEqual(
            actualHmac.getBytes(StandardCharsets.UTF_8),
            expectedHmac.getBytes(StandardCharsets.UTF_8)
        );
    }

    // ===== HASHING (SHA-256) =====

    /**
     * Hash data using SHA-256 (for data integrity, NOT passwords).
     */
    public String sha256(String data) throws Exception {
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hashBytes = digest.digest(data.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(hashBytes);
    }

    // ===== TOKEN GENERATION =====

    /**
     * Generate a URL-safe random token.
     */
    public String generateToken(int byteLength) {
        byte[] tokenBytes = new byte[byteLength];
        secureRandom.nextBytes(tokenBytes);
        return Base64.getUrlEncoder().withoutPadding().encodeToString(tokenBytes);
    }

    /**
     * Generate a numeric OTP.
     */
    public String generateOTP(int digits) {
        int max = (int) Math.pow(10, digits);
        int otp = secureRandom.nextInt(max);
        return String.format("%0" + digits + "d", otp);
    }
}

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public class SecureVaultDemo {
    public static void main(String[] args) throws Exception {

        SecureVault vault = new SecureVault();

        System.out.println("===== SecureVault Demo =====\n");

        // ---- 1. Encryption / Decryption ----
        System.out.println("--- 1. AES-256-GCM Encryption ---");
        SecretKey encKey = vault.generateEncryptionKey();
        String keyBase64 = vault.keyToBase64(encKey);
        System.out.println("Key (Base64): " + keyBase64);

        String secret = "My credit card number is 4111-1111-1111-1111";
        String encrypted = vault.encrypt(secret, encKey);
        System.out.println("Plaintext:  " + secret);
        System.out.println("Encrypted:  " + encrypted);

        String decrypted = vault.decrypt(encrypted, encKey);
        System.out.println("Decrypted:  " + decrypted);
        System.out.println("Match: " + secret.equals(decrypted));

        // Same plaintext, different ciphertext (random IV)
        String encrypted2 = vault.encrypt(secret, encKey);
        System.out.println("Same ciphertext? " + encrypted.equals(encrypted2));
        // Output: Same ciphertext? false

        // Reconstruct key from Base64
        SecretKey restoredKey = vault.keyFromBase64(keyBase64);
        String decrypted2 = vault.decrypt(encrypted, restoredKey);
        System.out.println("Decrypted with restored key: " + decrypted2);

        // ---- 2. Password Hashing ----
        System.out.println("\n--- 2. Password Hashing (PBKDF2) ---");
        String password = "S3cur3P@ssw0rd!";
        String hashedPassword = vault.hashPassword(password);
        System.out.println("Password: " + password);
        System.out.println("Hashed:   " + hashedPassword);

        boolean correctPassword = vault.verifyPassword(password, hashedPassword);
        System.out.println("Correct password: " + correctPassword);
        // Output: Correct password: true

        boolean wrongPassword = vault.verifyPassword("wrongpassword", hashedPassword);
        System.out.println("Wrong password: " + wrongPassword);
        // Output: Wrong password: false

        // ---- 3. HMAC ----
        System.out.println("\n--- 3. HMAC-SHA256 ---");
        SecretKey hmacKey = vault.generateEncryptionKey(); // can reuse AES key for HMAC
        String apiPayload = "{\"orderId\":\"12345\",\"amount\":99.99}";
        String signature = vault.hmac(apiPayload, hmacKey);
        System.out.println("Payload:   " + apiPayload);
        System.out.println("HMAC:      " + signature);

        boolean validHmac = vault.verifyHmac(apiPayload, signature, hmacKey);
        System.out.println("Valid HMAC: " + validHmac);
        // Output: Valid HMAC: true

        String tamperedPayload = "{\"orderId\":\"12345\",\"amount\":0.01}";
        boolean tamperedHmac = vault.verifyHmac(tamperedPayload, signature, hmacKey);
        System.out.println("Tampered HMAC valid: " + tamperedHmac);
        // Output: Tampered HMAC valid: false

        // ---- 4. SHA-256 Hashing ----
        System.out.println("\n--- 4. SHA-256 Hashing ---");
        String fileContent = "Important document content";
        String hash = vault.sha256(fileContent);
        System.out.println("Content: " + fileContent);
        System.out.println("SHA-256: " + hash);

        // Verify integrity
        String hash2 = vault.sha256(fileContent);
        System.out.println("Integrity check: " + hash.equals(hash2));
        // Output: Integrity check: true

        // ---- 5. Token Generation ----
        System.out.println("\n--- 5. Secure Token Generation ---");
        System.out.println("API Key (32 bytes):     " + vault.generateToken(32));
        System.out.println("Session Token (16 bytes): " + vault.generateToken(16));
        System.out.println("Reset Token (24 bytes):  " + vault.generateToken(24));
        System.out.println("6-digit OTP:            " + vault.generateOTP(6));
        System.out.println("4-digit OTP:            " + vault.generateOTP(4));

        // ---- 6. Tamper Detection ----
        System.out.println("\n--- 6. Tamper Detection (GCM) ---");
        String sensitiveData = "Transfer $10,000 to account 98765";
        String encryptedData = vault.encrypt(sensitiveData, encKey);
        System.out.println("Encrypted: " + encryptedData);

        try {
            // Simulate tampering: modify one character in the Base64 string
            char[] chars = encryptedData.toCharArray();
            chars[20] = (chars[20] == 'A') ? 'B' : 'A'; // flip a character
            String tampered = new String(chars);
            vault.decrypt(tampered, encKey); // This should throw an exception
            System.out.println("ERROR: Tampered data was accepted!");
        } catch (Exception e) {
            System.out.println("Tamper detected: " + e.getClass().getSimpleName());
            // Output: Tamper detected: AEADBadTagException
        }

        System.out.println("\n===== Demo Complete =====");
    }
}

===== SecureVault Demo =====

--- 1. AES-256-GCM Encryption ---
Key (Base64): kR7xN9pQ2sVwYz1A3bCdEfGhIjKlMnOp4qRsTuVw5X8=
Plaintext:  My credit card number is 4111-1111-1111-1111
Encrypted:  (Base64 encoded ciphertext -- different each time)
Decrypted:  My credit card number is 4111-1111-1111-1111
Match: true
Same ciphertext? false
Decrypted with restored key: My credit card number is 4111-1111-1111-1111

--- 2. Password Hashing (PBKDF2) ---
Password: S3cur3P@ssw0rd!
Hashed:   210000:BASE64_SALT:BASE64_HASH
Correct password: true
Wrong password: false

--- 3. HMAC-SHA256 ---
Payload:   {"orderId":"12345","amount":99.99}
HMAC:      (Base64 encoded HMAC)
Valid HMAC: true
Tampered HMAC valid: false

--- 4. SHA-256 Hashing ---
Content: Important document content
SHA-256: (Base64 encoded hash)
Integrity check: true

--- 5. Secure Token Generation ---
API Key (32 bytes):      xK9mPqR7sVwYz1A3bCdEfGhIjKlMnOp4qRsTuVw5X8
Session Token (16 bytes): a1B2c3D4e5F6g7H8i9J0kL
Reset Token (24 bytes):  Mj7kL2nP9qR3sT5uV8wX0yZ1a2B3c4D
6-digit OTP:             384729
4-digit OTP:             9152

--- 6. Tamper Detection (GCM) ---
Encrypted: (Base64 encoded ciphertext)
Tamper detected: AEADBadTagException

===== Demo Complete =====

log4j

// BAD: System.out.println for debugging
public class BadDebugging {
    public void processOrder(Order order) {
        System.out.println("Processing order: " + order.getId());      // No timestamp
        System.out.println("Order total: " + order.getTotal());        // No severity
        System.out.println("Sending to payment...");                   // Cannot turn off
        // These println calls will clutter production logs forever
    }
}

// GOOD: Proper logging
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class GoodLogging {
    private static final Logger log = LoggerFactory.getLogger(GoodLogging.class);

    public void processOrder(Order order) {
        log.info("Processing order id={}, total={}", order.getId(), order.getTotal());
        log.debug("Sending order to payment gateway");
        // Output: 2026-02-28 10:15:32.451 [main] INFO  GoodLogging - Processing order id=12345, total=99.99
        // In production, DEBUG messages are automatically suppressed
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LogLevelDemo {
    private static final Logger log = LoggerFactory.getLogger(LogLevelDemo.class);

    public void processPayment(String orderId, double amount) {
        log.trace("Entering processPayment(orderId={}, amount={})", orderId, amount);

        log.debug("Validating payment amount: {}", amount);

        if (amount <= 0) {
            log.warn("Invalid payment amount {} for order {}, using minimum $0.01", amount, orderId);
            amount = 0.01;
        }

        try {
            log.info("Processing payment of ${} for order {}", amount, orderId);
            // ... payment logic ...
            log.info("Payment successful for order {}", orderId);
        } catch (Exception e) {
            log.error("Payment failed for order {} with amount ${}", orderId, amount, e);
            // The exception 'e' is passed as the LAST argument -- SLF4J will print the full stack trace
        }

        log.trace("Exiting processPayment for order {}", orderId);
    }
}
// If level is set to INFO, output would be:
// 2026-02-28 10:30:00.123 [main] INFO  LogLevelDemo - Processing payment of $49.99 for order ORD-001
// 2026-02-28 10:30:00.456 [main] INFO  LogLevelDemo - Payment successful for order ORD-001
// (TRACE and DEBUG messages are suppressed)

import java.util.logging.Level;
import java.util.logging.Logger;

public class JulExample {
    // Create a logger named after the class
    private static final Logger logger = Logger.getLogger(JulExample.class.getName());

    public static void main(String[] args) {
        // Basic logging at different levels
        logger.info("Application starting");
        logger.warning("Configuration file not found, using defaults");
        logger.severe("Database connection failed!");

        // Parameterized logging (JUL uses {0}, {1} style -- not {} like SLF4J)
        String user = "alice";
        int loginAttempts = 3;
        logger.log(Level.INFO, "User {0} logged in after {1} attempts", new Object[]{user, loginAttempts});

        // Logging an exception
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            logger.log(Level.SEVERE, "Division error occurred", e);
        }

        // Check if level is enabled before expensive operations
        if (logger.isLoggable(Level.FINE)) {
            logger.fine("Debug data: " + expensiveToString());
        }
    }

    private static String expensiveToString() {
        // Imagine this method is costly to call
        return "detailed debug information";
    }
}
// Output:
// Feb 28, 2026 10:45:00 AM JulExample main
// INFO: Application starting
// Feb 28, 2026 10:45:00 AM JulExample main
// WARNING: Configuration file not found, using defaults
// Feb 28, 2026 10:45:00 AM JulExample main
// SEVERE: Database connection failed!

    
    
        org.slf4j
        slf4j-api
        2.0.16
    

    
    
        ch.qos.logback
        logback-classic
        1.5.15
    

// Gradle: Add to build.gradle
dependencies {
    implementation 'org.slf4j:slf4j-api:2.0.16'
    implementation 'ch.qos.logback:logback-classic:1.5.15'
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class UserService {
    // Step 1: Declare the logger -- always private static final
    private static final Logger log = LoggerFactory.getLogger(UserService.class);

    public User findUserById(long id) {
        log.info("Looking up user with id={}", id);

        User user = userRepository.findById(id);

        if (user == null) {
            log.warn("User not found for id={}", id);
            return null;
        }

        log.debug("Found user: name={}, email={}", user.getName(), user.getEmail());
        return user;
    }
}
// Output with INFO level:
// 2026-02-28 10:30:00.123 [main] INFO  c.e.service.UserService - Looking up user with id=42
// 2026-02-28 10:30:00.125 [main] WARN  c.e.service.UserService - User not found for id=42

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ParameterizedLogging {
    private static final Logger log = LoggerFactory.getLogger(ParameterizedLogging.class);

    public void demonstrate(Order order) {
        // BAD: String concatenation -- always builds the string, even if DEBUG is off
        log.debug("Processing order " + order.getId() + " for user " + order.getUserId()
                + " with " + order.getItems().size() + " items");

        // GOOD: Parameterized logging -- string built ONLY if DEBUG is enabled
        log.debug("Processing order {} for user {} with {} items",
                order.getId(), order.getUserId(), order.getItems().size());

        // Multiple placeholders -- they are filled in order
        log.info("User {} placed order {} with total ${}", "alice", "ORD-123", 99.99);
        // Output: User alice placed order ORD-123 with total $99.99

        // Logging exceptions -- exception is ALWAYS the last argument
        try {
            processPayment(order);
        } catch (Exception e) {
            // The exception goes last -- SLF4J recognizes it and prints the full stack trace
            log.error("Payment failed for order {}", order.getId(), e);
            // Output:
            // 2026-02-28 10:30:00.123 [main] ERROR ParameterizedLogging - Payment failed for order ORD-123
            // java.lang.RuntimeException: Insufficient funds
            //     at ParameterizedLogging.processPayment(ParameterizedLogging.java:35)
            //     at ParameterizedLogging.demonstrate(ParameterizedLogging.java:22)
            //     ...
        }
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ExceptionLogging {
    private static final Logger log = LoggerFactory.getLogger(ExceptionLogging.class);

    public void demonstrateExceptionLogging() {
        try {
            riskyOperation();
        } catch (Exception e) {
            // BAD: Loses the stack trace entirely
            log.error("Something failed");

            // BAD: Only logs the exception message, no stack trace
            log.error("Something failed: " + e.getMessage());

            // BAD: Converts stack trace to string manually -- ugly and loses structure
            log.error("Something failed: " + e.toString());

            // GOOD: Pass exception as the last argument -- full stack trace is printed
            log.error("Something failed", e);

            // GOOD: With context AND exception -- placeholders first, exception last
            log.error("Failed to process order {} for user {}", orderId, userId, e);
            // SLF4J knows the last argument is an exception because {} count (2) < argument count (3)
        }
    }
}

    
    
        org.slf4j
        slf4j-api
        2.0.16
    

    
    
        org.apache.logging.log4j
        log4j-slf4j2-impl
        2.24.3
    

    
    
        org.apache.logging.log4j
        log4j-core
        2.24.3
    

    com.lmax
    disruptor
    4.0.0

    
    
    
    
        
            %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
        
    

    
    
    
    
        logs/application.log
        
            %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
        
    

    
    
    
    
        logs/application.log

        
        
            logs/application.%d{yyyy-MM-dd}.%i.log.gz
            10MB
            30          
            1GB     
        

        
            %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
        
    

    
    
    

    
    
        
        
    

    
    

    
    
    

    
    
        
    

// Development pattern (human-readable with colors)
%d{HH:mm:ss.SSS} %highlight(%-5level) %cyan(%logger{36}) - %msg%n
// Output: 10:30:00.123 INFO  c.e.service.UserService - Order placed

// Production pattern (full detail, no color)
%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
// Output: 2026-02-28 10:30:00.123 [http-nio-8080-exec-1] INFO  c.e.service.UserService - Order placed

// Production with MDC (request tracking)
%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} [requestId=%X{requestId}] - %msg%n
// Output: 2026-02-28 10:30:00.123 [http-nio-8080-exec-1] INFO  c.e.service.UserService [requestId=abc-123-def] - Order placed

// JSON pattern for ELK/Splunk (see Section 12)
{"timestamp":"%d{yyyy-MM-dd'T'HH:mm:ss.SSSZ}","level":"%level","logger":"%logger","thread":"%thread","message":"%msg","requestId":"%X{requestId}"}%n

    
        
            %d{HH:mm:ss.SSS} %-5level %logger{36} - %msg%n
        
    

    
    

    
    

    
    

    
    

    
    

    
    

    
    
        
    

    net.logstash.logback
    logstash-logback-encoder
    8.0

    
    
        
            
            requestId
            userId
        
    

    
        
    

{"@timestamp":"2026-02-28T10:30:00.123Z","@version":"1","message":"Order ORD-123 placed successfully","logger_name":"com.myapp.service.OrderService","thread_name":"http-nio-8080-exec-1","level":"INFO","requestId":"abc-123-def","userId":"user-42"}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;

public class MdcExample {
    private static final Logger log = LoggerFactory.getLogger(MdcExample.class);

    public void handleRequest(String requestId, String userId) {
        // Put values into MDC at the start of the request
        MDC.put("requestId", requestId);
        MDC.put("userId", userId);

        try {
            log.info("Request received");
            processOrder();
            sendConfirmation();
            log.info("Request completed successfully");
        } finally {
            // CRITICAL: Always clear MDC when the request is done
            // Threads are reused in thread pools -- leftover MDC values leak into other requests!
            MDC.clear();
        }
    }

    private void processOrder() {
        // This log line automatically includes requestId and userId from MDC
        log.info("Processing order");
        // Output: 2026-02-28 10:30:00.123 [http-exec-1] INFO  MdcExample [requestId=abc-123, userId=user-42] - Processing order
    }

    private void sendConfirmation() {
        log.info("Sending confirmation email");
        // Output: 2026-02-28 10:30:00.456 [http-exec-1] INFO  MdcExample [requestId=abc-123, userId=user-42] - Sending confirmation email
    }
}

import org.slf4j.MDC;
import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.UUID;

public class LoggingFilter implements Filter {
    private static final String REQUEST_ID = "requestId";
    private static final String USER_ID = "userId";

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {

        HttpServletRequest httpRequest = (HttpServletRequest) request;

        try {
            // Generate or extract request ID
            String requestId = httpRequest.getHeader("X-Request-ID");
            if (requestId == null || requestId.isBlank()) {
                requestId = UUID.randomUUID().toString().substring(0, 8);
            }

            // Set MDC values
            MDC.put(REQUEST_ID, requestId);

            // Extract user from security context (if authenticated)
            String userId = extractUserId(httpRequest);
            if (userId != null) {
                MDC.put(USER_ID, userId);
            }

            // Continue processing the request
            chain.doFilter(request, response);

        } finally {
            // Always clean up to prevent thread pool contamination
            MDC.clear();
        }
    }

    private String extractUserId(HttpServletRequest request) {
        // In a real app, extract from security context or JWT token
        return request.getRemoteUser();
    }
}

    
        
            
            %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} [req=%X{requestId} user=%X{userId}] - %msg%n
        
    

    
        
    

// BAD: Coupling to a specific implementation
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
private static final Logger log = LogManager.getLogger(MyClass.class);

// BAD: Using java.util.logging directly
import java.util.logging.Logger;
private static final Logger log = Logger.getLogger(MyClass.class.getName());

// GOOD: SLF4J facade -- works with ANY implementation
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger log = LoggerFactory.getLogger(MyClass.class);

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ParameterizedBestPractice {
    private static final Logger log = LoggerFactory.getLogger(ParameterizedBestPractice.class);

    public void process(Order order) {
        // BAD: String concatenation -- always builds the string even if DEBUG is off
        log.debug("Order " + order.getId() + " has " + order.getItems().size() + " items totaling $" + order.getTotal());
        // This calls order.getId(), order.getItems().size(), and order.getTotal()
        // PLUS concatenates 5 strings -- all wasted work if DEBUG is disabled

        // GOOD: Parameterized -- only builds string if DEBUG is enabled
        log.debug("Order {} has {} items totaling ${}", order.getId(), order.getItems().size(), order.getTotal());
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class AppropriateLevel {
    private static final Logger log = LoggerFactory.getLogger(AppropriateLevel.class);

    public void processOrder(Order order) {
        // TRACE: Very fine-grained, method entry/exit
        log.trace("Entering processOrder with order={}", order);

        // DEBUG: Technical detail helpful during development
        log.debug("Validating order items against inventory");

        // INFO: Business event -- this is what operations teams monitor
        log.info("Order {} placed by user {} for ${}", order.getId(), order.getUserId(), order.getTotal());

        // WARN: Something unusual but recoverable
        if (order.getTotal() > 10000) {
            log.warn("High-value order {} for ${} -- flagged for review", order.getId(), order.getTotal());
        }

        // ERROR: Something failed -- needs human attention
        try {
            chargePayment(order);
        } catch (PaymentException e) {
            log.error("Payment failed for order {} with amount ${}", order.getId(), order.getTotal(), e);
        }
    }
}

// BAD: No context -- useless for debugging
log.error("Payment failed");
log.info("User logged in");
log.warn("Retry attempt");

// GOOD: Context-rich -- you can trace exactly what happened
log.error("Payment failed for order={} user={} amount=${} gateway={}", orderId, userId, amount, gateway);
log.info("User {} logged in from IP {} using {}", userId, ipAddress, userAgent);
log.warn("Retry attempt {}/{} for order={} after {}ms delay", attempt, maxRetries, orderId, delay);

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ExpensiveLogging {
    private static final Logger log = LoggerFactory.getLogger(ExpensiveLogging.class);

    public void processLargeDataSet(List records) {
        // BAD: computeStats() is called EVERY TIME, even when DEBUG is off
        log.debug("Dataset statistics: {}", computeStats(records));
        // computeStats() might iterate over millions of records

        // GOOD: Guard expensive computation
        if (log.isDebugEnabled()) {
            log.debug("Dataset statistics: {}", computeStats(records));
        }

        // ALSO GOOD for simple arguments -- no guard needed
        log.debug("Processing {} records", records.size());
        // records.size() is O(1) and trivially cheap
    }

    private String computeStats(List records) {
        // Imagine this iterates the entire list, computes averages, etc.
        return "min=1, max=100, avg=42.5, stddev=12.3";
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SensitiveDataLogging {
    private static final Logger log = LoggerFactory.getLogger(SensitiveDataLogging.class);

    public void authenticateUser(String username, String password) {
        // BAD: NEVER log passwords
        log.info("Login attempt: user={}, password={}", username, password);

        // GOOD: Log the event without sensitive data
        log.info("Login attempt for user={}", username);
    }

    public void processPayment(String creditCardNumber, double amount) {
        // BAD: NEVER log full credit card numbers
        log.info("Charging card {} for ${}", creditCardNumber, amount);

        // GOOD: Mask the sensitive data
        String masked = maskCreditCard(creditCardNumber);
        log.info("Charging card {} for ${}", masked, amount);
        // Output: Charging card ****-****-****-4242 for $99.99
    }

    private String maskCreditCard(String number) {
        if (number == null || number.length() < 4) return "****";
        return "****-****-****-" + number.substring(number.length() - 4);
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LoopLogging {
    private static final Logger log = LoggerFactory.getLogger(LoopLogging.class);

    public void processRecords(List records) {
        // BAD: Logging inside a loop with 1 million records = 1 million log lines
        for (Record record : records) {
            log.debug("Processing record: {}", record.getId());
            process(record);
        }

        // GOOD: Log summary information
        log.info("Starting to process {} records", records.size());
        int successCount = 0;
        int failCount = 0;

        for (Record record : records) {
            try {
                process(record);
                successCount++;
            } catch (Exception e) {
                failCount++;
                // Only log individual failures -- these are exceptional
                log.warn("Failed to process record {}: {}", record.getId(), e.getMessage());
            }
        }

        log.info("Completed processing: {} succeeded, {} failed out of {} total",
                successCount, failCount, records.size());
    }
}

// MISTAKE: System.out.println scattered through production code
public class OrderService {
    public void placeOrder(Order order) {
        System.out.println("Placing order: " + order);        // No level, no timestamp, no thread
        System.out.println("Validating...");                   // Cannot turn off without deleting
        System.out.println("Done!");                           // Goes to stdout only
    }
}

// FIX: Use a proper logger
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class OrderService {
    private static final Logger log = LoggerFactory.getLogger(OrderService.class);

    public void placeOrder(Order order) {
        log.info("Placing order {}", order.getId());
        log.debug("Validating order items");
        log.info("Order {} placed successfully", order.getId());
    }
}

// MISTAKE: String concatenation is evaluated even when the level is disabled
log.debug("User " + user.getName() + " has " + user.getOrders().size() + " orders"
        + " totaling $" + calculateTotal(user.getOrders()));
// If DEBUG is off, Java still:
//   1. Calls user.getName()
//   2. Calls user.getOrders().size()
//   3. Calls calculateTotal() -- potentially expensive!
//   4. Concatenates 5 strings
//   5. Throws the result away

// FIX: Use parameterized logging
log.debug("User {} has {} orders totaling ${}",
        user.getName(), user.getOrders().size(), calculateTotal(user.getOrders()));
// With parameterized logging, if DEBUG is off, SLF4J skips building the string.
// NOTE: The arguments are still evaluated. For expensive arguments, use isDebugEnabled() guard.

try {
    connectToDatabase();
} catch (SQLException e) {

    // MISTAKE 1: Swallowing the exception entirely
    // (empty catch block -- the worst possible thing)

    // MISTAKE 2: Only logging the message, losing the stack trace
    log.error("Database error: " + e.getMessage());
    // Output: Database error: Connection refused
    // WHERE did it fail? Which line? What was the root cause? All lost.

    // MISTAKE 3: Using printStackTrace() instead of logging
    e.printStackTrace();
    // This goes to System.err, bypassing the logging framework entirely.
    // No timestamp, no level, no file output, no MDC.

    // CORRECT: Pass the exception as the last argument
    log.error("Failed to connect to database", e);
    // Output includes the full stack trace:
    // 2026-02-28 10:30:00.123 [main] ERROR DatabaseService - Failed to connect to database
    // java.sql.SQLException: Connection refused
    //     at com.mysql.cj.jdbc.ConnectionImpl.createNewIO(ConnectionImpl.java:839)
    //     at com.mysql.cj.jdbc.ConnectionImpl.(ConnectionImpl.java:453)
    //     at DatabaseService.connectToDatabase(DatabaseService.java:42)
    //     ...
    // Caused by: java.net.ConnectException: Connection refused (Connection refused)
    //     at java.base/java.net.PlainSocketImpl.socketConnect(Native Method)
    //     ...
}

// MISTAKE: Logging too much -- "log diarrhea"
public double calculateTax(double amount, String state) {
    log.info("calculateTax called");                    // Noise
    log.info("amount = " + amount);                     // Noise + concatenation
    log.info("state = " + state);                       // Noise + concatenation
    double rate = getTaxRate(state);
    log.info("tax rate = " + rate);                     // Noise
    double tax = amount * rate;
    log.info("tax = " + tax);                           // Noise
    log.info("returning tax");                          // Noise
    return tax;
}
// This method generates 6 log lines for a simple calculation.
// Multiply by 1000 requests/second and you have 6000 lines/second of noise.

// MISTAKE: Logging too little
public double calculateTax(double amount, String state) {
    return amount * getTaxRate(state);
    // No logging at all. If tax calculations are wrong, where do you start?
}

// CORRECT: Log meaningful events at the right level
public double calculateTax(double amount, String state) {
    log.debug("Calculating tax for amount={} state={}", amount, state);
    double rate = getTaxRate(state);
    double tax = amount * rate;
    log.debug("Tax calculated: amount={} state={} rate={} tax={}", amount, state, rate, tax);
    return tax;
}
// Two DEBUG lines that can be turned off in production but enabled when needed.

// MISTAKE: Logging user data verbatim
public void registerUser(UserRegistration reg) {
    log.info("Registering user: {}", reg);
    // If UserRegistration.toString() includes password, SSN, or credit card... game over.
    // Log files are often stored in plain text, backed up to multiple servers,
    // and accessed by many team members.
}

// CORRECT: Log only safe, relevant fields
public void registerUser(UserRegistration reg) {
    log.info("Registering user: email={}", reg.getEmail());
    // Or override toString() to exclude sensitive fields:
    // @Override public String toString() {
    //     return "UserRegistration{email='" + email + "', name='" + name + "'}";
    //     // password, ssn, creditCard intentionally excluded
    // }
}

// MISTAKE: Still using Log4j 1.x (versions 1.2.x)
import org.apache.log4j.Logger;   // <-- This is Log4j 1.x -- SECURITY VULNERABILITY!

// Log4j 1.x reached End of Life in August 2015.
// CVE-2021-44228 (Log4Shell) allows Remote Code Execution -- attackers can take over your server.
// This is a CRITICAL vulnerability rated 10.0 out of 10.0 on the CVSS scale.

// FIX: Migrate to SLF4J + Logback (or Log4j2)
// Step 1: Remove log4j 1.x dependency
// Step 2: Add SLF4J + Logback dependencies (see Section 5)
// Step 3: Replace imports:
import org.slf4j.Logger;          // <-- SLF4J facade
import org.slf4j.LoggerFactory;

// Step 4: Replace logger creation:
// OLD: private static final Logger log = Logger.getLogger(MyClass.class);
// NEW:
private static final Logger log = LoggerFactory.getLogger(MyClass.class);

// Step 5: Replace log4j.properties with logback.xml (see Section 7)
// Step 6: The logging method calls (log.info, log.error, etc.) are almost identical

    logs/application.log

    
        
        logs/application.%d{yyyy-MM-dd}.%i.log.gz

        
        50MB

        
        90

        
        5GB
    

    
        %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} [%X{requestId}] - %msg%n
    

    
    
        logs/application.log
        
            logs/application.%d{yyyy-MM-dd}.log.gz
            30
        
        
            %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
        
    

    
    
        1024           
        0 
        false 
        
    

    
        
    

    
        org.slf4j
        slf4j-api
        2.0.16
    
    
        ch.qos.logback
        logback-classic
        1.5.15
    

    
        
            %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{30} [orderId=%X{orderId} user=%X{userId}] - %msg%n
        
    

    
        logs/orders.log
        
            logs/orders.%d{yyyy-MM-dd}.%i.log.gz
            10MB
            30
            1GB
        
        
            %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} [orderId=%X{orderId} user=%X{userId}] - %msg%n
        
    

    
        
        
    

    
        
    

package com.example.orders;

import java.util.List;

public class Order {
    private final String id;
    private final String userId;
    private final List items;
    private double total;
    private OrderStatus status;

    public Order(String id, String userId, List items) {
        this.id = id;
        this.userId = userId;
        this.items = items;
        this.total = items.stream().mapToDouble(OrderItem::getSubtotal).sum();
        this.status = OrderStatus.PENDING;
    }

    public String getId() { return id; }
    public String getUserId() { return userId; }
    public List getItems() { return items; }
    public double getTotal() { return total; }
    public OrderStatus getStatus() { return status; }
    public void setStatus(OrderStatus status) { this.status = status; }
    public void setTotal(double total) { this.total = total; }

    // toString excludes any sensitive user data
    @Override
    public String toString() {
        return "Order{id='" + id + "', items=" + items.size() + ", total=" + total + ", status=" + status + "}";
    }
}

enum OrderStatus { PENDING, VALIDATED, PAID, SHIPPED, CANCELLED }

class OrderItem {
    private final String productName;
    private final int quantity;
    private final double price;

    public OrderItem(String productName, int quantity, double price) {
        this.productName = productName;
        this.quantity = quantity;
        this.price = price;
    }

    public String getProductName() { return productName; }
    public int getQuantity() { return quantity; }
    public double getPrice() { return price; }
    public double getSubtotal() { return quantity * price; }
}

package com.example.orders;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;

import java.util.List;

public class OrderService {
    private static final Logger log = LoggerFactory.getLogger(OrderService.class);

    private static final double HIGH_VALUE_THRESHOLD = 1000.0;
    private static final double TAX_RATE = 0.08;
    private static final double DISCOUNT_THRESHOLD = 500.0;
    private static final double DISCOUNT_RATE = 0.10;

    /**
     * Process an order end-to-end with proper logging at every stage.
     */
    public void processOrder(Order order) {
        // Set MDC context for this order -- all subsequent log lines include these values
        MDC.put("orderId", order.getId());
        MDC.put("userId", order.getUserId());

        long startTime = System.currentTimeMillis();

        try {
            // INFO: Business event -- order processing started
            log.info("Order processing started: {} items, total=${}",
                    order.getItems().size(), order.getTotal());

            // Step 1: Validate
            validateOrder(order);

            // Step 2: Apply discounts
            applyDiscounts(order);

            // Step 3: Calculate tax
            calculateTax(order);

            // Step 4: Process payment
            processPayment(order);

            // Step 5: Ship
            shipOrder(order);

            long elapsed = System.currentTimeMillis() - startTime;
            // INFO: Business event -- order completed with timing
            log.info("Order processing completed successfully in {}ms, finalTotal=${}",
                    elapsed, order.getTotal());

        } catch (Exception e) {
            long elapsed = System.currentTimeMillis() - startTime;
            order.setStatus(OrderStatus.CANCELLED);
            // ERROR: Something went wrong -- include the exception for stack trace
            log.error("Order processing failed after {}ms", elapsed, e);
        } finally {
            // CRITICAL: Always clear MDC to prevent thread contamination
            MDC.clear();
        }
    }

    private void validateOrder(Order order) {
        log.debug("Validating order");

        if (order.getItems() == null || order.getItems().isEmpty()) {
            // ERROR: Invalid input -- this should not happen if upstream validation works
            log.error("Order has no items");
            throw new IllegalArgumentException("Order must have at least one item");
        }

        for (OrderItem item : order.getItems()) {
            if (item.getQuantity() <= 0) {
                log.error("Invalid quantity {} for product '{}'",
                        item.getQuantity(), item.getProductName());
                throw new IllegalArgumentException("Quantity must be positive for: " + item.getProductName());
            }
            if (item.getPrice() < 0) {
                log.error("Negative price ${} for product '{}'",
                        item.getPrice(), item.getProductName());
                throw new IllegalArgumentException("Price cannot be negative for: " + item.getProductName());
            }
        }

        order.setStatus(OrderStatus.VALIDATED);
        // DEBUG: Technical detail about validation result
        log.debug("Order validated: {} items passed all checks", order.getItems().size());
    }

    private void applyDiscounts(Order order) {
        double originalTotal = order.getTotal();
        log.debug("Checking discounts for total=${}", originalTotal);

        if (originalTotal >= DISCOUNT_THRESHOLD) {
            double discount = originalTotal * DISCOUNT_RATE;
            order.setTotal(originalTotal - discount);
            // INFO: Business event -- discount applied (operations wants to track this)
            log.info("Discount applied: {}% off ${} = -${}, newTotal=${}",
                    (int)(DISCOUNT_RATE * 100), originalTotal, discount, order.getTotal());
        } else {
            log.debug("No discount applied: total ${} below threshold ${}",
                    originalTotal, DISCOUNT_THRESHOLD);
        }
    }

    private void calculateTax(Order order) {
        double beforeTax = order.getTotal();
        double tax = beforeTax * TAX_RATE;
        order.setTotal(beforeTax + tax);
        // DEBUG: Technical calculation detail
        log.debug("Tax calculated: ${} * {} = ${}, newTotal=${}",
                beforeTax, TAX_RATE, tax, order.getTotal());
    }

    private void processPayment(Order order) {
        // INFO: Business event -- payment attempt
        log.info("Processing payment of ${}", order.getTotal());

        // WARN: Flag high-value orders
        if (order.getTotal() > HIGH_VALUE_THRESHOLD) {
            log.warn("High-value order detected: ${} exceeds threshold ${}",
                    order.getTotal(), HIGH_VALUE_THRESHOLD);
        }

        // Simulate payment processing
        try {
            simulatePaymentGateway(order);
            order.setStatus(OrderStatus.PAID);
            log.info("Payment processed successfully for ${}", order.getTotal());
        } catch (RuntimeException e) {
            // ERROR: Payment failed -- include the exception
            log.error("Payment gateway rejected transaction for ${}", order.getTotal(), e);
            throw e;
        }
    }

    private void simulatePaymentGateway(Order order) {
        // Simulate: orders with total over $5000 fail (for demo purposes)
        if (order.getTotal() > 5000) {
            throw new RuntimeException("Payment declined: exceeds single transaction limit");
        }
        log.debug("Payment gateway returned: APPROVED");
    }

    private void shipOrder(Order order) {
        log.info("Initiating shipment");
        order.setStatus(OrderStatus.SHIPPED);
        log.info("Order shipped to user {}", order.getUserId());
    }
}

package com.example.orders;

import java.util.List;

public class OrderApp {
    public static void main(String[] args) {
        OrderService service = new OrderService();

        // Scenario 1: Normal order
        System.out.println("=== Scenario 1: Normal Order ===");
        Order normalOrder = new Order("ORD-001", "alice",
                List.of(new OrderItem("Laptop Stand", 1, 45.99),
                        new OrderItem("USB-C Cable", 2, 12.99)));
        service.processOrder(normalOrder);

        System.out.println();

        // Scenario 2: High-value order with discount
        System.out.println("=== Scenario 2: High-Value Order ===");
        Order highValue = new Order("ORD-002", "bob",
                List.of(new OrderItem("MacBook Pro", 1, 2499.00),
                        new OrderItem("AppleCare+", 1, 399.00)));
        service.processOrder(highValue);

        System.out.println();

        // Scenario 3: Order that exceeds payment limit (will fail)
        System.out.println("=== Scenario 3: Failed Payment ===");
        Order tooExpensive = new Order("ORD-003", "charlie",
                List.of(new OrderItem("Server Rack", 3, 2500.00)));
        service.processOrder(tooExpensive);

        System.out.println();

        // Scenario 4: Invalid order (empty items)
        System.out.println("=== Scenario 4: Invalid Order ===");
        Order emptyOrder = new Order("ORD-004", "dave", List.of());
        service.processOrder(emptyOrder);
    }
}

=== Scenario 1: Normal Order ===
2026-02-28 10:30:00.001 [main] INFO  c.e.orders.OrderService [orderId=ORD-001 user=alice] - Order processing started: 2 items, total=$71.97
2026-02-28 10:30:00.002 [main] DEBUG c.e.orders.OrderService [orderId=ORD-001 user=alice] - Validating order
2026-02-28 10:30:00.002 [main] DEBUG c.e.orders.OrderService [orderId=ORD-001 user=alice] - Order validated: 2 items passed all checks
2026-02-28 10:30:00.002 [main] DEBUG c.e.orders.OrderService [orderId=ORD-001 user=alice] - Checking discounts for total=$71.97
2026-02-28 10:30:00.002 [main] DEBUG c.e.orders.OrderService [orderId=ORD-001 user=alice] - No discount applied: total $71.97 below threshold $500.0
2026-02-28 10:30:00.003 [main] DEBUG c.e.orders.OrderService [orderId=ORD-001 user=alice] - Tax calculated: $71.97 * 0.08 = $5.7576, newTotal=$77.7276
2026-02-28 10:30:00.003 [main] INFO  c.e.orders.OrderService [orderId=ORD-001 user=alice] - Processing payment of $77.7276
2026-02-28 10:30:00.003 [main] DEBUG c.e.orders.OrderService [orderId=ORD-001 user=alice] - Payment gateway returned: APPROVED
2026-02-28 10:30:00.003 [main] INFO  c.e.orders.OrderService [orderId=ORD-001 user=alice] - Payment processed successfully for $77.7276
2026-02-28 10:30:00.003 [main] INFO  c.e.orders.OrderService [orderId=ORD-001 user=alice] - Initiating shipment
2026-02-28 10:30:00.003 [main] INFO  c.e.orders.OrderService [orderId=ORD-001 user=alice] - Order shipped to user alice
2026-02-28 10:30:00.004 [main] INFO  c.e.orders.OrderService [orderId=ORD-001 user=alice] - Order processing completed successfully in 3ms, finalTotal=$77.7276

=== Scenario 2: High-Value Order ===
2026-02-28 10:30:00.005 [main] INFO  c.e.orders.OrderService [orderId=ORD-002 user=bob] - Order processing started: 2 items, total=$2898.0
2026-02-28 10:30:00.005 [main] DEBUG c.e.orders.OrderService [orderId=ORD-002 user=bob] - Validating order
2026-02-28 10:30:00.005 [main] DEBUG c.e.orders.OrderService [orderId=ORD-002 user=bob] - Order validated: 2 items passed all checks
2026-02-28 10:30:00.005 [main] DEBUG c.e.orders.OrderService [orderId=ORD-002 user=bob] - Checking discounts for total=$2898.0
2026-02-28 10:30:00.005 [main] INFO  c.e.orders.OrderService [orderId=ORD-002 user=bob] - Discount applied: 10% off $2898.0 = -$289.8, newTotal=$2608.2
2026-02-28 10:30:00.006 [main] DEBUG c.e.orders.OrderService [orderId=ORD-002 user=bob] - Tax calculated: $2608.2 * 0.08 = $208.656, newTotal=$2816.856
2026-02-28 10:30:00.006 [main] INFO  c.e.orders.OrderService [orderId=ORD-002 user=bob] - Processing payment of $2816.856
2026-02-28 10:30:00.006 [main] WARN  c.e.orders.OrderService [orderId=ORD-002 user=bob] - High-value order detected: $2816.856 exceeds threshold $1000.0
2026-02-28 10:30:00.006 [main] DEBUG c.e.orders.OrderService [orderId=ORD-002 user=bob] - Payment gateway returned: APPROVED
2026-02-28 10:30:00.006 [main] INFO  c.e.orders.OrderService [orderId=ORD-002 user=bob] - Payment processed successfully for $2816.856
2026-02-28 10:30:00.006 [main] INFO  c.e.orders.OrderService [orderId=ORD-002 user=bob] - Initiating shipment
2026-02-28 10:30:00.006 [main] INFO  c.e.orders.OrderService [orderId=ORD-002 user=bob] - Order shipped to user bob
2026-02-28 10:30:00.007 [main] INFO  c.e.orders.OrderService [orderId=ORD-002 user=bob] - Order processing completed successfully in 2ms, finalTotal=$2816.856

=== Scenario 3: Failed Payment ===
2026-02-28 10:30:00.008 [main] INFO  c.e.orders.OrderService [orderId=ORD-003 user=charlie] - Order processing started: 3 items, total=$7500.0
2026-02-28 10:30:00.008 [main] DEBUG c.e.orders.OrderService [orderId=ORD-003 user=charlie] - Validating order
2026-02-28 10:30:00.008 [main] DEBUG c.e.orders.OrderService [orderId=ORD-003 user=charlie] - Order validated: 3 items passed all checks
2026-02-28 10:30:00.008 [main] DEBUG c.e.orders.OrderService [orderId=ORD-003 user=charlie] - Checking discounts for total=$7500.0
2026-02-28 10:30:00.008 [main] INFO  c.e.orders.OrderService [orderId=ORD-003 user=charlie] - Discount applied: 10% off $7500.0 = -$750.0, newTotal=$6750.0
2026-02-28 10:30:00.009 [main] DEBUG c.e.orders.OrderService [orderId=ORD-003 user=charlie] - Tax calculated: $6750.0 * 0.08 = $540.0, newTotal=$7290.0
2026-02-28 10:30:00.009 [main] INFO  c.e.orders.OrderService [orderId=ORD-003 user=charlie] - Processing payment of $7290.0
2026-02-28 10:30:00.009 [main] WARN  c.e.orders.OrderService [orderId=ORD-003 user=charlie] - High-value order detected: $7290.0 exceeds threshold $1000.0
2026-02-28 10:30:00.009 [main] ERROR c.e.orders.OrderService [orderId=ORD-003 user=charlie] - Payment gateway rejected transaction for $7290.0
java.lang.RuntimeException: Payment declined: exceeds single transaction limit
    at com.example.orders.OrderService.simulatePaymentGateway(OrderService.java:112)
    ...
2026-02-28 10:30:00.010 [main] ERROR c.e.orders.OrderService [orderId=ORD-003 user=charlie] - Order processing failed after 2ms

=== Scenario 4: Invalid Order ===
2026-02-28 10:30:00.011 [main] INFO  c.e.orders.OrderService [orderId=ORD-004 user=dave] - Order processing started: 0 items, total=$0.0
2026-02-28 10:30:00.011 [main] DEBUG c.e.orders.OrderService [orderId=ORD-004 user=dave] - Validating order
2026-02-28 10:30:00.011 [main] ERROR c.e.orders.OrderService [orderId=ORD-004 user=dave] - Order has no items
2026-02-28 10:30:00.011 [main] ERROR c.e.orders.OrderService [orderId=ORD-004 user=dave] - Order processing failed after 0ms
java.lang.IllegalArgumentException: Order must have at least one item
    at com.example.orders.OrderService.validateOrder(OrderService.java:70)
    ...

Database

    +---------------------+
    |  Java Application   |   <-- Your code
    +---------------------+
             |
    +---------------------+
    |     JDBC API         |   <-- java.sql.* interfaces
    |  (DriverManager,     |       (Connection, Statement,
    |   DataSource)        |        ResultSet, etc.)
    +---------------------+
             |
    +---------------------+
    |    JDBC Driver       |   <-- Vendor-specific implementation
    |  (MySQL Connector/J, |       (mysql-connector-j, postgresql, etc.)
    |   PostgreSQL Driver) |
    +---------------------+
             |
    +---------------------+
    |     Database         |   <-- MySQL, PostgreSQL, Oracle, H2, etc.
    +---------------------+

    com.mysql
    mysql-connector-j
    8.3.0




    org.postgresql
    postgresql
    42.7.3




    com.h2database
    h2
    2.2.224

// MySQL
implementation 'com.mysql:mysql-connector-j:8.3.0'

// PostgreSQL
implementation 'org.postgresql:postgresql:42.7.3'

// H2
implementation 'com.h2database:h2:2.2.224'

// Legacy approach -- no longer needed since Java 6 / JDBC 4.0
Class.forName("com.mysql.cj.jdbc.Driver");
Class.forName("org.postgresql.Driver");

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class BasicConnection {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydb";
        String user = "root";
        String password = "secret";

        Connection connection = null;
        try {
            connection = DriverManager.getConnection(url, user, password);
            System.out.println("Connected to database!");
            System.out.println("Database: " + connection.getCatalog());
            System.out.println("Auto-commit: " + connection.getAutoCommit());

            // ... use connection ...

        } catch (SQLException e) {
            System.err.println("Connection failed: " + e.getMessage());
            System.err.println("SQL State: " + e.getSQLState());
            System.err.println("Error Code: " + e.getErrorCode());
        } finally {
            // Must close manually -- easy to forget!
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
// Output:
// Connected to database!
// Database: mydb
// Auto-commit: true

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ProperConnection {
    // Store these in environment variables or a config file, never hardcoded
    private static final String URL = "jdbc:mysql://localhost:3306/mydb";
    private static final String USER = "root";
    private static final String PASSWORD = "secret";

    public static void main(String[] args) {
        // try-with-resources -- connection auto-closes when block ends
        try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD)) {
            System.out.println("Connected!");
            System.out.println("Valid: " + conn.isValid(5)); // 5-second timeout
            // ... do work ...
        } catch (SQLException e) {
            // Connection automatically closed, even on exception
            System.err.println("Error: " + e.getMessage());
        }
        // No finally block needed -- connection is guaranteed closed
    }
}

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;

public class ConnectionWithProperties {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydb";

        Properties props = new Properties();
        props.setProperty("user", "root");
        props.setProperty("password", "secret");
        props.setProperty("useSSL", "true");
        props.setProperty("serverTimezone", "UTC");
        props.setProperty("characterEncoding", "UTF-8");
        props.setProperty("connectTimeout", "5000");  // 5 seconds

        try (Connection conn = DriverManager.getConnection(url, props)) {
            System.out.println("Connected with properties!");
        } catch (SQLException e) {
            System.err.println("Connection failed: " + e.getMessage());
        }
    }
}

import java.sql.*;

public class StatementExample {
    public static void main(String[] args) throws SQLException {
        try (Connection conn = DriverManager.getConnection(
                "jdbc:h2:mem:testdb", "sa", "")) {

            Statement stmt = conn.createStatement();

            // DDL -- creating a table (no user input, Statement is fine)
            stmt.executeUpdate("CREATE TABLE countries (id INT PRIMARY KEY, name VARCHAR(50))");

            // Static insert (no user input)
            stmt.executeUpdate("INSERT INTO countries VALUES (1, 'United States')");
            stmt.executeUpdate("INSERT INTO countries VALUES (2, 'Japan')");

            // Static query
            ResultSet rs = stmt.executeQuery("SELECT * FROM countries");
            while (rs.next()) {
                System.out.println(rs.getInt("id") + ": " + rs.getString("name"));
            }
        }
    }
}
// Output:
// 1: United States
// 2: Japan

// DANGEROUS -- NEVER DO THIS
public User findUser(String username) throws SQLException {
    Statement stmt = conn.createStatement();

    // User input is concatenated directly into SQL
    String sql = "SELECT * FROM users WHERE username = '" + username + "'";
    ResultSet rs = stmt.executeQuery(sql);
    // ...
}

// Normal input: username = "john"
// SQL becomes: SELECT * FROM users WHERE username = 'john'   <-- works fine

// Malicious input: username = "' OR '1'='1"
// SQL becomes: SELECT * FROM users WHERE username = '' OR '1'='1'
//              This returns ALL users!

// Even worse: username = "'; DROP TABLE users; --"
// SQL becomes: SELECT * FROM users WHERE username = ''; DROP TABLE users; --'
//              This DELETES your entire users table!

// SAFE -- Always use PreparedStatement for any query involving user input
public User findUser(String username) throws SQLException {
    String sql = "SELECT * FROM users WHERE username = ?";
    try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
        pstmt.setString(1, username);  // Parameter index starts at 1
        ResultSet rs = pstmt.executeQuery();
        // ...
    }
}

// Input: username = "' OR '1'='1"
// The driver treats the ENTIRE string as a literal value, not SQL.
// It effectively becomes: WHERE username = '\' OR \'1\'=\'1'
// No injection possible!

import java.sql.*;

public class CreateTableExample {
    public static void main(String[] args) {
        String url = "jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1";

        try (Connection conn = DriverManager.getConnection(url, "sa", "")) {

            String sql = """
                CREATE TABLE IF NOT EXISTS users (
                    id          INT AUTO_INCREMENT PRIMARY KEY,
                    username    VARCHAR(50)  NOT NULL UNIQUE,
                    email       VARCHAR(100) NOT NULL,
                    age         INT,
                    salary      DECIMAL(10,2),
                    active      BOOLEAN DEFAULT TRUE,
                    created_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                )
                """;

            try (Statement stmt = conn.createStatement()) {
                stmt.executeUpdate(sql);
                System.out.println("Table 'users' created successfully.");
            }

        } catch (SQLException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}
// Output:
// Table 'users' created successfully.

public class InsertExample {

    // Insert a single user and return the generated ID
    public static long insertUser(Connection conn, String username, String email,
                                   int age, double salary) throws SQLException {
        String sql = "INSERT INTO users (username, email, age, salary) VALUES (?, ?, ?, ?)";

        try (PreparedStatement pstmt = conn.prepareStatement(sql,
                Statement.RETURN_GENERATED_KEYS)) {

            pstmt.setString(1, username);
            pstmt.setString(2, email);
            pstmt.setInt(3, age);
            pstmt.setDouble(4, salary);

            int rowsAffected = pstmt.executeUpdate();
            System.out.println(rowsAffected + " row(s) inserted.");

            // Retrieve the auto-generated key
            try (ResultSet generatedKeys = pstmt.getGeneratedKeys()) {
                if (generatedKeys.next()) {
                    long id = generatedKeys.getLong(1);
                    System.out.println("Generated ID: " + id);
                    return id;
                }
            }
        }
        return -1;
    }

    public static void main(String[] args) throws SQLException {
        try (Connection conn = DriverManager.getConnection(
                "jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1", "sa", "")) {

            // Create table first (from previous example)
            // ...

            insertUser(conn, "john_doe", "john@example.com", 28, 75000.00);
            insertUser(conn, "jane_smith", "jane@example.com", 32, 92000.00);
            insertUser(conn, "bob_wilson", "bob@example.com", 45, 68000.00);
        }
    }
}
// Output:
// 1 row(s) inserted.
// Generated ID: 1
// 1 row(s) inserted.
// Generated ID: 2
// 1 row(s) inserted.
// Generated ID: 3

public class SelectExample {

    // Select all users
    public static void selectAllUsers(Connection conn) throws SQLException {
        String sql = "SELECT id, username, email, age, salary, active, created_at FROM users";

        try (PreparedStatement pstmt = conn.prepareStatement(sql);
             ResultSet rs = pstmt.executeQuery()) {

            System.out.println("--- All Users ---");
            while (rs.next()) {
                int id = rs.getInt("id");
                String username = rs.getString("username");
                String email = rs.getString("email");
                int age = rs.getInt("age");
                double salary = rs.getDouble("salary");
                boolean active = rs.getBoolean("active");
                Timestamp createdAt = rs.getTimestamp("created_at");

                System.out.printf("ID: %d | %s | %s | Age: %d | $%.2f | Active: %b | %s%n",
                        id, username, email, age, salary, active, createdAt);
            }
        }
    }

    // Select with a WHERE clause
    public static void selectUserByUsername(Connection conn, String username) throws SQLException {
        String sql = "SELECT * FROM users WHERE username = ?";

        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setString(1, username);

            try (ResultSet rs = pstmt.executeQuery()) {
                if (rs.next()) {
                    System.out.println("Found: " + rs.getString("username")
                            + " (" + rs.getString("email") + ")");
                } else {
                    System.out.println("User not found: " + username);
                }
            }
        }
    }

    // Select with multiple conditions
    public static void selectUsersAboveSalary(Connection conn, double minSalary)
            throws SQLException {
        String sql = "SELECT username, salary FROM users WHERE salary > ? AND active = ? ORDER BY salary DESC";

        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setDouble(1, minSalary);
            pstmt.setBoolean(2, true);

            try (ResultSet rs = pstmt.executeQuery()) {
                System.out.println("Users earning above $" + minSalary + ":");
                while (rs.next()) {
                    System.out.printf("  %s: $%.2f%n",
                            rs.getString("username"), rs.getDouble("salary"));
                }
            }
        }
    }
}
// Output:
// --- All Users ---
// ID: 1 | john_doe | john@example.com | Age: 28 | $75000.00 | Active: true | 2024-01-15 10:30:00.0
// ID: 2 | jane_smith | jane@example.com | Age: 32 | $92000.00 | Active: true | 2024-01-15 10:30:00.0
// ID: 3 | bob_wilson | bob@example.com | Age: 45 | $68000.00 | Active: true | 2024-01-15 10:30:00.0
//
// Found: john_doe (john@example.com)
//
// Users earning above $70000.0:
//   jane_smith: $92000.00
//   john_doe: $75000.00

public class UpdateExample {

    public static int updateUserEmail(Connection conn, int userId, String newEmail)
            throws SQLException {
        String sql = "UPDATE users SET email = ? WHERE id = ?";

        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setString(1, newEmail);
            pstmt.setInt(2, userId);

            int rowsAffected = pstmt.executeUpdate();
            if (rowsAffected > 0) {
                System.out.println("Updated email for user ID " + userId);
            } else {
                System.out.println("No user found with ID " + userId);
            }
            return rowsAffected;
        }
    }

    public static int giveRaise(Connection conn, double percentage, double minCurrentSalary)
            throws SQLException {
        String sql = "UPDATE users SET salary = salary * (1 + ? / 100) WHERE salary >= ?";

        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setDouble(1, percentage);
            pstmt.setDouble(2, minCurrentSalary);

            int rowsAffected = pstmt.executeUpdate();
            System.out.println(rowsAffected + " user(s) received a " + percentage + "% raise.");
            return rowsAffected;
        }
    }
}
// Output:
// Updated email for user ID 1
// 2 user(s) received a 10.0% raise.

public class DeleteExample {

    public static int deleteUser(Connection conn, int userId) throws SQLException {
        String sql = "DELETE FROM users WHERE id = ?";

        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setInt(1, userId);

            int rowsAffected = pstmt.executeUpdate();
            if (rowsAffected > 0) {
                System.out.println("Deleted user with ID " + userId);
            } else {
                System.out.println("No user found with ID " + userId);
            }
            return rowsAffected;
        }
    }

    // Soft delete -- better practice than hard delete
    public static int deactivateUser(Connection conn, int userId) throws SQLException {
        String sql = "UPDATE users SET active = false WHERE id = ? AND active = true";

        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setInt(1, userId);

            int rowsAffected = pstmt.executeUpdate();
            System.out.println(rowsAffected > 0 ? "User deactivated." : "User not found or already inactive.");
            return rowsAffected;
        }
    }
}
// Output:
// Deleted user with ID 3
// User deactivated.

public class ResultSetNavigation {
    public static void main(String[] args) throws SQLException {
        try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:testdb", "sa", "")) {
            // Setup
            Statement setup = conn.createStatement();
            setup.executeUpdate("CREATE TABLE products (id INT, name VARCHAR(50), price DECIMAL(10,2))");
            setup.executeUpdate("INSERT INTO products VALUES (1, 'Laptop', 999.99)");
            setup.executeUpdate("INSERT INTO products VALUES (2, 'Mouse', 29.99)");
            setup.executeUpdate("INSERT INTO products VALUES (3, 'Keyboard', 79.99)");

            // Basic forward-only iteration
            try (PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM products");
                 ResultSet rs = pstmt.executeQuery()) {

                // Access by column name (preferred -- more readable)
                while (rs.next()) {
                    String name = rs.getString("name");
                    double price = rs.getDouble("price");
                    System.out.println(name + ": $" + price);
                }
            }

            // Access by column index (1-based, faster but fragile)
            try (PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM products");
                 ResultSet rs = pstmt.executeQuery()) {

                while (rs.next()) {
                    int id = rs.getInt(1);        // column 1
                    String name = rs.getString(2); // column 2
                    double price = rs.getDouble(3); // column 3
                    System.out.println(id + ". " + name + ": $" + price);
                }
            }
        }
    }
}
// Output:
// Laptop: $999.99
// Mouse: $29.99
// Keyboard: $79.99
// 1. Laptop: $999.99
// 2. Mouse: $29.99
// 3. Keyboard: $79.99

// If age column is NULL in the database:
int age = rs.getInt("age");      // Returns 0 (not null, because int is a primitive)
boolean wasNull = rs.wasNull();  // Returns true -- the actual value was NULL

// Better approach: use wrapper types with getObject()
Integer age = rs.getObject("age", Integer.class);  // Returns null if column is NULL
if (age == null) {
    System.out.println("Age not provided");
} else {
    System.out.println("Age: " + age);
}

// For String, getString() already returns null for NULL columns
String email = rs.getString("email");  // Returns null if column is NULL

// Create a scrollable ResultSet
try (PreparedStatement pstmt = conn.prepareStatement(
        "SELECT * FROM products",
        ResultSet.TYPE_SCROLL_INSENSITIVE,
        ResultSet.CONCUR_READ_ONLY)) {

    ResultSet rs = pstmt.executeQuery();

    // Move to last row
    rs.last();
    System.out.println("Last product: " + rs.getString("name"));
    System.out.println("Total rows: " + rs.getRow());

    // Move to first row
    rs.first();
    System.out.println("First product: " + rs.getString("name"));

    // Move to a specific row
    rs.absolute(2);
    System.out.println("Second product: " + rs.getString("name"));

    // Move relative to current position
    rs.relative(-1);  // one row back
    System.out.println("Back to first: " + rs.getString("name"));
}
// Output:
// Last product: Keyboard
// Total rows: 3
// First product: Laptop
// Second product: Mouse
// Back to first: Laptop

try (PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM users");
     ResultSet rs = pstmt.executeQuery()) {

    ResultSetMetaData meta = rs.getMetaData();
    int columnCount = meta.getColumnCount();

    // Print column info
    System.out.println("Columns in result set:");
    for (int i = 1; i <= columnCount; i++) {
        System.out.printf("  %s (%s) - Nullable: %s%n",
                meta.getColumnName(i),
                meta.getColumnTypeName(i),
                meta.isNullable(i) == ResultSetMetaData.columnNullable ? "Yes" : "No");
    }

    // Print all data dynamically
    while (rs.next()) {
        for (int i = 1; i <= columnCount; i++) {
            System.out.print(meta.getColumnName(i) + "=" + rs.getObject(i) + " | ");
        }
        System.out.println();
    }
}
// Output:
// Columns in result set:
//   ID (INTEGER) - Nullable: No
//   USERNAME (VARCHAR) - Nullable: No
//   EMAIL (VARCHAR) - Nullable: No
//   AGE (INTEGER) - Nullable: Yes
//   SALARY (DECIMAL) - Nullable: Yes
//   ACTIVE (BOOLEAN) - Nullable: Yes
//   CREATED_AT (TIMESTAMP) - Nullable: Yes

import java.sql.*;

public class TransactionExample {

    public static void transferMoney(Connection conn, int fromAccountId,
                                      int toAccountId, double amount) throws SQLException {

        // Save auto-commit state to restore later
        boolean originalAutoCommit = conn.getAutoCommit();

        try {
            // Step 1: Disable auto-commit -- starts a transaction
            conn.setAutoCommit(false);

            // Step 2: Debit from source account
            String debitSql = "UPDATE accounts SET balance = balance - ? WHERE id = ? AND balance >= ?";
            try (PreparedStatement debit = conn.prepareStatement(debitSql)) {
                debit.setDouble(1, amount);
                debit.setInt(2, fromAccountId);
                debit.setDouble(3, amount);

                int rows = debit.executeUpdate();
                if (rows == 0) {
                    throw new SQLException("Insufficient funds or account not found: " + fromAccountId);
                }
            }

            // Step 3: Credit to destination account
            String creditSql = "UPDATE accounts SET balance = balance + ? WHERE id = ?";
            try (PreparedStatement credit = conn.prepareStatement(creditSql)) {
                credit.setDouble(1, amount);
                credit.setInt(2, toAccountId);

                int rows = credit.executeUpdate();
                if (rows == 0) {
                    throw new SQLException("Destination account not found: " + toAccountId);
                }
            }

            // Step 4: Both operations succeeded -- commit
            conn.commit();
            System.out.printf("Transferred $%.2f from account %d to account %d%n",
                    amount, fromAccountId, toAccountId);

        } catch (SQLException e) {
            // Step 5: Something went wrong -- rollback ALL changes
            conn.rollback();
            System.err.println("Transfer failed, rolled back: " + e.getMessage());
            throw e;

        } finally {
            // Restore original auto-commit state
            conn.setAutoCommit(originalAutoCommit);
        }
    }
}
// Output (success):
// Transferred $500.00 from account 1 to account 2
//
// Output (failure):
// Transfer failed, rolled back: Insufficient funds or account not found: 1

public static void processOrderWithSavepoint(Connection conn) throws SQLException {
    conn.setAutoCommit(false);
    Savepoint orderSavepoint = null;

    try {
        // Insert the order
        try (PreparedStatement pstmt = conn.prepareStatement(
                "INSERT INTO orders (customer_id, total) VALUES (?, ?)")) {
            pstmt.setInt(1, 42);
            pstmt.setDouble(2, 299.99);
            pstmt.executeUpdate();
        }

        // Mark a savepoint after the order is created
        orderSavepoint = conn.setSavepoint("afterOrder");

        // Try to insert shipping info (might fail)
        try {
            try (PreparedStatement pstmt = conn.prepareStatement(
                    "INSERT INTO shipping (order_id, address) VALUES (?, ?)")) {
                pstmt.setInt(1, 1);
                pstmt.setString(2, "123 Main St");
                pstmt.executeUpdate();
            }
        } catch (SQLException e) {
            // Shipping failed -- roll back to savepoint (order is still intact)
            conn.rollback(orderSavepoint);
            System.out.println("Shipping failed, but order preserved. Will ship later.");
        }

        conn.commit();
        System.out.println("Order processed successfully.");

    } catch (SQLException e) {
        conn.rollback();  // Roll back everything
        throw e;
    } finally {
        conn.setAutoCommit(true);
    }
}
// Output:
// Order processed successfully.

import java.sql.*;

public class BatchExample {

    public static void batchInsertUsers(Connection conn, List users) throws SQLException {
        String sql = "INSERT INTO users (username, email, age) VALUES (?, ?, ?)";

        conn.setAutoCommit(false);  // Wrap batch in a transaction for performance

        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {

            int batchSize = 500;  // Flush every 500 rows to avoid memory issues
            int count = 0;

            for (String[] user : users) {
                pstmt.setString(1, user[0]);  // username
                pstmt.setString(2, user[1]);  // email
                pstmt.setInt(3, Integer.parseInt(user[2]));  // age

                pstmt.addBatch();  // Add to batch
                count++;

                if (count % batchSize == 0) {
                    pstmt.executeBatch();  // Send batch to database
                    pstmt.clearBatch();    // Clear for next batch
                    System.out.println("Flushed " + count + " rows...");
                }
            }

            // Execute remaining records
            pstmt.executeBatch();

            conn.commit();
            System.out.println("Batch insert complete: " + count + " total rows.");

        } catch (SQLException e) {
            conn.rollback();
            System.err.println("Batch failed, rolled back: " + e.getMessage());
            throw e;
        } finally {
            conn.setAutoCommit(true);
        }
    }

    public static void main(String[] args) throws SQLException {
        try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:testdb", "sa", "")) {
            // Create table...

            List users = List.of(
                new String[]{"user1", "user1@mail.com", "25"},
                new String[]{"user2", "user2@mail.com", "30"},
                new String[]{"user3", "user3@mail.com", "35"},
                new String[]{"user4", "user4@mail.com", "28"},
                new String[]{"user5", "user5@mail.com", "42"}
            );

            batchInsertUsers(conn, users);
        }
    }
}
// Output:
// Batch insert complete: 5 total rows.

try (Statement stmt = conn.createStatement()) {
    conn.setAutoCommit(false);

    stmt.addBatch("INSERT INTO audit_log (action) VALUES ('User created')");
    stmt.addBatch("UPDATE users SET active = true WHERE id = 1");
    stmt.addBatch("DELETE FROM temp_tokens WHERE expired = true");

    int[] results = stmt.executeBatch();
    // results[0] = rows affected by first statement
    // results[1] = rows affected by second statement
    // results[2] = rows affected by third statement

    for (int i = 0; i < results.length; i++) {
        System.out.println("Statement " + (i + 1) + ": " + results[i] + " row(s) affected");
    }

    conn.commit();
}
// Output:
// Statement 1: 1 row(s) affected
// Statement 2: 1 row(s) affected
// Statement 3: 3 row(s) affected

Without Pooling:
  Request 1: Open connection -> Execute query -> Close connection  (200ms overhead)
  Request 2: Open connection -> Execute query -> Close connection  (200ms overhead)
  Request 3: Open connection -> Execute query -> Close connection  (200ms overhead)

With Pooling:
  Startup:   Create 10 connections in pool
  Request 1: Borrow connection -> Execute query -> Return to pool  (0ms overhead)
  Request 2: Borrow connection -> Execute query -> Return to pool  (0ms overhead)
  Request 3: Borrow connection -> Execute query -> Return to pool  (0ms overhead)

    com.zaxxer
    HikariCP
    5.1.0

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

public class ConnectionPoolExample {

    private static HikariDataSource dataSource;

    // Initialize the pool once at application startup
    public static void initPool() {
        HikariConfig config = new HikariConfig();

        // Required settings
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
        config.setUsername("root");
        config.setPassword("secret");

        // Pool sizing
        config.setMaximumPoolSize(10);    // Max connections in pool
        config.setMinimumIdle(5);         // Min idle connections maintained
        config.setIdleTimeout(300000);    // 5 min -- close idle connections after this
        config.setMaxLifetime(1800000);   // 30 min -- max lifetime of a connection

        // Connection validation
        config.setConnectionTimeout(30000);  // 30 sec -- wait for connection from pool
        config.setConnectionTestQuery("SELECT 1");  // Validate connection health

        // Performance settings
        config.addDataSourceProperty("cachePrepStmts", "true");
        config.addDataSourceProperty("prepStmtCacheSize", "250");
        config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");

        dataSource = new HikariDataSource(config);
        System.out.println("Connection pool initialized.");
    }

    // Get a connection from the pool
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }

    // Shutdown the pool at application exit
    public static void closePool() {
        if (dataSource != null && !dataSource.isClosed()) {
            dataSource.close();
            System.out.println("Connection pool closed.");
        }
    }

    public static void main(String[] args) {
        initPool();

        // Use connections from the pool
        try (Connection conn = getConnection()) {
            // Connection is borrowed from the pool
            System.out.println("Got connection from pool: " + conn.isValid(2));
            // ... do work ...
        } catch (SQLException e) {
            e.printStackTrace();
        }
        // Connection is returned to the pool here, NOT closed

        closePool();
    }
}
// Output:
// Connection pool initialized.
// Got connection from pool: true
// Connection pool closed.

-- MySQL stored procedure: Get user by ID
DELIMITER //
CREATE PROCEDURE get_user_by_id(IN user_id INT)
BEGIN
    SELECT id, username, email, salary FROM users WHERE id = user_id;
END //
DELIMITER ;

-- MySQL stored procedure with OUT parameter
DELIMITER //
CREATE PROCEDURE count_active_users(OUT user_count INT)
BEGIN
    SELECT COUNT(*) INTO user_count FROM users WHERE active = true;
END //
DELIMITER ;

-- MySQL stored procedure with IN and OUT
DELIMITER //
CREATE PROCEDURE calculate_bonus(
    IN employee_id INT,
    IN bonus_percentage DECIMAL(5,2),
    OUT bonus_amount DECIMAL(10,2)
)
BEGIN
    SELECT salary * (bonus_percentage / 100) INTO bonus_amount
    FROM users WHERE id = employee_id;
END //
DELIMITER ;

import java.sql.*;

public class StoredProcedureExample {

    // Call procedure with IN parameter that returns a ResultSet
    public static void getUserById(Connection conn, int userId) throws SQLException {
        String sql = "{CALL get_user_by_id(?)}";

        try (CallableStatement cstmt = conn.prepareCall(sql)) {
            cstmt.setInt(1, userId);

            try (ResultSet rs = cstmt.executeQuery()) {
                if (rs.next()) {
                    System.out.printf("User: %s (%s) - $%.2f%n",
                            rs.getString("username"),
                            rs.getString("email"),
                            rs.getDouble("salary"));
                }
            }
        }
    }

    // Call procedure with OUT parameter
    public static int countActiveUsers(Connection conn) throws SQLException {
        String sql = "{CALL count_active_users(?)}";

        try (CallableStatement cstmt = conn.prepareCall(sql)) {
            cstmt.registerOutParameter(1, Types.INTEGER);  // Register OUT param
            cstmt.execute();

            int count = cstmt.getInt(1);  // Get the OUT value
            System.out.println("Active users: " + count);
            return count;
        }
    }

    // Call procedure with IN and OUT parameters
    public static double calculateBonus(Connection conn, int employeeId,
                                         double percentage) throws SQLException {
        String sql = "{CALL calculate_bonus(?, ?, ?)}";

        try (CallableStatement cstmt = conn.prepareCall(sql)) {
            cstmt.setInt(1, employeeId);                      // IN
            cstmt.setDouble(2, percentage);                    // IN
            cstmt.registerOutParameter(3, Types.DECIMAL);      // OUT
            cstmt.execute();

            double bonus = cstmt.getDouble(3);
            System.out.printf("Bonus for employee %d at %.1f%%: $%.2f%n",
                    employeeId, percentage, bonus);
            return bonus;
        }
    }
}
// Output:
// User: john_doe (john@example.com) - $75000.00
// Active users: 3
// Bonus for employee 1 at 10.0%: $7500.00

// WRONG -- SQL injection vulnerability
String sql = "SELECT * FROM users WHERE username = '" + userInput + "'";
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql);

// RIGHT -- parameterized query
String sql = "SELECT * FROM users WHERE username = ?";
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.setString(1, userInput);
ResultSet rs = pstmt.executeQuery();

// WRONG -- resources never closed if exception occurs
Connection conn = DriverManager.getConnection(url, user, password);
PreparedStatement pstmt = conn.prepareStatement(sql);
ResultSet rs = pstmt.executeQuery();
// if exception here, conn, pstmt, and rs are leaked
rs.close();
pstmt.close();
conn.close();

// RIGHT -- try-with-resources guarantees cleanup
try (Connection conn = DriverManager.getConnection(url, user, password);
     PreparedStatement pstmt = conn.prepareStatement(sql);
     ResultSet rs = pstmt.executeQuery()) {
    // Work with rs...
} // All three auto-closed, even on exception

// WRONG -- auto-commit means each statement is independent
pstmt1.executeUpdate();  // Debits account A -- committed immediately
pstmt2.executeUpdate();  // Credits account B -- FAILS!
// Account A was debited but account B was never credited. Money vanished.

// RIGHT -- wrap related operations in a transaction
conn.setAutoCommit(false);
try {
    pstmt1.executeUpdate();  // Debits account A -- NOT committed yet
    pstmt2.executeUpdate();  // Credits account B -- NOT committed yet
    conn.commit();           // Both committed together
} catch (SQLException e) {
    conn.rollback();         // Both rolled back together
}

// WRONG -- N+1 problem: 1 query to get orders + N queries to get users
ResultSet orders = stmt.executeQuery("SELECT * FROM orders");  // 1 query
while (orders.next()) {
    int userId = orders.getInt("user_id");
    // This runs once per order -- if 1000 orders, that's 1000 extra queries!
    PreparedStatement userStmt = conn.prepareStatement("SELECT * FROM users WHERE id = ?");
    userStmt.setInt(1, userId);
    ResultSet user = userStmt.executeQuery();
    // ...
}

// RIGHT -- use a JOIN to get all data in one query
String sql = """
    SELECT o.id AS order_id, o.total, u.username, u.email
    FROM orders o
    JOIN users u ON o.user_id = u.id
    """;
ResultSet rs = stmt.executeQuery(sql);  // 1 query for everything

// WRONG -- credentials in source code (committed to git!)
Connection conn = DriverManager.getConnection(
    "jdbc:mysql://prod-server:3306/mydb", "admin", "P@ssw0rd!");

// RIGHT -- use environment variables or config files
String url = System.getenv("DB_URL");
String user = System.getenv("DB_USER");
String password = System.getenv("DB_PASSWORD");
Connection conn = DriverManager.getConnection(url, user, password);

// WRONG -- loses type safety, requires casting
Object value = rs.getObject("salary");
double salary = (Double) value;  // ClassCastException if null or wrong type

// RIGHT -- use typed getters
double salary = rs.getDouble("salary");
if (rs.wasNull()) {
    // Handle null case
}

// ALSO RIGHT -- use getObject with type parameter (Java 7+)
Double salary = rs.getObject("salary", Double.class);  // Returns null if SQL NULL

// Gold standard pattern for JDBC
try (Connection conn = dataSource.getConnection();
     PreparedStatement pstmt = conn.prepareStatement(sql)) {

    pstmt.setString(1, value);

    try (ResultSet rs = pstmt.executeQuery()) {
        while (rs.next()) {
            // Process row
        }
    }
}

public void doMultiStepWork(Connection conn) throws SQLException {
    conn.setAutoCommit(false);
    try {
        // Step 1...
        // Step 2...
        // Step 3...
        conn.commit();
    } catch (SQLException e) {
        conn.rollback();
        throw e;  // Re-throw so the caller knows it failed
    } finally {
        conn.setAutoCommit(true);
    }
}

try {
    // database operation
} catch (SQLException e) {
    // Log ALL the information -- you will need it for debugging
    logger.error("Database error - Message: {} | SQLState: {} | ErrorCode: {} | SQL: {}",
            e.getMessage(), e.getSQLState(), e.getErrorCode(), sql, e);
    throw e;  // Re-throw or wrap in a custom exception
}

// WRONG -- what does rs.getString(1) mean? Fragile if column order changes.
ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM table1");
String x = rs.getString(1);

// RIGHT -- use aliases and access by name
String sql = """
    SELECT u.username AS user_name,
           o.total    AS order_total,
           o.created  AS order_date
    FROM users u
    JOIN orders o ON u.id = o.user_id
    """;
ResultSet rs = stmt.executeQuery(sql);
String name = rs.getString("user_name");
double total = rs.getDouble("order_total");

    +------------------+          +------------------+
    |   UserService    | -------> |    UserDAO       |  <-- Interface
    | (business logic) |          |  (data contract) |
    +------------------+          +------------------+
                                         ^
                                         |  implements
                                  +------------------+
                                  |  UserDAOImpl     |  <-- JDBC implementation
                                  | (SQL + JDBC)     |
                                  +------------------+

import java.time.LocalDateTime;

public class User {
    private int id;
    private String username;
    private String email;
    private int age;
    private double salary;
    private boolean active;
    private LocalDateTime createdAt;

    // No-arg constructor (needed for DAO mapping)
    public User() {}

    // Constructor for creating new users (no ID yet)
    public User(String username, String email, int age, double salary) {
        this.username = username;
        this.email = email;
        this.age = age;
        this.salary = salary;
        this.active = true;
    }

    // Getters and setters
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public double getSalary() { return salary; }
    public void setSalary(double salary) { this.salary = salary; }
    public boolean isActive() { return active; }
    public void setActive(boolean active) { this.active = active; }
    public LocalDateTime getCreatedAt() { return createdAt; }
    public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }

    @Override
    public String toString() {
        return String.format("User{id=%d, username='%s', email='%s', age=%d, salary=%.2f, active=%b}",
                id, username, email, age, salary, active);
    }
}

import java.util.List;
import java.util.Optional;

public interface UserDAO {
    // Create
    User save(User user);

    // Read
    Optional findById(int id);
    Optional findByUsername(String username);
    List findAll();
    List findByMinSalary(double minSalary);

    // Update
    boolean update(User user);

    // Delete
    boolean deleteById(int id);

    // Count
    long count();
}

import javax.sql.DataSource;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

public class UserDAOImpl implements UserDAO {

    private final DataSource dataSource;

    public UserDAOImpl(DataSource dataSource) {
        this.dataSource = dataSource;  // Injected -- no hardcoded connection info
    }

    @Override
    public User save(User user) {
        String sql = "INSERT INTO users (username, email, age, salary, active) VALUES (?, ?, ?, ?, ?)";

        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {

            pstmt.setString(1, user.getUsername());
            pstmt.setString(2, user.getEmail());
            pstmt.setInt(3, user.getAge());
            pstmt.setDouble(4, user.getSalary());
            pstmt.setBoolean(5, user.isActive());

            pstmt.executeUpdate();

            try (ResultSet keys = pstmt.getGeneratedKeys()) {
                if (keys.next()) {
                    user.setId(keys.getInt(1));
                }
            }
            return user;

        } catch (SQLException e) {
            throw new RuntimeException("Failed to save user: " + user.getUsername(), e);
        }
    }

    @Override
    public Optional findById(int id) {
        String sql = "SELECT * FROM users WHERE id = ?";

        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setInt(1, id);

            try (ResultSet rs = pstmt.executeQuery()) {
                if (rs.next()) {
                    return Optional.of(mapRow(rs));
                }
            }
            return Optional.empty();

        } catch (SQLException e) {
            throw new RuntimeException("Failed to find user by ID: " + id, e);
        }
    }

    @Override
    public Optional findByUsername(String username) {
        String sql = "SELECT * FROM users WHERE username = ?";

        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setString(1, username);

            try (ResultSet rs = pstmt.executeQuery()) {
                if (rs.next()) {
                    return Optional.of(mapRow(rs));
                }
            }
            return Optional.empty();

        } catch (SQLException e) {
            throw new RuntimeException("Failed to find user by username: " + username, e);
        }
    }

    @Override
    public List findAll() {
        String sql = "SELECT * FROM users ORDER BY id";
        List users = new ArrayList<>();

        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql);
             ResultSet rs = pstmt.executeQuery()) {

            while (rs.next()) {
                users.add(mapRow(rs));
            }
            return users;

        } catch (SQLException e) {
            throw new RuntimeException("Failed to find all users", e);
        }
    }

    @Override
    public List findByMinSalary(double minSalary) {
        String sql = "SELECT * FROM users WHERE salary >= ? ORDER BY salary DESC";
        List users = new ArrayList<>();

        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setDouble(1, minSalary);

            try (ResultSet rs = pstmt.executeQuery()) {
                while (rs.next()) {
                    users.add(mapRow(rs));
                }
            }
            return users;

        } catch (SQLException e) {
            throw new RuntimeException("Failed to find users by salary", e);
        }
    }

    @Override
    public boolean update(User user) {
        String sql = "UPDATE users SET username = ?, email = ?, age = ?, salary = ?, active = ? WHERE id = ?";

        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setString(1, user.getUsername());
            pstmt.setString(2, user.getEmail());
            pstmt.setInt(3, user.getAge());
            pstmt.setDouble(4, user.getSalary());
            pstmt.setBoolean(5, user.isActive());
            pstmt.setInt(6, user.getId());

            return pstmt.executeUpdate() > 0;

        } catch (SQLException e) {
            throw new RuntimeException("Failed to update user: " + user.getId(), e);
        }
    }

    @Override
    public boolean deleteById(int id) {
        String sql = "DELETE FROM users WHERE id = ?";

        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setInt(1, id);
            return pstmt.executeUpdate() > 0;

        } catch (SQLException e) {
            throw new RuntimeException("Failed to delete user: " + id, e);
        }
    }

    @Override
    public long count() {
        String sql = "SELECT COUNT(*) FROM users";

        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql);
             ResultSet rs = pstmt.executeQuery()) {

            rs.next();
            return rs.getLong(1);

        } catch (SQLException e) {
            throw new RuntimeException("Failed to count users", e);
        }
    }

    // Private helper -- maps a ResultSet row to a User object
    private User mapRow(ResultSet rs) throws SQLException {
        User user = new User();
        user.setId(rs.getInt("id"));
        user.setUsername(rs.getString("username"));
        user.setEmail(rs.getString("email"));
        user.setAge(rs.getInt("age"));
        user.setSalary(rs.getDouble("salary"));
        user.setActive(rs.getBoolean("active"));

        Timestamp ts = rs.getTimestamp("created_at");
        if (ts != null) {
            user.setCreatedAt(ts.toLocalDateTime());
        }
        return user;
    }
}

public class UserService {

    private final UserDAO userDAO;

    public UserService(UserDAO userDAO) {
        this.userDAO = userDAO;  // Dependency injection
    }

    public User registerUser(String username, String email, int age, double salary) {
        // Business logic validation -- no SQL here
        if (username == null || username.isBlank()) {
            throw new IllegalArgumentException("Username cannot be empty");
        }
        if (userDAO.findByUsername(username).isPresent()) {
            throw new IllegalArgumentException("Username already taken: " + username);
        }

        User user = new User(username, email, age, salary);
        return userDAO.save(user);
    }

    public User getUserOrThrow(int id) {
        return userDAO.findById(id)
                .orElseThrow(() -> new RuntimeException("User not found: " + id));
    }

    public List getHighEarners(double threshold) {
        return userDAO.findByMinSalary(threshold);
    }
}

// Usage:
// UserDAO dao = new UserDAOImpl(dataSource);
// UserService service = new UserService(dao);
// User user = service.registerUser("john_doe", "john@example.com", 28, 75000);

src/
  Employee.java              -- Model class
  EmployeeDAO.java            -- DAO interface
  EmployeeDAOImpl.java        -- JDBC implementation with all best practices
  EmployeeApp.java            -- Main application demonstrating all operations

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;

public class Employee {
    private int id;
    private String firstName;
    private String lastName;
    private String email;
    private String department;
    private BigDecimal salary;
    private LocalDate hireDate;
    private boolean active;
    private LocalDateTime createdAt;

    public Employee() {}

    public Employee(String firstName, String lastName, String email,
                    String department, BigDecimal salary, LocalDate hireDate) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
        this.department = department;
        this.salary = salary;
        this.hireDate = hireDate;
        this.active = true;
    }

    // Getters and setters
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getFirstName() { return firstName; }
    public void setFirstName(String firstName) { this.firstName = firstName; }
    public String getLastName() { return lastName; }
    public void setLastName(String lastName) { this.lastName = lastName; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public String getDepartment() { return department; }
    public void setDepartment(String department) { this.department = department; }
    public BigDecimal getSalary() { return salary; }
    public void setSalary(BigDecimal salary) { this.salary = salary; }
    public LocalDate getHireDate() { return hireDate; }
    public void setHireDate(LocalDate hireDate) { this.hireDate = hireDate; }
    public boolean isActive() { return active; }
    public void setActive(boolean active) { this.active = active; }
    public LocalDateTime getCreatedAt() { return createdAt; }
    public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }

    public String getFullName() {
        return firstName + " " + lastName;
    }

    @Override
    public String toString() {
        return String.format("Employee{id=%d, name='%s %s', dept='%s', salary=%s, active=%b}",
                id, firstName, lastName, department, salary, active);
    }
}

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

public interface EmployeeDAO {

    // Schema management
    void createTable();

    // CRUD
    Employee save(Employee employee);
    Optional findById(int id);
    List findAll();
    List findByDepartment(String department);
    boolean update(Employee employee);
    boolean deleteById(int id);

    // Batch
    int[] saveBatch(List employees);

    // Transaction example
    boolean transferDepartment(int employeeId, String newDepartment, BigDecimal salaryAdjustment);

    // Aggregation
    long count();
    BigDecimal getAverageSalaryByDepartment(String department);
}

import javax.sql.DataSource;
import java.math.BigDecimal;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

public class EmployeeDAOImpl implements EmployeeDAO {

    private final DataSource dataSource;

    public EmployeeDAOImpl(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    @Override
    public void createTable() {
        String sql = """
            CREATE TABLE IF NOT EXISTS employees (
                id          INT AUTO_INCREMENT PRIMARY KEY,
                first_name  VARCHAR(50) NOT NULL,
                last_name   VARCHAR(50) NOT NULL,
                email       VARCHAR(100) NOT NULL UNIQUE,
                department  VARCHAR(50) NOT NULL,
                salary      DECIMAL(10,2) NOT NULL,
                hire_date   DATE NOT NULL,
                active      BOOLEAN DEFAULT TRUE,
                created_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
            """;

        try (Connection conn = dataSource.getConnection();
             Statement stmt = conn.createStatement()) {
            stmt.executeUpdate(sql);
        } catch (SQLException e) {
            throw new RuntimeException("Failed to create employees table", e);
        }
    }

    @Override
    public Employee save(Employee emp) {
        String sql = """
            INSERT INTO employees (first_name, last_name, email, department, salary, hire_date, active)
            VALUES (?, ?, ?, ?, ?, ?, ?)
            """;

        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {

            setEmployeeParams(pstmt, emp);
            pstmt.executeUpdate();

            try (ResultSet keys = pstmt.getGeneratedKeys()) {
                if (keys.next()) {
                    emp.setId(keys.getInt(1));
                }
            }
            return emp;

        } catch (SQLException e) {
            throw new RuntimeException("Failed to save employee: " + emp.getEmail(), e);
        }
    }

    @Override
    public Optional findById(int id) {
        String sql = "SELECT * FROM employees WHERE id = ?";

        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setInt(1, id);
            try (ResultSet rs = pstmt.executeQuery()) {
                return rs.next() ? Optional.of(mapRow(rs)) : Optional.empty();
            }

        } catch (SQLException e) {
            throw new RuntimeException("Failed to find employee: " + id, e);
        }
    }

    @Override
    public List findAll() {
        String sql = "SELECT * FROM employees ORDER BY last_name, first_name";
        return executeQuery(sql);
    }

    @Override
    public List findByDepartment(String department) {
        String sql = "SELECT * FROM employees WHERE department = ? AND active = true ORDER BY last_name";
        List employees = new ArrayList<>();

        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setString(1, department);
            try (ResultSet rs = pstmt.executeQuery()) {
                while (rs.next()) {
                    employees.add(mapRow(rs));
                }
            }
            return employees;

        } catch (SQLException e) {
            throw new RuntimeException("Failed to find employees in department: " + department, e);
        }
    }

    @Override
    public boolean update(Employee emp) {
        String sql = """
            UPDATE employees
            SET first_name = ?, last_name = ?, email = ?, department = ?,
                salary = ?, hire_date = ?, active = ?
            WHERE id = ?
            """;

        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            setEmployeeParams(pstmt, emp);
            pstmt.setInt(8, emp.getId());
            return pstmt.executeUpdate() > 0;

        } catch (SQLException e) {
            throw new RuntimeException("Failed to update employee: " + emp.getId(), e);
        }
    }

    @Override
    public boolean deleteById(int id) {
        String sql = "DELETE FROM employees WHERE id = ?";

        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setInt(1, id);
            return pstmt.executeUpdate() > 0;

        } catch (SQLException e) {
            throw new RuntimeException("Failed to delete employee: " + id, e);
        }
    }

    @Override
    public int[] saveBatch(List employees) {
        String sql = """
            INSERT INTO employees (first_name, last_name, email, department, salary, hire_date, active)
            VALUES (?, ?, ?, ?, ?, ?, ?)
            """;

        try (Connection conn = dataSource.getConnection()) {
            conn.setAutoCommit(false);

            try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
                for (Employee emp : employees) {
                    setEmployeeParams(pstmt, emp);
                    pstmt.addBatch();
                }

                int[] results = pstmt.executeBatch();
                conn.commit();
                return results;

            } catch (SQLException e) {
                conn.rollback();
                throw e;
            } finally {
                conn.setAutoCommit(true);
            }

        } catch (SQLException e) {
            throw new RuntimeException("Batch insert failed", e);
        }
    }

    @Override
    public boolean transferDepartment(int employeeId, String newDepartment,
                                       BigDecimal salaryAdjustment) {
        String updateEmpSql = "UPDATE employees SET department = ?, salary = salary + ? WHERE id = ?";
        String auditSql = """
            INSERT INTO department_transfers (employee_id, new_department, salary_change, transfer_date)
            VALUES (?, ?, ?, CURRENT_DATE)
            """;

        try (Connection conn = dataSource.getConnection()) {
            conn.setAutoCommit(false);

            try {
                // Step 1: Update employee's department and salary
                try (PreparedStatement pstmt = conn.prepareStatement(updateEmpSql)) {
                    pstmt.setString(1, newDepartment);
                    pstmt.setBigDecimal(2, salaryAdjustment);
                    pstmt.setInt(3, employeeId);

                    int rows = pstmt.executeUpdate();
                    if (rows == 0) {
                        throw new SQLException("Employee not found: " + employeeId);
                    }
                }

                // Step 2: Record the transfer in audit table
                // (Create audit table if it does not exist)
                try (Statement stmt = conn.createStatement()) {
                    stmt.executeUpdate("""
                        CREATE TABLE IF NOT EXISTS department_transfers (
                            id INT AUTO_INCREMENT PRIMARY KEY,
                            employee_id INT NOT NULL,
                            new_department VARCHAR(50) NOT NULL,
                            salary_change DECIMAL(10,2),
                            transfer_date DATE NOT NULL
                        )
                        """);
                }

                try (PreparedStatement pstmt = conn.prepareStatement(auditSql)) {
                    pstmt.setInt(1, employeeId);
                    pstmt.setString(2, newDepartment);
                    pstmt.setBigDecimal(3, salaryAdjustment);
                    pstmt.executeUpdate();
                }

                conn.commit();
                return true;

            } catch (SQLException e) {
                conn.rollback();
                throw e;
            } finally {
                conn.setAutoCommit(true);
            }

        } catch (SQLException e) {
            throw new RuntimeException("Department transfer failed for employee: " + employeeId, e);
        }
    }

    @Override
    public long count() {
        String sql = "SELECT COUNT(*) FROM employees";

        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql);
             ResultSet rs = pstmt.executeQuery()) {

            rs.next();
            return rs.getLong(1);

        } catch (SQLException e) {
            throw new RuntimeException("Failed to count employees", e);
        }
    }

    @Override
    public BigDecimal getAverageSalaryByDepartment(String department) {
        String sql = "SELECT AVG(salary) FROM employees WHERE department = ? AND active = true";

        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setString(1, department);
            try (ResultSet rs = pstmt.executeQuery()) {
                rs.next();
                BigDecimal avg = rs.getBigDecimal(1);
                return avg != null ? avg : BigDecimal.ZERO;
            }

        } catch (SQLException e) {
            throw new RuntimeException("Failed to get average salary for: " + department, e);
        }
    }

    // ---------- Private Helpers ----------

    private void setEmployeeParams(PreparedStatement pstmt, Employee emp) throws SQLException {
        pstmt.setString(1, emp.getFirstName());
        pstmt.setString(2, emp.getLastName());
        pstmt.setString(3, emp.getEmail());
        pstmt.setString(4, emp.getDepartment());
        pstmt.setBigDecimal(5, emp.getSalary());
        pstmt.setDate(6, Date.valueOf(emp.getHireDate()));
        pstmt.setBoolean(7, emp.isActive());
    }

    private Employee mapRow(ResultSet rs) throws SQLException {
        Employee emp = new Employee();
        emp.setId(rs.getInt("id"));
        emp.setFirstName(rs.getString("first_name"));
        emp.setLastName(rs.getString("last_name"));
        emp.setEmail(rs.getString("email"));
        emp.setDepartment(rs.getString("department"));
        emp.setSalary(rs.getBigDecimal("salary"));
        emp.setHireDate(rs.getDate("hire_date").toLocalDate());
        emp.setActive(rs.getBoolean("active"));
        Timestamp ts = rs.getTimestamp("created_at");
        if (ts != null) {
            emp.setCreatedAt(ts.toLocalDateTime());
        }
        return emp;
    }

    private List executeQuery(String sql) {
        List employees = new ArrayList<>();
        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql);
             ResultSet rs = pstmt.executeQuery()) {

            while (rs.next()) {
                employees.add(mapRow(rs));
            }
            return employees;

        } catch (SQLException e) {
            throw new RuntimeException("Query failed: " + sql, e);
        }
    }
}

import org.h2.jdbcx.JdbcDataSource;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.List;

public class EmployeeApp {

    public static void main(String[] args) {
        // 1. Set up DataSource (H2 in-memory database)
        JdbcDataSource dataSource = new JdbcDataSource();
        dataSource.setURL("jdbc:h2:mem:company;DB_CLOSE_DELAY=-1");
        dataSource.setUser("sa");
        dataSource.setPassword("");

        // 2. Create DAO
        EmployeeDAO dao = new EmployeeDAOImpl(dataSource);

        // 3. Create the table
        dao.createTable();
        System.out.println("=== Table created ===\n");

        // 4. INSERT -- Save individual employees
        Employee alice = dao.save(new Employee(
                "Alice", "Johnson", "alice@company.com",
                "Engineering", new BigDecimal("95000.00"), LocalDate.of(2020, 3, 15)));
        Employee bob = dao.save(new Employee(
                "Bob", "Smith", "bob@company.com",
                "Engineering", new BigDecimal("88000.00"), LocalDate.of(2021, 7, 1)));
        System.out.println("Saved: " + alice);
        System.out.println("Saved: " + bob);

        // 5. BATCH INSERT -- Save multiple employees at once
        List batch = List.of(
                new Employee("Carol", "Williams", "carol@company.com",
                        "Marketing", new BigDecimal("72000.00"), LocalDate.of(2022, 1, 10)),
                new Employee("David", "Brown", "david@company.com",
                        "Marketing", new BigDecimal("68000.00"), LocalDate.of(2022, 6, 20)),
                new Employee("Eve", "Davis", "eve@company.com",
                        "Engineering", new BigDecimal("105000.00"), LocalDate.of(2019, 11, 5))
        );
        int[] batchResults = dao.saveBatch(batch);
        System.out.println("\nBatch inserted " + batchResults.length + " employees.");

        // 6. SELECT -- Find all employees
        System.out.println("\n=== All Employees ===");
        List allEmployees = dao.findAll();
        allEmployees.forEach(System.out::println);

        // 7. SELECT -- Find by ID
        System.out.println("\n=== Find by ID ===");
        dao.findById(1).ifPresentOrElse(
                e -> System.out.println("Found: " + e),
                () -> System.out.println("Not found")
        );

        // 8. SELECT -- Find by department
        System.out.println("\n=== Engineering Department ===");
        dao.findByDepartment("Engineering").forEach(System.out::println);

        // 9. UPDATE -- Give Alice a raise
        System.out.println("\n=== Update: Alice gets a raise ===");
        alice.setSalary(new BigDecimal("105000.00"));
        alice.setEmail("alice.johnson@company.com");
        boolean updated = dao.update(alice);
        System.out.println("Updated: " + updated);
        dao.findById(alice.getId()).ifPresent(System.out::println);

        // 10. TRANSACTION -- Transfer Bob to Marketing with a salary adjustment
        System.out.println("\n=== Transaction: Transfer Bob to Marketing ===");
        boolean transferred = dao.transferDepartment(bob.getId(), "Marketing", new BigDecimal("5000.00"));
        System.out.println("Transfer successful: " + transferred);
        dao.findById(bob.getId()).ifPresent(System.out::println);

        // 11. AGGREGATION -- Average salary by department
        System.out.println("\n=== Average Salaries ===");
        System.out.println("Engineering avg: $" + dao.getAverageSalaryByDepartment("Engineering"));
        System.out.println("Marketing avg: $" + dao.getAverageSalaryByDepartment("Marketing"));

        // 12. DELETE -- Remove David
        System.out.println("\n=== Delete David ===");
        boolean deleted = dao.deleteById(4);
        System.out.println("Deleted: " + deleted);

        // 13. Final state
        System.out.println("\n=== Final State ===");
        System.out.println("Total employees: " + dao.count());
        dao.findAll().forEach(System.out::println);
    }
}

=== Table created ===

Saved: Employee{id=1, name='Alice Johnson', dept='Engineering', salary=95000.00, active=true}
Saved: Employee{id=2, name='Bob Smith', dept='Engineering', salary=88000.00, active=true}

Batch inserted 3 employees.

=== All Employees ===
Employee{id=4, name='David Brown', dept='Marketing', salary=68000.00, active=true}
Employee{id=5, name='Eve Davis', dept='Engineering', salary=105000.00, active=true}
Employee{id=1, name='Alice Johnson', dept='Engineering', salary=95000.00, active=true}
Employee{id=2, name='Bob Smith', dept='Engineering', salary=88000.00, active=true}
Employee{id=3, name='Carol Williams', dept='Marketing', salary=72000.00, active=true}

=== Find by ID ===
Found: Employee{id=1, name='Alice Johnson', dept='Engineering', salary=95000.00, active=true}

=== Engineering Department ===
Employee{id=5, name='Eve Davis', dept='Engineering', salary=105000.00, active=true}
Employee{id=1, name='Alice Johnson', dept='Engineering', salary=95000.00, active=true}
Employee{id=2, name='Bob Smith', dept='Engineering', salary=88000.00, active=true}

=== Update: Alice gets a raise ===
Updated: true
Employee{id=1, name='Alice Johnson', dept='Engineering', salary=105000.00, active=true}

=== Transaction: Transfer Bob to Marketing ===
Transfer successful: true
Employee{id=2, name='Bob Smith', dept='Marketing', salary=93000.00, active=true}

=== Average Salaries ===
Engineering avg: $105000.00
Marketing avg: $77666.67

=== Delete David ===
Deleted: true

=== Final State ===
Total employees: 4
Employee{id=5, name='Eve Davis', dept='Engineering', salary=105000.00, active=true}
Employee{id=1, name='Alice Johnson', dept='Engineering', salary=105000.00, active=true}
Employee{id=2, name='Bob Smith', dept='Marketing', salary=93000.00, active=true}
Employee{id=3, name='Carol Williams', dept='Marketing', salary=72000.00, active=true}

Regex

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class RegexBasics {
    public static void main(String[] args) {
        // Step 1: Compile the pattern
        Pattern pattern = Pattern.compile("Java");

        // Step 2: Create a matcher for the input string
        Matcher matcher = pattern.matcher("I love Java programming");

        // Step 3: Execute matching operations
        boolean found = matcher.find();
        System.out.println("Found 'Java': " + found); // Found 'Java': true

        // matches() checks if the ENTIRE string matches the pattern
        boolean fullMatch = matcher.matches();
        System.out.println("Entire string is 'Java': " + fullMatch); // Entire string is 'Java': false

        // Reset and find the match position
        matcher.reset();
        if (matcher.find()) {
            System.out.println("Match starts at index: " + matcher.start()); // Match starts at index: 7
            System.out.println("Match ends at index: " + matcher.end());     // Match ends at index: 11
            System.out.println("Matched text: " + matcher.group());          // Matched text: Java
        }
    }
}

// Quick one-off match (compiles a new Pattern every call -- avoid in loops)
boolean isMatch = Pattern.matches("\\d+", "12345");
System.out.println("All digits: " + isMatch); // All digits: true

// Even quicker: String.matches() delegates to Pattern.matches()
boolean isDigits = "12345".matches("\\d+");
System.out.println("All digits: " + isDigits); // All digits: true

import java.util.regex.*;

public class MetacharacterEscaping {
    public static void main(String[] args) {
        // Without escaping: . matches ANY character
        System.out.println("file.txt".matches("file.txt"));  // true
        System.out.println("fileXtxt".matches("file.txt"));  // true -- oops, . matched 'X'

        // With escaping: \\. matches only a literal dot
        System.out.println("file.txt".matches("file\\.txt")); // true
        System.out.println("fileXtxt".matches("file\\.txt")); // false -- correct!

        // Matching a literal dollar sign in a price
        Pattern price = Pattern.compile("\\$\\d+\\.\\d{2}");
        System.out.println(price.matcher("$19.99").matches()); // true
        System.out.println(price.matcher("$5.00").matches());  // true
        System.out.println(price.matcher("19.99").matches());  // false -- missing $

        // Use Pattern.quote() to treat an entire string as a literal
        String userInput = "price is $10.00 (USD)";
        String searchTerm = "$10.00";
        Pattern literal = Pattern.compile(Pattern.quote(searchTerm));
        Matcher m = literal.matcher(userInput);
        System.out.println(m.find()); // true -- matched "$10.00" literally
    }
}

import java.util.regex.*;

public class CharacterClasses {
    public static void main(String[] args) {
        // Custom character class: match a vowel followed by a consonant
        Pattern vc = Pattern.compile("[aeiou][^aeiou\\s\\d]");
        Matcher m = vc.matcher("hello world");
        while (m.find()) {
            System.out.println("Found: " + m.group() + " at index " + m.start());
        }
        // Found: el at index 1
        // Found: or at index 7

        // \\d matches any digit
        System.out.println("abc".matches("\\d+")); // false
        System.out.println("123".matches("\\d+")); // true

        // \\w matches word characters (letters, digits, underscore)
        System.out.println("hello_world".matches("\\w+")); // true
        System.out.println("hello world".matches("\\w+")); // false -- space is not a word char

        // \\s matches whitespace
        System.out.println("has spaces".matches(".*\\s.*")); // true
        System.out.println("nospaces".matches(".*\\s.*"));   // false

        // . matches any character except newline
        System.out.println("a".matches("."));  // true
        System.out.println("1".matches("."));  // true
        System.out.println("".matches("."));   // false -- needs exactly one char

        // Ranges: hex digit check
        Pattern hex = Pattern.compile("[0-9a-fA-F]+");
        System.out.println(hex.matcher("1a2bFF").matches()); // true
        System.out.println(hex.matcher("GHIJ").matches());   // false

        // Negation: match non-digits
        Matcher nonDigits = Pattern.compile("[^0-9]+").matcher("abc123def");
        while (nonDigits.find()) {
            System.out.println("Non-digit segment: " + nonDigits.group());
        }
        // Non-digit segment: abc
        // Non-digit segment: def
    }
}

import java.util.regex.*;

public class Quantifiers {
    public static void main(String[] args) {
        // Greedy vs Lazy demonstration
        String html = "bold and more bold";

        // Greedy: .* grabs as much as possible
        Matcher greedy = Pattern.compile(".*").matcher(html);
        if (greedy.find()) {
            System.out.println("Greedy: " + greedy.group());
            // Greedy: bold and more bold
            // -- matched from first  to LAST 
        }

        // Lazy: .*? grabs as little as possible
        Matcher lazy = Pattern.compile(".*?").matcher(html);
        while (lazy.find()) {
            System.out.println("Lazy: " + lazy.group());
        }
        // Lazy: bold
        // Lazy: more bold
        // -- matched each ... pair individually

        // Exact count: match a US zip code (5 digits, optional -4 digits)
        Pattern zip = Pattern.compile("\\d{5}(-\\d{4})?");
        System.out.println(zip.matcher("90210").matches());      // true
        System.out.println(zip.matcher("90210-1234").matches()); // true
        System.out.println(zip.matcher("9021").matches());       // false
        System.out.println(zip.matcher("902101234").matches());  // false

        // Range: password length check (8 to 20 characters)
        Pattern length = Pattern.compile(".{8,20}");
        System.out.println(length.matcher("short").matches());             // false (5 chars)
        System.out.println(length.matcher("justright").matches());         // true (9 chars)
        System.out.println(length.matcher("a]".repeat(11)).matches());     // false (22 chars)

        // Optional element: match "http" or "https"
        Pattern protocol = Pattern.compile("https?://.*");
        System.out.println(protocol.matcher("http://example.com").matches());  // true
        System.out.println(protocol.matcher("https://example.com").matches()); // true
        System.out.println(protocol.matcher("ftp://example.com").matches());   // false
    }
}

import java.util.regex.*;

public class AnchorsAndBoundaries {
    public static void main(String[] args) {
        // ^ and $ -- start and end anchors
        System.out.println("Hello World".matches("^Hello.*"));  // true
        System.out.println("Say Hello".matches("^Hello.*"));    // false

        // Without anchors, find() looks anywhere in the string
        Matcher m1 = Pattern.compile("error").matcher("An error occurred");
        System.out.println(m1.find()); // true

        // With anchors, matches() checks the entire string
        System.out.println("An error occurred".matches("error")); // false -- not the whole string
        System.out.println("error".matches("error"));             // true

        // \\b word boundary -- match whole words only
        String text = "The cat scattered the catalog across the category";
        Matcher wordCat = Pattern.compile("\\bcat\\b").matcher(text);
        int count = 0;
        while (wordCat.find()) {
            System.out.println("Found whole word 'cat' at index " + wordCat.start());
            count++;
        }
        System.out.println("Total matches: " + count);
        // Found whole word 'cat' at index 4
        // Total matches: 1
        // -- "scattered", "catalog", and "category" were correctly excluded

        // Without word boundary -- matches "cat" inside other words too
        Matcher anyCat = Pattern.compile("cat").matcher(text);
        count = 0;
        while (anyCat.find()) {
            count++;
        }
        System.out.println("Without boundary: " + count + " matches");
        // Without boundary: 4 matches

        // ^ and $ with MULTILINE flag -- match each line
        String multiline = "First line\nSecond line\nThird line";
        Matcher lineStarts = Pattern.compile("^\\w+", Pattern.MULTILINE).matcher(multiline);
        while (lineStarts.find()) {
            System.out.println("Line starts with: " + lineStarts.group());
        }
        // Line starts with: First
        // Line starts with: Second
        // Line starts with: Third
    }
}

import java.util.regex.*;

public class GroupsAndCapturing {
    public static void main(String[] args) {
        // --- Numbered Capturing Groups ---
        String phone = "Call me at 555-123-4567 or 800-555-0199";
        Pattern phonePattern = Pattern.compile("(\\d{3})-(\\d{3})-(\\d{4})");
        Matcher m = phonePattern.matcher(phone);

        while (m.find()) {
            System.out.println("Full match:  " + m.group(0));
            System.out.println("Area code:   " + m.group(1));
            System.out.println("Prefix:      " + m.group(2));
            System.out.println("Line number: " + m.group(3));
            System.out.println();
        }
        // Full match:  555-123-4567
        // Area code:   555
        // Prefix:      123
        // Line number: 4567
        //
        // Full match:  800-555-0199
        // Area code:   800
        // Prefix:      555
        // Line number: 0199

        // --- Named Capturing Groups ---
        String dateStr = "2026-02-28";
        Pattern datePattern = Pattern.compile(
            "(?\\d{4})-(?\\d{2})-(?\\d{2})"
        );
        Matcher dm = datePattern.matcher(dateStr);

        if (dm.matches()) {
            System.out.println("Year:  " + dm.group("year"));   // Year:  2026
            System.out.println("Month: " + dm.group("month"));  // Month: 02
            System.out.println("Day:   " + dm.group("day"));    // Day:   28
        }

        // --- Non-Capturing Groups ---
        // Match "http" or "https" without capturing the "s"
        Pattern url = Pattern.compile("(?:https?)://([\\w.]+)");
        Matcher um = url.matcher("Visit https://example.com today");

        if (um.find()) {
            System.out.println("Full match: " + um.group(0));  // Full match: https://example.com
            System.out.println("Domain:     " + um.group(1));  // Domain:     example.com
            // group(1) is the domain, not "https" -- because (?:...) did not capture
        }

        // --- Backreferences: find duplicate words ---
        String text = "This is is a test test of of duplicate words";
        Pattern dupes = Pattern.compile("\\b(\\w+)\\s+\\1\\b", Pattern.CASE_INSENSITIVE);
        Matcher dupeMatcher = dupes.matcher(text);

        while (dupeMatcher.find()) {
            System.out.println("Duplicate found: \"" + dupeMatcher.group() + "\"");
        }
        // Duplicate found: "is is"
        // Duplicate found: "test test"
        // Duplicate found: "of of"
    }
}

import java.util.regex.*;

public class AlternationAndLookaround {
    public static void main(String[] args) {
        // --- Alternation ---
        Pattern pet = Pattern.compile("cat|dog|bird");
        String text = "I have a cat and a dog but no bird";
        Matcher m = pet.matcher(text);
        while (m.find()) {
            System.out.println("Found pet: " + m.group());
        }
        // Found pet: cat
        // Found pet: dog
        // Found pet: bird

        // Alternation with grouping
        Pattern color = Pattern.compile("gr(a|e)y");
        System.out.println(color.matcher("gray").matches());  // true
        System.out.println(color.matcher("grey").matches());  // true
        System.out.println(color.matcher("griy").matches());  // false

        // --- Positive Lookahead: find numbers followed by "px" ---
        Matcher lookahead = Pattern.compile("\\d+(?=px)").matcher("width: 100px; height: 50px; margin: 10em");
        while (lookahead.find()) {
            System.out.println("Pixel value: " + lookahead.group());
        }
        // Pixel value: 100
        // Pixel value: 50
        // -- "10" was excluded because it is followed by "em", not "px"

        // --- Negative Lookahead: find numbers NOT followed by "px" ---
        Matcher negLookahead = Pattern.compile("\\d+(?!px)").matcher("width: 100px; margin: 10em");
        while (negLookahead.find()) {
            System.out.println("Non-pixel: " + negLookahead.group());
        }
        // Non-pixel: 10
        // Non-pixel: 10

        // --- Positive Lookbehind: extract amounts after $ ---
        Matcher lookbehind = Pattern.compile("(?<=\\$)\\d+\\.?\\d*").matcher("Price: $19.99 and $5.00");
        while (lookbehind.find()) {
            System.out.println("Amount: " + lookbehind.group());
        }
        // Amount: 19.99
        // Amount: 5.00

        // --- Password validation using multiple lookaheads ---
        // At least 8 chars, one uppercase, one lowercase, one digit, one special char
        Pattern strongPassword = Pattern.compile(
            "^(?=.*[A-Z])"  +   // at least one uppercase
            "(?=.*[a-z])"   +   // at least one lowercase
            "(?=.*\\d)"     +   // at least one digit
            "(?=.*[@#$%^&+=!])" + // at least one special character
            ".{8,}$"             // at least 8 characters total
        );

        String[] passwords = {"Passw0rd!", "password", "SHORT1!", "MyP@ss12"};
        for (String pw : passwords) {
            boolean strong = strongPassword.matcher(pw).matches();
            System.out.println(pw + " -> " + (strong ? "STRONG" : "WEAK"));
        }
        // Passw0rd! -> STRONG
        // password -> WEAK
        // SHORT1! -> WEAK
        // MyP@ss12 -> STRONG
    }
}

import java.util.Arrays;

public class StringRegexMethods {
    public static void main(String[] args) {
        // --- matches() -- checks the ENTIRE string ---
        System.out.println("12345".matches("\\d+"));       // true
        System.out.println("123abc".matches("\\d+"));      // false -- not all digits
        System.out.println("hello".matches("[a-z]+"));     // true

        // --- split() -- break a string into parts ---
        // Split on one or more whitespace characters
        String sentence = "Split   this   string   up";
        String[] words = sentence.split("\\s+");
        System.out.println(Arrays.toString(words));
        // [Split, this, string, up]

        // Split a CSV line (handles optional spaces after commas)
        String csv = "Java, Python,  C++, JavaScript";
        String[] languages = csv.split(",\\s*");
        System.out.println(Arrays.toString(languages));
        // [Java, Python, C++, JavaScript]

        // Split with a limit
        String path = "com.example.project.Main";
        String[] parts = path.split("\\.", 3); // at most 3 parts
        System.out.println(Arrays.toString(parts));
        // [com, example, project.Main]

        // --- replaceAll() -- replace all matches ---
        // Remove all non-alphanumeric characters
        String dirty = "Hello, World! @2026";
        String clean = dirty.replaceAll("[^a-zA-Z0-9]", "");
        System.out.println(clean); // HelloWorld2026

        // Normalize whitespace: replace multiple spaces/tabs with a single space
        String messy = "too   many     spaces    here";
        String normalized = messy.replaceAll("\\s+", " ");
        System.out.println(normalized); // too many spaces here

        // --- replaceFirst() -- replace only the first match ---
        String text = "error: file not found. error: permission denied.";
        String result = text.replaceFirst("error", "WARNING");
        System.out.println(result);
        // WARNING: file not found. error: permission denied.

        // Use captured groups in replacement with $1, $2, etc.
        // Reformat dates from MM/DD/YYYY to YYYY-MM-DD
        String date = "02/28/2026";
        String reformatted = date.replaceAll("(\\d{2})/(\\d{2})/(\\d{4})", "$3-$1-$2");
        System.out.println(reformatted); // 2026-02-28
    }
}

import java.util.regex.*;

public class PatternFlags {
    public static void main(String[] args) {
        // --- CASE_INSENSITIVE ---
        Pattern ci = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
        System.out.println(ci.matcher("JAVA").matches());   // true
        System.out.println(ci.matcher("Java").matches());   // true
        System.out.println(ci.matcher("jAvA").matches());   // true

        // Same thing using inline flag (?i)
        System.out.println("JAVA".matches("(?i)java"));     // true

        // --- MULTILINE ---
        String log = "ERROR: disk full\nWARN: low memory\nERROR: timeout";
        Pattern errorLines = Pattern.compile("^ERROR.*$", Pattern.MULTILINE);
        Matcher m = errorLines.matcher(log);
        while (m.find()) {
            System.out.println(m.group());
        }
        // ERROR: disk full
        // ERROR: timeout

        // --- DOTALL ---
        String html = "
\nHello\nWorld\n
";

        // Without DOTALL, . does not match newlines
        System.out.println(html.matches("
.*
"));                          // false

        // With DOTALL, . matches everything including newlines
        Pattern dotall = Pattern.compile("
.*
", Pattern.DOTALL);
        System.out.println(dotall.matcher(html).matches());                         // true

        // --- COMMENTS -- write readable patterns ---
        Pattern readable = Pattern.compile(
            "\\d{3}"    + // area code
            "-"         + // separator
            "\\d{3}"    + // prefix
            "-"         + // separator
            "\\d{4}"      // line number
        );
        System.out.println(readable.matcher("555-123-4567").matches()); // true

        // Using COMMENTS flag with whitespace and # comments in the pattern itself
        Pattern commented = Pattern.compile(
            "(?x)          " +  // enable comments mode
            "\\d{3}        " +  // area code
            "-             " +  // dash separator
            "\\d{3}        " +  // prefix
            "-             " +  // dash separator
            "\\d{4}          "  // line number
        );
        System.out.println(commented.matcher("555-123-4567").matches()); // true

        // --- Combining multiple flags ---
        Pattern combined = Pattern.compile(
            "^error.*$",
            Pattern.CASE_INSENSITIVE | Pattern.MULTILINE
        );
        Matcher cm = combined.matcher("Error: something\nERROR: another\ninfo: ok");
        while (cm.find()) {
            System.out.println("Found: " + cm.group());
        }
        // Found: Error: something
        // Found: ERROR: another
    }
}

// Email: local-part@domain.tld
// ^                    -- start of string
// [a-zA-Z0-9._%+-]+   -- local part: letters, digits, dots, underscores, %, +, -
// @                    -- literal @ symbol
// [a-zA-Z0-9.-]+      -- domain: letters, digits, dots, hyphens
// \.                   -- literal dot before TLD
// [a-zA-Z]{2,}        -- TLD: at least 2 letters (com, org, io, etc.)
// $                    -- end of string

String emailRegex = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";

String[] emails = {"user@example.com", "first.last@company.co.uk", "invalid@", "@nodomain.com", "test@site.io"};
for (String email : emails) {
    System.out.println(email + " -> " + (email.matches(emailRegex) ? "VALID" : "INVALID"));
}
// user@example.com -> VALID
// first.last@company.co.uk -> VALID
// invalid@ -> INVALID
// @nodomain.com -> INVALID
// test@site.io -> VALID

// US phone: optional country code, various separator formats
// ^                    -- start
// (\\+1[- ]?)?        -- optional +1 country code with optional separator
// \\(?                -- optional opening parenthesis
// \\d{3}              -- area code (3 digits)
// \\)?                -- optional closing parenthesis
// [- ]?               -- optional separator (dash or space)
// \\d{3}              -- prefix (3 digits)
// [- ]?               -- optional separator
// \\d{4}              -- line number (4 digits)
// $                    -- end

String phoneRegex = "^(\\+1[- ]?)?(\\(?\\d{3}\\)?[- ]?)?\\d{3}[- ]?\\d{4}$";

String[] phones = {"(555) 123-4567", "555-123-4567", "5551234567", "+1-555-123-4567", "123"};
for (String phone : phones) {
    System.out.println(phone + " -> " + (phone.matches(phoneRegex) ? "VALID" : "INVALID"));
}
// (555) 123-4567 -> VALID
// 555-123-4567 -> VALID
// 5551234567 -> VALID
// +1-555-123-4567 -> VALID
// 123 -> INVALID

// Password must have:
// (?=.*[A-Z])          -- at least one uppercase letter
// (?=.*[a-z])          -- at least one lowercase letter
// (?=.*\\d)            -- at least one digit
// (?=.*[@#$%^&+=!])    -- at least one special character
// .{8,20}              -- between 8 and 20 characters total

String passwordRegex = "^(?=.*[A-Z])(?=.*[a-z])(?=.*\\d)(?=.*[@#$%^&+=!]).{8,20}$";

String[] passwords = {"Str0ng!Pass", "weakpassword", "SHORT1!", "NoSpecial1", "G00d@Pwd"};
for (String pw : passwords) {
    System.out.println(pw + " -> " + (pw.matches(passwordRegex) ? "STRONG" : "WEAK"));
}
// Str0ng!Pass -> STRONG
// weakpassword -> WEAK (no uppercase, no digit, no special)
// SHORT1! -> WEAK (less than 8 chars)
// NoSpecial1 -> WEAK (no special character)
// G00d@Pwd -> STRONG

// URL: protocol://domain:port/path?query#fragment
// ^https?://           -- http or https
// [\\w.-]+             -- domain name
// (:\\d{1,5})?         -- optional port (1-5 digits)
// (/[\\w./-]*)*        -- optional path segments
// (\\?[\\w=&%-]*)?     -- optional query string
// (#[\\w-]*)?          -- optional fragment
// $

String urlRegex = "^https?://[\\w.-]+(:\\d{1,5})?(/[\\w./-]*)*(\\?[\\w=&%-]*)?(#[\\w-]*)?$";

String[] urls = {
    "https://example.com",
    "http://localhost:8080/api/users",
    "https://site.com/page?name=test&id=5",
    "ftp://invalid.com",
    "https://example.com/path#section"
};
for (String url : urls) {
    System.out.println(url + " -> " + (url.matches(urlRegex) ? "VALID" : "INVALID"));
}
// https://example.com -> VALID
// http://localhost:8080/api/users -> VALID
// https://site.com/page?name=test&id=5 -> VALID
// ftp://invalid.com -> INVALID
// https://example.com/path#section -> VALID

// IPv4: four octets (0-255) separated by dots
// Each octet: 25[0-5] | 2[0-4]\\d | [01]?\\d{1,2}
// This handles: 0-9, 10-99, 100-199, 200-249, 250-255

String ipRegex = "^((25[0-5]|2[0-4]\\d|[01]?\\d{1,2})\\.){3}(25[0-5]|2[0-4]\\d|[01]?\\d{1,2})$";

String[] ips = {"192.168.1.1", "255.255.255.255", "0.0.0.0", "256.1.1.1", "192.168.1"};
for (String ip : ips) {
    System.out.println(ip + " -> " + (ip.matches(ipRegex) ? "VALID" : "INVALID"));
}
// 192.168.1.1 -> VALID
// 255.255.255.255 -> VALID
// 0.0.0.0 -> VALID
// 256.1.1.1 -> INVALID (256 is out of range)
// 192.168.1 -> INVALID (only 3 octets)

// Date: YYYY-MM-DD (basic format validation, not full calendar validation)
// \\d{4}              -- 4-digit year
// -                   -- separator
// (0[1-9]|1[0-2])    -- month: 01-12
// -                   -- separator
// (0[1-9]|[12]\\d|3[01]) -- day: 01-31

String dateRegex = "^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$";

String[] dates = {"2026-02-28", "2026-13-01", "2026-00-15", "2026-12-31", "26-01-01"};
for (String date : dates) {
    System.out.println(date + " -> " + (date.matches(dateRegex) ? "VALID" : "INVALID"));
}
// 2026-02-28 -> VALID
// 2026-13-01 -> INVALID (month 13)
// 2026-00-15 -> INVALID (month 00)
// 2026-12-31 -> VALID
// 26-01-01 -> INVALID (2-digit year)

// Credit card: 13-19 digits, optionally separated by spaces or dashes every 4 digits
// Common formats: Visa (4xxx), Mastercard (5xxx), Amex (34xx/37xx)

String ccRegex = "^\\d{4}[- ]?\\d{4}[- ]?\\d{4}[- ]?\\d{1,7}$";

String[] cards = {"4111111111111111", "4111-1111-1111-1111", "4111 1111 1111 1111", "411", "1234567890123456789012"};
for (String card : cards) {
    System.out.println(card + " -> " + (card.matches(ccRegex) ? "VALID FORMAT" : "INVALID FORMAT"));
}
// 4111111111111111 -> VALID FORMAT
// 4111-1111-1111-1111 -> VALID FORMAT
// 4111 1111 1111 1111 -> VALID FORMAT
// 411 -> INVALID FORMAT
// 1234567890123456789012 -> INVALID FORMAT

// Note: this only validates the FORMAT, not the actual card number.
// Use the Luhn algorithm for checksum validation.

// SSN format: XXX-XX-XXXX
// (?!000|666)         -- area number cannot be 000 or 666
// (?!9)               -- area number cannot start with 9
// \\d{3}              -- 3-digit area number
// -                   -- separator
// (?!00)\\d{2}        -- 2-digit group number (not 00)
// -                   -- separator
// (?!0000)\\d{4}      -- 4-digit serial number (not 0000)

String ssnRegex = "^(?!000|666)(?!9\\d{2})\\d{3}-(?!00)\\d{2}-(?!0000)\\d{4}$";

String[] ssns = {"123-45-6789", "000-12-3456", "666-12-3456", "900-12-3456", "123-00-6789", "123-45-0000"};
for (String ssn : ssns) {
    System.out.println(ssn + " -> " + (ssn.matches(ssnRegex) ? "VALID" : "INVALID"));
}
// 123-45-6789 -> VALID
// 000-12-3456 -> INVALID (area 000)
// 666-12-3456 -> INVALID (area 666)
// 900-12-3456 -> INVALID (area starts with 9)
// 123-00-6789 -> INVALID (group 00)
// 123-45-0000 -> INVALID (serial 0000)

import java.util.regex.*;
import java.util.ArrayList;
import java.util.List;

public class SearchAndReplace {
    public static void main(String[] args) {
        // --- Finding all matches ---
        String text = "Contact us at support@company.com or sales@company.com. " +
                       "Personal: john.doe@gmail.com";
        Pattern emailPattern = Pattern.compile("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}");
        Matcher finder = emailPattern.matcher(text);

        List emails = new ArrayList<>();
        while (finder.find()) {
            emails.add(finder.group());
            System.out.println("Found email at [" + finder.start() + "-" + finder.end() + "]: " + finder.group());
        }
        // Found email at [17-36]: support@company.com
        // Found email at [40-57]: sales@company.com
        // Found email at [69-88]: john.doe@gmail.com
        System.out.println("Total emails found: " + emails.size()); // Total emails found: 3

        // --- Simple replaceAll ---
        String censored = emailPattern.matcher(text).replaceAll("[REDACTED]");
        System.out.println(censored);
        // Contact us at [REDACTED] or [REDACTED]. Personal: [REDACTED]

        // --- replaceFirst ---
        String firstOnly = emailPattern.matcher(text).replaceFirst("[REDACTED]");
        System.out.println(firstOnly);
        // Contact us at [REDACTED] or sales@company.com. Personal: john.doe@gmail.com
    }
}

import java.util.regex.*;

public class CustomReplacement {
    public static void main(String[] args) {
        // Convert all words to title case using appendReplacement
        String input = "the quick brown fox jumps over the lazy dog";
        Pattern wordPattern = Pattern.compile("\\b([a-z])(\\w*)");
        Matcher m = wordPattern.matcher(input);
        StringBuilder result = new StringBuilder();

        while (m.find()) {
            String titleCase = m.group(1).toUpperCase() + m.group(2);
            m.appendReplacement(result, titleCase);
        }
        m.appendTail(result);
        System.out.println(result);
        // The Quick Brown Fox Jumps Over The Lazy Dog

        // Mask credit card numbers: show only last 4 digits
        String data = "Card: 4111-1111-1111-1111, Another: 5500-0000-0000-0004";
        Pattern ccPattern = Pattern.compile("(\\d{4})[- ]?(\\d{4})[- ]?(\\d{4})[- ]?(\\d{4})");
        Matcher ccMatcher = ccPattern.matcher(data);
        StringBuilder masked = new StringBuilder();

        while (ccMatcher.find()) {
            String replacement = "****-****-****-" + ccMatcher.group(4);
            ccMatcher.appendReplacement(masked, replacement);
        }
        ccMatcher.appendTail(masked);
        System.out.println(masked);
        // Card: ****-****-****-1111, Another: ****-****-****-0004

        // Java 9+: Matcher.replaceAll with a Function
        String prices = "Items cost $5 and $23 and $100";
        Pattern pricePattern = Pattern.compile("\\$(\\d+)");
        String doubled = pricePattern.matcher(prices).replaceAll(mr -> {
            int amount = Integer.parseInt(mr.group(1));
            return "\\$" + (amount * 2);
        });
        System.out.println(doubled);
        // Items cost $10 and $46 and $200
    }
}

// WRONG -- Java does not recognize \d as a string escape
// String pattern = "\d+";  // Compilation error!

// CORRECT -- double backslash to produce \d for the regex engine
String pattern = "\\d+";

// To match a literal backslash in text, you need FOUR backslashes:
// Java string: "\\\\"  -> produces: \\  -> regex sees: \ (literal backslash)
String backslashPattern = "\\\\";
System.out.println("C:\\Users".matches(".*\\\\.*")); // true

// DANGEROUS -- nested quantifiers can cause catastrophic backtracking
// String bad = "(a+)+b";
// On input "aaaaaaaaaaaaaaaaaac", the engine tries every possible way
// to split the 'a's between the inner and outer groups before failing.
// This can freeze your application.

// SAFE -- flatten the nesting
String safe = "a+b";
// This matches the same thing but without the exponential backtracking risk.

// Another common danger: matching quoted strings with nested quantifiers
// DANGEROUS: "(.*)*"
// SAFE:      "[^"]*"   -- use negated character class instead

// BAD -- one massive unreadable regex
// String nightmare = "^(?=.*[A-Z])(?=.*[a-z])(?=.*\\d)(?=.*[@#$%^&+=!])[a-zA-Z0-9@#$%^&+=!]{8,20}$";

// BETTER -- break into understandable steps
public static boolean isStrongPassword(String password) {
    if (password == null) return false;
    if (password.length() < 8 || password.length() > 20) return false;
    if (!password.matches(".*[A-Z].*")) return false;  // needs uppercase
    if (!password.matches(".*[a-z].*")) return false;  // needs lowercase
    if (!password.matches(".*\\d.*")) return false;     // needs digit
    if (!password.matches(".*[@#$%^&+=!].*")) return false; // needs special char
    return true;
}
// Easier to read, debug, and extend. Each rule is independently testable.

// Testing an email regex -- you need ALL of these test cases
String emailRegex = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";

// Happy path
assert "user@example.com".matches(emailRegex);         // standard email
assert "first.last@company.co.uk".matches(emailRegex); // dots and subdomains

// Edge cases that should FAIL
assert !"".matches(emailRegex);                        // empty string
assert !"@example.com".matches(emailRegex);            // missing local part
assert !"user@".matches(emailRegex);                   // missing domain
assert !"user@.com".matches(emailRegex);               // domain starts with dot
assert !"user@com".matches(emailRegex);                // no TLD separator
assert !"user@@example.com".matches(emailRegex);       // double @

// Edge cases that should PASS
assert "a@b.co".matches(emailRegex);                   // minimal valid email
assert "user+tag@gmail.com".matches(emailRegex);       // plus addressing

String text = "Error code: 404";

// WRONG -- matches() checks the ENTIRE string
System.out.println(text.matches("\\d+"));  // false -- the entire string is not digits

// CORRECT -- find() searches for the pattern anywhere
Matcher m = Pattern.compile("\\d+").matcher(text);
System.out.println(m.find());     // true
System.out.println(m.group());    // 404

// If you must use matches(), wrap the pattern with .*
System.out.println(text.matches(".*\\d+.*")); // true -- but find() is cleaner

public class UserValidator {

    // GOOD -- compiled once, reused many times
    private static final Pattern EMAIL_PATTERN =
        Pattern.compile("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");

    private static final Pattern PHONE_PATTERN =
        Pattern.compile("^(\\+1[- ]?)?(\\(?\\d{3}\\)?[- ]?)?\\d{3}[- ]?\\d{4}$");

    public static boolean isValidEmail(String email) {
        return email != null && EMAIL_PATTERN.matcher(email).matches();
    }

    public static boolean isValidPhone(String phone) {
        return phone != null && PHONE_PATTERN.matcher(phone).matches();
    }

    // BAD -- compiles a new Pattern on every call
    // public static boolean isValidEmailBad(String email) {
    //     return email.matches("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");
    // }
}

import java.util.regex.*;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Complete Regex Example: LogParser and InputValidator
 *
 * Demonstrates:
 * - Pattern compilation and reuse (static final)
 * - Named capturing groups
 * - Multiple validation patterns
 * - find() with while loop for extraction
 * - replaceAll for data masking
 * - appendReplacement for custom replacement
 * - Lookaheads for password validation
 * - Word boundaries
 * - Greedy vs lazy matching
 * - Pattern flags
 */
public class RegexDemo {

    // =========================================================================
    // Part 1: Log Parser -- Extract structured data from log entries
    // =========================================================================

    // Pre-compiled patterns (compiled once, reused across all calls)
    private static final Pattern LOG_PATTERN = Pattern.compile(
        "(?\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2})" + // 2026-02-28 14:30:00
        "\\s+\\[(?\\w+)]"  +                                  // [ERROR]
        "\\s+(?[\\w.]+)"   +                                  // com.app.Service
        "\\s+-\\s+(?.*)"                                     // - The log message
    );

    private static final Pattern IP_PATTERN = Pattern.compile(
        "\\b(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d{1,2})\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d{1,2})\\b"
    );

    private static final Pattern ERROR_CODE_PATTERN = Pattern.compile(
        "\\b[A-Z]{2,4}-\\d{3,5}\\b"  // e.g., ERR-5001, HTTP-404
    );

    public static void parseLogEntries(String[] logLines) {
        System.out.println("=== LOG PARSER RESULTS ===");
        System.out.println();

        Map levelCounts = new LinkedHashMap<>();
        List errorMessages = new ArrayList<>();

        for (String line : logLines) {
            Matcher m = LOG_PATTERN.matcher(line);
            if (m.matches()) {
                String timestamp = m.group("timestamp");
                String level = m.group("level");
                String className = m.group("class");
                String message = m.group("message");

                // Count log levels
                levelCounts.merge(level, 1, Integer::sum);

                // Collect error messages
                if ("ERROR".equals(level)) {
                    errorMessages.add(timestamp + " | " + className + " | " + message);
                }

                // Extract IP addresses from the message
                Matcher ipMatcher = IP_PATTERN.matcher(message);
                while (ipMatcher.find()) {
                    System.out.println("  IP found in log: " + ipMatcher.group()
                        + " (from " + className + ")");
                }

                // Extract error codes from the message
                Matcher codeMatcher = ERROR_CODE_PATTERN.matcher(message);
                while (codeMatcher.find()) {
                    System.out.println("  Error code found: " + codeMatcher.group()
                        + " (at " + timestamp + ")");
                }
            }
        }

        System.out.println();
        System.out.println("Log Level Summary:");
        levelCounts.forEach((level, count) ->
            System.out.println("  " + level + ": " + count));

        System.out.println();
        System.out.println("Error Messages:");
        errorMessages.forEach(msg -> System.out.println("  " + msg));
    }

    // =========================================================================
    // Part 2: Input Validator -- Validate form fields for user registration
    // =========================================================================

    private static final Pattern EMAIL_PATTERN = Pattern.compile(
        "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"
    );

    private static final Pattern PHONE_PATTERN = Pattern.compile(
        "^(\\+1[- ]?)?(\\(?\\d{3}\\)?[- ]?)?\\d{3}[- ]?\\d{4}$"
    );

    private static final Pattern PASSWORD_PATTERN = Pattern.compile(
        "^(?=.*[A-Z])(?=.*[a-z])(?=.*\\d)(?=.*[@#$%^&+=!]).{8,20}$"
    );

    private static final Pattern USERNAME_PATTERN = Pattern.compile(
        "^[a-zA-Z][a-zA-Z0-9_]{2,19}$"  // starts with letter, 3-20 chars, only alphanumeric and _
    );

    private static final Pattern DATE_PATTERN = Pattern.compile(
        "^(?\\d{4})-(?0[1-9]|1[0-2])-(?0[1-9]|[12]\\d|3[01])$"
    );

    public static Map validateRegistration(
            String username, String email, String password, String phone, String birthDate) {

        Map errors = new LinkedHashMap<>();

        // Username validation
        if (username == null || username.isEmpty()) {
            errors.put("username", "Username is required");
        } else if (!USERNAME_PATTERN.matcher(username).matches()) {
            errors.put("username", "Must start with a letter, 3-20 chars, only letters/digits/underscore");
        }

        // Email validation
        if (email == null || email.isEmpty()) {
            errors.put("email", "Email is required");
        } else if (!EMAIL_PATTERN.matcher(email).matches()) {
            errors.put("email", "Invalid email format");
        }

        // Password validation with specific feedback
        if (password == null || password.isEmpty()) {
            errors.put("password", "Password is required");
        } else {
            List passwordIssues = new ArrayList<>();
            if (password.length() < 8) passwordIssues.add("at least 8 characters");
            if (password.length() > 20) passwordIssues.add("at most 20 characters");
            if (!password.matches(".*[A-Z].*")) passwordIssues.add("an uppercase letter");
            if (!password.matches(".*[a-z].*")) passwordIssues.add("a lowercase letter");
            if (!password.matches(".*\\d.*")) passwordIssues.add("a digit");
            if (!password.matches(".*[@#$%^&+=!].*")) passwordIssues.add("a special character (@#$%^&+=!)");
            if (!passwordIssues.isEmpty()) {
                errors.put("password", "Password needs: " + String.join(", ", passwordIssues));
            }
        }

        // Phone validation
        if (phone != null && !phone.isEmpty() && !PHONE_PATTERN.matcher(phone).matches()) {
            errors.put("phone", "Invalid US phone format");
        }

        // Birth date validation
        if (birthDate != null && !birthDate.isEmpty()) {
            Matcher dm = DATE_PATTERN.matcher(birthDate);
            if (!dm.matches()) {
                errors.put("birthDate", "Invalid date format (use YYYY-MM-DD)");
            } else {
                int year = Integer.parseInt(dm.group("year"));
                if (year > 2026 || year < 1900) {
                    errors.put("birthDate", "Year must be between 1900 and 2026");
                }
            }
        }

        return errors;
    }

    // =========================================================================
    // Part 3: Data Masking -- Redact sensitive information from text
    // =========================================================================

    private static final Pattern SSN_IN_TEXT = Pattern.compile(
        "\\b\\d{3}-\\d{2}-\\d{4}\\b"
    );

    private static final Pattern CC_IN_TEXT = Pattern.compile(
        "\\b(\\d{4})[- ]?(\\d{4})[- ]?(\\d{4})[- ]?(\\d{4})\\b"
    );

    private static final Pattern EMAIL_IN_TEXT = Pattern.compile(
        "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}"
    );

    public static String maskSensitiveData(String text) {
        // Mask SSNs: 123-45-6789 -> ***-**-6789
        String result = SSN_IN_TEXT.matcher(text).replaceAll(mr -> {
            String ssn = mr.group();
            return "***-**-" + ssn.substring(ssn.length() - 4);
        });

        // Mask credit cards: show only last 4 digits
        Matcher ccMatcher = CC_IN_TEXT.matcher(result);
        StringBuilder sb = new StringBuilder();
        while (ccMatcher.find()) {
            ccMatcher.appendReplacement(sb, "****-****-****-" + ccMatcher.group(4));
        }
        ccMatcher.appendTail(sb);
        result = sb.toString();

        // Mask emails: user@domain.com -> u***@domain.com
        Matcher emailMatcher = EMAIL_IN_TEXT.matcher(result);
        sb = new StringBuilder();
        while (emailMatcher.find()) {
            String email = emailMatcher.group();
            int atIndex = email.indexOf('@');
            String masked = email.charAt(0) + "***" + email.substring(atIndex);
            emailMatcher.appendReplacement(sb, Matcher.quoteReplacement(masked));
        }
        emailMatcher.appendTail(sb);

        return sb.toString();
    }

    // =========================================================================
    // Main -- Run all demonstrations
    // =========================================================================

    public static void main(String[] args) {

        // --- Part 1: Parse log entries ---
        String[] logLines = {
            "2026-02-28 14:30:00 [INFO] com.app.UserService - User login from 192.168.1.100",
            "2026-02-28 14:30:05 [ERROR] com.app.PaymentService - Payment failed: ERR-5001 for IP 10.0.0.1",
            "2026-02-28 14:30:10 [WARN] com.app.AuthService - Failed login attempt from 172.16.0.50",
            "2026-02-28 14:30:15 [ERROR] com.app.OrderService - Order processing failed: HTTP-500 timeout",
            "2026-02-28 14:30:20 [INFO] com.app.CacheService - Cache refreshed successfully",
            "2026-02-28 14:30:25 [ERROR] com.app.DatabaseService - Connection lost: DB-1001 to 192.168.1.200"
        };
        parseLogEntries(logLines);

        System.out.println();
        System.out.println("========================================");
        System.out.println();

        // --- Part 2: Validate registration forms ---
        System.out.println("=== REGISTRATION VALIDATION ===");
        System.out.println();

        // Test case 1: Valid registration
        Map errors1 = validateRegistration(
            "john_doe", "john@example.com", "MyP@ss123", "(555) 123-4567", "1990-06-15"
        );
        System.out.println("Test 1 (valid): " + (errors1.isEmpty() ? "PASSED" : "FAILED: " + errors1));

        // Test case 2: Multiple validation failures
        Map errors2 = validateRegistration(
            "2bad", "not-an-email", "weak", "12345", "2026-13-45"
        );
        System.out.println("Test 2 (invalid):");
        errors2.forEach((field, error) -> System.out.println("  " + field + ": " + error));

        // Test case 3: Specific password feedback
        Map errors3 = validateRegistration(
            "alice", "alice@test.com", "onlylowercase", null, null
        );
        System.out.println("Test 3 (weak password):");
        errors3.forEach((field, error) -> System.out.println("  " + field + ": " + error));

        System.out.println();
        System.out.println("========================================");
        System.out.println();

        // --- Part 3: Mask sensitive data ---
        System.out.println("=== DATA MASKING ===");
        System.out.println();
        String sensitiveText = "Customer SSN: 123-45-6789, CC: 4111-1111-1111-1111, " +
                               "Email: john.doe@gmail.com, Alt SSN: 987-65-4321";
        System.out.println("Original: " + sensitiveText);
        System.out.println("Masked:   " + maskSensitiveData(sensitiveText));
    }
}

=== LOG PARSER RESULTS ===

  IP found in log: 192.168.1.100 (from com.app.UserService)
  IP found in log: 10.0.0.1 (from com.app.PaymentService)
  Error code found: ERR-5001 (at 2026-02-28 14:30:05)
  IP found in log: 172.16.0.50 (from com.app.AuthService)
  Error code found: HTTP-500 (at 2026-02-28 14:30:15)
  Error code found: DB-1001 (at 2026-02-28 14:30:25)
  IP found in log: 192.168.1.200 (from com.app.DatabaseService)

Log Level Summary:
  INFO: 2
  ERROR: 3
  WARN: 1

Error Messages:
  2026-02-28 14:30:05 | com.app.PaymentService | Payment failed: ERR-5001 for IP 10.0.0.1
  2026-02-28 14:30:15 | com.app.OrderService | Order processing failed: HTTP-500 timeout
  2026-02-28 14:30:25 | com.app.DatabaseService | Connection lost: DB-1001 to 192.168.1.200

========================================

=== REGISTRATION VALIDATION ===

Test 1 (valid): PASSED
Test 2 (invalid):
  username: Must start with a letter, 3-20 chars, only letters/digits/underscore
  email: Invalid email format
  password: Password needs: at least 8 characters, an uppercase letter, a digit, a special character (@#$%^&+=!)
  phone: Invalid US phone format
  birthDate: Invalid date format (use YYYY-MM-DD)
Test 3 (weak password):
  password: Password needs: an uppercase letter, a digit, a special character (@#$%^&+=!)

========================================

=== DATA MASKING ===

Original: Customer SSN: 123-45-6789, CC: 4111-1111-1111-1111, Email: john.doe@gmail.com, Alt SSN: 987-65-4321
Masked:   Customer SSN: ***-**-6789, CC: ****-****-****-1111, Email: j***@gmail.com, Alt SSN: ***-**-4321

Generics

import java.util.ArrayList;
import java.util.List;

public class WithoutGenerics {
    public static void main(String[] args) {
        // Raw List -- no type information. Anything goes.
        List names = new ArrayList();
        names.add("Alice");
        names.add("Bob");
        names.add(42);  // No compiler error! An Integer slipped into a "names" list.

        // Later, when we retrieve elements...
        for (int i = 0; i < names.size(); i++) {
            String name = (String) names.get(i); // Manual cast required every time
            System.out.println(name.toUpperCase());
        }
        // Output:
        // ALICE
        // BOB
        // Exception in thread "main" java.lang.ClassCastException:
        //   java.lang.Integer cannot be cast to java.lang.String
    }
}

import java.util.ArrayList;
import java.util.List;

public class WithGenerics {
    public static void main(String[] args) {
        // Parameterized List -- only String elements allowed
        List names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        // names.add(42);  // COMPILE ERROR: incompatible types: int cannot be converted to String

        // No casting needed -- the compiler knows every element is a String
        for (String name : names) {
            System.out.println(name.toUpperCase());
        }
        // Output:
        // ALICE
        // BOB
    }
}

// T is a type parameter -- a placeholder for a real type
public class Box {
    private T content;

    public Box(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }

    public void setContent(T content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "Box[" + content + "]";
    }
}

// Usage -- T is replaced with actual types at instantiation
public class BoxDemo {
    public static void main(String[] args) {
        // Box of String
        Box nameBox = new Box<>("Alice");
        String name = nameBox.getContent(); // No cast needed
        System.out.println(name); // Output: Alice

        // Box of Integer
        Box ageBox = new Box<>(30);
        int age = ageBox.getContent(); // Autoboxing/unboxing works seamlessly
        System.out.println(age); // Output: 30

        // Box of a custom type
        Box> listBox = new Box<>(List.of("A", "B", "C"));
        List items = listBox.getContent();
        System.out.println(items); // Output: [A, B, C]
    }
}

public class Pair {
    private final K key;
    private final V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    @Override
    public String toString() {
        return "(" + key + ", " + value + ")";
    }

    // Static factory method -- type inference handles the type parameters
    public static  Pair of(K key, V value) {
        return new Pair<>(key, value);
    }
}

public class PairDemo {
    public static void main(String[] args) {
        // Explicit type arguments
        Pair entry = new Pair<>("age", 30);
        System.out.println(entry.getKey());   // Output: age
        System.out.println(entry.getValue()); // Output: 30

        // Using the factory method -- types are inferred
        Pair> config = Pair.of("roles", List.of("ADMIN", "USER"));
        System.out.println(config); // Output: (roles, [ADMIN, USER])

        // Pair of Pairs -- generics compose naturally
        Pair> location = Pair.of("Office", Pair.of(37.7749, -122.4194));
        System.out.println(location); // Output: (Office, (37.7749, -122.4194))
    }
}

// Only accepts types that are Numbers (Integer, Double, Long, etc.)
public class NumberBox {
    private T number;

    public NumberBox(T number) {
        this.number = number;
    }

    public double doubleValue() {
        // Because T extends Number, we can call Number's methods
        return number.doubleValue();
    }

    public boolean isPositive() {
        return number.doubleValue() > 0;
    }

    public T getNumber() {
        return number;
    }
}

public class NumberBoxDemo {
    public static void main(String[] args) {
        NumberBox intBox = new NumberBox<>(42);
        System.out.println(intBox.doubleValue()); // Output: 42.0
        System.out.println(intBox.isPositive());  // Output: true

        NumberBox doubleBox = new NumberBox<>(-3.14);
        System.out.println(doubleBox.isPositive()); // Output: false

        // NumberBox stringBox = new NumberBox<>("hello");
        // COMPILE ERROR: String does not extend Number
    }
}

public class GenericMethodDemo {

    // Generic method --  is declared before the return type
    public static  void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    // Generic method that returns a value
    public static  T getFirst(List list) {
        if (list == null || list.isEmpty()) {
            return null;
        }
        return list.get(0);
    }

    // Generic method with two type parameters
    public static  Map mapOf(K key, V value) {
        Map map = new HashMap<>();
        map.put(key, value);
        return map;
    }

    // Generic swap method
    public static  void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    // Generic max method -- requires Comparable bound
    public static > T max(T a, T b) {
        return a.compareTo(b) >= 0 ? a : b;
    }

    public static void main(String[] args) {
        // printArray -- type inferred from arguments
        Integer[] intArr = {1, 2, 3, 4, 5};
        String[] strArr = {"Hello", "World"};
        printArray(intArr);  // Output: 1 2 3 4 5
        printArray(strArr);  // Output: Hello World

        // getFirst -- type inferred from list
        List names = List.of("Alice", "Bob", "Charlie");
        String first = getFirst(names); // No cast needed
        System.out.println("First: " + first); // Output: First: Alice

        // swap
        String[] colors = {"Red", "Blue", "Green"};
        swap(colors, 0, 2);
        printArray(colors); // Output: Green Blue Red

        // max -- works with any Comparable type
        System.out.println(max(10, 20));          // Output: 20
        System.out.println(max("apple", "banana")); // Output: banana
        System.out.println(max(3.14, 2.71));      // Output: 3.14
    }
}

// This is NOT a generic class -- no type parameter on the class itself
public class ArrayUtils {

    // But these are generic methods
    public static  boolean contains(T[] array, T target) {
        for (T element : array) {
            if (element.equals(target)) {
                return true;
            }
        }
        return false;
    }

    public static  int indexOf(T[] array, T target) {
        for (int i = 0; i < array.length; i++) {
            if (array[i].equals(target)) {
                return i;
            }
        }
        return -1;
    }

    public static  T[] reverse(T[] array) {
        @SuppressWarnings("unchecked")
        T[] reversed = (T[]) java.lang.reflect.Array.newInstance(
            array.getClass().getComponentType(), array.length);
        for (int i = 0; i < array.length; i++) {
            reversed[i] = array[array.length - 1 - i];
        }
        return reversed;
    }

    public static void main(String[] args) {
        String[] fruits = {"Apple", "Banana", "Cherry"};

        System.out.println(contains(fruits, "Banana")); // Output: true
        System.out.println(contains(fruits, "Grape"));  // Output: false
        System.out.println(indexOf(fruits, "Cherry"));  // Output: 2

        String[] reversed = reverse(fruits);
        System.out.println(Arrays.toString(reversed)); // Output: [Cherry, Banana, Apple]
    }
}

public class BoundedTypeDemo {

    // Without bound: T is Object -- we can't call .doubleValue()
    // public static  double sum(List numbers) {
    //     double total = 0;
    //     for (T n : numbers) {
    //         total += n.doubleValue(); // COMPILE ERROR: Object has no doubleValue()
    //     }
    //     return total;
    // }

    // With upper bound: T must be a Number -- now we can call doubleValue()
    public static  double sum(List numbers) {
        double total = 0;
        for (T n : numbers) {
            total += n.doubleValue(); // OK: Number has doubleValue()
        }
        return total;
    }

    // Finding the maximum in a list -- T must be Comparable
    public static > T findMax(List list) {
        if (list == null || list.isEmpty()) {
            throw new IllegalArgumentException("List must not be null or empty");
        }
        T max = list.get(0);
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i).compareTo(max) > 0) {
                max = list.get(i);
            }
        }
        return max;
    }

    public static void main(String[] args) {
        List integers = List.of(10, 20, 30);
        List doubles = List.of(1.5, 2.5, 3.5);

        System.out.println("Sum of integers: " + sum(integers)); // Output: Sum of integers: 60.0
        System.out.println("Sum of doubles: " + sum(doubles));   // Output: Sum of doubles: 7.5

        // sum(List.of("a", "b")); // COMPILE ERROR: String does not extend Number

        List words = List.of("banana", "apple", "cherry");
        System.out.println("Max word: " + findMax(words));      // Output: Max word: cherry
        System.out.println("Max integer: " + findMax(integers)); // Output: Max integer: 30
    }
}

import java.io.Serializable;

public class MultipleBoundsDemo {

    // T must be Comparable AND Serializable
    public static  & Serializable> T clampedMax(T a, T b, T ceiling) {
        T larger = a.compareTo(b) >= 0 ? a : b;
        return larger.compareTo(ceiling) > 0 ? ceiling : larger;
    }

    // A practical example: a method that requires both Number and Comparable
    public static > T clamp(T value, T min, T max) {
        if (value.compareTo(min) < 0) return min;
        if (value.compareTo(max) > 0) return max;
        return value;
    }

    public static void main(String[] args) {
        // Integer implements both Comparable and Serializable
        System.out.println(clampedMax(10, 20, 15)); // Output: 15

        // clamp example
        System.out.println(clamp(5, 1, 10));   // Output: 5 (within range)
        System.out.println(clamp(-3, 1, 10));  // Output: 1 (below min, clamped up)
        System.out.println(clamp(15, 1, 10));  // Output: 10 (above max, clamped down)
        System.out.println(clamp(3.7, 1.0, 5.0)); // Output: 3.7
    }
}

public class UpperBoundedWildcardDemo {

    // This method accepts List, List, List, etc.
    public static double sumOfList(List list) {
        double total = 0;
        for (Number n : list) { // Safe to read as Number
            total += n.doubleValue();
        }
        return total;
    }

    // Without the wildcard, this would ONLY accept List -- not List!
    // Remember: List is NOT a subtype of List, even though Integer IS a subtype of Number.
    // This is called "invariance" and it's a critical concept to understand.

    public static void main(String[] args) {
        List integers = List.of(1, 2, 3);
        List doubles = List.of(1.5, 2.5, 3.5);
        List numbers = List.of(1, 2.5, 3L);

        System.out.println(sumOfList(integers)); // Output: 6.0
        System.out.println(sumOfList(doubles));  // Output: 7.5
        System.out.println(sumOfList(numbers));  // Output: 6.5

        // Why can't we add to a List?
        List unknown = integers;
        // unknown.add(42);    // COMPILE ERROR!
        // unknown.add(3.14);  // COMPILE ERROR!
        // The compiler doesn't know if the list is List, List, etc.
        // Adding a Double to a List would break type safety.
        Number first = unknown.get(0); // But READING is fine
        System.out.println("First: " + first); // Output: First: 1
    }
}

public class LowerBoundedWildcardDemo {

    // This method accepts List, List, List