Android中密码字段的正则表达式

Question

我如何通过允许特定字符来验证EditText 和Regex。 我的情况是：

密码规则：

1. 一个大写字母

2. 一个数字

3. 一个符号 (@,$,%,&,#,) 任何可接受的正常符号。

   我可以知道实现目标的正确方法是什么吗？

Answer 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();

    }

}

Answer 2

对于 Kotlin 爱好者来说：

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
}

Answer 3

试试这个。

(/^(?=.*\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
$/)

Answer 4

以上都不适合我。

什么对我有用：

fun isValidPasswordFormat(password: String): Boolean {
    val passwordREGEX = Pattern.compile("^" +
        "(?=.*[0-9])" +         //at least 1 digit
        "(?=.*[a-z])" +         //at least 1 lower case letter
        "(?=.*[A-Z])" +         //at least 1 upper case letter
        "(?=.*[a-zA-Z])" +      //any letter
        "(?=.*[@#$%^&+=])" +    //at least 1 special character
        "(?=\\S+$)" +           //no white spaces
        ".{8,}" +               //at least 8 characters
        "$");
    return passwordREGEX.matcher(password).matches()
}

来源：Coding in Flow

希望对某人有所帮助。

Answer 5

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.

Answer 6

作为对已经给出的答案的补充，我会建议一种不同的方法来识别特殊字符，并且还会分开检查不同的规则。

首先拆分它：不要制定一个大规则，而是拆分它并分别检查每个规则，以便您能够向用户提供有关其密码到底有什么问题的反馈。这可能需要更长的时间，但在密码检查之类的情况下，这不会引起注意。此外，这样条件的可读性更高。

其次，您可以翻转它并检查密码是否包含任何既不是拉丁字母 (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]")

Answer 7

我来不及回答，但它仍然可以帮助你。

我曾与Kotlin 合作过。

添加以下功能。

private fun isValidPassword(password: String): Boolean {
    val pattern: Pattern
    val matcher: Matcher
    val specialCharacters = "-@%\\[\\}+'!/#$^?:;,\\(\"\\)~`.*=&\\{>\\]<_"
    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]) # 一个数字必须至少出现一次
• (?=.*[a-z]) # 小写字母必须至少出现一次
• (?=.*[A-Z]) # 大写字母必须至少出现一次
• (?=.[-@%[}+'!/#$^?:;,(")~`.=&{>]<_>
• (?=\S+$) # 整个字符串中不允许有空格 .{8,} # 无论如何，至少有六个地方

您可以根据需要进行修改。

希望对你有帮助。

Answer 8

对于每种检查格式，您都可以使用 Patern 类而不是 Matcher。

我给你一个使用例子：

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

        }

Answer 9

所有其他答案都很好，但是特殊字符的实现对我来说有点太乱了。我将 Unicode 用于特殊字符。

我使用了OWASP website中指定的特殊字符。

科特林：

val SPECIAL_CHARACTERS_REGEX =
    "?=.*[\\u0020-\\u002F\\u003A-\\u0040\\u005B-\\u0060\\u007B-\\u007E]"
val PASSWORD_REGEX =
    "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])($SPECIAL_CHARACTERS_REGEX).{8,}\$"

fun isValidPassword(password: String) = Pattern.matches(PASSWORD_REGEX, password)

Answer 10

最常见的密码验证是

1. 至少 8 个字符
2. 需要数字
3. 需要特殊字符
4. 需要大写字母
5. 需要小写字母

正则表达式：

^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[\\\/%§"&“|`´}{°><:.;#')(@_$"!?*=^-]).{8,}$

Kotlin 代码：

    val PASSWORD_REGEX_PATTERN = "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[\\\/%§"&“|`´}{°><:.;#')(@_$"!?*=^-]).{8,}$"

    fun isValidPassword(password: String?): Boolean {
        val pattern: Pattern =
            Pattern.compile(PASSWORD_REGEX_PATTERN)
        val matcher: Matcher = pattern.matcher(password)
        return matcher.matches()
    }

在线正则表达式验证器来检查它：

• https://regex101.com/
• https://www.freeformatter.com/java-regex-tester.html#ad-output

Answer 11

private fun passwordValidate(password1: String, password2: String): Boolean {
    when {
        password1.length < 9 -> {
            textView2.text = "Password Has To Be At Least 9 Characters Long"
            return false
        }
        !password1.matches(".*[A-Z].*".toRegex()) -> {
            textView2.text = "Password Must Contain 1 Upper-case Character"
            return false
        }
        !password1.matches(".*[a-z].*".toRegex()) -> {
            textView2.text = "Password Must Contain 1 Lower-case Character"
            return false
        }
        !password1.matches(".*[!@#$%^&*+=/?].*".toRegex()) -> {
            textView2.text = "Password Must Contain 1 Symbol"
            return false
        }
        password1 != password2 -> {
            textView3.text = "Passwords Don't Match"
            return false
        }
        else -> return true

Answer 12

试试这个，

if (validatePassword())
  {
   // if valid
  }

private boolean validatePassword() {
    String passwordInput =  password.getText().toString().trim();

    if (!passwordInput.matches(".*[0-9].*")) {
        Toast.makeText(mActivity, "Password should contain at least 1 digit", Toast.LENGTH_SHORT).show();
        return false;
    }
    else if (!passwordInput.matches(".*[a-z].*")) {
        Toast.makeText(mActivity, "Password should contain at least 1 lower case letter", Toast.LENGTH_SHORT).show();
        return false;
    }
    else if (!passwordInput.matches(".*[A-Z].*")) {
        Toast.makeText(mActivity, "Password should contain at least 1 upper case letter", Toast.LENGTH_SHORT).show();
        return false;
    }
    else if (!passwordInput.matches(".*[a-zA-Z].*")) {
        Toast.makeText(mActivity, "Password should contain a letter", Toast.LENGTH_SHORT).show();
        return false;
    }
    else if (!passwordInput.matches( ".{8,}")) {
        Toast.makeText(mActivity, "Password should contain 8 characters", Toast.LENGTH_SHORT).show();
        return false;
    }
    else {
        return true;
    }
}