// Removes whitespace between a word character and . or ,
String pattern = "(\\w)(\\s+)([\\.,])";
System.out.println(EXAMPLE_TEST.replaceAll(pattern, "$1$3"));

// Extract the text between the two title elements
pattern = "(?i)(<title.*?>)(.+?)()";
String updated = EXAMPLE_TEST.replaceAll(pattern, "$2");

a(?!b)

package de.vogella.regex.test;

import java.util.Arrays;

/**
 * Demonstrates basic regex operations using String methods.
 * This example shows the fundamental regex support built into Java Strings.
 */
public class RegexTestStrings {
    public static final String EXAMPLE_TEXT = """
            This is my small example string which I'm going to use for pattern matching.
            """.trim();

    public static void main(String[] args) {
        System.out.println("=== String Regex Methods Demo ===");
        System.out.println("Example text: " + EXAMPLE_TEXT);
        System.out.println();

        // Test if string starts with a word character
        var startsWithWord = EXAMPLE_TEXT.matches("\\w.*");
        System.out.println("Starts with word character: " + startsWithWord);

        // Split the string by whitespace
        String[] words = EXAMPLE_TEXT.split("\\s+");
        System.out.println("Number of words: " + words.length);
        System.out.println("Words: " + Arrays.toString(words));

        // Replace all whitespace with tabs
        var tabSeparated = EXAMPLE_TEXT.replaceAll("\\s+", "\t");
        System.out.println("Tab-separated: " + tabSeparated);

        // Find and replace first occurrence
        var firstReplacement = EXAMPLE_TEXT.replaceFirst("small", "LARGE");
        System.out.println("First replacement: " + firstReplacement);

        // Multiple replacements example
        var cleaned = EXAMPLE_TEXT
                .replaceAll("\\s+", " ")  // normalize whitespace  
                .replaceAll("'", "'");    // normalize apostrophes
        System.out.println("Cleaned text: " + cleaned);
    }
}

package de.vogella.regex.string;

import java.util.regex.Pattern;

/**
 * StringMatcher demonstrates common string matching patterns using regular expressions.
 * This class showcases various regex patterns for typical validation scenarios.
 */
public class StringMatcher {
    
    // Pre-compiled patterns for better performance
    private static final Pattern TRUE_PATTERN = Pattern.compile("true");
    private static final Pattern TRUE_CASE_INSENSITIVE = Pattern.compile("[tT]rue");
    private static final Pattern TRUE_OR_YES = Pattern.compile("[tT]rue|[yY]es");
    private static final Pattern THREE_LETTERS = Pattern.compile("[a-zA-Z]{3}");
    private static final Pattern NO_NUMBER_START = Pattern.compile("^[^\\d].*");
    private static final Pattern WORD_EXCEPT_B = Pattern.compile("([\\w&&[^b]])*");
    private static final Pattern LESS_THAN_300 = Pattern.compile("[^0-9]*[12]?[0-9]{1,2}[^0-9]*");

    /**
     * Returns true if the string matches exactly "true"
     * @param input the string to test
     * @return true if exact match for "true"
     */
    public boolean isTrue(String input) {
        return TRUE_PATTERN.matcher(input).matches();
    }

    /**
     * Returns true if the string matches exactly "true" or "True" (case-insensitive first letter)
     * @param input the string to test
     * @return true if matches "true" or "True"
     */
    public boolean isTrueVersion2(String input) {
        return TRUE_CASE_INSENSITIVE.matcher(input).matches();
    }

    /**
     * Returns true if the string matches exactly "true", "True", "yes", or "Yes"
     * @param input the string to test
     * @return true if matches any of the allowed values
     */
    public boolean isTrueOrYes(String input) {
        return TRUE_OR_YES.matcher(input).matches();
    }

    /**
     * Returns true if the string contains "true" anywhere within it
     * @param input the string to test
     * @return true if "true" is found anywhere in the string
     */
    public boolean containsTrue(String input) {
        return input.matches(".*true.*");
    }

    /**
     * Returns true if the string consists of exactly three letters
     * @param input the string to test
     * @return true if exactly three alphabetic characters
     */
    public boolean isThreeLetters(String input) {
        return THREE_LETTERS.matcher(input).matches();
    }

    /**
     * Returns true if the string does not have a number at the beginning
     * @param input the string to test
     * @return true if first character is not a digit
     */
    public boolean isNoNumberAtBeginning(String input) {
        return NO_NUMBER_START.matcher(input).matches();
    }

