Java String contains - Case-Sensitive Payment Filter Fail

package io.thecodeforge.strings;

import java.util.Objects;

public class StringContainsExample {

    public static void main(String[] args) {
        String serviceName = "io.thecodeforge.payment.PaymentRetryService";

        // Basic contains — case-sensitive
        System.out.println(serviceName.contains("payment"));  // false — capital P
        System.out.println(serviceName.contains("Payment"));  // true
        System.out.println(serviceName.contains("Retry"));    // true

        // Case-insensitive contains
        String query = "PaymentRetry";
        boolean caseInsensitive =
            serviceName.toLowerCase(java.util.Locale.ROOT)
                       .contains(query.toLowerCase(java.util.Locale.ROOT));
        System.out.println("Case-insensitive: " + caseInsensitive); // true

        // Null safety — contains() throws NPE if called on null OR passed null
        String nullString = null;

        // Safe null check pattern
        boolean safeCheck = nullString != null && nullString.contains("Payment");
        System.out.println("Safe null check: " + safeCheck); // false, no NPE

        // Or use Objects utility
        boolean objectsCheck = Objects.toString(nullString, "").contains("Payment");
        System.out.println("Objects check: " + objectsCheck); // false

        // contains() vs indexOf() — when you need the position
        int position = serviceName.indexOf("PaymentRetry");
        System.out.println("Position: " + position); // 33 (0-indexed)
        // contains() returns true/false only; use indexOf() when you need index

        // Check if string contains any of multiple substrings
        String log = "ERROR: NullPointerException in PaymentService";
        boolean isError = log.contains("ERROR") || log.contains("FATAL");
        System.out.println("Is error: " + isError); // true
    }
}

package io.thecodeforge.performance;

public class ContainsPerformance {
    public static void main(String[] args) {
        String largeText = "abc".repeat(100_000); // 300K characters
        long start = System.nanoTime();
        // Repeated checks – don't do this in production
        for (int i = 0; i < 1000; i++) {
            boolean found = largeText.contains("xyz");
        }
        long end = System.nanoTime();
        System.out.println("1000 contains() calls: " + (end - start) / 1_000_000 + " ms");

        // Better: use indexOf to scan once and cache position, then check
        start = System.nanoTime();
        int position = largeText.indexOf("xyz");
        for (int i = 0; i < 1000; i++) {
            boolean found = position >= 0;
        }
        end = System.nanoTime();
        System.out.println("Cached indexOf check: " + (end - start) / 1_000_000 + " ms");
    }
}

package io.thecodeforge.strings;

import java.util.regex.Pattern;

public class StringMethodComparison {
    public static void main(String[] args) {
        String data = "Order#12345 processed";

        // contains – literal substring
        System.out.println(data.contains("12345")); // true
        System.out.println(data.contains("\\d+")); // false (literal backslash)

        // matches – requires full string match
        System.out.println(data.matches(".*12345.*")); // true
        System.out.println(data.matches(".*\\\\d+.*")); // false – wrong pattern

        // Using Pattern for partial regex
        Pattern digitPattern = Pattern.compile("\\d+");
        System.out.println(digitPattern.matcher(data).find()); // true

        // indexOf – returns position
        int idx = data.indexOf("processed");
        System.out.println("Index of 'processed': " + idx); // 15
    }
}

package io.thecodeforge.strings;

public class CharSequenceContains {
    public static void main(String[] args) {
        String source = "Hello World";
        StringBuilder sb = new StringBuilder("World");

        // You can pass a StringBuilder to contains()
        System.out.println(source.contains(sb)); // true

        // But StringBuilder itself does NOT have a contains() method
        // So you cannot do: sb.contains("World"); // compilation error
        // Use indexOf on StringBuilder instead
        int idx = sb.indexOf("World");
        System.out.println("StringBuilder.indexOf: " + idx); // 0
    }
}

package io.thecodeforge.streams;

import java.util.List;
import java.util.Objects;
import java.util.Locale;

public class StreamContains {
    public static void main(String[] args) {
        List<String> messages = List.of("INFO: startup complete", null, "ERROR: connection failed");

        // This will throw NPE because of the null element
        // List<String> errors = messages.stream()
        //     .filter(s -> s.contains("ERROR"))
        //     .collect(Collectors.toList());

        // Safe version with null check
        List<String> errors = messages.stream()
            .filter(Objects::nonNull)
            .filter(s -> s.contains("ERROR"))
            .toList();

        System.out.println(errors); // [ERROR: connection failed]

        // Case-insensitive version
        List<String> caseInsensitive = messages.stream()
            .filter(Objects::nonNull)
            .filter(s -> s.toLowerCase(Locale.ROOT).contains("error"))
            .toList();
        System.out.println(caseInsensitive); // [ERROR: connection failed]
    }
}