Регулярное выражение Java проверяет примеры имен пользователей

  ^[a-zA-Z0-9]([._-](?![._-])|[a-zA-Z0-9]){3,18}[a-zA-Z0-9]$

  ^[a-zA-Z0-9]      # start with an alphanumeric character
  (                 # start of (group 1)
    [._-](?![._-])  # follow by a dot, hyphen, or underscore, negative lookahead to
                    # ensures dot, hyphen, and underscore does not appear consecutively
    |               # or
    [a-zA-Z0-9]     # an alphanumeric character
  )                 # end of (group 1)
  {3,18}            # ensures the length of (group 1) between 3 and 18
  [a-zA-Z0-9]$      # end with an alphanumeric character

                    # {3,18} plus the first and last alphanumeric characters,
                    # total length became {5,20}

package com.mkyong.regex.username;

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

public class UsernameValidator {

    // simple regex
    //private static final String USERNAME_PATTERN = "^[a-z0-9\\._-]{5,20}$";

    // strict regex
    private static final String USERNAME_PATTERN =
            "^[a-zA-Z0-9]([._-](?![._-])|[a-zA-Z0-9]){3,18}[a-zA-Z0-9]$";

    private static final Pattern pattern = Pattern.compile(USERNAME_PATTERN);

    public static boolean isValid(final String username) {
        Matcher matcher = pattern.matcher(username);
        return matcher.matches();
    }

}

package com.mkyong.regex.username;

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;

import java.util.stream.Stream;

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

public class UsernameValidatorTest {

    @ParameterizedTest(name = "#{index} - Run test with username = {0}")
    @MethodSource("validUsernameProvider")
    void test_username_regex_valid(String username) {
        assertTrue(UsernameValidator.isValid(username));
    }

    @ParameterizedTest(name = "#{index} - Run test with username = {0}")
    @MethodSource("invalidUsernameProvider")
    void test_username_regex_invalid(String username) {
        assertFalse(UsernameValidator.isValid(username));
    }

    static Stream validUsernameProvider() {
        return Stream.of(
                "mkyong",
                "javaregex",
                "JAVAregex",
                "java.regex",
                "java-regex",
                "java_regex",
                "java.regex.123",
                "java-regex-123",
                "java_regex_123",
                "javaregex123",
                "123456",
                "java123",
                "01234567890123456789");
    }

    static Stream invalidUsernameProvider() {
        return Stream.of(
                "abc",                      // invalid length 3, length must between 5-20
                "01234567890123456789a",    // invalid length 21, length must between 5-20
                "_javaregex_",              // invalid start and last character
                ".javaregex.",              // invalid start and last character
                "-javaregex-",              // invalid start and last character
                "javaregex#$%@123",         // invalid symbols, support dot, hyphen and underscore
                "java..regex",              // dot cant appear consecutively
                "java--regex",              // hyphen can't appear consecutively
                "java__regex",              // underscore can't appear consecutively
                "java._regex",              // dot and underscore can't appear consecutively
                "java.-regex",              // dot and hyphen can't appear consecutively
                " ",                        // empty
                "");                        // empty
    }

}

package com.mkyong.regex.username;

public class UsernameValidatorCode {

    private static final char[] SUPPORT_SYMBOLS_CHAR = {'.', '_', '-'};

    public static boolean isValid(final String username) {

        // check empty
        if (username == null || username.length() == 0) {
            return false;
        }

        // check length
        if (username.length() < 5 || username.length() > 20) {
            return false;
        }

        return isValidUsername(username.toCharArray());
    }

    private static boolean isValidUsername(final char[] username) {

        int currentPosition = 0;
        boolean valid = true;

        // check char by char
        for (char c : username) {

            // if alphanumeric char, no need check, process next
            if (!Character.isLetterOrDigit(c)) {

                // for non-alphanumeric char, also not a supported symbol, break
                if (!isSupportedSymbols(c)) {
                    valid = false;
                    break;
                }

                // ensures first and last char not a supported symbol
                if (username[0] == c || username[username.length - 1] == c) {
                    valid = false;
                    break;
                }

                // ensure supported symbol does not appear consecutively
                // is next position also a supported symbol?
                if (isSupportedSymbols(username[currentPosition + 1])) {
                    valid = false;
                    break;
                }

            }

            currentPosition++;
        }

        return valid;

    }

    private static boolean isSupportedSymbols(final char symbol) {
        for (char temp : SUPPORT_SYMBOLS_CHAR) {
            if (temp == symbol) {
                return true;
            }
        }
        return false;
    }

}