    /**
     * Returns true if the string contains only word characters except 'b'
     * Uses intersection pattern [\\w&&[^b]] - word chars AND not 'b'
     * @param input the string to test
     * @return true if contains only word characters excluding 'b'
     */
    public boolean isIntersection(String input) {
        return WORD_EXCEPT_B.matcher(input).matches();
    }

    /**
     * Returns true if the string contains a number less than 300
     * This regex handles numbers embedded in text
     * @param input the string to test
     * @return true if contains a number less than 300
     */
    public boolean isLessThanThreeHundred(String input) {
        return LESS_THAN_300.matcher(input).matches();
    }
}

package de.vogella.regex.string;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;

@DisplayName("String Matcher Regular Expression Tests")
public class StringMatcherTest {
    private StringMatcher matcher;

    @BeforeEach
    void setUp() {
        matcher = new StringMatcher();
    }

    @Test
    @DisplayName("Should match exact 'true' string")
    void testIsTrue() {
        assertTrue(matcher.isTrue("true"));
        assertFalse(matcher.isTrue("true2"));
        assertFalse(matcher.isTrue("True"));
        assertFalse(matcher.isTrue(" true "));
    }

    @Test
    @DisplayName("Should match 'true' case-insensitive")
    void testIsTrueVersion2() {
        assertTrue(matcher.isTrueVersion2("true"));
        assertFalse(matcher.isTrueVersion2("true2"));
        assertTrue(matcher.isTrueVersion2("True"));
    }

    @ParameterizedTest
    @DisplayName("Should match 'true' or 'yes' case-insensitive")
    @ValueSource(strings = {"true", "True", "yes", "Yes"})
    void testIsTrueOrYesValid(String input) {
        assertTrue(matcher.isTrueOrYes(input));
    }

    @ParameterizedTest
    @DisplayName("Should not match invalid inputs for 'true' or 'yes'")
    @ValueSource(strings = {"no", "maybe", "false", "TRUE", "YES"})
    void testIsTrueOrYesInvalid(String input) {
        assertFalse(matcher.isTrueOrYes(input));
    }

    @Test
    @DisplayName("Should find 'true' anywhere in string")
    void testContainsTrue() {
        assertTrue(matcher.containsTrue("thetruewithin"));
        assertTrue(matcher.containsTrue("true"));
        assertTrue(matcher.containsTrue("start true end"));
        assertFalse(matcher.containsTrue("Truth"));
        assertFalse(matcher.containsTrue("untrue"));
    }

    @ParameterizedTest
    @DisplayName("Should match exactly three letters")
    @ValueSource(strings = {"abc", "XYZ", "DeF"})
    void testIsThreeLettersValid(String input) {
        assertTrue(matcher.isThreeLetters(input));
    }

    @ParameterizedTest
    @DisplayName("Should not match non-three-letter strings")
    @ValueSource(strings = {"ab", "abcd", "123", "ab1", "a b"})
    void testIsThreeLettersInvalid(String input) {
        assertFalse(matcher.isThreeLetters(input));
    }

    @Test
    @DisplayName("Should validate strings don't start with numbers")
    void testNoNumberAtBeginning() {
        assertTrue(matcher.isNoNumberAtBeginning("abc"));
        assertFalse(matcher.isNoNumberAtBeginning("1abcd"));
        assertTrue(matcher.isNoNumberAtBeginning("a1bcd"));
        assertTrue(matcher.isNoNumberAtBeginning("asdfdsf"));
        assertFalse(matcher.isNoNumberAtBeginning("9test"));
    }

    @Test
    @DisplayName("Should match intersection pattern (word chars except 'b')")
    void testIntersection() {
        assertTrue(matcher.isIntersection("1"));
        assertTrue(matcher.isIntersection("acdefg"));
        assertFalse(matcher.isIntersection("abc"));
        assertTrue(matcher.isIntersection("skdskfjsmcnxmvjwque484242"));
        assertFalse(matcher.isIntersection("hobbit"));
    }

    @Test
    @DisplayName("Should validate numbers less than 300")
    void testLessThanThreeHundred() {
        assertTrue(matcher.isLessThanThreeHundred("288"));
        assertFalse(matcher.isLessThanThreeHundred("3288"));
        assertFalse(matcher.isLessThanThreeHundred("328 8"));
        assertTrue(matcher.isLessThanThreeHundred("1"));
        assertTrue(matcher.isLessThanThreeHundred("99"));
        assertFalse(matcher.isLessThanThreeHundred("300"));
        assertTrue(matcher.isLessThanThreeHundred("299"));
        assertFalse(matcher.isLessThanThreeHundred("301"));
    }
}

