# java.util.regex

***

**1. Validating Email Addresses**

```java
import java.util.regex.Pattern;

public class EmailValidator {

    private static final String EMAIL_PATTERN = "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$";

    public static boolean isValidEmail(String email) {
        Pattern pattern = Pattern.compile(EMAIL_PATTERN);
        return pattern.matcher(email).matches();
    }
}
```

**2. Extracting Data from HTML**

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

public class HtmlExtractor {

    public static String extractTitle(String html) {
        Pattern pattern = Pattern.compile("<title>(.*?)</title>");
        Matcher matcher = pattern.matcher(html);
        if (matcher.find()) {
            return matcher.group(1);
        }
        return null;
    }
}
```

**3. Finding Duplicate Words in a String**

```java
import java.util.regex.Pattern;

public class DuplicateWordFinder {

    public static boolean hasDuplicateWords(String text) {
        String[] words = text.split("\\s+");
        for (int i = 0; i < words.length; i++) {
            for (int j = i + 1; j < words.length; j++) {
                if (words[i].equals(words[j])) {
                    return true;
                }
            }
        }
        return false;
    }
}
```

**4. Splitting a String on Multiple Delimiters**

```java
import java.util.regex.Pattern;

public class MultiDelimiterSplitter {

    public static String[] split(String text, String... delimiters) {
        String regex = String.join("|", delimiters);
        return text.split(regex);
    }
}
```

**5. Replacing All Occurrences of a String**

```java
import java.util.regex.Pattern;

public class StringReplacer {

    public static String replaceAll(String text, String pattern, String replacement) {
        return Pattern.compile(pattern).matcher(text).replaceAll(replacement);
    }
}
```

**6. Matching a Specific Pattern**

```java
import java.util.regex.Pattern;

public class PatternMatcher {

    public static boolean matches(String text, String pattern) {
        Pattern regex = Pattern.compile(pattern);
        return regex.matcher(text).matches();
    }
}
```

**7. Replacing the First Occurrence of a String**

```java
import java.util.regex.Pattern;

public class FirstOccurrenceReplacer {

    public static String replaceFirst(String text, String pattern, String replacement) {
        return Pattern.compile(pattern).matcher(text).replaceFirst(replacement);
    }
}
```

**8. Extracting Numbers from a String**

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

public class NumberExtractor {

    public static List<Integer> extractNumbers(String text) {
        List<Integer> numbers = new ArrayList<>();
        Pattern pattern = Pattern.compile("\\d+");
        Matcher matcher = pattern.matcher(text);
        while (matcher.find()) {
            numbers.add(Integer.parseInt(matcher.group()));
        }
        return numbers;
    }
}
```

**9. Validating Phone Numbers**

```java
import java.util.regex.Pattern;

public class PhoneNumberValidator {

    private static final String PHONE_PATTERN = "^(\\d{3}[- .]?){2}\\d{4}$";

    public static boolean isValidPhoneNumber(String phoneNumber) {
        Pattern pattern = Pattern.compile(PHONE_PATTERN);
        return pattern.matcher(phoneNumber).matches();
    }
}
```

**10. Matching a Specific Format**

```java
import java.util.regex.Pattern;

public class FormatMatcher {

    public static boolean matchesFormat(String text, String format) {
        Pattern pattern = Pattern.compile(String.format("^%s$", format));
        return pattern.matcher(text).matches();
    }
}
```

**11. Finding the First Occurrence of a Substring**

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

public class SubstringFinder {

    public static int findSubstring(String text, String substring) {
        Pattern pattern = Pattern.compile(substring);
        Matcher matcher = pattern.matcher(text);
        if (matcher.find()) {
            return matcher.start();
        }
        return -1;
    }
}
```

**12. Counting Occurrences of a String**

```java
import java.util.regex.Pattern;

public class StringCounter {

    public static int countOccurrences(String text, String pattern) {
        return Pattern.compile(pattern).matcher(text).groupCount();
    }
}
```

**13. Matching Any Character Except a Specific Set**

```java
import java.util.regex.Pattern;

public class CharacterExcluder {

    public static boolean matchesExcluding(String text, String excludedChars) {
        Pattern pattern = Pattern.compile(String.format("[^%s]+", excludedChars));
        return pattern.matcher(text).matches();
    }
}
```

**14. Removing Non-Alphanumeric Characters**

```java
import java.util.regex.Pattern;

public class NonAlphaNumericRemover {

    public static String removeNonAlphaNumeric(String text) {
        return Pattern.compile("[^a-zA-Z0-9]+").matcher(text).replaceAll("");
    }
}
```

**15. Extracting Hyperlinks from HTML**

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

public class HyperlinkExtractor {



```