Регулярное выражение в Android для поля пароля

Ответ 1

Попробуйте это, может помочь

^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{4,}$

Как это работает?

^                 # start-of-string
(?=.*[0-9])       # a digit must occur at least once
(?=.*[a-z])       # a lower case letter must occur at least once
(?=.*[A-Z])       # an upper case letter must occur at least once
(?=.*[@#$%^&+=])  # a special character must occur at least once you can replace with your special characters
(?=\\S+$)          # no whitespace allowed in the entire string
.{4,}             # anything, at least six places though
$                 # end-of-string

Как реализовать?

public class MainActivity extends Activity {

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        final EditText editText = (EditText) findViewById(R.id.edtText);
        Button btnCheck = (Button) findViewById(R.id.btnCheck);

        btnCheck.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View arg0) {
                if (isValidPassword(editText.getText().toString().trim())) {
                    Toast.makeText(MainActivity.this, "Valid", Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(MainActivity.this, "InValid", Toast.LENGTH_SHORT).show();
                }
            }
        });

    }

    public boolean isValidPassword(final String password) {

        Pattern pattern;
        Matcher matcher;

        final String PASSWORD_PATTERN = "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{4,}$";

        pattern = Pattern.compile(PASSWORD_PATTERN);
        matcher = pattern.matcher(password);

        return matcher.matches();

    }

}

Ответ 2

Попробуйте это.

(/^(?=.*\d)(?=.*[A-Z])([@$%&#])[0-9a-zA-Z]{4,}$/)


(/^
(?=.*\d)                //should contain at least one digit
(?=.*[@$%&#])           //should contain at least one special char
(?=.*[A-Z])             //should contain at least one upper case
[a-zA-Z0-9]{4,}         //should contain at least 8 from the mentioned characters
$/)

Ответ 3

А для любителей котлина:

fun isValidPassword(password: String?) : Boolean {
   password?.let {
       val passwordPattern = "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{4,}$"
       val passwordMatcher = Regex(passwordPattern)

       return passwordMatcher.find(password) != null
   } ?: return false
}

Ответ 4

try {
    if (subjectString.matches("^(?=.*[@$%&#_()=+?»«<>£§€{}\\[\\]-])(?=.*[A-Z])(?=.*[a-z])(?=.*\\d).*(?<=.{4,})$")) {
        // String matched entirely
    } else {
        // Match attempt failed
    } 
} catch (PatternSyntaxException ex) {
    // Syntax error in the regular expression
}


(?=.*[@\$%&#_()=+?»«<>£§€{}.[\]-]) -> must have at least 1 special character
(?=.*[A-Z])   -> Must have at least 1 upper case letter
(?=.*[a-z])   -> Must have at least 1 lower case letter
(?=.*\\d)     -> Must have at least 1 digit
(?<=.{4,})$") -> Must be equal or superior to 4 chars.

Ответ 5

вы можете использовать класс Patern, чем Matcher для каждого формата проверки.

Я даю вам пример использования:

        Pattern pattern = Pattern.compile("[email protected]+\\.[a-z]+");
        Matcher matcher = pattern.matcher(myEmailString);
        if (!myEmailString.contains("@") || !matcher.matches()) {
            // error in the email : do staff 
            myEmailView.setError("invalid email !");

        }

Ответ 6

Я слишком поздно, чтобы ответить, но все же это может помочь вам.

Я работал с Kotlin.

Добавьте следующую функцию.

private fun isValidPassword(password: String): Boolean {
    val pattern: Pattern
    val matcher: Matcher
    val specialCharacters = "[email protected]%\\[\\}+'!/#$^?:;,\\(\"\\)~'.*=&\\{>\\]<_"
    val PASSWORD_REGEX = "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[$specialCharacters])(?=\\S+$).{8,20}$"
    pattern = Pattern.compile(PASSWORD_REGEX)
    matcher = pattern.matcher(password)
    return matcher.matches()
}

Описание функции:

• (? =. * [0-9]) # цифра должна встречаться хотя бы один раз
• (? =. * [az]) # строчная буква должна встречаться хотя бы один раз
• (? =. * [AZ]) # заглавная буква должна встречаться хотя бы один раз
• (? =. [- @% [} + '!/# $ ^?:;, (") ~'. = & {>] <_]) # специальный символ должен встречаться хотя бы один раз и заменяться вашими специальными символами
• (? =\S+ $) # запрещены пробелы во всей строке. {8,} # что угодно, хотя бы шесть мест

Вы можете изменить его по мере необходимости.

Надеюсь, поможет.

Ответ 7

В дополнение к уже приведенным ответам я бы предложил другой способ определения специальных символов, а также разделил бы проверку для различных правил.

Сначала разделите его: вместо того, чтобы создавать одно большое правило, разделите его и проверьте каждое правило отдельно, чтобы вы могли предоставить пользователю обратную связь о том, что именно не так с его паролем. Это может занять немного больше времени, но при проверке пароля это не будет заметно. Кроме того, таким образом, условия более читабельны.

Во-вторых, вместо проверки списка специальных символов вы можете перевернуть его и проверить, содержит ли пароль какие-либо символы, которые не являются ни буквами латинского алфавита (a-zA-Z), ни цифрами (0-9). Таким образом, вы не "забудете" специальные символы. Например, допустим, что вы проверяете конкретно, но при проверке вы забываете символ типа "{". При таком подходе этого не может быть. Вы можете расширить этот список с помощью вещей, которые вы явно не считаете специальными символами, для пример пробела. В kotlin это будет выглядеть так:

val errorText = when {
    /* Rule 1 */
    !password.contains(Regex("[A-Z]")) -> "Password must contain one capital letter"
    /* Rule 2 */
    !password.contains(Regex("[0-9]")) -> "Password must contain one digit"
    /* Rule 3, not counting space as special character */
    !password.contains(Regex("[^a-zA-Z0-9 ]")) -> "Password must contain one special character"
    else -> null
}

В зависимости от вашей кодировки вы также можете использовать регулярные выражения и определять свои специальные символы, используя диапазоны шестнадцатеричных кодов, таких как

Reges("[\x00-\x7F]")