// Compile once, use many times
Pattern emailPattern = Pattern.compile(
    "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
    Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE
);

// Use with different inputs
boolean isValid1 = emailPattern.matcher("User@Example.COM").matches();
boolean isValid2 = emailPattern.matcher("test@domain.org").matches();

String text = "Call 555-1234 or 555-5678 for support";
Pattern phonePattern = Pattern.compile("\\d{3}-\\d{4}");
Matcher matcher = phonePattern.matcher(text);

// Find all matches
while (matcher.find()) {
    System.out.printf("Found '%s' at position %d-%d%n",
        matcher.group(), matcher.start(), matcher.end());
}

// Reset and replace
matcher.reset();
String result = matcher.replaceAll("XXX-XXXX");
System.out.println("Masked: " + result);

// Check if entire string matches
boolean fullMatch = phonePattern.matcher("555-1234").matches();

// Check if string contains pattern
boolean contains = phonePattern.matcher("Call 555-1234").find();

String logEntry = "2024-01-15 10:30:45 [ERROR] Connection failed";
Pattern logPattern = Pattern.compile(
    "(\\d{4}-\\d{2}-\\d{2})\\s+(\\d{2}:\\d{2}:\\d{2})\\s+\\[(\\w+)\\]\\s+(.+)"
);

Matcher matcher = logPattern.matcher(logEntry);
if (matcher.matches()) {
    String date = matcher.group(1);     // "2024-01-15"
    String time = matcher.group(2);     // "10:30:45"
    String level = matcher.group(3);    // "ERROR"
    String message = matcher.group(4);  // "Connection failed"

    System.out.printf("Date: %s, Time: %s, Level: %s, Message: %s%n",
        date, time, level, message);
}

package de.vogella.regex.eitheror;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * Demonstrates the OR operator (|) in regular expressions.
 * This example shows how to match multiple alternative patterns.
 */
@DisplayName("Either/Or Pattern Matching Tests")
public class EitherOrCheck {

    @ParameterizedTest
    @DisplayName("Should match strings containing 'jim' or 'joe'")
    @ValueSource(strings = {
        "humbapumpa jim",
        "humbaPumpa joe", 
        "humbapumpa joe jim",
        "jim is here",
        "where is joe?",
        "both jim and joe are here"
    })
    void testMatchesJimOrJoe(String input) {
        assertTrue(input.matches(".*(jim|joe).*"),
            "Should match strings containing 'jim' or 'joe': " + input);
    }

    @ParameterizedTest
    @DisplayName("Should not match strings without 'jim' or 'joe'")
    @ValueSource(strings = {
        "humbapumpa jom",
        "hello world",
        "jamie and joel", // similar but not exact matches
        "jimbo and joey"  // contains the letters but not the exact words
    })
    void testDoesNotMatchOtherStrings(String input) {
        assertFalse(input.matches(".*(jim|joe).*"),
            "Should not match strings without exact 'jim' or 'joe': " + input);
    }

    @Test
    @DisplayName("Demonstrate case-sensitive vs case-insensitive matching")
    void testCaseSensitivity() {
        var text = "Hello JIM and JOE";
        
        // Case-sensitive (should fail)
        assertFalse(text.matches(".*(jim|joe).*"),
            "Case-sensitive matching should fail for uppercase");
        
        // Case-insensitive (should pass)  
        assertTrue(text.matches("(?i).*(jim|joe).*"),
            "Case-insensitive matching should work for uppercase");
    }

    @Test
    @DisplayName("More complex OR patterns with word boundaries")
    void testWordBoundaryMatching() {
        // Using word boundaries to match exact words only
        var pattern = "\\b(jim|joe|james|joseph)\\b";
        
        assertTrue("jim".matches(pattern), "Should match exact word 'jim'");
        assertTrue("joe".matches(pattern), "Should match exact word 'joe'");
        assertTrue("james".matches(pattern), "Should match exact word 'james'");
        assertTrue("joseph".matches(pattern), "Should match exact word 'joseph'");
        
        assertFalse("jimmy".matches(pattern), "Should not match partial word 'jimmy'");
        assertFalse("joey".matches(pattern), "Should not match partial word 'joey'");
    }
}

package de.vogella.regex.phonenumber;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

import java.util.regex.Pattern;

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * Demonstrates phone number validation using regular expressions.
 * Includes patterns for various international and US phone number formats.
 */
@DisplayName("Phone Number Validation Tests")
public class CheckPhone {

    // US phone number patterns
    private static final Pattern US_PHONE_SIMPLE = Pattern.compile("\\d{3}[,\\s]?\\d{4}");
    private static final Pattern US_PHONE_FULL = Pattern.compile("\\(?\\d{3}\\)?[-\\s]?\\d{3}[-\\s]?\\d{4}");
    
    // International phone number pattern (basic)
    private static final Pattern INTERNATIONAL_PHONE = Pattern.compile("\\+?\\d{1,4}[-\\s]?\\(?\\d{1,4}\\)?[-\\s]?\\d{1,4}[-\\s]?\\d{1,9}");

    @Test
    @DisplayName("Test simple 7-digit phone pattern")
    void testSimplePhonePattern() {
        var pattern = "\\d{3}[,\\s]?\\d{4}";
        
        // Valid 7-digit numbers
        assertTrue("1233323".matches(pattern), "Should match 7 digits");
        assertTrue("123 3323".matches(pattern), "Should match with space");
        assertTrue("123,3323".matches(pattern), "Should match with comma");
        
        // Invalid patterns
        assertFalse("1233323322".matches(pattern), "Should not match 10 digits");
        assertFalse("12333".matches(pattern), "Should not match 5 digits");
    }

    @ParameterizedTest
    @DisplayName("Test US phone number formats")
    @ValueSource(strings = {
        "123-456-7890",
        "(123) 456-7890", 
        "(123)456-7890",
        "123 456 7890",
        "1234567890"
    })
    void testUSPhoneFormats(String phoneNumber) {
        assertTrue(US_PHONE_FULL.matcher(phoneNumber).matches(),
            "Should match US phone format: " + phoneNumber);
    }

    @ParameterizedTest
    @DisplayName("Test international phone number formats")
    @ValueSource(strings = {
        "+1 123 456 7890",    // US with country code
        "+44 20 7946 0958",   // UK London
        "+49 30 12345678",    // Germany Berlin
        "+33 1 42 86 83 26",  // France Paris  
        "+81 3 1234 5678"     // Japan Tokyo
    })
    void testInternationalPhoneFormats(String phoneNumber) {
        assertTrue(INTERNATIONAL_PHONE.matcher(phoneNumber).matches(),
            "Should match international phone format: " + phoneNumber);
    }

    @ParameterizedTest
    @DisplayName("Test invalid phone number formats")
    @ValueSource(strings = {
        "123",           // too short
        "abc-def-ghij",  // letters instead of numbers
        "123-45-67890",  // wrong grouping
        "123 456 78901", // too many digits
        "+",             // just plus sign
        "++1 123 456 7890" // double plus
    })
    void testInvalidPhoneFormats(String phoneNumber) {
        assertFalse(US_PHONE_FULL.matcher(phoneNumber).matches(),
            "Should not match invalid phone format: " + phoneNumber);
    }

    @Test
    @DisplayName("Test phone number extraction from text")
    void testPhoneNumberExtraction() {
        var text = "Call me at (555) 123-4567 or reach John at +1-800-555-0199 for support.";
        var matcher = US_PHONE_FULL.matcher(text);
        
        assertTrue(matcher.find(), "Should find first phone number");
        System.out.println("Found phone: " + matcher.group());
        
        // Reset matcher to find all occurrences
        matcher.reset();
        int count = 0;
        while (matcher.find()) {
            count++;
            System.out.printf("Phone %d: %s (positions %d-%d)%n", 
                count, matcher.group(), matcher.start(), matcher.end());
        }
        
        assertTrue(count > 0, "Should find at least one phone number");
    }
}

package de.vogella.regex.numbermatch;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.junit.Test;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

public class CheckNumber {

    
    @Test
    public void testSimpleTrue() {
        String s= "1233";
        assertTrue(test(s));
        s= "0";
        assertFalse(test(s));
        s = "29 Kasdkf 2300 Kdsdf";
        assertTrue(test(s));
        s = "99900234";
        assertTrue(test(s));
    }
    

    
    
    public static boolean test (String s){
        Pattern pattern = Pattern.compile("\\d{3}");
        Matcher matcher = pattern.matcher(s);
        if (matcher.find()){
            return true; 
        } 
        return false; 
    }

}

package de.vogella.regex.weblinks;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

/**
 * Modern link extractor using Java 11+ HttpClient and improved regex patterns.
 * Extracts links from web pages while filtering out unwanted protocols.
 */
public class LinkGetter {
    
    // More robust HTML link pattern
    private static final Pattern LINK_PATTERN = Pattern.compile(
        "<a\\s+(?:[^>]*?\\s+)?href=([\"'])(.*?)\\1[^>]*>",
        Pattern.CASE_INSENSITIVE | Pattern.DOTALL
    );
    
    // Pattern to exclude unwanted link types
    private static final Pattern EXCLUDED_PROTOCOLS = Pattern.compile(
        "^(?:javascript:|mailto:|tel:|ftp:).*",
        Pattern.CASE_INSENSITIVE
    );
    
    private final HttpClient httpClient;

    public LinkGetter() {
        this.httpClient = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(10))
            .followRedirects(HttpClient.Redirect.NORMAL)
            .build();
    }

    /**
     * Extracts all valid HTTP/HTTPS links from the given URL
     */
    public List<String> getLinks(String url) {
        try {
            var htmlContent = fetchWebPage(url);
            return extractLinksFromHtml(htmlContent, url);
        } catch (Exception e) {
            System.err.println("Error fetching links from " + url + ": " + e.getMessage());
            return new ArrayList<>();
        }
    }

    /**
     * Fetches web page content using modern HttpClient
     */
    private String fetchWebPage(String url) throws IOException, InterruptedException {
        try {
            var request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .timeout(Duration.ofSeconds(30))
                .header("User-Agent", "Java-LinkExtractor/1.0")
                .GET()
                .build();

            var response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
            
            if (response.statusCode() == 200) {
                return response.body();
            } else {
                throw new IOException("HTTP " + response.statusCode() + " for " + url);
            }
        } catch (URISyntaxException e) {
            throw new IOException("Invalid URL: " + url, e);
        }
    }

    /**
     * Extracts links from HTML content using regex
     */
    private List<String> extractLinksFromHtml(String html, String baseUrl) {
        var links = new ArrayList<String>();
        var matcher = LINK_PATTERN.matcher(html);

        while (matcher.find()) {
            var link = matcher.group(2); // The href value
            
            if (isValidLink(link)) {
                try {
                    var absoluteLink = makeAbsolute(baseUrl, link);
                    if (!links.contains(absoluteLink)) {
                        links.add(absoluteLink);
                    }
                } catch (Exception e) {
                    // Skip invalid links
                    System.err.println("Skipping invalid link: " + link + " (" + e.getMessage() + ")");
                }
            }
        }

        return links;
    }

    /**
     * Validates if a link should be included in results
     */
    private boolean isValidLink(String link) {
        if (link == null || link.trim().isEmpty()) {
            return false;
        }
        
        var trimmedLink = link.trim();
        
        // Exclude unwanted protocols
        if (EXCLUDED_PROTOCOLS.matcher(trimmedLink).matches()) {
            return false;
        }
        
        // Exclude anchors and empty hrefs
        if (trimmedLink.equals("#") || trimmedLink.startsWith("#")) {
            return false;
        }
        
        return true;
    }

    /**
     * Converts relative URLs to absolute URLs using modern URI handling
     */
    private String makeAbsolute(String baseUrl, String link) throws URISyntaxException {
        var baseUri = new URI(baseUrl);
        var linkUri = new URI(link);
        
        // If link is already absolute, return as-is
        if (linkUri.isAbsolute()) {
            return linkUri.toString();
        }
        
        // Resolve relative URL against base URL
        var resolvedUri = baseUri.resolve(linkUri);
        return resolvedUri.toString();
    }

    /**
     * Demonstration method showing usage
     */
    public static void main(String[] args) {
        var linkGetter = new LinkGetter();
        
        // Example usage - replace with actual URL
        var testUrl = "https://httpbin.org/links/10/0"; // Test URL with links
        
        System.out.println("Extracting links from: " + testUrl);
        var links = linkGetter.getLinks(testUrl);
        
        System.out.println("Found " + links.size() + " links:");
        links.forEach(link -> System.out.println("  " + link));
    }

    // Close resources
    public void close() {
        // HttpClient doesn't need explicit closing in Java 11+
        // but included for completeness
    }
}

\b(\w+)\s+\1\b

(\n\s*)title

(?s) /\* \(non-Javadoc\).*?\*/

// Instead of regex for simple checks:
if (text.matches(".*error.*")) { /* ... */ }

// Use simpler string method:
if (text.contains("error")) { /* ... */ }

// For complex structured data, use proper parsers:
// Instead of regex for JSON: "\\{.*\"name\"\\s*:\\s*\"([^\"]+)\".*\\}"
// Use: ObjectMapper mapper = new ObjectMapper(); JsonNode node = mapper.readTree(json);